Commit | Line | Data |
---|---|---|
085dd6e6 JM |
1 | /* OBSOLETE /* Convex host-dependent code for GDB. */ |
2 | /* OBSOLETE Copyright 1990, 1991, 1992 Free Software Foundation, Inc. */ | |
3 | /* OBSOLETE */ | |
4 | /* OBSOLETE This file is part of GDB. */ | |
5 | /* OBSOLETE */ | |
6 | /* OBSOLETE This program is free software; you can redistribute it and/or modify */ | |
7 | /* OBSOLETE it under the terms of the GNU General Public License as published by */ | |
8 | /* OBSOLETE the Free Software Foundation; either version 2 of the License, or */ | |
9 | /* OBSOLETE (at your option) any later version. */ | |
10 | /* OBSOLETE */ | |
11 | /* OBSOLETE This program is distributed in the hope that it will be useful, */ | |
12 | /* OBSOLETE but WITHOUT ANY WARRANTY; without even the implied warranty of */ | |
13 | /* OBSOLETE MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */ | |
14 | /* OBSOLETE GNU General Public License for more details. */ | |
15 | /* OBSOLETE */ | |
16 | /* OBSOLETE You should have received a copy of the GNU General Public License */ | |
17 | /* OBSOLETE along with this program; if not, write to the Free Software */ | |
18 | /* OBSOLETE Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *x/ */ | |
19 | /* OBSOLETE */ | |
20 | /* OBSOLETE #include "defs.h" */ | |
21 | /* OBSOLETE #include "command.h" */ | |
22 | /* OBSOLETE #include "symtab.h" */ | |
23 | /* OBSOLETE #include "value.h" */ | |
24 | /* OBSOLETE #include "frame.h" */ | |
25 | /* OBSOLETE #include "inferior.h" */ | |
26 | /* OBSOLETE #include "wait.h" */ | |
27 | /* OBSOLETE */ | |
28 | /* OBSOLETE #include <signal.h> */ | |
29 | /* OBSOLETE #include <fcntl.h> */ | |
30 | /* OBSOLETE #include "gdbcore.h" */ | |
31 | /* OBSOLETE */ | |
32 | /* OBSOLETE #include <sys/param.h> */ | |
33 | /* OBSOLETE #include <sys/dir.h> */ | |
34 | /* OBSOLETE #include <sys/user.h> */ | |
35 | /* OBSOLETE #include <sys/ioctl.h> */ | |
36 | /* OBSOLETE #include <sys/pcntl.h> */ | |
37 | /* OBSOLETE #include <sys/thread.h> */ | |
38 | /* OBSOLETE #include <sys/proc.h> */ | |
39 | /* OBSOLETE #include <sys/file.h> */ | |
40 | /* OBSOLETE #include "gdb_stat.h" */ | |
41 | /* OBSOLETE #include <sys/mman.h> */ | |
42 | /* OBSOLETE */ | |
43 | /* OBSOLETE #include <convex/vmparam.h> */ | |
44 | /* OBSOLETE #include <convex/filehdr.h> */ | |
45 | /* OBSOLETE #include <convex/opthdr.h> */ | |
46 | /* OBSOLETE #include <convex/scnhdr.h> */ | |
47 | /* OBSOLETE #include <convex/core.h> */ | |
48 | /* OBSOLETE */ | |
49 | /* OBSOLETE /* Per-thread data, read from the inferior at each stop and written */ | |
50 | /* OBSOLETE back at each resume. *x/ */ | |
51 | /* OBSOLETE */ | |
52 | /* OBSOLETE /* Number of active threads. */ | |
53 | /* OBSOLETE Tables are valid for thread numbers less than this. *x/ */ | |
54 | /* OBSOLETE */ | |
55 | /* OBSOLETE static int n_threads; */ | |
56 | /* OBSOLETE */ | |
57 | /* OBSOLETE #define MAXTHREADS 8 */ | |
c5aa993b | 58 | /* OBSOLETE */ |
085dd6e6 JM |
59 | /* OBSOLETE /* Thread state. The remaining data is valid only if this is PI_TALIVE. *x/ */ |
60 | /* OBSOLETE */ | |
61 | /* OBSOLETE static int thread_state[MAXTHREADS]; */ | |
62 | /* OBSOLETE */ | |
63 | /* OBSOLETE /* Stop pc, signal, signal subcode *x/ */ | |
64 | /* OBSOLETE */ | |
65 | /* OBSOLETE static int thread_pc[MAXTHREADS]; */ | |
66 | /* OBSOLETE static int thread_signal[MAXTHREADS]; */ | |
c5aa993b | 67 | /* OBSOLETE static int thread_sigcode[MAXTHREADS]; */ |
085dd6e6 JM |
68 | /* OBSOLETE */ |
69 | /* OBSOLETE /* Thread registers. */ | |
70 | /* OBSOLETE If thread is selected, the regs are in registers[] instead. *x/ */ | |
71 | /* OBSOLETE */ | |
72 | /* OBSOLETE static char thread_regs[MAXTHREADS][REGISTER_BYTES]; */ | |
73 | /* OBSOLETE */ | |
74 | /* OBSOLETE /* 1 if the top frame on the thread's stack was a context frame, */ | |
75 | /* OBSOLETE meaning that the kernel is up to something and we should not */ | |
76 | /* OBSOLETE touch the thread at all except to resume it. *x/ */ | |
77 | /* OBSOLETE */ | |
78 | /* OBSOLETE static char thread_is_in_kernel[MAXTHREADS]; */ | |
79 | /* OBSOLETE */ | |
80 | /* OBSOLETE /* The currently selected thread's number. *x/ */ | |
81 | /* OBSOLETE */ | |
82 | /* OBSOLETE static int inferior_thread; */ | |
83 | /* OBSOLETE */ | |
84 | /* OBSOLETE /* Inferior process's file handle and a process control block */ | |
85 | /* OBSOLETE to feed args to ioctl with. *x/ */ | |
86 | /* OBSOLETE */ | |
87 | /* OBSOLETE static int inferior_fd; */ | |
88 | /* OBSOLETE static struct pcntl ps; */ | |
89 | /* OBSOLETE */ | |
90 | /* OBSOLETE /* SOFF file headers for exec or core file. *x/ */ | |
91 | /* OBSOLETE */ | |
92 | /* OBSOLETE static FILEHDR filehdr; */ | |
93 | /* OBSOLETE static OPTHDR opthdr; */ | |
94 | /* OBSOLETE static SCNHDR scnhdr; */ | |
95 | /* OBSOLETE */ | |
96 | /* OBSOLETE /* Address maps constructed from section headers of exec and core files. */ | |
97 | /* OBSOLETE Defines process address -> file address translation. *x/ */ | |
98 | /* OBSOLETE */ | |
99 | /* OBSOLETE struct pmap */ | |
100 | /* OBSOLETE { */ | |
c5aa993b JM |
101 | /* OBSOLETE long mem_addr; /* process start address *x/ */ |
102 | /* OBSOLETE long mem_end; /* process end+1 address *x/ */ | |
103 | /* OBSOLETE long file_addr; /* file start address *x/ */ | |
104 | /* OBSOLETE long thread; /* -1 shared; 0,1,... thread-local *x/ */ | |
105 | /* OBSOLETE long type; /* S_TEXT S_DATA S_BSS S_TBSS etc *x/ */ | |
106 | /* OBSOLETE long which; /* used to sort map for info files *x/ */ | |
085dd6e6 JM |
107 | /* OBSOLETE }; */ |
108 | /* OBSOLETE */ | |
109 | /* OBSOLETE static int n_exec, n_core; */ | |
110 | /* OBSOLETE static struct pmap exec_map[100]; */ | |
111 | /* OBSOLETE static struct pmap core_map[100]; */ | |
112 | /* OBSOLETE */ | |
113 | /* OBSOLETE /* Offsets in the core file of core_context and core_tcontext blocks. *x/ */ | |
114 | /* OBSOLETE */ | |
115 | /* OBSOLETE static int context_offset; */ | |
116 | /* OBSOLETE static int tcontext_offset[MAXTHREADS]; */ | |
117 | /* OBSOLETE */ | |
118 | /* OBSOLETE /* Core file control blocks. *x/ */ | |
119 | /* OBSOLETE */ | |
120 | /* OBSOLETE static struct core_context_v70 c; */ | |
121 | /* OBSOLETE static struct core_tcontext_v70 tc; */ | |
122 | /* OBSOLETE static struct user u; */ | |
123 | /* OBSOLETE static thread_t th; */ | |
124 | /* OBSOLETE static proc_t pr; */ | |
125 | /* OBSOLETE */ | |
126 | /* OBSOLETE */ | |
127 | /* OBSOLETE /* Vector and communication registers from core dump or from inferior. */ | |
128 | /* OBSOLETE These are read on demand, ie, not normally valid. *x/ */ | |
129 | /* OBSOLETE */ | |
130 | /* OBSOLETE static struct vecst vector_registers; */ | |
131 | /* OBSOLETE static struct creg_ctx comm_registers; */ | |
132 | /* OBSOLETE */ | |
133 | /* OBSOLETE /* Flag, set on a vanilla CONT command and cleared when the inferior */ | |
134 | /* OBSOLETE is continued. *x/ */ | |
135 | /* OBSOLETE */ | |
136 | /* OBSOLETE static int all_continue; */ | |
137 | /* OBSOLETE */ | |
138 | /* OBSOLETE /* Flag, set when the inferior is continued by a vanilla CONT command, */ | |
139 | /* OBSOLETE cleared if it is continued for any other purpose. *x/ */ | |
140 | /* OBSOLETE */ | |
141 | /* OBSOLETE static int thread_switch_ok; */ | |
142 | /* OBSOLETE */ | |
143 | /* OBSOLETE /* Stack of signals recieved from threads but not yet delivered to gdb. *x/ */ | |
144 | /* OBSOLETE */ | |
145 | /* OBSOLETE struct threadpid */ | |
146 | /* OBSOLETE { */ | |
147 | /* OBSOLETE int pid; */ | |
148 | /* OBSOLETE int thread; */ | |
149 | /* OBSOLETE int signo; */ | |
150 | /* OBSOLETE int subsig; */ | |
151 | /* OBSOLETE int pc; */ | |
152 | /* OBSOLETE }; */ | |
153 | /* OBSOLETE */ | |
154 | /* OBSOLETE static struct threadpid signal_stack_bot[100]; */ | |
155 | /* OBSOLETE static struct threadpid *signal_stack = signal_stack_bot; */ | |
156 | /* OBSOLETE */ | |
157 | /* OBSOLETE /* How to detect empty stack -- bottom frame is all zero. *x/ */ | |
158 | /* OBSOLETE */ | |
159 | /* OBSOLETE #define signal_stack_is_empty() (signal_stack->pid == 0) */ | |
160 | /* OBSOLETE */ | |
161 | /* OBSOLETE /* Mode controlled by SET PIPE command, controls the psw SEQ bit */ | |
162 | /* OBSOLETE which forces each instruction to complete before the next one starts. *x/ */ | |
163 | /* OBSOLETE */ | |
164 | /* OBSOLETE static int sequential = 0; */ | |
165 | /* OBSOLETE */ | |
166 | /* OBSOLETE /* Mode controlled by the SET PARALLEL command. Values are: */ | |
167 | /* OBSOLETE 0 concurrency limit 1 thread, dynamic scheduling */ | |
168 | /* OBSOLETE 1 no concurrency limit, dynamic scheduling */ | |
169 | /* OBSOLETE 2 no concurrency limit, fixed scheduling *x/ */ | |
170 | /* OBSOLETE */ | |
171 | /* OBSOLETE static int parallel = 1; */ | |
172 | /* OBSOLETE */ | |
173 | /* OBSOLETE /* Mode controlled by SET BASE command, output radix for unformatted */ | |
174 | /* OBSOLETE integer typeout, as in argument lists, aggregates, and so on. */ | |
175 | /* OBSOLETE Zero means guess whether it's an address (hex) or not (decimal). *x/ */ | |
176 | /* OBSOLETE */ | |
177 | /* OBSOLETE static int output_radix = 0; */ | |
178 | /* OBSOLETE */ | |
179 | /* OBSOLETE /* Signal subcode at last thread stop. *x/ */ | |
180 | /* OBSOLETE */ | |
181 | /* OBSOLETE static int stop_sigcode; */ | |
182 | /* OBSOLETE */ | |
183 | /* OBSOLETE /* Hack, see wait() below. *x/ */ | |
184 | /* OBSOLETE */ | |
185 | /* OBSOLETE static int exec_trap_timer; */ | |
186 | /* OBSOLETE */ | |
187 | /* OBSOLETE #include "gdbcmd.h" */ | |
188 | /* OBSOLETE */ | |
189 | /* OBSOLETE static struct type *vector_type (); */ | |
190 | /* OBSOLETE static long *read_vector_register (); */ | |
191 | /* OBSOLETE static long *read_vector_register_1 (); */ | |
192 | /* OBSOLETE static void write_vector_register (); */ | |
193 | /* OBSOLETE static ULONGEST read_comm_register (); */ | |
194 | /* OBSOLETE static void write_comm_register (); */ | |
195 | /* OBSOLETE static void convex_cont_command (); */ | |
196 | /* OBSOLETE static void thread_continue (); */ | |
197 | /* OBSOLETE static void select_thread (); */ | |
198 | /* OBSOLETE static void scan_stack (); */ | |
199 | /* OBSOLETE static void set_fixed_scheduling (); */ | |
200 | /* OBSOLETE static char *subsig_name (); */ | |
201 | /* OBSOLETE static void psw_info (); */ | |
202 | /* OBSOLETE static sig_noop (); */ | |
203 | /* OBSOLETE static ptr_cmp (); */ | |
204 | /* OBSOLETE */ | |
205 | /* OBSOLETE \f */ | |
206 | /* OBSOLETE /* Execute ptrace. Convex V7 replaced ptrace with pattach. */ | |
207 | /* OBSOLETE Allow ptrace (0) as a no-op. *x/ */ | |
208 | /* OBSOLETE */ | |
209 | /* OBSOLETE int */ | |
210 | /* OBSOLETE call_ptrace (request, pid, procaddr, buf) */ | |
211 | /* OBSOLETE int request, pid; */ | |
212 | /* OBSOLETE PTRACE_ARG3_TYPE procaddr; */ | |
213 | /* OBSOLETE int buf; */ | |
214 | /* OBSOLETE { */ | |
215 | /* OBSOLETE if (request == 0) */ | |
216 | /* OBSOLETE return; */ | |
217 | /* OBSOLETE error ("no ptrace"); */ | |
218 | /* OBSOLETE } */ | |
219 | /* OBSOLETE */ | |
220 | /* OBSOLETE /* Replacement for system execle routine. */ | |
221 | /* OBSOLETE Convert it to an equivalent exect, which pattach insists on. *x/ */ | |
222 | /* OBSOLETE */ | |
223 | /* OBSOLETE execle (name, argv) */ | |
224 | /* OBSOLETE char *name, *argv; */ | |
225 | /* OBSOLETE { */ | |
226 | /* OBSOLETE char ***envp = (char ***) &argv; */ | |
227 | /* OBSOLETE while (*envp++) ; */ | |
228 | /* OBSOLETE */ | |
229 | /* OBSOLETE signal (SIGTRAP, sig_noop); */ | |
230 | /* OBSOLETE exect (name, &argv, *envp); */ | |
231 | /* OBSOLETE } */ | |
232 | /* OBSOLETE */ | |
233 | /* OBSOLETE /* Stupid handler for stupid trace trap that otherwise causes */ | |
234 | /* OBSOLETE startup to stupidly hang. *x/ */ | |
235 | /* OBSOLETE */ | |
236 | /* OBSOLETE static sig_noop () */ | |
237 | /* OBSOLETE {} */ | |
238 | /* OBSOLETE */ | |
239 | /* OBSOLETE /* Read registers from inferior into registers[] array. */ | |
240 | /* OBSOLETE For convex, they are already there, read in when the inferior stops. *x/ */ | |
241 | /* OBSOLETE */ | |
242 | /* OBSOLETE void */ | |
243 | /* OBSOLETE fetch_inferior_registers (regno) */ | |
244 | /* OBSOLETE int regno; */ | |
245 | /* OBSOLETE { */ | |
246 | /* OBSOLETE } */ | |
247 | /* OBSOLETE */ | |
248 | /* OBSOLETE /* Store our register values back into the inferior. */ | |
249 | /* OBSOLETE For Convex, do this only once, right before resuming inferior. *x/ */ | |
250 | /* OBSOLETE */ | |
251 | /* OBSOLETE void */ | |
252 | /* OBSOLETE store_inferior_registers (regno) */ | |
253 | /* OBSOLETE int regno; */ | |
254 | /* OBSOLETE { */ | |
255 | /* OBSOLETE } */ | |
256 | /* OBSOLETE */ | |
257 | /* OBSOLETE /* Copy LEN bytes from inferior's memory starting at MEMADDR */ | |
258 | /* OBSOLETE to debugger memory starting at MYADDR. */ | |
259 | /* OBSOLETE On failure (cannot read from inferior, usually because address is out */ | |
260 | /* OBSOLETE of bounds) returns the value of errno. *x/ */ | |
261 | /* OBSOLETE */ | |
262 | /* OBSOLETE int */ | |
263 | /* OBSOLETE read_inferior_memory (memaddr, myaddr, len) */ | |
264 | /* OBSOLETE CORE_ADDR memaddr; */ | |
265 | /* OBSOLETE char *myaddr; */ | |
266 | /* OBSOLETE int len; */ | |
267 | /* OBSOLETE { */ | |
268 | /* OBSOLETE errno = 0; */ | |
269 | /* OBSOLETE while (len > 0) */ | |
270 | /* OBSOLETE { */ | |
271 | /* OBSOLETE /* little-known undocumented max request size *x/ */ | |
272 | /* OBSOLETE int i = (len < 12288) ? len : 12288; */ | |
273 | /* OBSOLETE */ | |
274 | /* OBSOLETE lseek (inferior_fd, memaddr, 0); */ | |
275 | /* OBSOLETE read (inferior_fd, myaddr, i); */ | |
276 | /* OBSOLETE */ | |
277 | /* OBSOLETE memaddr += i; */ | |
278 | /* OBSOLETE myaddr += i; */ | |
279 | /* OBSOLETE len -= i; */ | |
280 | /* OBSOLETE } */ | |
281 | /* OBSOLETE if (errno) */ | |
282 | /* OBSOLETE memset (myaddr, '\0', len); */ | |
283 | /* OBSOLETE return errno; */ | |
284 | /* OBSOLETE } */ | |
285 | /* OBSOLETE */ | |
286 | /* OBSOLETE /* Copy LEN bytes of data from debugger memory at MYADDR */ | |
287 | /* OBSOLETE to inferior's memory at MEMADDR. */ | |
288 | /* OBSOLETE Returns errno on failure (cannot write the inferior) *x/ */ | |
289 | /* OBSOLETE */ | |
290 | /* OBSOLETE int */ | |
291 | /* OBSOLETE write_inferior_memory (memaddr, myaddr, len) */ | |
292 | /* OBSOLETE CORE_ADDR memaddr; */ | |
293 | /* OBSOLETE char *myaddr; */ | |
294 | /* OBSOLETE int len; */ | |
295 | /* OBSOLETE { */ | |
296 | /* OBSOLETE errno = 0; */ | |
297 | /* OBSOLETE lseek (inferior_fd, memaddr, 0); */ | |
298 | /* OBSOLETE write (inferior_fd, myaddr, len); */ | |
299 | /* OBSOLETE return errno; */ | |
300 | /* OBSOLETE } */ | |
301 | /* OBSOLETE */ | |
302 | /* OBSOLETE /* Here from create_inferior when the inferior process has been created */ | |
303 | /* OBSOLETE and started up. We must do a pattach to grab it for debugging. */ | |
304 | /* OBSOLETE */ | |
305 | /* OBSOLETE Also, intercept the CONT command by altering its dispatch address. *x/ */ | |
306 | /* OBSOLETE /* FIXME: This used to be called from a macro CREATE_INFERIOR_HOOK. */ | |
307 | /* OBSOLETE But now init_trace_fun is in the same place. So re-write this to */ | |
308 | /* OBSOLETE use the init_trace_fun (making convex a debugging target). *x/ */ | |
309 | /* OBSOLETE */ | |
310 | /* OBSOLETE create_inferior_hook (pid) */ | |
311 | /* OBSOLETE int pid; */ | |
312 | /* OBSOLETE { */ | |
313 | /* OBSOLETE static char cont[] = "cont"; */ | |
314 | /* OBSOLETE static char cont1[] = "c"; */ | |
315 | /* OBSOLETE char *linep = cont; */ | |
316 | /* OBSOLETE char *linep1 = cont1; */ | |
317 | /* OBSOLETE char **line = &linep; */ | |
318 | /* OBSOLETE char **line1 = &linep1; */ | |
319 | /* OBSOLETE struct cmd_list_element *c; */ | |
320 | /* OBSOLETE */ | |
321 | /* OBSOLETE c = lookup_cmd (line, cmdlist, "", 0); */ | |
322 | /* OBSOLETE c->function = convex_cont_command; */ | |
323 | /* OBSOLETE c = lookup_cmd (line1, cmdlist, "", 0); */ | |
324 | /* OBSOLETE c->function = convex_cont_command; */ | |
325 | /* OBSOLETE */ | |
326 | /* OBSOLETE inferior_fd = pattach (pid, O_EXCL); */ | |
327 | /* OBSOLETE if (inferior_fd < 0) */ | |
328 | /* OBSOLETE perror_with_name ("pattach"); */ | |
329 | /* OBSOLETE inferior_thread = 0; */ | |
330 | /* OBSOLETE set_fixed_scheduling (pid, parallel == 2); */ | |
331 | /* OBSOLETE } */ | |
332 | /* OBSOLETE */ | |
333 | /* OBSOLETE /* Attach process PID for debugging. *x/ */ | |
334 | /* OBSOLETE */ | |
335 | /* OBSOLETE attach (pid) */ | |
336 | /* OBSOLETE int pid; */ | |
337 | /* OBSOLETE { */ | |
338 | /* OBSOLETE int fd = pattach (pid, O_EXCL); */ | |
339 | /* OBSOLETE if (fd < 0) */ | |
340 | /* OBSOLETE perror_with_name ("pattach"); */ | |
341 | /* OBSOLETE attach_flag = 1; */ | |
342 | /* OBSOLETE /* wait for strange kernel reverberations to go away *x/ */ | |
343 | /* OBSOLETE sleep (1); */ | |
344 | /* OBSOLETE */ | |
345 | /* OBSOLETE setpgrp (pid, pid); */ | |
346 | /* OBSOLETE */ | |
347 | /* OBSOLETE inferior_fd = fd; */ | |
348 | /* OBSOLETE inferior_thread = 0; */ | |
349 | /* OBSOLETE return pid; */ | |
350 | /* OBSOLETE } */ | |
351 | /* OBSOLETE */ | |
352 | /* OBSOLETE /* Stop debugging the process whose number is PID */ | |
353 | /* OBSOLETE and continue it with signal number SIGNAL. */ | |
354 | /* OBSOLETE SIGNAL = 0 means just continue it. *x/ */ | |
355 | /* OBSOLETE */ | |
356 | /* OBSOLETE void */ | |
357 | /* OBSOLETE detach (signal) */ | |
358 | /* OBSOLETE int signal; */ | |
359 | /* OBSOLETE { */ | |
360 | /* OBSOLETE signal_stack = signal_stack_bot; */ | |
361 | /* OBSOLETE thread_continue (-1, 0, signal); */ | |
362 | /* OBSOLETE ioctl (inferior_fd, PIXDETACH, &ps); */ | |
363 | /* OBSOLETE close (inferior_fd); */ | |
364 | /* OBSOLETE inferior_fd = 0; */ | |
365 | /* OBSOLETE attach_flag = 0; */ | |
366 | /* OBSOLETE } */ | |
367 | /* OBSOLETE */ | |
368 | /* OBSOLETE /* Kill off the inferior process. *x/ */ | |
369 | /* OBSOLETE */ | |
370 | /* OBSOLETE kill_inferior () */ | |
371 | /* OBSOLETE { */ | |
372 | /* OBSOLETE if (inferior_pid == 0) */ | |
373 | /* OBSOLETE return; */ | |
374 | /* OBSOLETE ioctl (inferior_fd, PIXTERMINATE, 0); */ | |
375 | /* OBSOLETE wait (0); */ | |
376 | /* OBSOLETE target_mourn_inferior (); */ | |
377 | /* OBSOLETE } */ | |
378 | /* OBSOLETE */ | |
379 | /* OBSOLETE /* Read vector register REG, and return a pointer to the value. *x/ */ | |
380 | /* OBSOLETE */ | |
381 | /* OBSOLETE static long * */ | |
382 | /* OBSOLETE read_vector_register (reg) */ | |
383 | /* OBSOLETE int reg; */ | |
384 | /* OBSOLETE { */ | |
385 | /* OBSOLETE if (have_inferior_p ()) */ | |
386 | /* OBSOLETE { */ | |
387 | /* OBSOLETE errno = 0; */ | |
388 | /* OBSOLETE ps.pi_buffer = (char *) &vector_registers; */ | |
389 | /* OBSOLETE ps.pi_nbytes = sizeof vector_registers; */ | |
390 | /* OBSOLETE ps.pi_offset = 0; */ | |
391 | /* OBSOLETE ps.pi_thread = inferior_thread; */ | |
392 | /* OBSOLETE ioctl (inferior_fd, PIXRDVREGS, &ps); */ | |
393 | /* OBSOLETE if (errno) */ | |
c5aa993b | 394 | /* OBSOLETE memset (&vector_registers, '\0', sizeof vector_registers); */ |
085dd6e6 JM |
395 | /* OBSOLETE } */ |
396 | /* OBSOLETE else if (corechan >= 0) */ | |
397 | /* OBSOLETE { */ | |
398 | /* OBSOLETE lseek (corechan, tcontext_offset[inferior_thread], 0); */ | |
399 | /* OBSOLETE if (myread (corechan, &tc, sizeof tc) < 0) */ | |
c5aa993b | 400 | /* OBSOLETE perror_with_name (corefile); */ |
085dd6e6 JM |
401 | /* OBSOLETE lseek (corechan, tc.core_thread_p, 0); */ |
402 | /* OBSOLETE if (myread (corechan, &th, sizeof th) < 0) */ | |
c5aa993b | 403 | /* OBSOLETE perror_with_name (corefile); */ |
085dd6e6 JM |
404 | /* OBSOLETE lseek (corechan, tc.core_vregs_p, 0); */ |
405 | /* OBSOLETE if (myread (corechan, &vector_registers, 16*128) < 0) */ | |
c5aa993b | 406 | /* OBSOLETE perror_with_name (corefile); */ |
085dd6e6 JM |
407 | /* OBSOLETE vector_registers.vm[0] = th.t_vect_ctx.vc_vm[0]; */ |
408 | /* OBSOLETE vector_registers.vm[1] = th.t_vect_ctx.vc_vm[1]; */ | |
409 | /* OBSOLETE vector_registers.vls = th.t_vect_ctx.vc_vls; */ | |
410 | /* OBSOLETE } */ | |
411 | /* OBSOLETE */ | |
412 | /* OBSOLETE return read_vector_register_1 (reg); */ | |
413 | /* OBSOLETE } */ | |
414 | /* OBSOLETE */ | |
415 | /* OBSOLETE /* Return a pointer to vector register REG, which must already have been */ | |
416 | /* OBSOLETE fetched from the inferior or core file. *x/ */ | |
417 | /* OBSOLETE */ | |
418 | /* OBSOLETE static long * */ | |
419 | /* OBSOLETE read_vector_register_1 (reg) */ | |
420 | /* OBSOLETE int reg; */ | |
421 | /* OBSOLETE { */ | |
422 | /* OBSOLETE switch (reg) */ | |
423 | /* OBSOLETE { */ | |
424 | /* OBSOLETE case VM_REGNUM: */ | |
425 | /* OBSOLETE return (long *) vector_registers.vm; */ | |
426 | /* OBSOLETE case VS_REGNUM: */ | |
427 | /* OBSOLETE return (long *) &vector_registers.vls; */ | |
428 | /* OBSOLETE case VL_REGNUM: */ | |
429 | /* OBSOLETE return 1 + (long *) &vector_registers.vls; */ | |
430 | /* OBSOLETE default: */ | |
431 | /* OBSOLETE return (long *) &vector_registers.vr[reg]; */ | |
432 | /* OBSOLETE } */ | |
433 | /* OBSOLETE } */ | |
434 | /* OBSOLETE */ | |
435 | /* OBSOLETE /* Write vector register REG, element ELEMENT, new value VAL. */ | |
436 | /* OBSOLETE NB: must use read-modify-write on the entire vector state, */ | |
437 | /* OBSOLETE since pattach does not do offsetted writes correctly. *x/ */ | |
438 | /* OBSOLETE */ | |
439 | /* OBSOLETE static void */ | |
440 | /* OBSOLETE write_vector_register (reg, element, val) */ | |
441 | /* OBSOLETE int reg, element; */ | |
442 | /* OBSOLETE ULONGEST val; */ | |
443 | /* OBSOLETE { */ | |
444 | /* OBSOLETE if (have_inferior_p ()) */ | |
445 | /* OBSOLETE { */ | |
446 | /* OBSOLETE errno = 0; */ | |
447 | /* OBSOLETE ps.pi_thread = inferior_thread; */ | |
448 | /* OBSOLETE ps.pi_offset = 0; */ | |
449 | /* OBSOLETE ps.pi_buffer = (char *) &vector_registers; */ | |
450 | /* OBSOLETE ps.pi_nbytes = sizeof vector_registers; */ | |
451 | /* OBSOLETE */ | |
452 | /* OBSOLETE ioctl (inferior_fd, PIXRDVREGS, &ps); */ | |
453 | /* OBSOLETE */ | |
454 | /* OBSOLETE switch (reg) */ | |
c5aa993b JM |
455 | /* OBSOLETE { */ |
456 | /* OBSOLETE case VL_REGNUM: */ | |
457 | /* OBSOLETE vector_registers.vls = */ | |
458 | /* OBSOLETE (vector_registers.vls & 0xffffffff00000000LL) */ | |
459 | /* OBSOLETE + (unsigned long) val; */ | |
460 | /* OBSOLETE break; */ | |
461 | /* OBSOLETE */ | |
462 | /* OBSOLETE case VS_REGNUM: */ | |
463 | /* OBSOLETE vector_registers.vls = */ | |
464 | /* OBSOLETE (val << 32) + (unsigned long) vector_registers.vls; */ | |
465 | /* OBSOLETE break; */ | |
466 | /* OBSOLETE */ | |
467 | /* OBSOLETE default: */ | |
468 | /* OBSOLETE vector_registers.vr[reg].el[element] = val; */ | |
469 | /* OBSOLETE break; */ | |
470 | /* OBSOLETE } */ | |
085dd6e6 JM |
471 | /* OBSOLETE */ |
472 | /* OBSOLETE ioctl (inferior_fd, PIXWRVREGS, &ps); */ | |
473 | /* OBSOLETE */ | |
474 | /* OBSOLETE if (errno) */ | |
c5aa993b | 475 | /* OBSOLETE perror_with_name ("writing vector register"); */ |
085dd6e6 JM |
476 | /* OBSOLETE } */ |
477 | /* OBSOLETE } */ | |
478 | /* OBSOLETE */ | |
479 | /* OBSOLETE /* Return the contents of communication register NUM. *x/ */ | |
480 | /* OBSOLETE */ | |
481 | /* OBSOLETE static ULONGEST */ | |
482 | /* OBSOLETE read_comm_register (num) */ | |
483 | /* OBSOLETE int num; */ | |
484 | /* OBSOLETE { */ | |
485 | /* OBSOLETE if (have_inferior_p ()) */ | |
486 | /* OBSOLETE { */ | |
487 | /* OBSOLETE ps.pi_buffer = (char *) &comm_registers; */ | |
488 | /* OBSOLETE ps.pi_nbytes = sizeof comm_registers; */ | |
489 | /* OBSOLETE ps.pi_offset = 0; */ | |
490 | /* OBSOLETE ps.pi_thread = inferior_thread; */ | |
491 | /* OBSOLETE ioctl (inferior_fd, PIXRDCREGS, &ps); */ | |
492 | /* OBSOLETE } */ | |
493 | /* OBSOLETE return comm_registers.crreg.r4[num]; */ | |
494 | /* OBSOLETE } */ | |
495 | /* OBSOLETE */ | |
496 | /* OBSOLETE /* Store a new value VAL into communication register NUM. */ | |
497 | /* OBSOLETE NB: Must use read-modify-write on the whole comm register set */ | |
498 | /* OBSOLETE since pattach does not do offsetted writes correctly. *x/ */ | |
499 | /* OBSOLETE */ | |
500 | /* OBSOLETE static void */ | |
501 | /* OBSOLETE write_comm_register (num, val) */ | |
502 | /* OBSOLETE int num; */ | |
503 | /* OBSOLETE ULONGEST val; */ | |
504 | /* OBSOLETE { */ | |
505 | /* OBSOLETE if (have_inferior_p ()) */ | |
506 | /* OBSOLETE { */ | |
507 | /* OBSOLETE ps.pi_buffer = (char *) &comm_registers; */ | |
508 | /* OBSOLETE ps.pi_nbytes = sizeof comm_registers; */ | |
509 | /* OBSOLETE ps.pi_offset = 0; */ | |
510 | /* OBSOLETE ps.pi_thread = inferior_thread; */ | |
511 | /* OBSOLETE ioctl (inferior_fd, PIXRDCREGS, &ps); */ | |
512 | /* OBSOLETE comm_registers.crreg.r4[num] = val; */ | |
513 | /* OBSOLETE ioctl (inferior_fd, PIXWRCREGS, &ps); */ | |
514 | /* OBSOLETE } */ | |
515 | /* OBSOLETE } */ | |
516 | /* OBSOLETE */ | |
517 | /* OBSOLETE /* Resume execution of the inferior process. */ | |
518 | /* OBSOLETE If STEP is nonzero, single-step it. */ | |
519 | /* OBSOLETE If SIGNAL is nonzero, give it that signal. *x/ */ | |
520 | /* OBSOLETE */ | |
521 | /* OBSOLETE void */ | |
522 | /* OBSOLETE resume (step, signal) */ | |
523 | /* OBSOLETE int step; */ | |
524 | /* OBSOLETE int signal; */ | |
525 | /* OBSOLETE { */ | |
526 | /* OBSOLETE errno = 0; */ | |
527 | /* OBSOLETE if (step || signal) */ | |
528 | /* OBSOLETE thread_continue (inferior_thread, step, signal); */ | |
529 | /* OBSOLETE else */ | |
530 | /* OBSOLETE thread_continue (-1, 0, 0); */ | |
531 | /* OBSOLETE } */ | |
532 | /* OBSOLETE */ | |
533 | /* OBSOLETE /* Maybe resume some threads. */ | |
534 | /* OBSOLETE THREAD is which thread to resume, or -1 to resume them all. */ | |
535 | /* OBSOLETE STEP and SIGNAL are as in resume. */ | |
536 | /* OBSOLETE */ | |
537 | /* OBSOLETE Global variable ALL_CONTINUE is set when we are here to do a */ | |
538 | /* OBSOLETE `cont' command; otherwise we may be doing `finish' or a call or */ | |
539 | /* OBSOLETE something else that will not tolerate an automatic thread switch. */ | |
540 | /* OBSOLETE */ | |
541 | /* OBSOLETE If there are stopped threads waiting to deliver signals, and */ | |
542 | /* OBSOLETE ALL_CONTINUE, do not actually resume anything. gdb will do a wait */ | |
543 | /* OBSOLETE and see one of the stopped threads in the queue. *x/ */ | |
544 | /* OBSOLETE */ | |
545 | /* OBSOLETE static void */ | |
546 | /* OBSOLETE thread_continue (thread, step, signal) */ | |
547 | /* OBSOLETE int thread, step, signal; */ | |
548 | /* OBSOLETE { */ | |
549 | /* OBSOLETE int n; */ | |
550 | /* OBSOLETE */ | |
551 | /* OBSOLETE /* If we are to continue all threads, but not for the CONTINUE command, */ | |
552 | /* OBSOLETE pay no attention and continue only the selected thread. *x/ */ | |
553 | /* OBSOLETE */ | |
554 | /* OBSOLETE if (thread < 0 && ! all_continue) */ | |
555 | /* OBSOLETE thread = inferior_thread; */ | |
556 | /* OBSOLETE */ | |
557 | /* OBSOLETE /* If we are not stepping, we have now executed the continue part */ | |
558 | /* OBSOLETE of a CONTINUE command. *x/ */ | |
559 | /* OBSOLETE */ | |
560 | /* OBSOLETE if (! step) */ | |
561 | /* OBSOLETE all_continue = 0; */ | |
562 | /* OBSOLETE */ | |
563 | /* OBSOLETE /* Allow wait() to switch threads if this is an all-out continue. *x/ */ | |
564 | /* OBSOLETE */ | |
565 | /* OBSOLETE thread_switch_ok = thread < 0; */ | |
566 | /* OBSOLETE */ | |
567 | /* OBSOLETE /* If there are threads queued up, don't resume. *x/ */ | |
568 | /* OBSOLETE */ | |
569 | /* OBSOLETE if (thread_switch_ok && ! signal_stack_is_empty ()) */ | |
570 | /* OBSOLETE return; */ | |
571 | /* OBSOLETE */ | |
572 | /* OBSOLETE /* OK, do it. *x/ */ | |
573 | /* OBSOLETE */ | |
574 | /* OBSOLETE for (n = 0; n < n_threads; n++) */ | |
575 | /* OBSOLETE if (thread_state[n] == PI_TALIVE) */ | |
576 | /* OBSOLETE { */ | |
c5aa993b JM |
577 | /* OBSOLETE select_thread (n); */ |
578 | /* OBSOLETE */ | |
579 | /* OBSOLETE if ((thread < 0 || n == thread) && ! thread_is_in_kernel[n]) */ | |
580 | /* OBSOLETE { */ | |
581 | /* OBSOLETE /* Blam the trace bits in the stack's saved psws to match */ | |
582 | /* OBSOLETE the desired step mode. This is required so that */ | |
583 | /* OBSOLETE single-stepping a return doesn't restore a psw with a */ | |
584 | /* OBSOLETE clear trace bit and fly away, and conversely, */ | |
585 | /* OBSOLETE proceeding through a return in a routine that was */ | |
586 | /* OBSOLETE stepped into doesn't cause a phantom break by restoring */ | |
587 | /* OBSOLETE a psw with the trace bit set. *x/ */ | |
588 | /* OBSOLETE scan_stack (PSW_T_BIT, step); */ | |
589 | /* OBSOLETE scan_stack (PSW_S_BIT, sequential); */ | |
590 | /* OBSOLETE } */ | |
591 | /* OBSOLETE */ | |
592 | /* OBSOLETE ps.pi_buffer = registers; */ | |
593 | /* OBSOLETE ps.pi_nbytes = REGISTER_BYTES; */ | |
594 | /* OBSOLETE ps.pi_offset = 0; */ | |
595 | /* OBSOLETE ps.pi_thread = n; */ | |
596 | /* OBSOLETE if (! thread_is_in_kernel[n]) */ | |
597 | /* OBSOLETE if (ioctl (inferior_fd, PIXWRREGS, &ps)) */ | |
598 | /* OBSOLETE perror_with_name ("PIXWRREGS"); */ | |
599 | /* OBSOLETE */ | |
600 | /* OBSOLETE if (thread < 0 || n == thread) */ | |
601 | /* OBSOLETE { */ | |
602 | /* OBSOLETE ps.pi_pc = 1; */ | |
603 | /* OBSOLETE ps.pi_signo = signal; */ | |
604 | /* OBSOLETE if (ioctl (inferior_fd, step ? PIXSTEP : PIXCONTINUE, &ps) < 0) */ | |
605 | /* OBSOLETE perror_with_name ("PIXCONTINUE"); */ | |
606 | /* OBSOLETE } */ | |
085dd6e6 JM |
607 | /* OBSOLETE } */ |
608 | /* OBSOLETE */ | |
609 | /* OBSOLETE if (ioctl (inferior_fd, PIXRUN, &ps) < 0) */ | |
610 | /* OBSOLETE perror_with_name ("PIXRUN"); */ | |
611 | /* OBSOLETE } */ | |
612 | /* OBSOLETE */ | |
613 | /* OBSOLETE /* Replacement for system wait routine. */ | |
614 | /* OBSOLETE */ | |
615 | /* OBSOLETE The system wait returns with one or more threads stopped by */ | |
616 | /* OBSOLETE signals. Put stopped threads on a stack and return them one by */ | |
617 | /* OBSOLETE one, so that it appears that wait returns one thread at a time. */ | |
618 | /* OBSOLETE */ | |
619 | /* OBSOLETE Global variable THREAD_SWITCH_OK is set when gdb can tolerate wait */ | |
620 | /* OBSOLETE returning a new thread. If it is false, then only one thread is */ | |
621 | /* OBSOLETE running; we will do a real wait, the thread will do something, and */ | |
622 | /* OBSOLETE we will return that. *x/ */ | |
623 | /* OBSOLETE */ | |
624 | /* OBSOLETE pid_t */ | |
625 | /* OBSOLETE wait (w) */ | |
626 | /* OBSOLETE union wait *w; */ | |
627 | /* OBSOLETE { */ | |
628 | /* OBSOLETE int pid; */ | |
629 | /* OBSOLETE */ | |
630 | /* OBSOLETE if (!w) */ | |
631 | /* OBSOLETE return wait3 (0, 0, 0); */ | |
632 | /* OBSOLETE */ | |
633 | /* OBSOLETE /* Do a real wait if we were told to, or if there are no queued threads. *x/ */ | |
634 | /* OBSOLETE */ | |
635 | /* OBSOLETE if (! thread_switch_ok || signal_stack_is_empty ()) */ | |
636 | /* OBSOLETE { */ | |
637 | /* OBSOLETE int thread; */ | |
638 | /* OBSOLETE */ | |
639 | /* OBSOLETE pid = wait3 (w, 0, 0); */ | |
640 | /* OBSOLETE */ | |
641 | /* OBSOLETE if (!WIFSTOPPED (*w) || pid != inferior_pid) */ | |
c5aa993b | 642 | /* OBSOLETE return pid; */ |
085dd6e6 JM |
643 | /* OBSOLETE */ |
644 | /* OBSOLETE /* The inferior has done something and stopped. Read in all the */ | |
c5aa993b | 645 | /* OBSOLETE threads' registers, and queue up any signals that happened. *x/ */ |
085dd6e6 JM |
646 | /* OBSOLETE */ |
647 | /* OBSOLETE if (ioctl (inferior_fd, PIXGETTHCOUNT, &ps) < 0) */ | |
c5aa993b | 648 | /* OBSOLETE perror_with_name ("PIXGETTHCOUNT"); */ |
085dd6e6 JM |
649 | /* OBSOLETE */ |
650 | /* OBSOLETE n_threads = ps.pi_othdcnt; */ | |
651 | /* OBSOLETE for (thread = 0; thread < n_threads; thread++) */ | |
c5aa993b JM |
652 | /* OBSOLETE { */ |
653 | /* OBSOLETE ps.pi_thread = thread; */ | |
654 | /* OBSOLETE if (ioctl (inferior_fd, PIXGETSUBCODE, &ps) < 0) */ | |
655 | /* OBSOLETE perror_with_name ("PIXGETSUBCODE"); */ | |
656 | /* OBSOLETE thread_state[thread] = ps.pi_otstate; */ | |
657 | /* OBSOLETE */ | |
658 | /* OBSOLETE if (ps.pi_otstate == PI_TALIVE) */ | |
659 | /* OBSOLETE { */ | |
660 | /* OBSOLETE select_thread (thread); */ | |
661 | /* OBSOLETE ps.pi_buffer = registers; */ | |
662 | /* OBSOLETE ps.pi_nbytes = REGISTER_BYTES; */ | |
663 | /* OBSOLETE ps.pi_offset = 0; */ | |
664 | /* OBSOLETE ps.pi_thread = thread; */ | |
665 | /* OBSOLETE if (ioctl (inferior_fd, PIXRDREGS, &ps) < 0) */ | |
666 | /* OBSOLETE perror_with_name ("PIXRDREGS"); */ | |
667 | /* OBSOLETE */ | |
668 | /* OBSOLETE registers_fetched (); */ | |
669 | /* OBSOLETE */ | |
670 | /* OBSOLETE thread_pc[thread] = read_pc (); */ | |
671 | /* OBSOLETE thread_signal[thread] = ps.pi_osigno; */ | |
672 | /* OBSOLETE thread_sigcode[thread] = ps.pi_osigcode; */ | |
673 | /* OBSOLETE */ | |
674 | /* OBSOLETE /* If the thread's stack has a context frame */ | |
675 | /* OBSOLETE on top, something fucked is going on. I do not */ | |
676 | /* OBSOLETE know what, but do I know this: the only thing you */ | |
677 | /* OBSOLETE can do with such a thread is continue it. *x/ */ | |
678 | /* OBSOLETE */ | |
679 | /* OBSOLETE thread_is_in_kernel[thread] = */ | |
680 | /* OBSOLETE ((read_register (PS_REGNUM) >> 25) & 3) == 0; */ | |
681 | /* OBSOLETE */ | |
682 | /* OBSOLETE /* Signals push an extended frame and then fault */ | |
683 | /* OBSOLETE with a ridiculous pc. Pop the frame. *x/ */ | |
684 | /* OBSOLETE */ | |
685 | /* OBSOLETE if (thread_pc[thread] > STACK_END_ADDR) */ | |
686 | /* OBSOLETE { */ | |
687 | /* OBSOLETE POP_FRAME; */ | |
688 | /* OBSOLETE if (is_break_pc (thread_pc[thread])) */ | |
689 | /* OBSOLETE thread_pc[thread] = read_pc () - 2; */ | |
690 | /* OBSOLETE else */ | |
691 | /* OBSOLETE thread_pc[thread] = read_pc (); */ | |
692 | /* OBSOLETE write_register (PC_REGNUM, thread_pc[thread]); */ | |
693 | /* OBSOLETE } */ | |
694 | /* OBSOLETE */ | |
695 | /* OBSOLETE if (ps.pi_osigno || ps.pi_osigcode) */ | |
696 | /* OBSOLETE { */ | |
697 | /* OBSOLETE signal_stack++; */ | |
698 | /* OBSOLETE signal_stack->pid = pid; */ | |
699 | /* OBSOLETE signal_stack->thread = thread; */ | |
700 | /* OBSOLETE signal_stack->signo = thread_signal[thread]; */ | |
701 | /* OBSOLETE signal_stack->subsig = thread_sigcode[thread]; */ | |
702 | /* OBSOLETE signal_stack->pc = thread_pc[thread]; */ | |
703 | /* OBSOLETE } */ | |
704 | /* OBSOLETE */ | |
705 | /* OBSOLETE /* The following hackery is caused by a unix 7.1 feature: */ | |
706 | /* OBSOLETE the inferior's fixed scheduling mode is cleared when */ | |
707 | /* OBSOLETE it execs the shell (since the shell is not a parallel */ | |
708 | /* OBSOLETE program). So, note the 5.4 trap we get when */ | |
709 | /* OBSOLETE the shell does its exec, then catch the 5.0 trap */ | |
710 | /* OBSOLETE that occurs when the debuggee starts, and set fixed */ | |
711 | /* OBSOLETE scheduling mode properly. *x/ */ | |
712 | /* OBSOLETE */ | |
713 | /* OBSOLETE if (ps.pi_osigno == 5 && ps.pi_osigcode == 4) */ | |
714 | /* OBSOLETE exec_trap_timer = 1; */ | |
715 | /* OBSOLETE else */ | |
716 | /* OBSOLETE exec_trap_timer--; */ | |
717 | /* OBSOLETE */ | |
718 | /* OBSOLETE if (ps.pi_osigno == 5 && exec_trap_timer == 0) */ | |
719 | /* OBSOLETE set_fixed_scheduling (pid, parallel == 2); */ | |
720 | /* OBSOLETE } */ | |
721 | /* OBSOLETE } */ | |
085dd6e6 JM |
722 | /* OBSOLETE */ |
723 | /* OBSOLETE if (signal_stack_is_empty ()) */ | |
c5aa993b | 724 | /* OBSOLETE error ("no active threads?!"); */ |
085dd6e6 JM |
725 | /* OBSOLETE } */ |
726 | /* OBSOLETE */ | |
727 | /* OBSOLETE /* Select the thread that stopped, and return *w saying why. *x/ */ | |
728 | /* OBSOLETE */ | |
729 | /* OBSOLETE select_thread (signal_stack->thread); */ | |
730 | /* OBSOLETE */ | |
731 | /* OBSOLETE FIXME: need to convert from host sig. */ | |
732 | /* OBSOLETE stop_signal = signal_stack->signo; */ | |
733 | /* OBSOLETE stop_sigcode = signal_stack->subsig; */ | |
734 | /* OBSOLETE */ | |
735 | /* OBSOLETE WSETSTOP (*w, signal_stack->signo); */ | |
736 | /* OBSOLETE w->w_thread = signal_stack->thread; */ | |
737 | /* OBSOLETE return (signal_stack--)->pid; */ | |
738 | /* OBSOLETE } */ | |
739 | /* OBSOLETE */ | |
740 | /* OBSOLETE /* Select thread THREAD -- its registers, stack, per-thread memory. */ | |
741 | /* OBSOLETE This is the only routine that may assign to inferior_thread */ | |
742 | /* OBSOLETE or thread_regs[]. *x/ */ | |
743 | /* OBSOLETE */ | |
744 | /* OBSOLETE static void */ | |
745 | /* OBSOLETE select_thread (thread) */ | |
746 | /* OBSOLETE int thread; */ | |
747 | /* OBSOLETE { */ | |
748 | /* OBSOLETE if (thread == inferior_thread) */ | |
749 | /* OBSOLETE return; */ | |
750 | /* OBSOLETE */ | |
751 | /* OBSOLETE memcpy (thread_regs[inferior_thread], registers, REGISTER_BYTES); */ | |
752 | /* OBSOLETE ps.pi_thread = inferior_thread = thread; */ | |
753 | /* OBSOLETE if (have_inferior_p ()) */ | |
754 | /* OBSOLETE ioctl (inferior_fd, PISETRWTID, &ps); */ | |
755 | /* OBSOLETE memcpy (registers, thread_regs[thread], REGISTER_BYTES); */ | |
756 | /* OBSOLETE } */ | |
757 | /* OBSOLETE */ | |
758 | /* OBSOLETE /* Routine to set or clear a psw bit in the psw and also all psws */ | |
759 | /* OBSOLETE saved on the stack. Quits when we get to a frame in which the */ | |
760 | /* OBSOLETE saved psw is correct. *x/ */ | |
761 | /* OBSOLETE */ | |
762 | /* OBSOLETE static void */ | |
763 | /* OBSOLETE scan_stack (bit, val) */ | |
764 | /* OBSOLETE long bit, val; */ | |
765 | /* OBSOLETE { */ | |
766 | /* OBSOLETE long ps = read_register (PS_REGNUM); */ | |
767 | /* OBSOLETE long fp; */ | |
768 | /* OBSOLETE if (val ? !(ps & bit) : (ps & bit)) */ | |
769 | /* OBSOLETE { */ | |
770 | /* OBSOLETE ps ^= bit; */ | |
771 | /* OBSOLETE write_register (PS_REGNUM, ps); */ | |
772 | /* OBSOLETE */ | |
773 | /* OBSOLETE fp = read_register (FP_REGNUM); */ | |
774 | /* OBSOLETE while (fp & 0x80000000) */ | |
c5aa993b JM |
775 | /* OBSOLETE { */ |
776 | /* OBSOLETE ps = read_memory_integer (fp + 4, 4); */ | |
777 | /* OBSOLETE if (val ? (ps & bit) : !(ps & bit)) */ | |
778 | /* OBSOLETE break; */ | |
779 | /* OBSOLETE ps ^= bit; */ | |
780 | /* OBSOLETE write_memory (fp + 4, &ps, 4); */ | |
781 | /* OBSOLETE fp = read_memory_integer (fp + 8, 4); */ | |
782 | /* OBSOLETE } */ | |
085dd6e6 JM |
783 | /* OBSOLETE } */ |
784 | /* OBSOLETE } */ | |
785 | /* OBSOLETE */ | |
786 | /* OBSOLETE /* Set fixed scheduling (alliant mode) of process PID to ARG (0 or 1). *x/ */ | |
787 | /* OBSOLETE */ | |
788 | /* OBSOLETE static void */ | |
789 | /* OBSOLETE set_fixed_scheduling (pid, arg) */ | |
790 | /* OBSOLETE int arg; */ | |
791 | /* OBSOLETE { */ | |
792 | /* OBSOLETE struct pattributes pattr; */ | |
793 | /* OBSOLETE getpattr (pid, &pattr); */ | |
794 | /* OBSOLETE pattr.pattr_pfixed = arg; */ | |
795 | /* OBSOLETE setpattr (pid, &pattr); */ | |
796 | /* OBSOLETE } */ | |
797 | /* OBSOLETE \f */ | |
798 | /* OBSOLETE void */ | |
799 | /* OBSOLETE core_file_command (filename, from_tty) */ | |
800 | /* OBSOLETE char *filename; */ | |
801 | /* OBSOLETE int from_tty; */ | |
802 | /* OBSOLETE { */ | |
803 | /* OBSOLETE int n; */ | |
804 | /* OBSOLETE */ | |
805 | /* OBSOLETE /* Discard all vestiges of any previous core file */ | |
806 | /* OBSOLETE and mark data and stack spaces as empty. *x/ */ | |
807 | /* OBSOLETE */ | |
808 | /* OBSOLETE if (corefile) */ | |
809 | /* OBSOLETE free (corefile); */ | |
810 | /* OBSOLETE corefile = 0; */ | |
811 | /* OBSOLETE */ | |
812 | /* OBSOLETE if (corechan >= 0) */ | |
813 | /* OBSOLETE close (corechan); */ | |
814 | /* OBSOLETE corechan = -1; */ | |
815 | /* OBSOLETE */ | |
816 | /* OBSOLETE data_start = 0; */ | |
817 | /* OBSOLETE data_end = 0; */ | |
818 | /* OBSOLETE stack_start = STACK_END_ADDR; */ | |
819 | /* OBSOLETE stack_end = STACK_END_ADDR; */ | |
820 | /* OBSOLETE n_core = 0; */ | |
821 | /* OBSOLETE */ | |
822 | /* OBSOLETE /* Now, if a new core file was specified, open it and digest it. *x/ */ | |
823 | /* OBSOLETE */ | |
824 | /* OBSOLETE if (filename) */ | |
825 | /* OBSOLETE { */ | |
826 | /* OBSOLETE filename = tilde_expand (filename); */ | |
827 | /* OBSOLETE make_cleanup (free, filename); */ | |
828 | /* OBSOLETE */ | |
829 | /* OBSOLETE if (have_inferior_p ()) */ | |
c5aa993b | 830 | /* OBSOLETE error ("To look at a core file, you must kill the program with \"kill\"."); */ |
085dd6e6 JM |
831 | /* OBSOLETE corechan = open (filename, O_RDONLY, 0); */ |
832 | /* OBSOLETE if (corechan < 0) */ | |
c5aa993b | 833 | /* OBSOLETE perror_with_name (filename); */ |
085dd6e6 JM |
834 | /* OBSOLETE */ |
835 | /* OBSOLETE if (myread (corechan, &filehdr, sizeof filehdr) < 0) */ | |
c5aa993b | 836 | /* OBSOLETE perror_with_name (filename); */ |
085dd6e6 JM |
837 | /* OBSOLETE */ |
838 | /* OBSOLETE if (!IS_CORE_SOFF_MAGIC (filehdr.h_magic)) */ | |
c5aa993b | 839 | /* OBSOLETE error ("%s: not a core file.\n", filename); */ |
085dd6e6 JM |
840 | /* OBSOLETE */ |
841 | /* OBSOLETE if (myread (corechan, &opthdr, filehdr.h_opthdr) < 0) */ | |
c5aa993b | 842 | /* OBSOLETE perror_with_name (filename); */ |
085dd6e6 JM |
843 | /* OBSOLETE */ |
844 | /* OBSOLETE /* Read through the section headers. */ | |
c5aa993b JM |
845 | /* OBSOLETE For text, data, etc, record an entry in the core file map. */ |
846 | /* OBSOLETE For context and tcontext, record the file address of */ | |
847 | /* OBSOLETE the context blocks. *x/ */ | |
085dd6e6 JM |
848 | /* OBSOLETE */ |
849 | /* OBSOLETE lseek (corechan, (long) filehdr.h_scnptr, 0); */ | |
850 | /* OBSOLETE */ | |
851 | /* OBSOLETE n_threads = 0; */ | |
852 | /* OBSOLETE for (n = 0; n < filehdr.h_nscns; n++) */ | |
c5aa993b JM |
853 | /* OBSOLETE { */ |
854 | /* OBSOLETE if (myread (corechan, &scnhdr, sizeof scnhdr) < 0) */ | |
855 | /* OBSOLETE perror_with_name (filename); */ | |
856 | /* OBSOLETE if ((scnhdr.s_flags & S_TYPMASK) >= S_TEXT */ | |
857 | /* OBSOLETE && (scnhdr.s_flags & S_TYPMASK) <= S_COMON) */ | |
858 | /* OBSOLETE { */ | |
859 | /* OBSOLETE core_map[n_core].mem_addr = scnhdr.s_vaddr; */ | |
860 | /* OBSOLETE core_map[n_core].mem_end = scnhdr.s_vaddr + scnhdr.s_size; */ | |
861 | /* OBSOLETE core_map[n_core].file_addr = scnhdr.s_scnptr; */ | |
862 | /* OBSOLETE core_map[n_core].type = scnhdr.s_flags & S_TYPMASK; */ | |
863 | /* OBSOLETE if (core_map[n_core].type != S_TBSS */ | |
864 | /* OBSOLETE && core_map[n_core].type != S_TDATA */ | |
865 | /* OBSOLETE && core_map[n_core].type != S_TTEXT) */ | |
866 | /* OBSOLETE core_map[n_core].thread = -1; */ | |
867 | /* OBSOLETE else if (n_core == 0 */ | |
868 | /* OBSOLETE || core_map[n_core-1].mem_addr != scnhdr.s_vaddr) */ | |
869 | /* OBSOLETE core_map[n_core].thread = 0; */ | |
870 | /* OBSOLETE else */ | |
871 | /* OBSOLETE core_map[n_core].thread = core_map[n_core-1].thread + 1; */ | |
872 | /* OBSOLETE n_core++; */ | |
873 | /* OBSOLETE } */ | |
874 | /* OBSOLETE else if ((scnhdr.s_flags & S_TYPMASK) == S_CONTEXT) */ | |
875 | /* OBSOLETE context_offset = scnhdr.s_scnptr; */ | |
876 | /* OBSOLETE else if ((scnhdr.s_flags & S_TYPMASK) == S_TCONTEXT) */ | |
877 | /* OBSOLETE tcontext_offset[n_threads++] = scnhdr.s_scnptr; */ | |
878 | /* OBSOLETE } */ | |
085dd6e6 JM |
879 | /* OBSOLETE */ |
880 | /* OBSOLETE /* Read the context block, struct user, struct proc, */ | |
c5aa993b | 881 | /* OBSOLETE and the comm regs. *x/ */ |
085dd6e6 JM |
882 | /* OBSOLETE */ |
883 | /* OBSOLETE lseek (corechan, context_offset, 0); */ | |
884 | /* OBSOLETE if (myread (corechan, &c, sizeof c) < 0) */ | |
c5aa993b | 885 | /* OBSOLETE perror_with_name (filename); */ |
085dd6e6 JM |
886 | /* OBSOLETE lseek (corechan, c.core_user_p, 0); */ |
887 | /* OBSOLETE if (myread (corechan, &u, sizeof u) < 0) */ | |
c5aa993b | 888 | /* OBSOLETE perror_with_name (filename); */ |
085dd6e6 JM |
889 | /* OBSOLETE lseek (corechan, c.core_proc_p, 0); */ |
890 | /* OBSOLETE if (myread (corechan, &pr, sizeof pr) < 0) */ | |
c5aa993b | 891 | /* OBSOLETE perror_with_name (filename); */ |
085dd6e6 JM |
892 | /* OBSOLETE comm_registers = pr.p_creg; */ |
893 | /* OBSOLETE */ | |
894 | /* OBSOLETE /* Core file apparently is really there. Make it really exist */ | |
c5aa993b | 895 | /* OBSOLETE for xfer_core_file so we can do read_memory on it. *x/ */ |
085dd6e6 JM |
896 | /* OBSOLETE */ |
897 | /* OBSOLETE if (filename[0] == '/') */ | |
c5aa993b | 898 | /* OBSOLETE corefile = savestring (filename, strlen (filename)); */ |
085dd6e6 | 899 | /* OBSOLETE else */ |
c5aa993b | 900 | /* OBSOLETE corefile = concat (current_directory, "/", filename, NULL); */ |
085dd6e6 JM |
901 | /* OBSOLETE */ |
902 | /* OBSOLETE printf_filtered ("Program %s ", u.u_comm); */ | |
903 | /* OBSOLETE */ | |
904 | /* OBSOLETE /* Read the thread registers and fill in the thread_xxx[] data. *x/ */ | |
905 | /* OBSOLETE */ | |
906 | /* OBSOLETE for (n = 0; n < n_threads; n++) */ | |
c5aa993b JM |
907 | /* OBSOLETE { */ |
908 | /* OBSOLETE select_thread (n); */ | |
909 | /* OBSOLETE */ | |
910 | /* OBSOLETE lseek (corechan, tcontext_offset[n], 0); */ | |
911 | /* OBSOLETE if (myread (corechan, &tc, sizeof tc) < 0) */ | |
912 | /* OBSOLETE perror_with_name (corefile); */ | |
913 | /* OBSOLETE lseek (corechan, tc.core_thread_p, 0); */ | |
914 | /* OBSOLETE if (myread (corechan, &th, sizeof th) < 0) */ | |
915 | /* OBSOLETE perror_with_name (corefile); */ | |
916 | /* OBSOLETE */ | |
917 | /* OBSOLETE lseek (corechan, tc.core_syscall_context_p, 0); */ | |
918 | /* OBSOLETE if (myread (corechan, registers, REGISTER_BYTES) < 0) */ | |
919 | /* OBSOLETE perror_with_name (corefile); */ | |
920 | /* OBSOLETE */ | |
921 | /* OBSOLETE thread_signal[n] = th.t_cursig; */ | |
922 | /* OBSOLETE thread_sigcode[n] = th.t_code; */ | |
923 | /* OBSOLETE thread_state[n] = th.t_state; */ | |
924 | /* OBSOLETE thread_pc[n] = read_pc (); */ | |
925 | /* OBSOLETE */ | |
926 | /* OBSOLETE if (thread_pc[n] > STACK_END_ADDR) */ | |
927 | /* OBSOLETE { */ | |
928 | /* OBSOLETE POP_FRAME; */ | |
929 | /* OBSOLETE if (is_break_pc (thread_pc[n])) */ | |
930 | /* OBSOLETE thread_pc[n] = read_pc () - 2; */ | |
931 | /* OBSOLETE else */ | |
932 | /* OBSOLETE thread_pc[n] = read_pc (); */ | |
933 | /* OBSOLETE write_register (PC_REGNUM, thread_pc[n]); */ | |
934 | /* OBSOLETE } */ | |
935 | /* OBSOLETE */ | |
936 | /* OBSOLETE printf_filtered ("thread %d received signal %d, %s\n", */ | |
937 | /* OBSOLETE n, thread_signal[n], */ | |
938 | /* OBSOLETE safe_strsignal (thread_signal[n])); */ | |
939 | /* OBSOLETE } */ | |
085dd6e6 JM |
940 | /* OBSOLETE */ |
941 | /* OBSOLETE /* Select an interesting thread -- also-rans died with SIGKILL, */ | |
c5aa993b | 942 | /* OBSOLETE so find one that didn't. *x/ */ |
085dd6e6 JM |
943 | /* OBSOLETE */ |
944 | /* OBSOLETE for (n = 0; n < n_threads; n++) */ | |
c5aa993b JM |
945 | /* OBSOLETE if (thread_signal[n] != 0 && thread_signal[n] != SIGKILL) */ |
946 | /* OBSOLETE { */ | |
947 | /* OBSOLETE select_thread (n); */ | |
948 | /* OBSOLETE stop_signal = thread_signal[n]; */ | |
949 | /* OBSOLETE stop_sigcode = thread_sigcode[n]; */ | |
950 | /* OBSOLETE break; */ | |
951 | /* OBSOLETE } */ | |
085dd6e6 JM |
952 | /* OBSOLETE */ |
953 | /* OBSOLETE core_aouthdr.a_magic = 0; */ | |
954 | /* OBSOLETE */ | |
955 | /* OBSOLETE flush_cached_frames (); */ | |
956 | /* OBSOLETE select_frame (get_current_frame (), 0); */ | |
957 | /* OBSOLETE validate_files (); */ | |
958 | /* OBSOLETE */ | |
959 | /* OBSOLETE print_stack_frame (selected_frame, selected_frame_level, -1); */ | |
960 | /* OBSOLETE } */ | |
961 | /* OBSOLETE else if (from_tty) */ | |
962 | /* OBSOLETE printf_filtered ("No core file now.\n"); */ | |
963 | /* OBSOLETE } */ |