| 1 | /* Definitions to make GDB run on a Pyramid under OSx 4.0 (4.2bsd). |
| 2 | Copyright (C) 1988, 1989, 1991 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 TARGET_BYTE_ORDER BIG_ENDIAN |
| 21 | |
| 22 | /* Traditional Unix virtual address spaces have thre regions: text, |
| 23 | data and stack. The text, initialised data, and uninitialised data |
| 24 | are represented in separate segments of the a.out file. |
| 25 | When a process dumps core, the data and stack regions are written |
| 26 | to a core file. This gives a debugger enough information to |
| 27 | reconstruct (and debug) the virtual address space at the time of |
| 28 | the coredump. |
| 29 | Pyramids have an distinct fourth region of the virtual address |
| 30 | space, in which the contents of the windowed registers are stacked |
| 31 | in fixed-size frames. Pyramid refer to this region as the control |
| 32 | stack. Each call (or trap) automatically allocates a new register |
| 33 | frame; each return deallocates the current frame and restores the |
| 34 | windowed registers to their values before the call. |
| 35 | |
| 36 | When dumping core, the control stack is written to a core files as |
| 37 | a third segment. The core-handling functions need to know to deal |
| 38 | with it. */ |
| 39 | /* Tell core.c there is an extra segment. */ |
| 40 | #define REG_STACK_SEGMENT |
| 41 | |
| 42 | /* Floating point is IEEE compatible on most Pyramid hardware |
| 43 | (Older processors do not have IEEE NaNs). */ |
| 44 | #define IEEE_FLOAT |
| 45 | |
| 46 | /* Define this if the C compiler puts an underscore at the front |
| 47 | of external names before giving them to the linker. */ |
| 48 | |
| 49 | #define NAMES_HAVE_UNDERSCORE |
| 50 | |
| 51 | /* Offset from address of function to start of its code. |
| 52 | Zero on most machines. */ |
| 53 | |
| 54 | #define FUNCTION_START_OFFSET 0 |
| 55 | |
| 56 | /* Advance PC across any function entry prologue instructions |
| 57 | to reach some "real" code. */ |
| 58 | |
| 59 | /* FIXME -- do we want to skip insns to allocate the local frame? |
| 60 | If so, what do they look like? |
| 61 | This is becoming harder, since tege@sics.SE wants to change |
| 62 | gcc to not output a prologue when no frame is needed. */ |
| 63 | #define SKIP_PROLOGUE(pc) do {} while (0) |
| 64 | |
| 65 | |
| 66 | /* Immediately after a function call, return the saved pc. |
| 67 | Can't always go through the frames for this because on some machines |
| 68 | the new frame is not set up until the new function executes |
| 69 | some instructions. */ |
| 70 | |
| 71 | #define SAVED_PC_AFTER_CALL(frame) FRAME_SAVED_PC(frame) |
| 72 | |
| 73 | /* Address of end of stack space. */ |
| 74 | /* This seems to be right for the 90x comp.vuw.ac.nz. |
| 75 | The correct value at any site may be a function of the configured |
| 76 | maximum control stack depth. If so, I don't know where the |
| 77 | control-stack depth is configured, so I can't #include it here. */ |
| 78 | #define STACK_END_ADDR (0xc00cc000) |
| 79 | |
| 80 | /* Register window stack (Control stack) stack definitions |
| 81 | - Address of beginning of control stack. |
| 82 | - size of control stack frame |
| 83 | (Note that since crts0 is usually the first function called, |
| 84 | main()'s control stack is one frame (0x80 bytes) beyond this value. */ |
| 85 | |
| 86 | #define CONTROL_STACK_ADDR (0xc00cd000) |
| 87 | |
| 88 | /* Bytes in a register window -- 16 parameter regs, 16 local regs |
| 89 | for each call, is 32 regs * 4 bytes */ |
| 90 | |
| 91 | #define CONTROL_STACK_FRAME_SIZE (32*4) |
| 92 | |
| 93 | /* FIXME. On a pyr, Data Stack grows downward; control stack goes upwards. |
| 94 | Which direction should we use for INNER_THAN, PC_INNER_THAN ?? */ |
| 95 | |
| 96 | #define INNER_THAN < |
| 97 | #define PC_INNER_THAN > |
| 98 | |
| 99 | /* Stack has strict alignment. */ |
| 100 | |
| 101 | #define STACK_ALIGN(ADDR) (((ADDR)+3)&-4) |
| 102 | |
| 103 | /* Sequence of bytes for breakpoint instruction. */ |
| 104 | |
| 105 | #define BREAKPOINT {0xf0, 00, 00, 00} |
| 106 | |
| 107 | /* Amount PC must be decremented by after a breakpoint. |
| 108 | This is often the number of bytes in BREAKPOINT |
| 109 | but not always. */ |
| 110 | |
| 111 | #define DECR_PC_AFTER_BREAK 0 |
| 112 | |
| 113 | /* Nonzero if instruction at PC is a return instruction. |
| 114 | On a pyr, this is either "ret" or "retd". |
| 115 | It would be friendly to check that any "retd" always had an |
| 116 | argument of 0, since anything else is invalid. */ |
| 117 | |
| 118 | #define ABOUT_TO_RETURN(pc) \ |
| 119 | (((read_memory_integer (pc, 2) & 0x3ff0) == 0x3090) || \ |
| 120 | ((read_memory_integer (pc, 2) & 0x0ff0) == 0x00a0)) |
| 121 | |
| 122 | /* Return 1 if P points to an invalid floating point value. |
| 123 | LEN is the length in bytes -- not relevant on the Vax. */ |
| 124 | /* FIXME -- this is ok for a vax, bad for big-endian ieee format. |
| 125 | I would use the definition for a Sun; but it is no better! */ |
| 126 | |
| 127 | #define INVALID_FLOAT(p, len) ((*(short *) p & 0xff80) == 0x8000) |
| 128 | |
| 129 | /* Say how long (ordinary) registers are. */ |
| 130 | |
| 131 | #define REGISTER_TYPE long |
| 132 | |
| 133 | /* Number of machine registers */ |
| 134 | /* pyramids have 64, plus one for the PSW; plus perhaps one more for the |
| 135 | kernel stack pointer (ksp) and control-stack pointer (CSP) */ |
| 136 | |
| 137 | #define NUM_REGS 67 |
| 138 | |
| 139 | /* Initializer for an array of names of registers. |
| 140 | There should be NUM_REGS strings in this initializer. */ |
| 141 | |
| 142 | #define REGISTER_NAMES \ |
| 143 | {"gr0", "gr1", "gr2", "gr3", "gr4", "gr5", "gr6", "gr7", \ |
| 144 | "gr8", "gr9", "gr10", "gr11", "logpsw", "cfp", "sp", "pc", \ |
| 145 | "pr0", "pr1", "pr2", "pr3", "pr4", "pr5", "pr6", "pr7", \ |
| 146 | "pr8", "pr9", "pr10", "pr11", "pr12", "pr13", "pr14", "pr15", \ |
| 147 | "lr0", "lr1", "lr2", "lr3", "lr4", "lr5", "lr6", "lr7", \ |
| 148 | "lr8", "lr9", "lr10", "lr11", "lr12", "lr13", "lr14", "lr15", \ |
| 149 | "tr0", "tr1", "tr2", "tr3", "tr4", "tr5", "tr6", "tr7", \ |
| 150 | "tr8", "tr9", "tr10", "tr11", "tr12", "tr13", "tr14", "tr15", \ |
| 151 | "psw", "ksp", "csp"} |
| 152 | |
| 153 | /* Register numbers of various important registers. |
| 154 | Note that some of these values are "real" register numbers, |
| 155 | and correspond to the general registers of the machine, |
| 156 | and some are "phony" register numbers which are too large |
| 157 | to be actual register numbers as far as the user is concerned |
| 158 | but do serve to get the desired values when passed to read_register. */ |
| 159 | |
| 160 | /* pseudo-registers: */ |
| 161 | #define PS_REGNUM 64 /* Contains processor status */ |
| 162 | #define PSW_REGNUM 64 /* Contains current psw, whatever it is.*/ |
| 163 | #define CSP_REGNUM 65 /* address of this control stack frame*/ |
| 164 | #define KSP_REGNUM 66 /* Contains process's Kernel Stack Pointer */ |
| 165 | |
| 166 | #define CFP_REGNUM 13 /* Current data-stack frame ptr */ |
| 167 | #define TR0_REGNUM 48 /* After function call, contains |
| 168 | function result */ |
| 169 | |
| 170 | /* Registers interesting to the machine-independent part of gdb*/ |
| 171 | |
| 172 | #define FP_REGNUM CSP_REGNUM /* Contains address of executing (control) |
| 173 | stack frame */ |
| 174 | #define SP_REGNUM 14 /* Contains address of top of stack -??*/ |
| 175 | #define PC_REGNUM 15 /* Contains program counter */ |
| 176 | |
| 177 | /* Define DO_REGISTERS_INFO() to do machine-specific formatting |
| 178 | of register dumps. */ |
| 179 | |
| 180 | #define DO_REGISTERS_INFO(_regnum, fp) pyr_do_registers_info(_regnum, fp) |
| 181 | |
| 182 | /* need this so we can find the global registers: they never get saved. */ |
| 183 | extern unsigned int global_reg_offset; |
| 184 | extern unsigned int last_frame_offset; |
| 185 | |
| 186 | /* Total amount of space needed to store our copies of the machine's |
| 187 | register state, the array `registers'. */ |
| 188 | #define REGISTER_BYTES (NUM_REGS*4) |
| 189 | |
| 190 | /* the Pyramid has register windows. */ |
| 191 | |
| 192 | #define HAVE_REGISTER_WINDOWS |
| 193 | |
| 194 | /* Is this register part of the register window system? A yes answer |
| 195 | implies that 1) The name of this register will not be the same in |
| 196 | other frames, and 2) This register is automatically "saved" (out |
| 197 | registers shifting into ins counts) upon subroutine calls and thus |
| 198 | there is no need to search more than one stack frame for it. */ |
| 199 | |
| 200 | #define REGISTER_IN_WINDOW_P(regnum) \ |
| 201 | ((regnum) >= 16 && (regnum) < 64) |
| 202 | |
| 203 | /* Index within `registers' of the first byte of the space for |
| 204 | register N. */ |
| 205 | |
| 206 | #define REGISTER_BYTE(N) ((N) * 4) |
| 207 | |
| 208 | /* Number of bytes of storage in the actual machine representation |
| 209 | for register N. On the Pyramid, all regs are 4 bytes. */ |
| 210 | |
| 211 | #define REGISTER_RAW_SIZE(N) 4 |
| 212 | |
| 213 | /* Number of bytes of storage in the program's representation |
| 214 | for register N. On the Pyramid, all regs are 4 bytes. */ |
| 215 | |
| 216 | #define REGISTER_VIRTUAL_SIZE(N) 4 |
| 217 | |
| 218 | /* Largest value REGISTER_RAW_SIZE can have. */ |
| 219 | |
| 220 | #define MAX_REGISTER_RAW_SIZE 4 |
| 221 | |
| 222 | /* Largest value REGISTER_VIRTUAL_SIZE can have. */ |
| 223 | |
| 224 | #define MAX_REGISTER_VIRTUAL_SIZE 4 |
| 225 | |
| 226 | /* Nonzero if register N requires conversion |
| 227 | from raw format to virtual format. */ |
| 228 | |
| 229 | #define REGISTER_CONVERTIBLE(N) 0 |
| 230 | |
| 231 | /* Convert data from raw format for register REGNUM |
| 232 | to virtual format for register REGNUM. */ |
| 233 | |
| 234 | #define REGISTER_CONVERT_TO_VIRTUAL(REGNUM,FROM,TO) \ |
| 235 | bcopy ((FROM), (TO), 4); |
| 236 | |
| 237 | /* Convert data from virtual format for register REGNUM |
| 238 | to raw format for register REGNUM. */ |
| 239 | |
| 240 | #define REGISTER_CONVERT_TO_RAW(REGNUM,FROM,TO) \ |
| 241 | bcopy ((FROM), (TO), 4); |
| 242 | |
| 243 | /* Return the GDB type object for the "standard" data type |
| 244 | of data in register N. */ |
| 245 | |
| 246 | #define REGISTER_VIRTUAL_TYPE(N) builtin_type_int |
| 247 | |
| 248 | /* FIXME: It seems impossible for both EXTRACT_RETURN_VALUE and |
| 249 | STORE_RETURN_VALUE to be correct. */ |
| 250 | |
| 251 | /* Store the address of the place in which to copy the structure the |
| 252 | subroutine will return. This is called from call_function. */ |
| 253 | |
| 254 | /****FIXME****/ |
| 255 | #define STORE_STRUCT_RETURN(ADDR, SP) \ |
| 256 | { write_register (TR0_REGNUM, (ADDR)); } |
| 257 | |
| 258 | /* Extract from an array REGBUF containing the (raw) register state |
| 259 | a function return value of type TYPE, and copy that, in virtual format, |
| 260 | into VALBUF. */ |
| 261 | |
| 262 | /* Note that on a register-windowing machine (eg, Pyr, SPARC), this is |
| 263 | where the value is found after the function call -- ie, it should |
| 264 | correspond to GNU CC's FUNCTION_VALUE rather than FUNCTION_OUTGOING_VALUE.*/ |
| 265 | |
| 266 | #define EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \ |
| 267 | bcopy (((int *)(REGBUF))+TR0_REGNUM, VALBUF, TYPE_LENGTH (TYPE)) |
| 268 | |
| 269 | /* Write into appropriate registers a function return value |
| 270 | of type TYPE, given in virtual format. */ |
| 271 | /* on pyrs, values are returned in */ |
| 272 | |
| 273 | #define STORE_RETURN_VALUE(TYPE,VALBUF) \ |
| 274 | write_register_bytes (REGISTER_BYTE(TR0_REGNUM), VALBUF, TYPE_LENGTH (TYPE)) |
| 275 | |
| 276 | /* Extract from an array REGBUF containing the (raw) register state |
| 277 | the address in which a function should return its structure value, |
| 278 | as a CORE_ADDR (or an expression that can be used as one). */ |
| 279 | /* FIXME */ |
| 280 | #define EXTRACT_STRUCT_VALUE_ADDRESS(REGBUF) \ |
| 281 | ( ((int *)(REGBUF)) [TR0_REGNUM]) |
| 282 | |
| 283 | \f |
| 284 | /* Describe the pointer in each stack frame to the previous stack frame |
| 285 | (its caller). */ |
| 286 | |
| 287 | #define EXTRA_FRAME_INFO \ |
| 288 | FRAME_ADDR bottom; \ |
| 289 | CORE_ADDR frame_cfp; \ |
| 290 | CORE_ADDR frame_window_addr; |
| 291 | |
| 292 | #define INIT_EXTRA_FRAME_INFO(fromleaf, fci) \ |
| 293 | do { \ |
| 294 | (fci)->frame_window_addr = (fci)->frame; \ |
| 295 | (fci)->bottom = \ |
| 296 | ((fci)->next ? \ |
| 297 | ((fci)->frame == (fci)->next_frame ? \ |
| 298 | (fci)->next->bottom : (fci)->next->frame) : \ |
| 299 | read_register (SP_REGNUM)); \ |
| 300 | (fci)->frame_cfp = \ |
| 301 | read_register (CFP_REGNUM); \ |
| 302 | /***fprintf (stderr, \ |
| 303 | "[[creating new frame for %0x,pc=%0x,csp=%0x]]\n", \ |
| 304 | (fci)->frame, (fci)->pc,(fci)->frame_cfp);*/ \ |
| 305 | } while (0); |
| 306 | |
| 307 | /* FRAME_CHAIN takes a frame's nominal address |
| 308 | and produces the frame's chain-pointer. */ |
| 309 | |
| 310 | /* In the case of the pyr, the frame's nominal address is the address |
| 311 | of parameter register 0. The previous frame is found 32 words up. */ |
| 312 | |
| 313 | #define FRAME_CHAIN(thisframe) \ |
| 314 | ( (thisframe) -> frame - CONTROL_STACK_FRAME_SIZE) |
| 315 | |
| 316 | /*((thisframe) >= CONTROL_STACK_ADDR))*/ |
| 317 | |
| 318 | /* Define other aspects of the stack frame. */ |
| 319 | |
| 320 | /* A macro that tells us whether the function invocation represented |
| 321 | by FI does not have a frame on the stack associated with it. If it |
| 322 | does not, FRAMELESS is set to 1, else 0. |
| 323 | |
| 324 | I do not understand what this means on a Pyramid, where functions |
| 325 | *always* have a control-stack frame, but may or may not have a |
| 326 | frame on the data stack. Since GBD uses the value of the |
| 327 | control stack pointer as its "address" of a frame, FRAMELESS |
| 328 | is always 1, so does not need to be defined. */ |
| 329 | |
| 330 | |
| 331 | /* Where is the PC for a specific frame */ |
| 332 | |
| 333 | #define FRAME_SAVED_PC(fi) \ |
| 334 | ((CORE_ADDR) (read_memory_integer ( (fi) -> frame + 60, 4))) |
| 335 | |
| 336 | /* There may be bugs in FRAME_ARGS_ADDRESS and FRAME_LOCALS_ADDRESS; |
| 337 | or there may be bugs in accessing the registers that break |
| 338 | their definitions. |
| 339 | Having the macros expand into functions makes them easier to debug. |
| 340 | When the bug is finally located, the inline macro defintions can |
| 341 | be un-#if 0ed, and frame_args_addr and frame_locals_address can |
| 342 | be deleted from pyr-dep.c */ |
| 343 | |
| 344 | /* If the argument is on the stack, it will be here. */ |
| 345 | #define FRAME_ARGS_ADDRESS(fi) \ |
| 346 | frame_args_addr(fi) |
| 347 | |
| 348 | #define FRAME_LOCALS_ADDRESS(fi) \ |
| 349 | frame_locals_address(fi) |
| 350 | |
| 351 | /* The following definitions doesn't seem to work. |
| 352 | I don't understand why. */ |
| 353 | #if 0 |
| 354 | #define FRAME_ARGS_ADDRESS(fi) \ |
| 355 | /*(FRAME_FP(fi) + (13*4))*/ (read_register (CFP_REGNUM)) |
| 356 | |
| 357 | #define FRAME_LOCALS_ADDRESS(fi) \ |
| 358 | ((fi)->frame +(16*4)) |
| 359 | |
| 360 | #endif /* 0 */ |
| 361 | |
| 362 | /* Return number of args passed to a frame. |
| 363 | Can return -1, meaning no way to tell. */ |
| 364 | |
| 365 | #define FRAME_NUM_ARGS(val, fi) (val = -1) |
| 366 | |
| 367 | /* Return number of bytes at start of arglist that are not really args. */ |
| 368 | |
| 369 | #define FRAME_ARGS_SKIP 0 |
| 370 | |
| 371 | /* Put here the code to store, into a struct frame_saved_regs, |
| 372 | the addresses of the saved registers of frame described by FRAME_INFO. |
| 373 | This includes special registers such as pc and fp saved in special |
| 374 | ways in the stack frame. sp is even more special: |
| 375 | the address we return for it IS the sp for the next frame. |
| 376 | |
| 377 | Note that on register window machines, we are currently making the |
| 378 | assumption that window registers are being saved somewhere in the |
| 379 | frame in which they are being used. If they are stored in an |
| 380 | inferior frame, find_saved_register will break. |
| 381 | |
| 382 | On pyrs, frames of window registers are stored contiguously on a |
| 383 | separate stack. All window registers are always stored. |
| 384 | The pc and psw (gr15 and gr14) are also always saved: the call |
| 385 | insn saves them in pr15 and pr14 of the new frame (tr15,tr14 of the |
| 386 | old frame). |
| 387 | The data-stack frame pointer (CFP) is only saved in functions which |
| 388 | allocate a (data)stack frame (with "adsf"). We detect them by |
| 389 | looking at the first insn of the procedure. |
| 390 | |
| 391 | Other non-window registers (gr0-gr11) are never saved. Pyramid's C |
| 392 | compiler and gcc currently ignore them, so it's not an issue. */ |
| 393 | |
| 394 | #define FRAME_FIND_SAVED_REGS(fi_p, frame_saved_regs) \ |
| 395 | { register int regnum; \ |
| 396 | register CORE_ADDR pc; \ |
| 397 | register CORE_ADDR fn_start_pc; \ |
| 398 | register int first_insn; \ |
| 399 | register CORE_ADDR prev_cf_addr; \ |
| 400 | register int window_ptr; \ |
| 401 | FRAME fid = FRAME_INFO_ID (fi_p); \ |
| 402 | if (!fid) fatal ("Bad frame info struct in FRAME_FIND_SAVED_REGS"); \ |
| 403 | bzero (&(frame_saved_regs), sizeof (frame_saved_regs)); \ |
| 404 | \ |
| 405 | window_ptr = prev_cf_addr = FRAME_FP(fi_p); \ |
| 406 | \ |
| 407 | for (regnum = 16 ; regnum < 64; regnum++,window_ptr+=4) \ |
| 408 | { \ |
| 409 | (frame_saved_regs).regs[regnum] = window_ptr; \ |
| 410 | } \ |
| 411 | \ |
| 412 | /* In each window, psw, and pc are "saved" in tr14,tr15. */ \ |
| 413 | /*** psw is sometimes saved in gr12 (so sez <sys/pcb.h>) */ \ |
| 414 | (frame_saved_regs).regs[PS_REGNUM] = FRAME_FP(fi_p) + (14*4); \ |
| 415 | \ |
| 416 | /*(frame_saved_regs).regs[PC_REGNUM] = (frame_saved_regs).regs[31];*/ \ |
| 417 | (frame_saved_regs).regs[PC_REGNUM] = FRAME_FP(fi_p) + ((15+32)*4); \ |
| 418 | \ |
| 419 | /* Functions that allocate a frame save sp *where*? */ \ |
| 420 | /*first_insn = read_memory_integer (get_pc_function_start ((fi_p)->pc),4); */ \ |
| 421 | \ |
| 422 | fn_start_pc = (get_pc_function_start ((fi_p)->pc)); \ |
| 423 | first_insn = read_memory_integer(fn_start_pc, 4); \ |
| 424 | \ |
| 425 | if (0x08 == ((first_insn >> 20) &0x0ff)) { \ |
| 426 | /* NB: because WINDOW_REGISTER_P(cfp) is false, a saved cfp \ |
| 427 | in this frame is only visible in this frame's callers. \ |
| 428 | That means the cfp we mark saved is my caller's cfp, ie pr13. \ |
| 429 | I don't understand why we don't have to do that for pc, too. */ \ |
| 430 | \ |
| 431 | (frame_saved_regs).regs[CFP_REGNUM] = FRAME_FP(fi_p)+(13*4); \ |
| 432 | \ |
| 433 | (frame_saved_regs).regs[SP_REGNUM] = \ |
| 434 | read_memory_integer (FRAME_FP(fi_p)+((13+32)*4),4); \ |
| 435 | } \ |
| 436 | \ |
| 437 | /* \ |
| 438 | *(frame_saved_regs).regs[CFP_REGNUM] = (frame_saved_regs).regs[61]; \ |
| 439 | * (frame_saved_regs).regs[SP_REGNUM] = \ |
| 440 | * read_memory_integer (FRAME_FP(fi_p)+((13+32)*4),4); \ |
| 441 | */ \ |
| 442 | \ |
| 443 | (frame_saved_regs).regs[CSP_REGNUM] = prev_cf_addr; \ |
| 444 | } |
| 445 | \f |
| 446 | /* Things needed for making the inferior call functions. */ |
| 447 | #if 0 |
| 448 | /* These are all lies. These macro definitions are appropriate for a |
| 449 | SPARC. On a pyramid, pushing a dummy frame will |
| 450 | surely involve writing the control stack pointer, |
| 451 | then saving the pc. This requires a privileged instruction. |
| 452 | Maybe one day Pyramid can be persuaded to add a syscall to do this. |
| 453 | Until then, we are out of luck. */ |
| 454 | |
| 455 | /* Push an empty stack frame, to record the current PC, etc. */ |
| 456 | |
| 457 | #define PUSH_DUMMY_FRAME \ |
| 458 | { register CORE_ADDR sp = read_register (SP_REGNUM);\ |
| 459 | register int regnum; \ |
| 460 | sp = push_word (sp, 0); /* arglist */ \ |
| 461 | for (regnum = 11; regnum >= 0; regnum--) \ |
| 462 | sp = push_word (sp, read_register (regnum)); \ |
| 463 | sp = push_word (sp, read_register (PC_REGNUM)); \ |
| 464 | sp = push_word (sp, read_register (FP_REGNUM)); \ |
| 465 | /* sp = push_word (sp, read_register (AP_REGNUM));*/ \ |
| 466 | sp = push_word (sp, (read_register (PS_REGNUM) & 0xffef) \ |
| 467 | + 0x2fff0000); \ |
| 468 | sp = push_word (sp, 0); \ |
| 469 | write_register (SP_REGNUM, sp); \ |
| 470 | write_register (FP_REGNUM, sp); \ |
| 471 | /* write_register (AP_REGNUM, sp + 17 * sizeof (int));*/ } |
| 472 | |
| 473 | /* Discard from the stack the innermost frame, restoring all registers. */ |
| 474 | |
| 475 | #define POP_FRAME \ |
| 476 | { register CORE_ADDR fp = read_register (FP_REGNUM); \ |
| 477 | register int regnum; \ |
| 478 | register int regmask = read_memory_integer (fp + 4, 4); \ |
| 479 | write_register (PS_REGNUM, \ |
| 480 | (regmask & 0xffff) \ |
| 481 | | (read_register (PS_REGNUM) & 0xffff0000)); \ |
| 482 | write_register (PC_REGNUM, read_memory_integer (fp + 16, 4)); \ |
| 483 | write_register (FP_REGNUM, read_memory_integer (fp + 12, 4)); \ |
| 484 | /* write_register (AP_REGNUM, read_memory_integer (fp + 8, 4));*/ \ |
| 485 | fp += 16; \ |
| 486 | for (regnum = 0; regnum < 12; regnum++) \ |
| 487 | if (regmask & (0x10000 << regnum)) \ |
| 488 | write_register (regnum, read_memory_integer (fp += 4, 4)); \ |
| 489 | fp = fp + 4 + ((regmask >> 30) & 3); \ |
| 490 | if (regmask & 0x20000000) \ |
| 491 | { regnum = read_memory_integer (fp, 4); \ |
| 492 | fp += (regnum + 1) * 4; } \ |
| 493 | write_register (SP_REGNUM, fp); \ |
| 494 | set_current_frame (read_register (FP_REGNUM)); } |
| 495 | |
| 496 | /* This sequence of words is the instructions |
| 497 | calls #69, @#32323232 |
| 498 | bpt |
| 499 | Note this is 8 bytes. */ |
| 500 | |
| 501 | #define CALL_DUMMY {0x329f69fb, 0x03323232} |
| 502 | |
| 503 | #define CALL_DUMMY_START_OFFSET 0 /* Start execution at beginning of dummy */ |
| 504 | |
| 505 | /* Insert the specified number of args and function address |
| 506 | into a call sequence of the above form stored at DUMMYNAME. */ |
| 507 | |
| 508 | #define FIX_CALL_DUMMY(dummyname, pc, fun, nargs, args, type, gcc_p) \ |
| 509 | { *((char *) dummyname + 1) = nargs; \ |
| 510 | *(int *)((char *) dummyname + 3) = fun; } |
| 511 | #endif /* 0 */ |
| 512 | |
| 513 | #define POP_FRAME \ |
| 514 | { error ("The return command is not supported on this machine."); } |