Commit | Line | Data |
---|---|---|
c906108c SS |
1 | /* Native support for Motorola 88k running Harris CX/UX. |
2 | Copyright 1988, 1990, 1991, 1992, 1993, 1994 Free Software Foundation, Inc. | |
3 | ||
c5aa993b | 4 | This file is part of GDB. |
c906108c | 5 | |
c5aa993b JM |
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. | |
c906108c | 10 | |
c5aa993b JM |
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. | |
c906108c | 15 | |
c5aa993b JM |
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., 59 Temple Place - Suite 330, | |
19 | Boston, MA 02111-1307, USA. */ | |
c906108c SS |
20 | |
21 | #include "defs.h" | |
22 | #include "frame.h" | |
23 | #include "inferior.h" | |
24 | ||
25 | #include <sys/types.h> | |
26 | #include <sys/param.h> | |
27 | #include <sys/dir.h> | |
28 | #include <signal.h> | |
29 | #include "gdbcore.h" | |
30 | #include <sys/user.h> | |
31 | ||
32 | #include "bfd.h" | |
33 | #include "symfile.h" | |
34 | #include "objfiles.h" | |
35 | #include "symtab.h" | |
36 | ||
37 | #ifndef USER /* added to support BCS ptrace_user */ | |
38 | #define USER ptrace_user | |
39 | #endif | |
40 | #include <sys/ioctl.h> | |
41 | #include <fcntl.h> | |
42 | #include <sys/file.h> | |
43 | #include "gdb_stat.h" | |
44 | ||
45 | #include "symtab.h" | |
46 | #include "setjmp.h" | |
47 | #include "value.h" | |
48 | ||
49 | #include <sys/ptrace.h> | |
50 | ||
51 | /* CX/UX provides them already, but as word offsets instead of char offsets */ | |
52 | #define SXIP_OFFSET (PT_SXIP * 4) | |
53 | #define SNIP_OFFSET (PT_SNIP * 4) | |
54 | #define SFIP_OFFSET (PT_SFIP * 4) | |
55 | #define PSR_OFFSET (PT_PSR * sizeof(int)) | |
56 | #define FPSR_OFFSET (PT_FPSR * sizeof(int)) | |
57 | #define FPCR_OFFSET (PT_FPCR * sizeof(int)) | |
58 | ||
59 | #define XREGADDR(r) (((char *)&u.pt_x0-(char *)&u) + \ | |
60 | ((r)-X0_REGNUM)*sizeof(X_REGISTER_RAW_TYPE)) | |
61 | ||
c5aa993b | 62 | extern int have_symbol_file_p (); |
c906108c SS |
63 | |
64 | extern jmp_buf stack_jmp; | |
65 | ||
66 | extern int errno; | |
c906108c SS |
67 | |
68 | void | |
69 | fetch_inferior_registers (regno) | |
c5aa993b | 70 | int regno; /* Original value discarded */ |
c906108c SS |
71 | { |
72 | register unsigned int regaddr; | |
73 | char buf[MAX_REGISTER_RAW_SIZE]; | |
74 | register int i; | |
75 | ||
76 | struct USER u; | |
77 | unsigned int offset; | |
78 | ||
c5aa993b JM |
79 | offset = (char *) &u.pt_r0 - (char *) &u; |
80 | regaddr = offset; /* byte offset to r0; */ | |
c906108c SS |
81 | |
82 | /* offset = ptrace (3, inferior_pid, (PTRACE_ARG3_TYPE) offset, 0) - KERNEL_U_ADDR; */ | |
83 | for (regno = 0; regno < PC_REGNUM; regno++) | |
84 | { | |
c5aa993b JM |
85 | /*regaddr = register_addr (regno, offset); */ |
86 | /* 88k enhancement */ | |
87 | ||
c906108c | 88 | for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof (int)) |
c5aa993b JM |
89 | { |
90 | *(int *) &buf[i] = ptrace (3, inferior_pid, | |
c906108c | 91 | (PTRACE_ARG3_TYPE) regaddr, 0); |
c5aa993b JM |
92 | regaddr += sizeof (int); |
93 | } | |
c906108c SS |
94 | supply_register (regno, buf); |
95 | } | |
c5aa993b JM |
96 | /* now load up registers 32-37; special pc registers */ |
97 | *(int *) &buf[0] = ptrace (3, inferior_pid, | |
98 | (PTRACE_ARG3_TYPE) PSR_OFFSET, 0); | |
99 | supply_register (PSR_REGNUM, buf); | |
100 | *(int *) &buf[0] = ptrace (3, inferior_pid, | |
101 | (PTRACE_ARG3_TYPE) FPSR_OFFSET, 0); | |
102 | supply_register (FPSR_REGNUM, buf); | |
103 | *(int *) &buf[0] = ptrace (3, inferior_pid, | |
104 | (PTRACE_ARG3_TYPE) FPCR_OFFSET, 0); | |
105 | supply_register (FPCR_REGNUM, buf); | |
106 | *(int *) &buf[0] = ptrace (3, inferior_pid, | |
107 | (PTRACE_ARG3_TYPE) SXIP_OFFSET, 0); | |
108 | supply_register (SXIP_REGNUM, buf); | |
109 | *(int *) &buf[0] = ptrace (3, inferior_pid, | |
110 | (PTRACE_ARG3_TYPE) SNIP_OFFSET, 0); | |
111 | supply_register (SNIP_REGNUM, buf); | |
112 | *(int *) &buf[0] = ptrace (3, inferior_pid, | |
113 | (PTRACE_ARG3_TYPE) SFIP_OFFSET, 0); | |
114 | supply_register (SFIP_REGNUM, buf); | |
115 | ||
116 | if (target_is_m88110) | |
117 | { | |
118 | for (regaddr = XREGADDR (X0_REGNUM), regno = X0_REGNUM; | |
119 | regno < NUM_REGS; | |
120 | regno++, regaddr += 16) | |
121 | { | |
122 | X_REGISTER_RAW_TYPE xval; | |
123 | ||
124 | *(int *) &xval.w1 = ptrace (3, inferior_pid, | |
125 | (PTRACE_ARG3_TYPE) regaddr, 0); | |
126 | *(int *) &xval.w2 = ptrace (3, inferior_pid, | |
127 | (PTRACE_ARG3_TYPE) (regaddr + 4), 0); | |
128 | *(int *) &xval.w3 = ptrace (3, inferior_pid, | |
129 | (PTRACE_ARG3_TYPE) (regaddr + 8), 0); | |
130 | *(int *) &xval.w4 = ptrace (3, inferior_pid, | |
131 | (PTRACE_ARG3_TYPE) (regaddr + 12), 0); | |
132 | supply_register (regno, (void *) &xval); | |
133 | } | |
134 | } | |
c906108c SS |
135 | } |
136 | ||
137 | /* Store our register values back into the inferior. | |
138 | If REGNO is -1, do this for all registers. | |
139 | Otherwise, REGNO specifies which register (so we can save time). */ | |
140 | ||
141 | void | |
fba45db2 | 142 | store_inferior_registers (int regno) |
c906108c SS |
143 | { |
144 | register unsigned int regaddr; | |
145 | char buf[80]; | |
146 | ||
147 | struct USER u; | |
148 | ||
149 | unsigned int offset = (char *) &u.pt_r0 - (char *) &u; | |
150 | ||
151 | regaddr = offset; | |
152 | ||
153 | /* Don't try to deal with EXIP_REGNUM or ENIP_REGNUM, because I think either | |
154 | svr3 doesn't run on an 88110, or the kernel isolates the different (not | |
155 | completely sure this is true, but seems to be. */ | |
156 | if (regno >= 0) | |
157 | { | |
158 | /* regaddr = register_addr (regno, offset); */ | |
159 | if (regno < PC_REGNUM) | |
c5aa993b | 160 | { |
c906108c SS |
161 | regaddr = offset + regno * sizeof (int); |
162 | errno = 0; | |
163 | ptrace (6, inferior_pid, | |
164 | (PTRACE_ARG3_TYPE) regaddr, read_register (regno)); | |
165 | if (errno != 0) | |
166 | { | |
167 | sprintf (buf, "writing register number %d", regno); | |
168 | perror_with_name (buf); | |
169 | } | |
170 | } | |
171 | else if (regno == PSR_REGNUM) | |
c5aa993b JM |
172 | ptrace (6, inferior_pid, |
173 | (PTRACE_ARG3_TYPE) PSR_OFFSET, read_register (regno)); | |
c906108c | 174 | else if (regno == FPSR_REGNUM) |
c5aa993b JM |
175 | ptrace (6, inferior_pid, |
176 | (PTRACE_ARG3_TYPE) FPSR_OFFSET, read_register (regno)); | |
c906108c | 177 | else if (regno == FPCR_REGNUM) |
c5aa993b JM |
178 | ptrace (6, inferior_pid, |
179 | (PTRACE_ARG3_TYPE) FPCR_OFFSET, read_register (regno)); | |
c906108c SS |
180 | else if (regno == SXIP_REGNUM) |
181 | ptrace (6, inferior_pid, | |
c5aa993b | 182 | (PTRACE_ARG3_TYPE) SXIP_OFFSET, read_register (regno)); |
c906108c SS |
183 | else if (regno == SNIP_REGNUM) |
184 | ptrace (6, inferior_pid, | |
c5aa993b | 185 | (PTRACE_ARG3_TYPE) SNIP_OFFSET, read_register (regno)); |
c906108c SS |
186 | else if (regno == SFIP_REGNUM) |
187 | ptrace (6, inferior_pid, | |
c5aa993b | 188 | (PTRACE_ARG3_TYPE) SFIP_OFFSET, read_register (regno)); |
c906108c | 189 | else if (target_is_m88110 && regno < NUM_REGS) |
c5aa993b JM |
190 | { |
191 | X_REGISTER_RAW_TYPE xval; | |
192 | ||
193 | read_register_bytes (REGISTER_BYTE (regno), (char *) &xval, | |
194 | sizeof (X_REGISTER_RAW_TYPE)); | |
195 | regaddr = XREGADDR (regno); | |
196 | ptrace (6, inferior_pid, (PTRACE_ARG3_TYPE) regaddr, xval.w1); | |
197 | ptrace (6, inferior_pid, (PTRACE_ARG3_TYPE) regaddr + 4, xval.w2); | |
198 | ptrace (6, inferior_pid, (PTRACE_ARG3_TYPE) regaddr + 8, xval.w3); | |
199 | ptrace (6, inferior_pid, (PTRACE_ARG3_TYPE) regaddr + 12, xval.w4); | |
200 | } | |
c906108c SS |
201 | else |
202 | printf_unfiltered ("Bad register number for store_inferior routine\n"); | |
203 | } | |
204 | else | |
c5aa993b | 205 | { |
c906108c SS |
206 | for (regno = 0; regno < PC_REGNUM; regno++) |
207 | { | |
208 | /* regaddr = register_addr (regno, offset); */ | |
209 | errno = 0; | |
210 | regaddr = offset + regno * sizeof (int); | |
211 | ptrace (6, inferior_pid, | |
212 | (PTRACE_ARG3_TYPE) regaddr, read_register (regno)); | |
213 | if (errno != 0) | |
214 | { | |
215 | sprintf (buf, "writing register number %d", regno); | |
216 | perror_with_name (buf); | |
217 | } | |
218 | } | |
219 | ptrace (6, inferior_pid, | |
c5aa993b JM |
220 | (PTRACE_ARG3_TYPE) PSR_OFFSET, read_register (regno)); |
221 | ptrace (6, inferior_pid, | |
222 | (PTRACE_ARG3_TYPE) FPSR_OFFSET, read_register (regno)); | |
223 | ptrace (6, inferior_pid, | |
224 | (PTRACE_ARG3_TYPE) FPCR_OFFSET, read_register (regno)); | |
225 | ptrace (6, inferior_pid, | |
226 | (PTRACE_ARG3_TYPE) SXIP_OFFSET, read_register (SXIP_REGNUM)); | |
c906108c | 227 | ptrace (6, inferior_pid, |
c5aa993b | 228 | (PTRACE_ARG3_TYPE) SNIP_OFFSET, read_register (SNIP_REGNUM)); |
c906108c | 229 | ptrace (6, inferior_pid, |
c5aa993b | 230 | (PTRACE_ARG3_TYPE) SFIP_OFFSET, read_register (SFIP_REGNUM)); |
c906108c | 231 | if (target_is_m88110) |
c5aa993b JM |
232 | { |
233 | for (regno = X0_REGNUM; regno < NUM_REGS; regno++) | |
234 | { | |
235 | X_REGISTER_RAW_TYPE xval; | |
236 | ||
237 | read_register_bytes (REGISTER_BYTE (regno), (char *) &xval, | |
238 | sizeof (X_REGISTER_RAW_TYPE)); | |
239 | regaddr = XREGADDR (regno); | |
240 | ptrace (6, inferior_pid, (PTRACE_ARG3_TYPE) regaddr, xval.w1); | |
241 | ptrace (6, inferior_pid, (PTRACE_ARG3_TYPE) (regaddr + 4), xval.w2); | |
242 | ptrace (6, inferior_pid, (PTRACE_ARG3_TYPE) (regaddr + 8), xval.w3); | |
243 | ptrace (6, inferior_pid, (PTRACE_ARG3_TYPE) (regaddr + 12), xval.w4); | |
244 | } | |
245 | } | |
c906108c SS |
246 | } |
247 | } | |
248 | ||
249 | /* blockend is the address of the end of the user structure */ | |
250 | ||
fba45db2 | 251 | m88k_register_u_addr (int blockend, int regnum) |
c906108c SS |
252 | { |
253 | struct USER u; | |
254 | int ustart = blockend - sizeof (struct USER); | |
255 | ||
256 | if (regnum < PSR_REGNUM) | |
c5aa993b JM |
257 | return (ustart + ((int) &u.pt_r0 - (int) &u) + |
258 | REGISTER_SIZE * regnum); | |
c906108c | 259 | else if (regnum == PSR_REGNUM) |
c5aa993b | 260 | return (ustart + ((int) &u.pt_psr) - (int) &u); |
c906108c | 261 | else if (regnum == FPSR_REGNUM) |
c5aa993b | 262 | return (ustart + ((int) &u.pt_fpsr) - (int) &u); |
c906108c | 263 | else if (regnum == FPCR_REGNUM) |
c5aa993b | 264 | return (ustart + ((int) &u.pt_fpcr) - (int) &u); |
c906108c | 265 | else if (regnum == SXIP_REGNUM) |
c5aa993b | 266 | return (ustart + SXIP_OFFSET); |
c906108c | 267 | else if (regnum == SNIP_REGNUM) |
c5aa993b | 268 | return (ustart + SNIP_OFFSET); |
c906108c | 269 | else if (regnum == SFIP_REGNUM) |
c5aa993b JM |
270 | return (ustart + SFIP_OFFSET); |
271 | else if (target_is_m88110) | |
272 | return (ustart + ((int) &u.pt_x0 - (int) &u) + /* Must be X register */ | |
273 | sizeof (u.pt_x0) * (regnum - X0_REGNUM)); | |
c906108c | 274 | else |
c5aa993b | 275 | return (blockend + REGISTER_SIZE * regnum); |
c906108c SS |
276 | } |
277 | ||
278 | #ifdef USE_PROC_FS | |
279 | ||
280 | #include <sys/procfs.h> | |
281 | ||
c60c0f5f MS |
282 | /* Prototypes for supply_gregset etc. */ |
283 | #include "gregset.h" | |
284 | ||
c906108c | 285 | /* Given a pointer to a general register set in /proc format (gregset_t *), |
c5aa993b JM |
286 | unpack the register contents and supply them as gdb's idea of the current |
287 | register values. */ | |
c906108c SS |
288 | |
289 | void | |
fba45db2 | 290 | supply_gregset (gregset_t *gregsetp) |
c906108c | 291 | { |
c5aa993b JM |
292 | register int regi; |
293 | register greg_t *regp = (greg_t *) gregsetp; | |
294 | ||
295 | for (regi = 0; regi <= SP_REGNUM; regi++) | |
296 | supply_register (regi, (char *) (regp + regi)); | |
297 | ||
298 | supply_register (SXIP_REGNUM, (char *) (regp + R_XIP)); | |
299 | supply_register (SNIP_REGNUM, (char *) (regp + R_NIP)); | |
300 | supply_register (SFIP_REGNUM, (char *) (regp + R_FIP)); | |
301 | supply_register (PSR_REGNUM, (char *) (regp + R_PSR)); | |
302 | supply_register (FPSR_REGNUM, (char *) (regp + R_FPSR)); | |
303 | supply_register (FPCR_REGNUM, (char *) (regp + R_FPCR)); | |
c906108c SS |
304 | } |
305 | ||
306 | void | |
fba45db2 | 307 | fill_gregset (gregset_t *gregsetp, int regno) |
c906108c | 308 | { |
c5aa993b JM |
309 | int regi; |
310 | register greg_t *regp = (greg_t *) gregsetp; | |
311 | ||
312 | for (regi = 0; regi <= R_R31; regi++) | |
313 | if ((regno == -1) || (regno == regi)) | |
314 | *(regp + regi) = *(int *) ®isters[REGISTER_BYTE (regi)]; | |
315 | ||
316 | if ((regno == -1) || (regno == SXIP_REGNUM)) | |
317 | *(regp + R_XIP) = *(int *) ®isters[REGISTER_BYTE (SXIP_REGNUM)]; | |
318 | if ((regno == -1) || (regno == SNIP_REGNUM)) | |
319 | *(regp + R_NIP) = *(int *) ®isters[REGISTER_BYTE (SNIP_REGNUM)]; | |
320 | if ((regno == -1) || (regno == SFIP_REGNUM)) | |
321 | *(regp + R_FIP) = *(int *) ®isters[REGISTER_BYTE (SFIP_REGNUM)]; | |
322 | if ((regno == -1) || (regno == PSR_REGNUM)) | |
323 | *(regp + R_PSR) = *(int *) ®isters[REGISTER_BYTE (PSR_REGNUM)]; | |
324 | if ((regno == -1) || (regno == FPSR_REGNUM)) | |
325 | *(regp + R_FPSR) = *(int *) ®isters[REGISTER_BYTE (FPSR_REGNUM)]; | |
326 | if ((regno == -1) || (regno == FPCR_REGNUM)) | |
327 | *(regp + R_FPCR) = *(int *) ®isters[REGISTER_BYTE (FPCR_REGNUM)]; | |
c906108c SS |
328 | } |
329 | ||
330 | #endif /* USE_PROC_FS */ | |
331 | ||
332 | /* This support adds the equivalent of adb's % command. When | |
333 | the `add-shared-symbol-files' command is given, this routine scans | |
334 | the dynamic linker's link map and reads the minimal symbols | |
335 | from each shared object file listed in the map. */ | |
336 | ||
c5aa993b JM |
337 | struct link_map |
338 | { | |
c906108c SS |
339 | unsigned long l_addr; /* address at which object is mapped */ |
340 | char *l_name; /* full name of loaded object */ | |
341 | void *l_ld; /* dynamic structure of object */ | |
342 | struct link_map *l_next; /* next link object */ | |
343 | struct link_map *l_prev; /* previous link object */ | |
344 | }; | |
345 | ||
346 | #define LINKS_MAP_POINTER "_ld_tail" | |
347 | #define LIBC_FILE "/usr/lib/libc.so.1" | |
348 | #define SHARED_OFFSET 0xf0001000 | |
349 | ||
350 | #ifndef PATH_MAX | |
351 | #define PATH_MAX 1023 /* maximum size of path name on OS */ | |
352 | #endif | |
353 | ||
354 | void | |
fba45db2 | 355 | add_shared_symbol_files (void) |
c906108c SS |
356 | { |
357 | void *desc; | |
358 | struct link_map *ld_map, *lm, lms; | |
c5aa993b | 359 | struct minimal_symbol *minsym; |
c906108c SS |
360 | struct objfile *objfile; |
361 | char *path_name; | |
362 | ||
c5aa993b | 363 | if (!inferior_pid) |
c906108c SS |
364 | { |
365 | warning ("The program has not yet been started."); | |
366 | return; | |
367 | } | |
368 | ||
2df3850c | 369 | objfile = symbol_file_add (LIBC_FILE, 0, NULL, 0, OBJF_READNOW); |
c906108c SS |
370 | minsym = lookup_minimal_symbol (LINKS_MAP_POINTER, objfile); |
371 | ||
372 | ld_map = (struct link_map *) | |
c5aa993b | 373 | read_memory_integer (((int) SYMBOL_VALUE_ADDRESS (minsym) + SHARED_OFFSET), 4); |
c906108c SS |
374 | lm = ld_map; |
375 | while (lm) | |
376 | { | |
377 | int local_errno = 0; | |
378 | ||
c5aa993b | 379 | read_memory ((CORE_ADDR) lm, (char *) &lms, sizeof (struct link_map)); |
c906108c SS |
380 | if (lms.l_name) |
381 | { | |
c5aa993b JM |
382 | if (target_read_string ((CORE_ADDR) lms.l_name, &path_name, |
383 | PATH_MAX, &local_errno)) | |
c906108c | 384 | { |
2acceee2 JM |
385 | struct section_addr_info section_addrs; |
386 | memset (§ion_addrs, 0, sizeof (section_addrs)); | |
a034fba4 EZ |
387 | section_addrs.other[0].addr = lms.l_addr; |
388 | section_addrs.other[0].name = ".text"; | |
2df3850c | 389 | symbol_file_add (path_name, 1, §ion_addrs, 0, 0); |
c5aa993b | 390 | free (path_name); |
c906108c SS |
391 | } |
392 | } | |
393 | /* traverse links in reverse order so that we get the | |
c5aa993b | 394 | the symbols the user actually gets. */ |
c906108c SS |
395 | lm = lms.l_prev; |
396 | } | |
397 | ||
398 | /* Getting new symbols may change our opinion about what is | |
399 | frameless. */ | |
400 | reinit_frame_cache (); | |
401 | } | |
402 | ||
403 | #if defined(_ES_MP) | |
404 | ||
405 | #include <sys/regset.h> | |
406 | ||
407 | unsigned int | |
fba45db2 | 408 | m88k_harris_core_register_addr (int regno, int reg_ptr) |
c906108c | 409 | { |
c5aa993b JM |
410 | unsigned int word_offset; |
411 | ||
412 | switch (regno) | |
413 | { | |
414 | case PSR_REGNUM: | |
415 | word_offset = R_EPSR; | |
416 | break; | |
417 | case FPSR_REGNUM: | |
418 | word_offset = R_FPSR; | |
419 | break; | |
420 | case FPCR_REGNUM: | |
421 | word_offset = R_FPCR; | |
422 | break; | |
423 | case SXIP_REGNUM: | |
424 | word_offset = R_EXIP; | |
425 | break; | |
426 | case SNIP_REGNUM: | |
427 | word_offset = R_ENIP; | |
428 | break; | |
429 | case SFIP_REGNUM: | |
430 | word_offset = R_EFIP; | |
431 | break; | |
432 | default: | |
433 | if (regno <= FP_REGNUM) | |
434 | word_offset = regno; | |
435 | else | |
436 | word_offset = ((regno - X0_REGNUM) * 4); | |
437 | } | |
438 | return (word_offset * 4); | |
c906108c SS |
439 | } |
440 | ||
441 | #endif /* _ES_MP */ | |
442 | ||
443 | void | |
fba45db2 | 444 | _initialize_m88k_nat (void) |
c906108c SS |
445 | { |
446 | #ifdef _ES_MP | |
c5aa993b | 447 | /* Enable 88110 support, as we don't support the 88100 under ES/MP. */ |
c906108c | 448 | |
c5aa993b | 449 | target_is_m88110 = 1; |
c906108c | 450 | #elif defined(_CX_UX) |
c5aa993b JM |
451 | /* Determine whether we're running on an 88100 or an 88110. */ |
452 | target_is_m88110 = (sinfo (SYSMACHINE, 0) == SYS5800); | |
c906108c SS |
453 | #endif /* _CX_UX */ |
454 | } | |
455 | ||
456 | #ifdef _ES_MP | |
457 | /* Given a pointer to a general register set in /proc format (gregset_t *), | |
458 | unpack the register contents and supply them as gdb's idea of the current | |
459 | register values. */ | |
460 | ||
461 | void | |
fba45db2 | 462 | supply_gregset (gregset_t *gregsetp) |
c906108c SS |
463 | { |
464 | register int regi; | |
465 | register greg_t *regp = (greg_t *) gregsetp; | |
466 | ||
c5aa993b | 467 | for (regi = 0; regi < R_R31; regi++) |
c906108c SS |
468 | { |
469 | supply_register (regi, (char *) (regp + regi)); | |
470 | } | |
c5aa993b | 471 | supply_register (PSR_REGNUM, (char *) (regp + R_EPSR)); |
c906108c SS |
472 | supply_register (FPSR_REGNUM, (char *) (regp + R_FPSR)); |
473 | supply_register (FPCR_REGNUM, (char *) (regp + R_FPCR)); | |
474 | supply_register (SXIP_REGNUM, (char *) (regp + R_EXIP)); | |
475 | supply_register (SNIP_REGNUM, (char *) (regp + R_ENIP)); | |
476 | supply_register (SFIP_REGNUM, (char *) (regp + R_EFIP)); | |
477 | } | |
478 | ||
479 | /* Given a pointer to a floating point register set in /proc format | |
480 | (fpregset_t *), unpack the register contents and supply them as gdb's | |
481 | idea of the current floating point register values. */ | |
482 | ||
c5aa993b | 483 | void |
fba45db2 | 484 | supply_fpregset (fpregset_t *fpregsetp) |
c906108c SS |
485 | { |
486 | register int regi; | |
487 | char *from; | |
c5aa993b JM |
488 | |
489 | for (regi = FP0_REGNUM; regi <= FPLAST_REGNUM; regi++) | |
c906108c | 490 | { |
c5aa993b | 491 | from = (char *) &((*fpregsetp)[regi - FP0_REGNUM]); |
c906108c SS |
492 | supply_register (regi, from); |
493 | } | |
494 | } | |
495 | ||
496 | #endif /* _ES_MP */ | |
497 | ||
498 | #ifdef _CX_UX | |
499 | ||
500 | #include <sys/regset.h> | |
501 | ||
c5aa993b JM |
502 | unsigned int |
503 | m88k_harris_core_register_addr (int regno, int reg_ptr) | |
c906108c | 504 | { |
c5aa993b JM |
505 | unsigned int word_offset; |
506 | ||
507 | switch (regno) | |
508 | { | |
509 | case PSR_REGNUM: | |
510 | word_offset = R_PSR; | |
511 | break; | |
512 | case FPSR_REGNUM: | |
513 | word_offset = R_FPSR; | |
514 | break; | |
515 | case FPCR_REGNUM: | |
516 | word_offset = R_FPCR; | |
517 | break; | |
518 | case SXIP_REGNUM: | |
519 | word_offset = R_XIP; | |
520 | break; | |
521 | case SNIP_REGNUM: | |
522 | word_offset = R_NIP; | |
523 | break; | |
524 | case SFIP_REGNUM: | |
525 | word_offset = R_FIP; | |
526 | break; | |
527 | default: | |
528 | if (regno <= FP_REGNUM) | |
529 | word_offset = regno; | |
530 | else | |
531 | word_offset = ((regno - X0_REGNUM) * 4) + R_X0; | |
532 | } | |
533 | return (word_offset * 4); | |
c906108c SS |
534 | } |
535 | ||
536 | #endif /* _CX_UX */ |