projects / deliverable / binutils-gdb.git / blame
| Commit | Line | Data |
|---|---|---|
| 4d210288 AC |
1 | // OBSOLETE /* Target-machine dependent code for the Intel 960 |
| 2 | // OBSOLETE | |
| 3 | // OBSOLETE Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, | |
| 4 | // OBSOLETE 2001, 2002 Free Software Foundation, Inc. | |
| 5 | // OBSOLETE | |
| 6 | // OBSOLETE Contributed by Intel Corporation. | |
| 7 | // OBSOLETE examine_prologue and other parts contributed by Wind River Systems. | |
| 8 | // OBSOLETE | |
| 9 | // OBSOLETE This file is part of GDB. | |
| 10 | // OBSOLETE | |
| 11 | // OBSOLETE This program is free software; you can redistribute it and/or modify | |
| 12 | // OBSOLETE it under the terms of the GNU General Public License as published by | |
| 13 | // OBSOLETE the Free Software Foundation; either version 2 of the License, or | |
| 14 | // OBSOLETE (at your option) any later version. | |
| 15 | // OBSOLETE | |
| 16 | // OBSOLETE This program is distributed in the hope that it will be useful, | |
| 17 | // OBSOLETE but WITHOUT ANY WARRANTY; without even the implied warranty of | |
| 18 | // OBSOLETE MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
| 19 | // OBSOLETE GNU General Public License for more details. | |
| 20 | // OBSOLETE | |
| 21 | // OBSOLETE You should have received a copy of the GNU General Public License | |
| 22 | // OBSOLETE along with this program; if not, write to the Free Software | |
| 23 | // OBSOLETE Foundation, Inc., 59 Temple Place - Suite 330, | |
| 24 | // OBSOLETE Boston, MA 02111-1307, USA. */ | |
| 25 | // OBSOLETE | |
| 26 | // OBSOLETE #include "defs.h" | |
| 27 | // OBSOLETE #include "symtab.h" | |
| 28 | // OBSOLETE #include "value.h" | |
| 29 | // OBSOLETE #include "frame.h" | |
| 30 | // OBSOLETE #include "floatformat.h" | |
| 31 | // OBSOLETE #include "target.h" | |
| 32 | // OBSOLETE #include "gdbcore.h" | |
| 33 | // OBSOLETE #include "inferior.h" | |
| 34 | // OBSOLETE #include "regcache.h" | |
| 35 | // OBSOLETE #include "gdb_string.h" | |
| 36 | // OBSOLETE | |
| 37 | // OBSOLETE static CORE_ADDR next_insn (CORE_ADDR memaddr, | |
| 38 | // OBSOLETE unsigned int *pword1, unsigned int *pword2); | |
| 39 | // OBSOLETE | |
| 40 | // OBSOLETE struct type * | |
| 41 | // OBSOLETE i960_register_type (int regnum) | |
| 42 | // OBSOLETE { | |
| 43 | // OBSOLETE if (regnum < FP0_REGNUM) | |
| 44 | // OBSOLETE return builtin_type_int32; | |
| 45 | // OBSOLETE else | |
| 46 | // OBSOLETE return builtin_type_i960_ext; | |
| 47 | // OBSOLETE } | |
| 48 | // OBSOLETE | |
| 49 | // OBSOLETE | |
| 50 | // OBSOLETE /* Does the specified function use the "struct returning" convention | |
| 51 | // OBSOLETE or the "value returning" convention? The "value returning" convention | |
| 52 | // OBSOLETE almost invariably returns the entire value in registers. The | |
| 53 | // OBSOLETE "struct returning" convention often returns the entire value in | |
| 54 | // OBSOLETE memory, and passes a pointer (out of or into the function) saying | |
| 55 | // OBSOLETE where the value (is or should go). | |
| 56 | // OBSOLETE | |
| 57 | // OBSOLETE Since this sometimes depends on whether it was compiled with GCC, | |
| 58 | // OBSOLETE this is also an argument. This is used in call_function to build a | |
| 59 | // OBSOLETE stack, and in value_being_returned to print return values. | |
| 60 | // OBSOLETE | |
| 61 | // OBSOLETE On i960, a structure is returned in registers g0-g3, if it will fit. | |
| 62 | // OBSOLETE If it's more than 16 bytes long, g13 pointed to it on entry. */ | |
| 63 | // OBSOLETE | |
| 64 | // OBSOLETE int | |
| 65 | // OBSOLETE i960_use_struct_convention (int gcc_p, struct type *type) | |
| 66 | // OBSOLETE { | |
| 67 | // OBSOLETE return (TYPE_LENGTH (type) > 16); | |
| 68 | // OBSOLETE } | |
| 69 | // OBSOLETE | |
| 70 | // OBSOLETE /* gdb960 is always running on a non-960 host. Check its characteristics. | |
| 71 | // OBSOLETE This routine must be called as part of gdb initialization. */ | |
| 72 | // OBSOLETE | |
| 73 | // OBSOLETE static void | |
| 74 | // OBSOLETE check_host (void) | |
| 75 | // OBSOLETE { | |
| 76 | // OBSOLETE int i; | |
| 77 | // OBSOLETE | |
| 78 | // OBSOLETE static struct typestruct | |
| 79 | // OBSOLETE { | |
| 80 | // OBSOLETE int hostsize; /* Size of type on host */ | |
| 81 | // OBSOLETE int i960size; /* Size of type on i960 */ | |
| 82 | // OBSOLETE char *typename; /* Name of type, for error msg */ | |
| 83 | // OBSOLETE } | |
| 84 | // OBSOLETE types[] = | |
| 85 | // OBSOLETE { | |
| 86 | // OBSOLETE { | |
| 87 | // OBSOLETE sizeof (short), 2, "short" | |
| 88 | // OBSOLETE } | |
| 89 | // OBSOLETE , | |
| 90 | // OBSOLETE { | |
| 91 | // OBSOLETE sizeof (int), 4, "int" | |
| 92 | // OBSOLETE } | |
| 93 | // OBSOLETE , | |
| 94 | // OBSOLETE { | |
| 95 | // OBSOLETE sizeof (long), 4, "long" | |
| 96 | // OBSOLETE } | |
| 97 | // OBSOLETE , | |
| 98 | // OBSOLETE { | |
| 99 | // OBSOLETE sizeof (float), 4, "float" | |
| 100 | // OBSOLETE } | |
| 101 | // OBSOLETE , | |
| 102 | // OBSOLETE { | |
| 103 | // OBSOLETE sizeof (double), 8, "double" | |
| 104 | // OBSOLETE } | |
| 105 | // OBSOLETE , | |
| 106 | // OBSOLETE { | |
| 107 | // OBSOLETE sizeof (char *), 4, "pointer" | |
| 108 | // OBSOLETE } | |
| 109 | // OBSOLETE , | |
| 110 | // OBSOLETE }; | |
| 111 | // OBSOLETE #define TYPELEN (sizeof(types) / sizeof(struct typestruct)) | |
| 112 | // OBSOLETE | |
| 113 | // OBSOLETE /* Make sure that host type sizes are same as i960 | |
| 114 | // OBSOLETE */ | |
| 115 | // OBSOLETE for (i = 0; i < TYPELEN; i++) | |
| 116 | // OBSOLETE { | |
| 117 | // OBSOLETE if (types[i].hostsize != types[i].i960size) | |
| 118 | // OBSOLETE { | |
| 119 | // OBSOLETE printf_unfiltered ("sizeof(%s) != %d: PROCEED AT YOUR OWN RISK!\n", | |
| 120 | // OBSOLETE types[i].typename, types[i].i960size); | |
| 121 | // OBSOLETE } | |
| 122 | // OBSOLETE | |
| 123 | // OBSOLETE } | |
| 124 | // OBSOLETE } | |
| 125 | // OBSOLETE \f | |
| 126 | // OBSOLETE /* Is this register part of the register window system? A yes answer | |
| 127 | // OBSOLETE implies that 1) The name of this register will not be the same in | |
| 128 | // OBSOLETE other frames, and 2) This register is automatically "saved" upon | |
| 129 | // OBSOLETE subroutine calls and thus there is no need to search more than one | |
| 130 | // OBSOLETE stack frame for it. | |
| 131 | // OBSOLETE | |
| 132 | // OBSOLETE On the i960, in fact, the name of this register in another frame is | |
| 133 | // OBSOLETE "mud" -- there is no overlap between the windows. Each window is | |
| 134 | // OBSOLETE simply saved into the stack (true for our purposes, after having been | |
| 135 | // OBSOLETE flushed; normally they reside on-chip and are restored from on-chip | |
| 136 | // OBSOLETE without ever going to memory). */ | |
| 137 | // OBSOLETE | |
| 138 | // OBSOLETE static int | |
| 139 | // OBSOLETE register_in_window_p (int regnum) | |
| 140 | // OBSOLETE { | |
| 141 | // OBSOLETE return regnum <= R15_REGNUM; | |
| 142 | // OBSOLETE } | |
| 143 | // OBSOLETE | |
| 144 | // OBSOLETE /* i960_find_saved_register () | |
| 145 | // OBSOLETE | |
| 146 | // OBSOLETE Return the address in which frame FRAME's value of register REGNUM | |
| 147 | // OBSOLETE has been saved in memory. Or return zero if it has not been saved. | |
| 148 | // OBSOLETE If REGNUM specifies the SP, the value we return is actually the SP | |
| 149 | // OBSOLETE value, not an address where it was saved. */ | |
| 150 | // OBSOLETE | |
| 151 | // OBSOLETE static CORE_ADDR | |
| 152 | // OBSOLETE i960_find_saved_register (struct frame_info *frame, int regnum) | |
| 153 | // OBSOLETE { | |
| 154 | // OBSOLETE register struct frame_info *frame1 = NULL; | |
| 155 | // OBSOLETE register CORE_ADDR addr = 0; | |
| 156 | // OBSOLETE | |
| 157 | // OBSOLETE if (frame == NULL) /* No regs saved if want current frame */ | |
| 158 | // OBSOLETE return 0; | |
| 159 | // OBSOLETE | |
| 160 | // OBSOLETE /* We assume that a register in a register window will only be saved | |
| 161 | // OBSOLETE in one place (since the name changes and/or disappears as you go | |
| 162 | // OBSOLETE towards inner frames), so we only call get_frame_saved_regs on | |
| 163 | // OBSOLETE the current frame. This is directly in contradiction to the | |
| 164 | // OBSOLETE usage below, which assumes that registers used in a frame must be | |
| 165 | // OBSOLETE saved in a lower (more interior) frame. This change is a result | |
| 166 | // OBSOLETE of working on a register window machine; get_frame_saved_regs | |
| 167 | // OBSOLETE always returns the registers saved within a frame, within the | |
| 168 | // OBSOLETE context (register namespace) of that frame. */ | |
| 169 | // OBSOLETE | |
| 170 | // OBSOLETE /* However, note that we don't want this to return anything if | |
| 171 | // OBSOLETE nothing is saved (if there's a frame inside of this one). Also, | |
| 172 | // OBSOLETE callers to this routine asking for the stack pointer want the | |
| 173 | // OBSOLETE stack pointer saved for *this* frame; this is returned from the | |
| 174 | // OBSOLETE next frame. */ | |
| 175 | // OBSOLETE | |
| 176 | // OBSOLETE if (register_in_window_p (regnum)) | |
| 177 | // OBSOLETE { | |
| 178 | // OBSOLETE frame1 = get_next_frame (frame); | |
| 179 | // OBSOLETE if (!frame1) | |
| 180 | // OBSOLETE return 0; /* Registers of this frame are active. */ | |
| 181 | // OBSOLETE | |
| 182 | // OBSOLETE /* Get the SP from the next frame in; it will be this | |
| 183 | // OBSOLETE current frame. */ | |
| 184 | // OBSOLETE if (regnum != SP_REGNUM) | |
| 185 | // OBSOLETE frame1 = frame; | |
| 186 | // OBSOLETE | |
| 187 | // OBSOLETE FRAME_INIT_SAVED_REGS (frame1); | |
| 188 | // OBSOLETE return frame1->saved_regs[regnum]; /* ... which might be zero */ | |
| 189 | // OBSOLETE } | |
| 190 | // OBSOLETE | |
| 191 | // OBSOLETE /* Note that this next routine assumes that registers used in | |
| 192 | // OBSOLETE frame x will be saved only in the frame that x calls and | |
| 193 | // OBSOLETE frames interior to it. This is not true on the sparc, but the | |
| 194 | // OBSOLETE above macro takes care of it, so we should be all right. */ | |
| 195 | // OBSOLETE while (1) | |
| 196 | // OBSOLETE { | |
| 197 | // OBSOLETE QUIT; | |
| 198 | // OBSOLETE frame1 = get_next_frame (frame); | |
| 199 | // OBSOLETE if (frame1 == 0) | |
| 200 | // OBSOLETE break; | |
| 201 | // OBSOLETE frame = frame1; | |
| 202 | // OBSOLETE FRAME_INIT_SAVED_REGS (frame1); | |
| 203 | // OBSOLETE if (frame1->saved_regs[regnum]) | |
| 204 | // OBSOLETE addr = frame1->saved_regs[regnum]; | |
| 205 | // OBSOLETE } | |
| 206 | // OBSOLETE | |
| 207 | // OBSOLETE return addr; | |
| 208 | // OBSOLETE } | |
| 209 | // OBSOLETE | |
| 210 | // OBSOLETE /* i960_get_saved_register () | |
| 211 | // OBSOLETE | |
| 212 | // OBSOLETE Find register number REGNUM relative to FRAME and put its (raw, | |
| 213 | // OBSOLETE target format) contents in *RAW_BUFFER. Set *OPTIMIZED if the | |
| 214 | // OBSOLETE variable was optimized out (and thus can't be fetched). Set *LVAL | |
| 215 | // OBSOLETE to lval_memory, lval_register, or not_lval, depending on whether | |
| 216 | // OBSOLETE the value was fetched from memory, from a register, or in a strange | |
| 217 | // OBSOLETE and non-modifiable way (e.g. a frame pointer which was calculated | |
| 218 | // OBSOLETE rather than fetched). Set *ADDRP to the address, either in memory | |
| 219 | // OBSOLETE on as a REGISTER_BYTE offset into the registers array. | |
| 220 | // OBSOLETE | |
| 221 | // OBSOLETE Note that this implementation never sets *LVAL to not_lval. But it | |
| 222 | // OBSOLETE can be replaced by defining GET_SAVED_REGISTER and supplying your | |
| 223 | // OBSOLETE own. | |
| 224 | // OBSOLETE | |
| 225 | // OBSOLETE The argument RAW_BUFFER must point to aligned memory. */ | |
| 226 | // OBSOLETE | |
| 227 | // OBSOLETE void | |
| 228 | // OBSOLETE i960_get_saved_register (char *raw_buffer, | |
| 229 | // OBSOLETE int *optimized, | |
| 230 | // OBSOLETE CORE_ADDR *addrp, | |
| 231 | // OBSOLETE struct frame_info *frame, | |
| 232 | // OBSOLETE int regnum, | |
| 233 | // OBSOLETE enum lval_type *lval) | |
| 234 | // OBSOLETE { | |
| 235 | // OBSOLETE CORE_ADDR addr; | |
| 236 | // OBSOLETE | |
| 237 | // OBSOLETE if (!target_has_registers) | |
| 238 | // OBSOLETE error ("No registers."); | |
| 239 | // OBSOLETE | |
| 240 | // OBSOLETE /* Normal systems don't optimize out things with register numbers. */ | |
| 241 | // OBSOLETE if (optimized != NULL) | |
| 242 | // OBSOLETE *optimized = 0; | |
| 243 | // OBSOLETE addr = i960_find_saved_register (frame, regnum); | |
| 244 | // OBSOLETE if (addr != 0) | |
| 245 | // OBSOLETE { | |
| 246 | // OBSOLETE if (lval != NULL) | |
| 247 | // OBSOLETE *lval = lval_memory; | |
| 248 | // OBSOLETE if (regnum == SP_REGNUM) | |
| 249 | // OBSOLETE { | |
| 250 | // OBSOLETE if (raw_buffer != NULL) | |
| 251 | // OBSOLETE { | |
| 252 | // OBSOLETE /* Put it back in target format. */ | |
| 253 | // OBSOLETE store_address (raw_buffer, REGISTER_RAW_SIZE (regnum), | |
| 254 | // OBSOLETE (LONGEST) addr); | |
| 255 | // OBSOLETE } | |
| 256 | // OBSOLETE if (addrp != NULL) | |
| 257 | // OBSOLETE *addrp = 0; | |
| 258 | // OBSOLETE return; | |
| 259 | // OBSOLETE } | |
| 260 | // OBSOLETE if (raw_buffer != NULL) | |
| 261 | // OBSOLETE target_read_memory (addr, raw_buffer, REGISTER_RAW_SIZE (regnum)); | |
| 262 | // OBSOLETE } | |
| 263 | // OBSOLETE else | |
| 264 | // OBSOLETE { | |
| 265 | // OBSOLETE if (lval != NULL) | |
| 266 | // OBSOLETE *lval = lval_register; | |
| 267 | // OBSOLETE addr = REGISTER_BYTE (regnum); | |
| 268 | // OBSOLETE if (raw_buffer != NULL) | |
| 269 | // OBSOLETE read_register_gen (regnum, raw_buffer); | |
| 270 | // OBSOLETE } | |
| 271 | // OBSOLETE if (addrp != NULL) | |
| 272 | // OBSOLETE *addrp = addr; | |
| 273 | // OBSOLETE } | |
| 274 | // OBSOLETE \f | |
| 275 | // OBSOLETE /* Examine an i960 function prologue, recording the addresses at which | |
| 276 | // OBSOLETE registers are saved explicitly by the prologue code, and returning | |
| 277 | // OBSOLETE the address of the first instruction after the prologue (but not | |
| 278 | // OBSOLETE after the instruction at address LIMIT, as explained below). | |
| 279 | // OBSOLETE | |
| 280 | // OBSOLETE LIMIT places an upper bound on addresses of the instructions to be | |
| 281 | // OBSOLETE examined. If the prologue code scan reaches LIMIT, the scan is | |
| 282 | // OBSOLETE aborted and LIMIT is returned. This is used, when examining the | |
| 283 | // OBSOLETE prologue for the current frame, to keep examine_prologue () from | |
| 284 | // OBSOLETE claiming that a given register has been saved when in fact the | |
| 285 | // OBSOLETE instruction that saves it has not yet been executed. LIMIT is used | |
| 286 | // OBSOLETE at other times to stop the scan when we hit code after the true | |
| 287 | // OBSOLETE function prologue (e.g. for the first source line) which might | |
| 288 | // OBSOLETE otherwise be mistaken for function prologue. | |
| 289 | // OBSOLETE | |
| 290 | // OBSOLETE The format of the function prologue matched by this routine is | |
| 291 | // OBSOLETE derived from examination of the source to gcc960 1.21, particularly | |
| 292 | // OBSOLETE the routine i960_function_prologue (). A "regular expression" for | |
| 293 | // OBSOLETE the function prologue is given below: | |
| 294 | // OBSOLETE | |
| 295 | // OBSOLETE (lda LRn, g14 | |
| 296 | // OBSOLETE mov g14, g[0-7] | |
| 297 | // OBSOLETE (mov 0, g14) | (lda 0, g14))? | |
| 298 | // OBSOLETE | |
| 299 | // OBSOLETE (mov[qtl]? g[0-15], r[4-15])* | |
| 300 | // OBSOLETE ((addo [1-31], sp, sp) | (lda n(sp), sp))? | |
| 301 | // OBSOLETE (st[qtl]? g[0-15], n(fp))* | |
| 302 | // OBSOLETE | |
| 303 | // OBSOLETE (cmpobne 0, g14, LFn | |
| 304 | // OBSOLETE mov sp, g14 | |
| 305 | // OBSOLETE lda 0x30(sp), sp | |
| 306 | // OBSOLETE LFn: stq g0, (g14) | |
| 307 | // OBSOLETE stq g4, 0x10(g14) | |
| 308 | // OBSOLETE stq g8, 0x20(g14))? | |
| 309 | // OBSOLETE | |
| 310 | // OBSOLETE (st g14, n(fp))? | |
| 311 | // OBSOLETE (mov g13,r[4-15])? | |
| 312 | // OBSOLETE */ | |
| 313 | // OBSOLETE | |
| 314 | // OBSOLETE /* Macros for extracting fields from i960 instructions. */ | |
| 315 | // OBSOLETE | |
| 316 | // OBSOLETE #define BITMASK(pos, width) (((0x1 << (width)) - 1) << (pos)) | |
| 317 | // OBSOLETE #define EXTRACT_FIELD(val, pos, width) ((val) >> (pos) & BITMASK (0, width)) | |
| 318 | // OBSOLETE | |
| 319 | // OBSOLETE #define REG_SRC1(insn) EXTRACT_FIELD (insn, 0, 5) | |
| 320 | // OBSOLETE #define REG_SRC2(insn) EXTRACT_FIELD (insn, 14, 5) | |
| 321 | // OBSOLETE #define REG_SRCDST(insn) EXTRACT_FIELD (insn, 19, 5) | |
| 322 | // OBSOLETE #define MEM_SRCDST(insn) EXTRACT_FIELD (insn, 19, 5) | |
| 323 | // OBSOLETE #define MEMA_OFFSET(insn) EXTRACT_FIELD (insn, 0, 12) | |
| 324 | // OBSOLETE | |
| 325 | // OBSOLETE /* Fetch the instruction at ADDR, returning 0 if ADDR is beyond LIM or | |
| 326 | // OBSOLETE is not the address of a valid instruction, the address of the next | |
| 327 | // OBSOLETE instruction beyond ADDR otherwise. *PWORD1 receives the first word | |
| 328 | // OBSOLETE of the instruction, and (for two-word instructions), *PWORD2 receives | |
| 329 | // OBSOLETE the second. */ | |
| 330 | // OBSOLETE | |
| 331 | // OBSOLETE #define NEXT_PROLOGUE_INSN(addr, lim, pword1, pword2) \ | |
| 332 | // OBSOLETE (((addr) < (lim)) ? next_insn (addr, pword1, pword2) : 0) | |
| 333 | // OBSOLETE | |
| 334 | // OBSOLETE static CORE_ADDR | |
| 335 | // OBSOLETE examine_prologue (register CORE_ADDR ip, register CORE_ADDR limit, | |
| 336 | // OBSOLETE CORE_ADDR frame_addr, struct frame_saved_regs *fsr) | |
| 337 | // OBSOLETE { | |
| 338 | // OBSOLETE register CORE_ADDR next_ip; | |
| 339 | // OBSOLETE register int src, dst; | |
| 340 | // OBSOLETE register unsigned int *pcode; | |
| 341 | // OBSOLETE unsigned int insn1, insn2; | |
| 342 | // OBSOLETE int size; | |
| 343 | // OBSOLETE int within_leaf_prologue; | |
| 344 | // OBSOLETE CORE_ADDR save_addr; | |
| 345 | // OBSOLETE static unsigned int varargs_prologue_code[] = | |
| 346 | // OBSOLETE { | |
| 347 | // OBSOLETE 0x3507a00c, /* cmpobne 0x0, g14, LFn */ | |
| 348 | // OBSOLETE 0x5cf01601, /* mov sp, g14 */ | |
| 349 | // OBSOLETE 0x8c086030, /* lda 0x30(sp), sp */ | |
| 350 | // OBSOLETE 0xb2879000, /* LFn: stq g0, (g14) */ | |
| 351 | // OBSOLETE 0xb2a7a010, /* stq g4, 0x10(g14) */ | |
| 352 | // OBSOLETE 0xb2c7a020 /* stq g8, 0x20(g14) */ | |
| 353 | // OBSOLETE }; | |
| 354 | // OBSOLETE | |
| 355 | // OBSOLETE /* Accept a leaf procedure prologue code fragment if present. | |
| 356 | // OBSOLETE Note that ip might point to either the leaf or non-leaf | |
| 357 | // OBSOLETE entry point; we look for the non-leaf entry point first: */ | |
| 358 | // OBSOLETE | |
| 359 | // OBSOLETE within_leaf_prologue = 0; | |
| 360 | // OBSOLETE if ((next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn1, &insn2)) | |
| 361 | // OBSOLETE && ((insn1 & 0xfffff000) == 0x8cf00000 /* lda LRx, g14 (MEMA) */ | |
| 362 | // OBSOLETE || (insn1 & 0xfffffc60) == 0x8cf03000)) /* lda LRx, g14 (MEMB) */ | |
| 363 | // OBSOLETE { | |
| 364 | // OBSOLETE within_leaf_prologue = 1; | |
| 365 | // OBSOLETE next_ip = NEXT_PROLOGUE_INSN (next_ip, limit, &insn1, &insn2); | |
| 366 | // OBSOLETE } | |
| 367 | // OBSOLETE | |
| 368 | // OBSOLETE /* Now look for the prologue code at a leaf entry point: */ | |
| 369 | // OBSOLETE | |
| 370 | // OBSOLETE if (next_ip | |
| 371 | // OBSOLETE && (insn1 & 0xff87ffff) == 0x5c80161e /* mov g14, gx */ | |
| 372 | // OBSOLETE && REG_SRCDST (insn1) <= G0_REGNUM + 7) | |
| 373 | // OBSOLETE { | |
| 374 | // OBSOLETE within_leaf_prologue = 1; | |
| 375 | // OBSOLETE if ((next_ip = NEXT_PROLOGUE_INSN (next_ip, limit, &insn1, &insn2)) | |
| 376 | // OBSOLETE && (insn1 == 0x8cf00000 /* lda 0, g14 */ | |
| 377 | // OBSOLETE || insn1 == 0x5cf01e00)) /* mov 0, g14 */ | |
| 378 | // OBSOLETE { | |
| 379 | // OBSOLETE ip = next_ip; | |
| 380 | // OBSOLETE next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn1, &insn2); | |
| 381 | // OBSOLETE within_leaf_prologue = 0; | |
| 382 | // OBSOLETE } | |
| 383 | // OBSOLETE } | |
| 384 | // OBSOLETE | |
| 385 | // OBSOLETE /* If something that looks like the beginning of a leaf prologue | |
| 386 | // OBSOLETE has been seen, but the remainder of the prologue is missing, bail. | |
| 387 | // OBSOLETE We don't know what we've got. */ | |
| 388 | // OBSOLETE | |
| 389 | // OBSOLETE if (within_leaf_prologue) | |
| 390 | // OBSOLETE return (ip); | |
| 391 | // OBSOLETE | |
| 392 | // OBSOLETE /* Accept zero or more instances of "mov[qtl]? gx, ry", where y >= 4. | |
| 393 | // OBSOLETE This may cause us to mistake the moving of a register | |
| 394 | // OBSOLETE parameter to a local register for the saving of a callee-saved | |
| 395 | // OBSOLETE register, but that can't be helped, since with the | |
| 396 | // OBSOLETE "-fcall-saved" flag, any register can be made callee-saved. */ | |
| 397 | // OBSOLETE | |
| 398 | // OBSOLETE while (next_ip | |
| 399 | // OBSOLETE && (insn1 & 0xfc802fb0) == 0x5c000610 | |
| 400 | // OBSOLETE && (dst = REG_SRCDST (insn1)) >= (R0_REGNUM + 4)) | |
| 401 | // OBSOLETE { | |
| 402 | // OBSOLETE src = REG_SRC1 (insn1); | |
| 403 | // OBSOLETE size = EXTRACT_FIELD (insn1, 24, 2) + 1; | |
| 404 | // OBSOLETE save_addr = frame_addr + ((dst - R0_REGNUM) * 4); | |
| 405 | // OBSOLETE while (size--) | |
| 406 | // OBSOLETE { | |
| 407 | // OBSOLETE fsr->regs[src++] = save_addr; | |
| 408 | // OBSOLETE save_addr += 4; | |
| 409 | // OBSOLETE } | |
| 410 | // OBSOLETE ip = next_ip; | |
| 411 | // OBSOLETE next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn1, &insn2); | |
| 412 | // OBSOLETE } | |
| 413 | // OBSOLETE | |
| 414 | // OBSOLETE /* Accept an optional "addo n, sp, sp" or "lda n(sp), sp". */ | |
| 415 | // OBSOLETE | |
| 416 | // OBSOLETE if (next_ip && | |
| 417 | // OBSOLETE ((insn1 & 0xffffffe0) == 0x59084800 /* addo n, sp, sp */ | |
| 418 | // OBSOLETE || (insn1 & 0xfffff000) == 0x8c086000 /* lda n(sp), sp (MEMA) */ | |
| 419 | // OBSOLETE || (insn1 & 0xfffffc60) == 0x8c087400)) /* lda n(sp), sp (MEMB) */ | |
| 420 | // OBSOLETE { | |
| 421 | // OBSOLETE ip = next_ip; | |
| 422 | // OBSOLETE next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn1, &insn2); | |
| 423 | // OBSOLETE } | |
| 424 | // OBSOLETE | |
| 425 | // OBSOLETE /* Accept zero or more instances of "st[qtl]? gx, n(fp)". | |
| 426 | // OBSOLETE This may cause us to mistake the copying of a register | |
| 427 | // OBSOLETE parameter to the frame for the saving of a callee-saved | |
| 428 | // OBSOLETE register, but that can't be helped, since with the | |
| 429 | // OBSOLETE "-fcall-saved" flag, any register can be made callee-saved. | |
| 430 | // OBSOLETE We can, however, refuse to accept a save of register g14, | |
| 431 | // OBSOLETE since that is matched explicitly below. */ | |
| 432 | // OBSOLETE | |
| 433 | // OBSOLETE while (next_ip && | |
| 434 | // OBSOLETE ((insn1 & 0xf787f000) == 0x9287e000 /* stl? gx, n(fp) (MEMA) */ | |
| 435 | // OBSOLETE || (insn1 & 0xf787fc60) == 0x9287f400 /* stl? gx, n(fp) (MEMB) */ | |
| 436 | // OBSOLETE || (insn1 & 0xef87f000) == 0xa287e000 /* st[tq] gx, n(fp) (MEMA) */ | |
| 437 | // OBSOLETE || (insn1 & 0xef87fc60) == 0xa287f400) /* st[tq] gx, n(fp) (MEMB) */ | |
| 438 | // OBSOLETE && ((src = MEM_SRCDST (insn1)) != G14_REGNUM)) | |
| 439 | // OBSOLETE { | |
| 440 | // OBSOLETE save_addr = frame_addr + ((insn1 & BITMASK (12, 1)) | |
| 441 | // OBSOLETE ? insn2 : MEMA_OFFSET (insn1)); | |
| 442 | // OBSOLETE size = (insn1 & BITMASK (29, 1)) ? ((insn1 & BITMASK (28, 1)) ? 4 : 3) | |
| 443 | // OBSOLETE : ((insn1 & BITMASK (27, 1)) ? 2 : 1); | |
| 444 | // OBSOLETE while (size--) | |
| 445 | // OBSOLETE { | |
| 446 | // OBSOLETE fsr->regs[src++] = save_addr; | |
| 447 | // OBSOLETE save_addr += 4; | |
| 448 | // OBSOLETE } | |
| 449 | // OBSOLETE ip = next_ip; | |
| 450 | // OBSOLETE next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn1, &insn2); | |
| 451 | // OBSOLETE } | |
| 452 | // OBSOLETE | |
| 453 | // OBSOLETE /* Accept the varargs prologue code if present. */ | |
| 454 | // OBSOLETE | |
| 455 | // OBSOLETE size = sizeof (varargs_prologue_code) / sizeof (int); | |
| 456 | // OBSOLETE pcode = varargs_prologue_code; | |
| 457 | // OBSOLETE while (size-- && next_ip && *pcode++ == insn1) | |
| 458 | // OBSOLETE { | |
| 459 | // OBSOLETE ip = next_ip; | |
| 460 | // OBSOLETE next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn1, &insn2); | |
| 461 | // OBSOLETE } | |
| 462 | // OBSOLETE | |
| 463 | // OBSOLETE /* Accept an optional "st g14, n(fp)". */ | |
| 464 | // OBSOLETE | |
| 465 | // OBSOLETE if (next_ip && | |
| 466 | // OBSOLETE ((insn1 & 0xfffff000) == 0x92f7e000 /* st g14, n(fp) (MEMA) */ | |
| 467 | // OBSOLETE || (insn1 & 0xfffffc60) == 0x92f7f400)) /* st g14, n(fp) (MEMB) */ | |
| 468 | // OBSOLETE { | |
| 469 | // OBSOLETE fsr->regs[G14_REGNUM] = frame_addr + ((insn1 & BITMASK (12, 1)) | |
| 470 | // OBSOLETE ? insn2 : MEMA_OFFSET (insn1)); | |
| 471 | // OBSOLETE ip = next_ip; | |
| 472 | // OBSOLETE next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn1, &insn2); | |
| 473 | // OBSOLETE } | |
| 474 | // OBSOLETE | |
| 475 | // OBSOLETE /* Accept zero or one instance of "mov g13, ry", where y >= 4. | |
| 476 | // OBSOLETE This is saving the address where a struct should be returned. */ | |
| 477 | // OBSOLETE | |
| 478 | // OBSOLETE if (next_ip | |
| 479 | // OBSOLETE && (insn1 & 0xff802fbf) == 0x5c00061d | |
| 480 | // OBSOLETE && (dst = REG_SRCDST (insn1)) >= (R0_REGNUM + 4)) | |
| 481 | // OBSOLETE { | |
| 482 | // OBSOLETE save_addr = frame_addr + ((dst - R0_REGNUM) * 4); | |
| 483 | // OBSOLETE fsr->regs[G0_REGNUM + 13] = save_addr; | |
| 484 | // OBSOLETE ip = next_ip; | |
| 485 | // OBSOLETE #if 0 /* We'll need this once there is a subsequent instruction examined. */ | |
| 486 | // OBSOLETE next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn1, &insn2); | |
| 487 | // OBSOLETE #endif | |
| 488 | // OBSOLETE } | |
| 489 | // OBSOLETE | |
| 490 | // OBSOLETE return (ip); | |
| 491 | // OBSOLETE } | |
| 492 | // OBSOLETE | |
| 493 | // OBSOLETE /* Given an ip value corresponding to the start of a function, | |
| 494 | // OBSOLETE return the ip of the first instruction after the function | |
| 495 | // OBSOLETE prologue. */ | |
| 496 | // OBSOLETE | |
| 497 | // OBSOLETE CORE_ADDR | |
| 498 | // OBSOLETE i960_skip_prologue (CORE_ADDR ip) | |
| 499 | // OBSOLETE { | |
| 500 | // OBSOLETE struct frame_saved_regs saved_regs_dummy; | |
| 501 | // OBSOLETE struct symtab_and_line sal; | |
| 502 | // OBSOLETE CORE_ADDR limit; | |
| 503 | // OBSOLETE | |
| 504 | // OBSOLETE sal = find_pc_line (ip, 0); | |
| 505 | // OBSOLETE limit = (sal.end) ? sal.end : 0xffffffff; | |
| 506 | // OBSOLETE | |
| 507 | // OBSOLETE return (examine_prologue (ip, limit, (CORE_ADDR) 0, &saved_regs_dummy)); | |
| 508 | // OBSOLETE } | |
| 509 | // OBSOLETE | |
| 510 | // OBSOLETE /* Put here the code to store, into a struct frame_saved_regs, | |
| 511 | // OBSOLETE the addresses of the saved registers of frame described by FRAME_INFO. | |
| 512 | // OBSOLETE This includes special registers such as pc and fp saved in special | |
| 513 | // OBSOLETE ways in the stack frame. sp is even more special: | |
| 514 | // OBSOLETE the address we return for it IS the sp for the next frame. | |
| 515 | // OBSOLETE | |
| 516 | // OBSOLETE We cache the result of doing this in the frame_obstack, since it is | |
| 517 | // OBSOLETE fairly expensive. */ | |
| 518 | // OBSOLETE | |
| 519 | // OBSOLETE void | |
| 520 | // OBSOLETE frame_find_saved_regs (struct frame_info *fi, struct frame_saved_regs *fsr) | |
| 521 | // OBSOLETE { | |
| 522 | // OBSOLETE register CORE_ADDR next_addr; | |
| 523 | // OBSOLETE register CORE_ADDR *saved_regs; | |
| 524 | // OBSOLETE register int regnum; | |
| 525 | // OBSOLETE register struct frame_saved_regs *cache_fsr; | |
| 526 | // OBSOLETE CORE_ADDR ip; | |
| 527 | // OBSOLETE struct symtab_and_line sal; | |
| 528 | // OBSOLETE CORE_ADDR limit; | |
| 529 | // OBSOLETE | |
| 530 | // OBSOLETE if (!fi->fsr) | |
| 531 | // OBSOLETE { | |
| 532 | // OBSOLETE cache_fsr = (struct frame_saved_regs *) | |
| 533 | // OBSOLETE frame_obstack_alloc (sizeof (struct frame_saved_regs)); | |
| 534 | // OBSOLETE memset (cache_fsr, '\0', sizeof (struct frame_saved_regs)); | |
| 535 | // OBSOLETE fi->fsr = cache_fsr; | |
| 536 | // OBSOLETE | |
| 537 | // OBSOLETE /* Find the start and end of the function prologue. If the PC | |
| 538 | // OBSOLETE is in the function prologue, we only consider the part that | |
| 539 | // OBSOLETE has executed already. */ | |
| 540 | // OBSOLETE | |
| 541 | // OBSOLETE ip = get_pc_function_start (fi->pc); | |
| 542 | // OBSOLETE sal = find_pc_line (ip, 0); | |
| 543 | // OBSOLETE limit = (sal.end && sal.end < fi->pc) ? sal.end : fi->pc; | |
| 544 | // OBSOLETE | |
| 545 | // OBSOLETE examine_prologue (ip, limit, fi->frame, cache_fsr); | |
| 546 | // OBSOLETE | |
| 547 | // OBSOLETE /* Record the addresses at which the local registers are saved. | |
| 548 | // OBSOLETE Strictly speaking, we should only do this for non-leaf procedures, | |
| 549 | // OBSOLETE but no one will ever look at these values if it is a leaf procedure, | |
| 550 | // OBSOLETE since local registers are always caller-saved. */ | |
| 551 | // OBSOLETE | |
| 552 | // OBSOLETE next_addr = (CORE_ADDR) fi->frame; | |
| 553 | // OBSOLETE saved_regs = cache_fsr->regs; | |
| 554 | // OBSOLETE for (regnum = R0_REGNUM; regnum <= R15_REGNUM; regnum++) | |
| 555 | // OBSOLETE { | |
| 556 | // OBSOLETE *saved_regs++ = next_addr; | |
| 557 | // OBSOLETE next_addr += 4; | |
| 558 | // OBSOLETE } | |
| 559 | // OBSOLETE | |
| 560 | // OBSOLETE cache_fsr->regs[FP_REGNUM] = cache_fsr->regs[PFP_REGNUM]; | |
| 561 | // OBSOLETE } | |
| 562 | // OBSOLETE | |
| 563 | // OBSOLETE *fsr = *fi->fsr; | |
| 564 | // OBSOLETE | |
| 565 | // OBSOLETE /* Fetch the value of the sp from memory every time, since it | |
| 566 | // OBSOLETE is conceivable that it has changed since the cache was flushed. | |
| 567 | // OBSOLETE This unfortunately undoes much of the savings from caching the | |
| 568 | // OBSOLETE saved register values. I suggest adding an argument to | |
| 569 | // OBSOLETE get_frame_saved_regs () specifying the register number we're | |
| 570 | // OBSOLETE interested in (or -1 for all registers). This would be passed | |
| 571 | // OBSOLETE through to FRAME_FIND_SAVED_REGS (), permitting more efficient | |
| 572 | // OBSOLETE computation of saved register addresses (e.g., on the i960, | |
| 573 | // OBSOLETE we don't have to examine the prologue to find local registers). | |
| 574 | // OBSOLETE -- markf@wrs.com | |
| 575 | // OBSOLETE FIXME, we don't need to refetch this, since the cache is cleared | |
| 576 | // OBSOLETE every time the child process is restarted. If GDB itself | |
| 577 | // OBSOLETE modifies SP, it has to clear the cache by hand (does it?). -gnu */ | |
| 578 | // OBSOLETE | |
| 579 | // OBSOLETE fsr->regs[SP_REGNUM] = read_memory_integer (fsr->regs[SP_REGNUM], 4); | |
| 580 | // OBSOLETE } | |
| 581 | // OBSOLETE | |
| 582 | // OBSOLETE /* Return the address of the argument block for the frame | |
| 583 | // OBSOLETE described by FI. Returns 0 if the address is unknown. */ | |
| 584 | // OBSOLETE | |
| 585 | // OBSOLETE CORE_ADDR | |
| 586 | // OBSOLETE frame_args_address (struct frame_info *fi, int must_be_correct) | |
| 587 | // OBSOLETE { | |
| 588 | // OBSOLETE struct frame_saved_regs fsr; | |
| 589 | // OBSOLETE CORE_ADDR ap; | |
| 590 | // OBSOLETE | |
| 591 | // OBSOLETE /* If g14 was saved in the frame by the function prologue code, return | |
| 592 | // OBSOLETE the saved value. If the frame is current and we are being sloppy, | |
| 593 | // OBSOLETE return the value of g14. Otherwise, return zero. */ | |
| 594 | // OBSOLETE | |
| 595 | // OBSOLETE get_frame_saved_regs (fi, &fsr); | |
| 596 | // OBSOLETE if (fsr.regs[G14_REGNUM]) | |
| 597 | // OBSOLETE ap = read_memory_integer (fsr.regs[G14_REGNUM], 4); | |
| 598 | // OBSOLETE else | |
| 599 | // OBSOLETE { | |
| 600 | // OBSOLETE if (must_be_correct) | |
| 601 | // OBSOLETE return 0; /* Don't cache this result */ | |
| 602 | // OBSOLETE if (get_next_frame (fi)) | |
| 603 | // OBSOLETE ap = 0; | |
| 604 | // OBSOLETE else | |
| 605 | // OBSOLETE ap = read_register (G14_REGNUM); | |
| 606 | // OBSOLETE if (ap == 0) | |
| 607 | // OBSOLETE ap = fi->frame; | |
| 608 | // OBSOLETE } | |
| 609 | // OBSOLETE fi->arg_pointer = ap; /* Cache it for next time */ | |
| 610 | // OBSOLETE return ap; | |
| 611 | // OBSOLETE } | |
| 612 | // OBSOLETE | |
| 613 | // OBSOLETE /* Return the address of the return struct for the frame | |
| 614 | // OBSOLETE described by FI. Returns 0 if the address is unknown. */ | |
| 615 | // OBSOLETE | |
| 616 | // OBSOLETE CORE_ADDR | |
| 617 | // OBSOLETE frame_struct_result_address (struct frame_info *fi) | |
| 618 | // OBSOLETE { | |
| 619 | // OBSOLETE struct frame_saved_regs fsr; | |
| 620 | // OBSOLETE CORE_ADDR ap; | |
| 621 | // OBSOLETE | |
| 622 | // OBSOLETE /* If the frame is non-current, check to see if g14 was saved in the | |
| 623 | // OBSOLETE frame by the function prologue code; return the saved value if so, | |
| 624 | // OBSOLETE zero otherwise. If the frame is current, return the value of g14. | |
| 625 | // OBSOLETE | |
| 626 | // OBSOLETE FIXME, shouldn't this use the saved value as long as we are past | |
| 627 | // OBSOLETE the function prologue, and only use the current value if we have | |
| 628 | // OBSOLETE no saved value and are at TOS? -- gnu@cygnus.com */ | |
| 629 | // OBSOLETE | |
| 630 | // OBSOLETE if (get_next_frame (fi)) | |
| 631 | // OBSOLETE { | |
| 632 | // OBSOLETE get_frame_saved_regs (fi, &fsr); | |
| 633 | // OBSOLETE if (fsr.regs[G13_REGNUM]) | |
| 634 | // OBSOLETE ap = read_memory_integer (fsr.regs[G13_REGNUM], 4); | |
| 635 | // OBSOLETE else | |
| 636 | // OBSOLETE ap = 0; | |
| 637 | // OBSOLETE } | |
| 638 | // OBSOLETE else | |
| 639 | // OBSOLETE ap = read_register (G13_REGNUM); | |
| 640 | // OBSOLETE | |
| 641 | // OBSOLETE return ap; | |
| 642 | // OBSOLETE } | |
| 643 | // OBSOLETE | |
| 644 | // OBSOLETE /* Return address to which the currently executing leafproc will return, | |
| 645 | // OBSOLETE or 0 if IP, the value of the instruction pointer from the currently | |
| 646 | // OBSOLETE executing function, is not in a leafproc (or if we can't tell if it | |
| 647 | // OBSOLETE is). | |
| 648 | // OBSOLETE | |
| 649 | // OBSOLETE Do this by finding the starting address of the routine in which IP lies. | |
| 650 | // OBSOLETE If the instruction there is "mov g14, gx" (where x is in [0,7]), this | |
| 651 | // OBSOLETE is a leafproc and the return address is in register gx. Well, this is | |
| 652 | // OBSOLETE true unless the return address points at a RET instruction in the current | |
| 653 | // OBSOLETE procedure, which indicates that we have a 'dual entry' routine that | |
| 654 | // OBSOLETE has been entered through the CALL entry point. */ | |
| 655 | // OBSOLETE | |
| 656 | // OBSOLETE CORE_ADDR | |
| 657 | // OBSOLETE leafproc_return (CORE_ADDR ip) | |
| 658 | // OBSOLETE { | |
| 659 | // OBSOLETE register struct minimal_symbol *msymbol; | |
| 660 | // OBSOLETE char *p; | |
| 661 | // OBSOLETE int dst; | |
| 662 | // OBSOLETE unsigned int insn1, insn2; | |
| 663 | // OBSOLETE CORE_ADDR return_addr; | |
| 664 | // OBSOLETE | |
| 665 | // OBSOLETE if ((msymbol = lookup_minimal_symbol_by_pc (ip)) != NULL) | |
| 666 | // OBSOLETE { | |
| 667 | // OBSOLETE if ((p = strchr (SYMBOL_NAME (msymbol), '.')) && STREQ (p, ".lf")) | |
| 668 | // OBSOLETE { | |
| 669 | // OBSOLETE if (next_insn (SYMBOL_VALUE_ADDRESS (msymbol), &insn1, &insn2) | |
| 670 | // OBSOLETE && (insn1 & 0xff87ffff) == 0x5c80161e /* mov g14, gx */ | |
| 671 | // OBSOLETE && (dst = REG_SRCDST (insn1)) <= G0_REGNUM + 7) | |
| 672 | // OBSOLETE { | |
| 673 | // OBSOLETE /* Get the return address. If the "mov g14, gx" | |
| 674 | // OBSOLETE instruction hasn't been executed yet, read | |
| 675 | // OBSOLETE the return address from g14; otherwise, read it | |
| 676 | // OBSOLETE from the register into which g14 was moved. */ | |
| 677 | // OBSOLETE | |
| 678 | // OBSOLETE return_addr = | |
| 679 | // OBSOLETE read_register ((ip == SYMBOL_VALUE_ADDRESS (msymbol)) | |
| 680 | // OBSOLETE ? G14_REGNUM : dst); | |
| 681 | // OBSOLETE | |
| 682 | // OBSOLETE /* We know we are in a leaf procedure, but we don't know | |
| 683 | // OBSOLETE whether the caller actually did a "bal" to the ".lf" | |
| 684 | // OBSOLETE entry point, or a normal "call" to the non-leaf entry | |
| 685 | // OBSOLETE point one instruction before. In the latter case, the | |
| 686 | // OBSOLETE return address will be the address of a "ret" | |
| 687 | // OBSOLETE instruction within the procedure itself. We test for | |
| 688 | // OBSOLETE this below. */ | |
| 689 | // OBSOLETE | |
| 690 | // OBSOLETE if (!next_insn (return_addr, &insn1, &insn2) | |
| 691 | // OBSOLETE || (insn1 & 0xff000000) != 0xa000000 /* ret */ | |
| 692 | // OBSOLETE || lookup_minimal_symbol_by_pc (return_addr) != msymbol) | |
| 693 | // OBSOLETE return (return_addr); | |
| 694 | // OBSOLETE } | |
| 695 | // OBSOLETE } | |
| 696 | // OBSOLETE } | |
| 697 | // OBSOLETE | |
| 698 | // OBSOLETE return (0); | |
| 699 | // OBSOLETE } | |
| 700 | // OBSOLETE | |
| 701 | // OBSOLETE /* Immediately after a function call, return the saved pc. | |
| 702 | // OBSOLETE Can't go through the frames for this because on some machines | |
| 703 | // OBSOLETE the new frame is not set up until the new function executes | |
| 704 | // OBSOLETE some instructions. | |
| 705 | // OBSOLETE On the i960, the frame *is* set up immediately after the call, | |
| 706 | // OBSOLETE unless the function is a leaf procedure. */ | |
| 707 | // OBSOLETE | |
| 708 | // OBSOLETE CORE_ADDR | |
| 709 | // OBSOLETE saved_pc_after_call (struct frame_info *frame) | |
| 710 | // OBSOLETE { | |
| 711 | // OBSOLETE CORE_ADDR saved_pc; | |
| 712 | // OBSOLETE | |
| 713 | // OBSOLETE saved_pc = leafproc_return (get_frame_pc (frame)); | |
| 714 | // OBSOLETE if (!saved_pc) | |
| 715 | // OBSOLETE saved_pc = FRAME_SAVED_PC (frame); | |
| 716 | // OBSOLETE | |
| 717 | // OBSOLETE return saved_pc; | |
| 718 | // OBSOLETE } | |
| 719 | // OBSOLETE | |
| 720 | // OBSOLETE /* Discard from the stack the innermost frame, | |
| 721 | // OBSOLETE restoring all saved registers. */ | |
| 722 | // OBSOLETE | |
| 723 | // OBSOLETE void | |
| 724 | // OBSOLETE i960_pop_frame (void) | |
| 725 | // OBSOLETE { | |
| 726 | // OBSOLETE register struct frame_info *current_fi, *prev_fi; | |
| 727 | // OBSOLETE register int i; | |
| 728 | // OBSOLETE CORE_ADDR save_addr; | |
| 729 | // OBSOLETE CORE_ADDR leaf_return_addr; | |
| 730 | // OBSOLETE struct frame_saved_regs fsr; | |
| 731 | // OBSOLETE char local_regs_buf[16 * 4]; | |
| 732 | // OBSOLETE | |
| 733 | // OBSOLETE current_fi = get_current_frame (); | |
| 734 | // OBSOLETE | |
| 735 | // OBSOLETE /* First, undo what the hardware does when we return. | |
| 736 | // OBSOLETE If this is a non-leaf procedure, restore local registers from | |
| 737 | // OBSOLETE the save area in the calling frame. Otherwise, load the return | |
| 738 | // OBSOLETE address obtained from leafproc_return () into the rip. */ | |
| 739 | // OBSOLETE | |
| 740 | // OBSOLETE leaf_return_addr = leafproc_return (current_fi->pc); | |
| 741 | // OBSOLETE if (!leaf_return_addr) | |
| 742 | // OBSOLETE { | |
| 743 | // OBSOLETE /* Non-leaf procedure. Restore local registers, incl IP. */ | |
| 744 | // OBSOLETE prev_fi = get_prev_frame (current_fi); | |
| 745 | // OBSOLETE read_memory (prev_fi->frame, local_regs_buf, sizeof (local_regs_buf)); | |
| 746 | // OBSOLETE write_register_bytes (REGISTER_BYTE (R0_REGNUM), local_regs_buf, | |
| 747 | // OBSOLETE sizeof (local_regs_buf)); | |
| 748 | // OBSOLETE | |
| 749 | // OBSOLETE /* Restore frame pointer. */ | |
| 750 | // OBSOLETE write_register (FP_REGNUM, prev_fi->frame); | |
| 751 | // OBSOLETE } | |
| 752 | // OBSOLETE else | |
| 753 | // OBSOLETE { | |
| 754 | // OBSOLETE /* Leaf procedure. Just restore the return address into the IP. */ | |
| 755 | // OBSOLETE write_register (RIP_REGNUM, leaf_return_addr); | |
| 756 | // OBSOLETE } | |
| 757 | // OBSOLETE | |
| 758 | // OBSOLETE /* Now restore any global regs that the current function had saved. */ | |
| 759 | // OBSOLETE get_frame_saved_regs (current_fi, &fsr); | |
| 760 | // OBSOLETE for (i = G0_REGNUM; i < G14_REGNUM; i++) | |
| 761 | // OBSOLETE { | |
| 762 | // OBSOLETE save_addr = fsr.regs[i]; | |
| 763 | // OBSOLETE if (save_addr != 0) | |
| 764 | // OBSOLETE write_register (i, read_memory_integer (save_addr, 4)); | |
| 765 | // OBSOLETE } | |
| 766 | // OBSOLETE | |
| 767 | // OBSOLETE /* Flush the frame cache, create a frame for the new innermost frame, | |
| 768 | // OBSOLETE and make it the current frame. */ | |
| 769 | // OBSOLETE | |
| 770 | // OBSOLETE flush_cached_frames (); | |
| 771 | // OBSOLETE } | |
| 772 | // OBSOLETE | |
| 773 | // OBSOLETE /* Given a 960 stop code (fault or trace), return the signal which | |
| 774 | // OBSOLETE corresponds. */ | |
| 775 | // OBSOLETE | |
| 776 | // OBSOLETE enum target_signal | |
| 777 | // OBSOLETE i960_fault_to_signal (int fault) | |
| 778 | // OBSOLETE { | |
| 779 | // OBSOLETE switch (fault) | |
| 780 | // OBSOLETE { | |
| 781 | // OBSOLETE case 0: | |
| 782 | // OBSOLETE return TARGET_SIGNAL_BUS; /* parallel fault */ | |
| 783 | // OBSOLETE case 1: | |
| 784 | // OBSOLETE return TARGET_SIGNAL_UNKNOWN; | |
| 785 | // OBSOLETE case 2: | |
| 786 | // OBSOLETE return TARGET_SIGNAL_ILL; /* operation fault */ | |
| 787 | // OBSOLETE case 3: | |
| 788 | // OBSOLETE return TARGET_SIGNAL_FPE; /* arithmetic fault */ | |
| 789 | // OBSOLETE case 4: | |
| 790 | // OBSOLETE return TARGET_SIGNAL_FPE; /* floating point fault */ | |
| 791 | // OBSOLETE | |
| 792 | // OBSOLETE /* constraint fault. This appears not to distinguish between | |
| 793 | // OBSOLETE a range constraint fault (which should be SIGFPE) and a privileged | |
| 794 | // OBSOLETE fault (which should be SIGILL). */ | |
| 795 | // OBSOLETE case 5: | |
| 796 | // OBSOLETE return TARGET_SIGNAL_ILL; | |
| 797 | // OBSOLETE | |
| 798 | // OBSOLETE case 6: | |
| 799 | // OBSOLETE return TARGET_SIGNAL_SEGV; /* virtual memory fault */ | |
| 800 | // OBSOLETE | |
| 801 | // OBSOLETE /* protection fault. This is for an out-of-range argument to | |
| 802 | // OBSOLETE "calls". I guess it also could be SIGILL. */ | |
| 803 | // OBSOLETE case 7: | |
| 804 | // OBSOLETE return TARGET_SIGNAL_SEGV; | |
| 805 | // OBSOLETE | |
| 806 | // OBSOLETE case 8: | |
| 807 | // OBSOLETE return TARGET_SIGNAL_BUS; /* machine fault */ | |
| 808 | // OBSOLETE case 9: | |
| 809 | // OBSOLETE return TARGET_SIGNAL_BUS; /* structural fault */ | |
| 810 | // OBSOLETE case 0xa: | |
| 811 | // OBSOLETE return TARGET_SIGNAL_ILL; /* type fault */ | |
| 812 | // OBSOLETE case 0xb: | |
| 813 | // OBSOLETE return TARGET_SIGNAL_UNKNOWN; /* reserved fault */ | |
| 814 | // OBSOLETE case 0xc: | |
| 815 | // OBSOLETE return TARGET_SIGNAL_BUS; /* process fault */ | |
| 816 | // OBSOLETE case 0xd: | |
| 817 | // OBSOLETE return TARGET_SIGNAL_SEGV; /* descriptor fault */ | |
| 818 | // OBSOLETE case 0xe: | |
| 819 | // OBSOLETE return TARGET_SIGNAL_BUS; /* event fault */ | |
| 820 | // OBSOLETE case 0xf: | |
| 821 | // OBSOLETE return TARGET_SIGNAL_UNKNOWN; /* reserved fault */ | |
| 822 | // OBSOLETE case 0x10: | |
| 823 | // OBSOLETE return TARGET_SIGNAL_TRAP; /* single-step trace */ | |
| 824 | // OBSOLETE case 0x11: | |
| 825 | // OBSOLETE return TARGET_SIGNAL_TRAP; /* branch trace */ | |
| 826 | // OBSOLETE case 0x12: | |
| 827 | // OBSOLETE return TARGET_SIGNAL_TRAP; /* call trace */ | |
| 828 | // OBSOLETE case 0x13: | |
| 829 | // OBSOLETE return TARGET_SIGNAL_TRAP; /* return trace */ | |
| 830 | // OBSOLETE case 0x14: | |
| 831 | // OBSOLETE return TARGET_SIGNAL_TRAP; /* pre-return trace */ | |
| 832 | // OBSOLETE case 0x15: | |
| 833 | // OBSOLETE return TARGET_SIGNAL_TRAP; /* supervisor call trace */ | |
| 834 | // OBSOLETE case 0x16: | |
| 835 | // OBSOLETE return TARGET_SIGNAL_TRAP; /* breakpoint trace */ | |
| 836 | // OBSOLETE default: | |
| 837 | // OBSOLETE return TARGET_SIGNAL_UNKNOWN; | |
| 838 | // OBSOLETE } | |
| 839 | // OBSOLETE } | |
| 840 | // OBSOLETE | |
| 841 | // OBSOLETE /****************************************/ | |
| 842 | // OBSOLETE /* MEM format */ | |
| 843 | // OBSOLETE /****************************************/ | |
| 844 | // OBSOLETE | |
| 845 | // OBSOLETE struct tabent | |
| 846 | // OBSOLETE { | |
| 847 | // OBSOLETE char *name; | |
| 848 | // OBSOLETE char numops; | |
| 849 | // OBSOLETE }; | |
| 850 | // OBSOLETE | |
| 851 | // OBSOLETE /* Return instruction length, either 4 or 8. When NOPRINT is non-zero | |
| 852 | // OBSOLETE (TRUE), don't output any text. (Actually, as implemented, if NOPRINT | |
| 853 | // OBSOLETE is 0, abort() is called.) */ | |
| 854 | // OBSOLETE | |
| 855 | // OBSOLETE static int | |
| 856 | // OBSOLETE mem (unsigned long memaddr, unsigned long word1, unsigned long word2, | |
| 857 | // OBSOLETE int noprint) | |
| 858 | // OBSOLETE { | |
| 859 | // OBSOLETE int i, j; | |
| 860 | // OBSOLETE int len; | |
| 861 | // OBSOLETE int mode; | |
| 862 | // OBSOLETE int offset; | |
| 863 | // OBSOLETE const char *reg1, *reg2, *reg3; | |
| 864 | // OBSOLETE | |
| 865 | // OBSOLETE /* This lookup table is too sparse to make it worth typing in, but not | |
| 866 | // OBSOLETE * so large as to make a sparse array necessary. We allocate the | |
| 867 | // OBSOLETE * table at runtime, initialize all entries to empty, and copy the | |
| 868 | // OBSOLETE * real ones in from an initialization table. | |
| 869 | // OBSOLETE * | |
| 870 | // OBSOLETE * NOTE: In this table, the meaning of 'numops' is: | |
| 871 | // OBSOLETE * 1: single operand | |
| 872 | // OBSOLETE * 2: 2 operands, load instruction | |
| 873 | // OBSOLETE * -2: 2 operands, store instruction | |
| 874 | // OBSOLETE */ | |
| 875 | // OBSOLETE static struct tabent *mem_tab = NULL; | |
| 876 | // OBSOLETE /* Opcodes of 0x8X, 9X, aX, bX, and cX must be in the table. */ | |
| 877 | // OBSOLETE #define MEM_MIN 0x80 | |
| 878 | // OBSOLETE #define MEM_MAX 0xcf | |
| 879 | // OBSOLETE #define MEM_SIZ ((MEM_MAX-MEM_MIN+1) * sizeof(struct tabent)) | |
| 880 | // OBSOLETE | |
| 881 | // OBSOLETE static struct | |
| 882 | // OBSOLETE { | |
| 883 | // OBSOLETE int opcode; | |
| 884 | // OBSOLETE char *name; | |
| 885 | // OBSOLETE char numops; | |
| 886 | // OBSOLETE } | |
| 887 | // OBSOLETE mem_init[] = | |
| 888 | // OBSOLETE { | |
| 889 | // OBSOLETE 0x80, "ldob", 2, | |
| 890 | // OBSOLETE 0x82, "stob", -2, | |
| 891 | // OBSOLETE 0x84, "bx", 1, | |
| 892 | // OBSOLETE 0x85, "balx", 2, | |
| 893 | // OBSOLETE 0x86, "callx", 1, | |
| 894 | // OBSOLETE 0x88, "ldos", 2, | |
| 895 | // OBSOLETE 0x8a, "stos", -2, | |
| 896 | // OBSOLETE 0x8c, "lda", 2, | |
| 897 | // OBSOLETE 0x90, "ld", 2, | |
| 898 | // OBSOLETE 0x92, "st", -2, | |
| 899 | // OBSOLETE 0x98, "ldl", 2, | |
| 900 | // OBSOLETE 0x9a, "stl", -2, | |
| 901 | // OBSOLETE 0xa0, "ldt", 2, | |
| 902 | // OBSOLETE 0xa2, "stt", -2, | |
| 903 | // OBSOLETE 0xb0, "ldq", 2, | |
| 904 | // OBSOLETE 0xb2, "stq", -2, | |
| 905 | // OBSOLETE 0xc0, "ldib", 2, | |
| 906 | // OBSOLETE 0xc2, "stib", -2, | |
| 907 | // OBSOLETE 0xc8, "ldis", 2, | |
| 908 | // OBSOLETE 0xca, "stis", -2, | |
| 909 | // OBSOLETE 0, NULL, 0 | |
| 910 | // OBSOLETE }; | |
| 911 | // OBSOLETE | |
| 912 | // OBSOLETE if (mem_tab == NULL) | |
| 913 | // OBSOLETE { | |
| 914 | // OBSOLETE mem_tab = (struct tabent *) xmalloc (MEM_SIZ); | |
| 915 | // OBSOLETE memset (mem_tab, '\0', MEM_SIZ); | |
| 916 | // OBSOLETE for (i = 0; mem_init[i].opcode != 0; i++) | |
| 917 | // OBSOLETE { | |
| 918 | // OBSOLETE j = mem_init[i].opcode - MEM_MIN; | |
| 919 | // OBSOLETE mem_tab[j].name = mem_init[i].name; | |
| 920 | // OBSOLETE mem_tab[j].numops = mem_init[i].numops; | |
| 921 | // OBSOLETE } | |
| 922 | // OBSOLETE } | |
| 923 | // OBSOLETE | |
| 924 | // OBSOLETE i = ((word1 >> 24) & 0xff) - MEM_MIN; | |
| 925 | // OBSOLETE mode = (word1 >> 10) & 0xf; | |
| 926 | // OBSOLETE | |
| 927 | // OBSOLETE if ((mem_tab[i].name != NULL) /* Valid instruction */ | |
| 928 | // OBSOLETE && ((mode == 5) || (mode >= 12))) | |
| 929 | // OBSOLETE { /* With 32-bit displacement */ | |
| 930 | // OBSOLETE len = 8; | |
| 931 | // OBSOLETE } | |
| 932 | // OBSOLETE else | |
| 933 | // OBSOLETE { | |
| 934 | // OBSOLETE len = 4; | |
| 935 | // OBSOLETE } | |
| 936 | // OBSOLETE | |
| 937 | // OBSOLETE if (noprint) | |
| 938 | // OBSOLETE { | |
| 939 | // OBSOLETE return len; | |
| 940 | // OBSOLETE } | |
| 941 | // OBSOLETE internal_error (__FILE__, __LINE__, "failed internal consistency check"); | |
| 942 | // OBSOLETE } | |
| 943 | // OBSOLETE | |
| 944 | // OBSOLETE /* Read the i960 instruction at 'memaddr' and return the address of | |
| 945 | // OBSOLETE the next instruction after that, or 0 if 'memaddr' is not the | |
| 946 | // OBSOLETE address of a valid instruction. The first word of the instruction | |
| 947 | // OBSOLETE is stored at 'pword1', and the second word, if any, is stored at | |
| 948 | // OBSOLETE 'pword2'. */ | |
| 949 | // OBSOLETE | |
| 950 | // OBSOLETE static CORE_ADDR | |
| 951 | // OBSOLETE next_insn (CORE_ADDR memaddr, unsigned int *pword1, unsigned int *pword2) | |
| 952 | // OBSOLETE { | |
| 953 | // OBSOLETE int len; | |
| 954 | // OBSOLETE char buf[8]; | |
| 955 | // OBSOLETE | |
| 956 | // OBSOLETE /* Read the two (potential) words of the instruction at once, | |
| 957 | // OBSOLETE to eliminate the overhead of two calls to read_memory (). | |
| 958 | // OBSOLETE FIXME: Loses if the first one is readable but the second is not | |
| 959 | // OBSOLETE (e.g. last word of the segment). */ | |
| 960 | // OBSOLETE | |
| 961 | // OBSOLETE read_memory (memaddr, buf, 8); | |
| 962 | // OBSOLETE *pword1 = extract_unsigned_integer (buf, 4); | |
| 963 | // OBSOLETE *pword2 = extract_unsigned_integer (buf + 4, 4); | |
| 964 | // OBSOLETE | |
| 965 | // OBSOLETE /* Divide instruction set into classes based on high 4 bits of opcode */ | |
| 966 | // OBSOLETE | |
| 967 | // OBSOLETE switch ((*pword1 >> 28) & 0xf) | |
| 968 | // OBSOLETE { | |
| 969 | // OBSOLETE case 0x0: | |
| 970 | // OBSOLETE case 0x1: /* ctrl */ | |
| 971 | // OBSOLETE | |
| 972 | // OBSOLETE case 0x2: | |
| 973 | // OBSOLETE case 0x3: /* cobr */ | |
| 974 | // OBSOLETE | |
| 975 | // OBSOLETE case 0x5: | |
| 976 | // OBSOLETE case 0x6: | |
| 977 | // OBSOLETE case 0x7: /* reg */ | |
| 978 | // OBSOLETE len = 4; | |
| 979 | // OBSOLETE break; | |
| 980 | // OBSOLETE | |
| 981 | // OBSOLETE case 0x8: | |
| 982 | // OBSOLETE case 0x9: | |
| 983 | // OBSOLETE case 0xa: | |
| 984 | // OBSOLETE case 0xb: | |
| 985 | // OBSOLETE case 0xc: | |
| 986 | // OBSOLETE len = mem (memaddr, *pword1, *pword2, 1); | |
| 987 | // OBSOLETE break; | |
| 988 | // OBSOLETE | |
| 989 | // OBSOLETE default: /* invalid instruction */ | |
| 990 | // OBSOLETE len = 0; | |
| 991 | // OBSOLETE break; | |
| 992 | // OBSOLETE } | |
| 993 | // OBSOLETE | |
| 994 | // OBSOLETE if (len) | |
| 995 | // OBSOLETE return memaddr + len; | |
| 996 | // OBSOLETE else | |
| 997 | // OBSOLETE return 0; | |
| 998 | // OBSOLETE } | |
| 999 | // OBSOLETE | |
| 1000 | // OBSOLETE /* 'start_frame' is a variable in the MON960 runtime startup routine | |
| 1001 | // OBSOLETE that contains the frame pointer of the 'start' routine (the routine | |
| 1002 | // OBSOLETE that calls 'main'). By reading its contents out of remote memory, | |
| 1003 | // OBSOLETE we can tell where the frame chain ends: backtraces should halt before | |
| 1004 | // OBSOLETE they display this frame. */ | |
| 1005 | // OBSOLETE | |
| 1006 | // OBSOLETE int | |
| 1007 | // OBSOLETE mon960_frame_chain_valid (CORE_ADDR chain, struct frame_info *curframe) | |
| 1008 | // OBSOLETE { | |
| 1009 | // OBSOLETE struct symbol *sym; | |
| 1010 | // OBSOLETE struct minimal_symbol *msymbol; | |
| 1011 | // OBSOLETE | |
| 1012 | // OBSOLETE /* crtmon960.o is an assembler module that is assumed to be linked | |
| 1013 | // OBSOLETE * first in an i80960 executable. It contains the true entry point; | |
| 1014 | // OBSOLETE * it performs startup up initialization and then calls 'main'. | |
| 1015 | // OBSOLETE * | |
| 1016 | // OBSOLETE * 'sf' is the name of a variable in crtmon960.o that is set | |
| 1017 | // OBSOLETE * during startup to the address of the first frame. | |
| 1018 | // OBSOLETE * | |
| 1019 | // OBSOLETE * 'a' is the address of that variable in 80960 memory. | |
| 1020 | // OBSOLETE */ | |
| 1021 | // OBSOLETE static char sf[] = "start_frame"; | |
| 1022 | // OBSOLETE CORE_ADDR a; | |
| 1023 | // OBSOLETE | |
| 1024 | // OBSOLETE | |
| 1025 | // OBSOLETE chain &= ~0x3f; /* Zero low 6 bits because previous frame pointers | |
| 1026 | // OBSOLETE contain return status info in them. */ | |
| 1027 | // OBSOLETE if (chain == 0) | |
| 1028 | // OBSOLETE { | |
| 1029 | // OBSOLETE return 0; | |
| 1030 | // OBSOLETE } | |
| 1031 | // OBSOLETE | |
| 1032 | // OBSOLETE sym = lookup_symbol (sf, 0, VAR_NAMESPACE, (int *) NULL, | |
| 1033 | // OBSOLETE (struct symtab **) NULL); | |
| 1034 | // OBSOLETE if (sym != 0) | |
| 1035 | // OBSOLETE { | |
| 1036 | // OBSOLETE a = SYMBOL_VALUE (sym); | |
| 1037 | // OBSOLETE } | |
| 1038 | // OBSOLETE else | |
| 1039 | // OBSOLETE { | |
| 1040 | // OBSOLETE msymbol = lookup_minimal_symbol (sf, NULL, NULL); | |
| 1041 | // OBSOLETE if (msymbol == NULL) | |
| 1042 | // OBSOLETE return 0; | |
| 1043 | // OBSOLETE a = SYMBOL_VALUE_ADDRESS (msymbol); | |
| 1044 | // OBSOLETE } | |
| 1045 | // OBSOLETE | |
| 1046 | // OBSOLETE return (chain != read_memory_integer (a, 4)); | |
| 1047 | // OBSOLETE } | |
| 1048 | // OBSOLETE | |
| 1049 | // OBSOLETE | |
| 1050 | // OBSOLETE void | |
| 1051 | // OBSOLETE _initialize_i960_tdep (void) | |
| 1052 | // OBSOLETE { | |
| 1053 | // OBSOLETE check_host (); | |
| 1054 | // OBSOLETE | |
| 1055 | // OBSOLETE tm_print_insn = print_insn_i960; | |
| 1056 | // OBSOLETE } |