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