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 | ||
dd3b648e RP |
215 | \f |
216 | /* Execute ptrace. Convex V7 replaced ptrace with pattach. | |
217 | Allow ptrace (0) as a no-op. */ | |
218 | ||
219 | int | |
220 | call_ptrace (request, pid, procaddr, buf) | |
221 | int request, pid, procaddr, buf; | |
222 | { | |
223 | if (request == 0) | |
224 | return; | |
225 | error ("no ptrace"); | |
226 | } | |
227 | ||
228 | /* Replacement for system execle routine. | |
229 | Convert it to an equivalent exect, which pattach insists on. */ | |
230 | ||
231 | execle (name, argv) | |
232 | char *name, *argv; | |
233 | { | |
234 | char ***envp = (char ***) &argv; | |
235 | while (*envp++) ; | |
236 | ||
237 | signal (SIGTRAP, sig_noop); | |
238 | exect (name, &argv, *envp); | |
239 | } | |
240 | ||
241 | /* Stupid handler for stupid trace trap that otherwise causes | |
242 | startup to stupidly hang. */ | |
243 | ||
244 | static sig_noop () | |
245 | {} | |
246 | ||
247 | /* Read registers from inferior into registers[] array. | |
248 | For convex, they are already there, read in when the inferior stops. */ | |
249 | ||
250 | void | |
251 | fetch_inferior_registers (regno) | |
252 | int regno; | |
253 | { | |
254 | } | |
255 | ||
256 | /* Store our register values back into the inferior. | |
257 | For Convex, do this only once, right before resuming inferior. */ | |
258 | ||
1ab3bf1b | 259 | void |
dd3b648e RP |
260 | store_inferior_registers (regno) |
261 | int regno; | |
262 | { | |
263 | } | |
264 | ||
265 | /* Copy LEN bytes from inferior's memory starting at MEMADDR | |
266 | to debugger memory starting at MYADDR. | |
267 | On failure (cannot read from inferior, usually because address is out | |
268 | of bounds) returns the value of errno. */ | |
269 | ||
270 | int | |
271 | read_inferior_memory (memaddr, myaddr, len) | |
272 | CORE_ADDR memaddr; | |
273 | char *myaddr; | |
274 | int len; | |
275 | { | |
276 | errno = 0; | |
277 | while (len > 0) | |
278 | { | |
279 | /* little-known undocumented max request size */ | |
280 | int i = (len < 12288) ? len : 12288; | |
281 | ||
282 | lseek (inferior_fd, memaddr, 0); | |
283 | read (inferior_fd, myaddr, i); | |
284 | ||
285 | memaddr += i; | |
286 | myaddr += i; | |
287 | len -= i; | |
288 | } | |
289 | if (errno) | |
290 | bzero (myaddr, len); | |
291 | return errno; | |
292 | } | |
293 | ||
294 | /* Copy LEN bytes of data from debugger memory at MYADDR | |
295 | to inferior's memory at MEMADDR. | |
296 | Returns errno on failure (cannot write the inferior) */ | |
297 | ||
298 | int | |
299 | write_inferior_memory (memaddr, myaddr, len) | |
300 | CORE_ADDR memaddr; | |
301 | char *myaddr; | |
302 | int len; | |
303 | { | |
304 | errno = 0; | |
305 | lseek (inferior_fd, memaddr, 0); | |
306 | write (inferior_fd, myaddr, len); | |
307 | return errno; | |
308 | } | |
309 | ||
310 | /* Here from create_inferior when the inferior process has been created | |
311 | and started up. We must do a pattach to grab it for debugging. | |
312 | ||
313 | Also, intercept the CONT command by altering its dispatch address. */ | |
314 | ||
315 | create_inferior_hook (pid) | |
316 | int pid; | |
317 | { | |
318 | static char cont[] = "cont"; | |
319 | static char cont1[] = "c"; | |
320 | char *linep = cont; | |
321 | char *linep1 = cont1; | |
322 | char **line = &linep; | |
323 | char **line1 = &linep1; | |
324 | struct cmd_list_element *c; | |
325 | ||
326 | c = lookup_cmd (line, cmdlist, "", 0); | |
327 | c->function = convex_cont_command; | |
328 | c = lookup_cmd (line1, cmdlist, "", 0); | |
329 | c->function = convex_cont_command; | |
330 | ||
331 | inferior_fd = pattach (pid, O_EXCL); | |
332 | if (inferior_fd < 0) | |
333 | perror_with_name ("pattach"); | |
334 | inferior_thread = 0; | |
335 | set_fixed_scheduling (pid, parallel == 2); | |
336 | } | |
337 | ||
338 | /* Attach process PID for debugging. */ | |
339 | ||
340 | attach (pid) | |
341 | int pid; | |
342 | { | |
343 | int fd = pattach (pid, O_EXCL); | |
344 | if (fd < 0) | |
345 | perror_with_name ("pattach"); | |
346 | attach_flag = 1; | |
347 | /* wait for strange kernel reverberations to go away */ | |
348 | sleep (1); | |
349 | ||
350 | setpgrp (pid, pid); | |
351 | ||
352 | inferior_fd = fd; | |
353 | inferior_thread = 0; | |
354 | return pid; | |
355 | } | |
356 | ||
357 | /* Stop debugging the process whose number is PID | |
358 | and continue it with signal number SIGNAL. | |
359 | SIGNAL = 0 means just continue it. */ | |
360 | ||
361 | void | |
362 | detach (signal) | |
363 | int signal; | |
364 | { | |
365 | signal_stack = signal_stack_bot; | |
366 | thread_continue (-1, 0, signal); | |
367 | ioctl (inferior_fd, PIXDETACH, &ps); | |
368 | close (inferior_fd); | |
369 | inferior_fd = 0; | |
370 | attach_flag = 0; | |
371 | } | |
372 | ||
373 | /* Kill off the inferior process. */ | |
374 | ||
375 | kill_inferior () | |
376 | { | |
377 | if (inferior_pid == 0) | |
378 | return; | |
379 | ioctl (inferior_fd, PIXTERMINATE, 0); | |
380 | wait (0); | |
381 | target_mourn_inferior (); | |
382 | } | |
383 | ||
384 | /* This is used when GDB is exiting. It gives less chance of error.*/ | |
385 | ||
386 | kill_inferior_fast () | |
387 | { | |
388 | if (inferior_pid == 0) | |
389 | return; | |
390 | ioctl (inferior_fd, PIXTERMINATE, 0); | |
391 | wait (0); | |
392 | } | |
393 | ||
394 | /* Read vector register REG, and return a pointer to the value. */ | |
395 | ||
396 | static long * | |
397 | read_vector_register (reg) | |
398 | int reg; | |
399 | { | |
400 | if (have_inferior_p ()) | |
401 | { | |
402 | errno = 0; | |
403 | ps.pi_buffer = (char *) &vector_registers; | |
404 | ps.pi_nbytes = sizeof vector_registers; | |
405 | ps.pi_offset = 0; | |
406 | ps.pi_thread = inferior_thread; | |
407 | ioctl (inferior_fd, PIXRDVREGS, &ps); | |
408 | if (errno) | |
409 | bzero (&vector_registers, sizeof vector_registers); | |
410 | } | |
411 | else if (corechan >= 0) | |
412 | { | |
413 | lseek (corechan, tcontext_offset[inferior_thread], 0); | |
414 | if (myread (corechan, &tc, sizeof tc) < 0) | |
415 | perror_with_name (corefile); | |
416 | lseek (corechan, tc.core_thread_p, 0); | |
417 | if (myread (corechan, &th, sizeof th) < 0) | |
418 | perror_with_name (corefile); | |
419 | lseek (corechan, tc.core_vregs_p, 0); | |
420 | if (myread (corechan, &vector_registers, 16*128) < 0) | |
421 | perror_with_name (corefile); | |
422 | vector_registers.vm[0] = th.t_vect_ctx.vc_vm[0]; | |
423 | vector_registers.vm[1] = th.t_vect_ctx.vc_vm[1]; | |
424 | vector_registers.vls = th.t_vect_ctx.vc_vls; | |
425 | } | |
426 | ||
427 | return read_vector_register_1 (reg); | |
428 | } | |
429 | ||
430 | /* Return a pointer to vector register REG, which must already have been | |
431 | fetched from the inferior or core file. */ | |
432 | ||
433 | static long * | |
434 | read_vector_register_1 (reg) | |
435 | int reg; | |
436 | { | |
437 | switch (reg) | |
438 | { | |
439 | case VM_REGNUM: | |
440 | return (long *) vector_registers.vm; | |
441 | case VS_REGNUM: | |
442 | return (long *) &vector_registers.vls; | |
443 | case VL_REGNUM: | |
444 | return 1 + (long *) &vector_registers.vls; | |
445 | default: | |
446 | return (long *) &vector_registers.vr[reg]; | |
447 | } | |
448 | } | |
449 | ||
450 | /* Write vector register REG, element ELEMENT, new value VAL. | |
451 | NB: must use read-modify-write on the entire vector state, | |
452 | since pattach does not do offsetted writes correctly. */ | |
453 | ||
454 | static void | |
455 | write_vector_register (reg, element, val) | |
456 | int reg, element; | |
457 | REGISTER_TYPE val; | |
458 | { | |
459 | if (have_inferior_p ()) | |
460 | { | |
461 | errno = 0; | |
462 | ps.pi_thread = inferior_thread; | |
463 | ps.pi_offset = 0; | |
464 | ps.pi_buffer = (char *) &vector_registers; | |
465 | ps.pi_nbytes = sizeof vector_registers; | |
466 | ||
467 | ioctl (inferior_fd, PIXRDVREGS, &ps); | |
468 | ||
469 | switch (reg) | |
470 | { | |
471 | case VL_REGNUM: | |
472 | vector_registers.vls = | |
473 | (vector_registers.vls & 0xffffffff00000000LL) | |
474 | + (unsigned long) val; | |
475 | break; | |
476 | ||
477 | case VS_REGNUM: | |
478 | vector_registers.vls = | |
479 | (val << 32) + (unsigned long) vector_registers.vls; | |
480 | break; | |
481 | ||
482 | default: | |
483 | vector_registers.vr[reg].el[element] = val; | |
484 | break; | |
485 | } | |
486 | ||
487 | ioctl (inferior_fd, PIXWRVREGS, &ps); | |
488 | ||
489 | if (errno) | |
490 | perror_with_name ("writing vector register"); | |
491 | } | |
492 | } | |
493 | ||
494 | /* Return the contents of communication register NUM. */ | |
495 | ||
496 | static REGISTER_TYPE | |
497 | read_comm_register (num) | |
498 | int num; | |
499 | { | |
500 | if (have_inferior_p ()) | |
501 | { | |
502 | ps.pi_buffer = (char *) &comm_registers; | |
503 | ps.pi_nbytes = sizeof comm_registers; | |
504 | ps.pi_offset = 0; | |
505 | ps.pi_thread = inferior_thread; | |
506 | ioctl (inferior_fd, PIXRDCREGS, &ps); | |
507 | } | |
508 | return comm_registers.crreg.r4[num]; | |
509 | } | |
510 | ||
511 | /* Store a new value VAL into communication register NUM. | |
512 | NB: Must use read-modify-write on the whole comm register set | |
513 | since pattach does not do offsetted writes correctly. */ | |
514 | ||
515 | static void | |
516 | write_comm_register (num, val) | |
517 | int num; | |
518 | REGISTER_TYPE val; | |
519 | { | |
520 | if (have_inferior_p ()) | |
521 | { | |
522 | ps.pi_buffer = (char *) &comm_registers; | |
523 | ps.pi_nbytes = sizeof comm_registers; | |
524 | ps.pi_offset = 0; | |
525 | ps.pi_thread = inferior_thread; | |
526 | ioctl (inferior_fd, PIXRDCREGS, &ps); | |
527 | comm_registers.crreg.r4[num] = val; | |
528 | ioctl (inferior_fd, PIXWRCREGS, &ps); | |
529 | } | |
530 | } | |
531 | ||
532 | /* Resume execution of the inferior process. | |
533 | If STEP is nonzero, single-step it. | |
534 | If SIGNAL is nonzero, give it that signal. */ | |
535 | ||
536 | void | |
537 | resume (step, signal) | |
538 | int step; | |
539 | int signal; | |
540 | { | |
541 | errno = 0; | |
542 | if (step || signal) | |
543 | thread_continue (inferior_thread, step, signal); | |
544 | else | |
545 | thread_continue (-1, 0, 0); | |
546 | } | |
547 | ||
548 | /* Maybe resume some threads. | |
549 | THREAD is which thread to resume, or -1 to resume them all. | |
550 | STEP and SIGNAL are as in resume. | |
551 | ||
552 | Global variable ALL_CONTINUE is set when we are here to do a | |
553 | `cont' command; otherwise we may be doing `finish' or a call or | |
554 | something else that will not tolerate an automatic thread switch. | |
555 | ||
556 | If there are stopped threads waiting to deliver signals, and | |
557 | ALL_CONTINUE, do not actually resume anything. gdb will do a wait | |
558 | and see one of the stopped threads in the queue. */ | |
559 | ||
560 | static void | |
561 | thread_continue (thread, step, signal) | |
562 | int thread, step, signal; | |
563 | { | |
564 | int n; | |
565 | ||
566 | /* If we are to continue all threads, but not for the CONTINUE command, | |
567 | pay no attention and continue only the selected thread. */ | |
568 | ||
569 | if (thread < 0 && ! all_continue) | |
570 | thread = inferior_thread; | |
571 | ||
572 | /* If we are not stepping, we have now executed the continue part | |
573 | of a CONTINUE command. */ | |
574 | ||
575 | if (! step) | |
576 | all_continue = 0; | |
577 | ||
578 | /* Allow wait() to switch threads if this is an all-out continue. */ | |
579 | ||
580 | thread_switch_ok = thread < 0; | |
581 | ||
582 | /* If there are threads queued up, don't resume. */ | |
583 | ||
584 | if (thread_switch_ok && ! signal_stack_is_empty ()) | |
585 | return; | |
586 | ||
587 | /* OK, do it. */ | |
588 | ||
589 | for (n = 0; n < n_threads; n++) | |
590 | if (thread_state[n] == PI_TALIVE) | |
591 | { | |
592 | select_thread (n); | |
593 | ||
594 | if ((thread < 0 || n == thread) && ! thread_is_in_kernel[n]) | |
595 | { | |
596 | /* Blam the trace bits in the stack's saved psws to match | |
597 | the desired step mode. This is required so that | |
598 | single-stepping a return doesn't restore a psw with a | |
599 | clear trace bit and fly away, and conversely, | |
600 | proceeding through a return in a routine that was | |
601 | stepped into doesn't cause a phantom break by restoring | |
602 | a psw with the trace bit set. */ | |
603 | scan_stack (PSW_T_BIT, step); | |
604 | scan_stack (PSW_S_BIT, sequential); | |
605 | } | |
606 | ||
607 | ps.pi_buffer = registers; | |
608 | ps.pi_nbytes = REGISTER_BYTES; | |
609 | ps.pi_offset = 0; | |
610 | ps.pi_thread = n; | |
611 | if (! thread_is_in_kernel[n]) | |
612 | if (ioctl (inferior_fd, PIXWRREGS, &ps)) | |
613 | perror_with_name ("PIXWRREGS"); | |
614 | ||
615 | if (thread < 0 || n == thread) | |
616 | { | |
617 | ps.pi_pc = 1; | |
618 | ps.pi_signo = signal; | |
619 | if (ioctl (inferior_fd, step ? PIXSTEP : PIXCONTINUE, &ps) < 0) | |
620 | perror_with_name ("PIXCONTINUE"); | |
621 | } | |
622 | } | |
623 | ||
624 | if (ioctl (inferior_fd, PIXRUN, &ps) < 0) | |
625 | perror_with_name ("PIXRUN"); | |
626 | } | |
627 | ||
628 | /* Replacement for system wait routine. | |
629 | ||
630 | The system wait returns with one or more threads stopped by | |
631 | signals. Put stopped threads on a stack and return them one by | |
632 | one, so that it appears that wait returns one thread at a time. | |
633 | ||
634 | Global variable THREAD_SWITCH_OK is set when gdb can tolerate wait | |
635 | returning a new thread. If it is false, then only one thread is | |
636 | running; we will do a real wait, the thread will do something, and | |
637 | we will return that. */ | |
638 | ||
639 | pid_t | |
640 | wait (w) | |
641 | union wait *w; | |
642 | { | |
643 | int pid; | |
644 | ||
645 | if (!w) | |
646 | return wait3 (0, 0, 0); | |
647 | ||
648 | /* Do a real wait if we were told to, or if there are no queued threads. */ | |
649 | ||
650 | if (! thread_switch_ok || signal_stack_is_empty ()) | |
651 | { | |
652 | int thread; | |
653 | ||
654 | pid = wait3 (w, 0, 0); | |
655 | ||
656 | if (!WIFSTOPPED (*w) || pid != inferior_pid) | |
657 | return pid; | |
658 | ||
659 | /* The inferior has done something and stopped. Read in all the | |
660 | threads' registers, and queue up any signals that happened. */ | |
661 | ||
662 | if (ioctl (inferior_fd, PIXGETTHCOUNT, &ps) < 0) | |
663 | perror_with_name ("PIXGETTHCOUNT"); | |
664 | ||
665 | n_threads = ps.pi_othdcnt; | |
666 | for (thread = 0; thread < n_threads; thread++) | |
667 | { | |
668 | ps.pi_thread = thread; | |
669 | if (ioctl (inferior_fd, PIXGETSUBCODE, &ps) < 0) | |
670 | perror_with_name ("PIXGETSUBCODE"); | |
671 | thread_state[thread] = ps.pi_otstate; | |
672 | ||
673 | if (ps.pi_otstate == PI_TALIVE) | |
674 | { | |
675 | select_thread (thread); | |
676 | ps.pi_buffer = registers; | |
677 | ps.pi_nbytes = REGISTER_BYTES; | |
678 | ps.pi_offset = 0; | |
679 | ps.pi_thread = thread; | |
680 | if (ioctl (inferior_fd, PIXRDREGS, &ps) < 0) | |
681 | perror_with_name ("PIXRDREGS"); | |
682 | ||
683 | registers_fetched (); | |
684 | ||
685 | thread_pc[thread] = read_pc (); | |
686 | thread_signal[thread] = ps.pi_osigno; | |
687 | thread_sigcode[thread] = ps.pi_osigcode; | |
688 | ||
689 | /* If the thread's stack has a context frame | |
690 | on top, something fucked is going on. I do not | |
691 | know what, but do I know this: the only thing you | |
692 | can do with such a thread is continue it. */ | |
693 | ||
694 | thread_is_in_kernel[thread] = | |
695 | ((read_register (PS_REGNUM) >> 25) & 3) == 0; | |
696 | ||
697 | /* Signals push an extended frame and then fault | |
698 | with a ridiculous pc. Pop the frame. */ | |
699 | ||
700 | if (thread_pc[thread] > STACK_END_ADDR) | |
701 | { | |
702 | POP_FRAME; | |
703 | if (is_break_pc (thread_pc[thread])) | |
704 | thread_pc[thread] = read_pc () - 2; | |
705 | else | |
706 | thread_pc[thread] = read_pc (); | |
707 | write_register (PC_REGNUM, thread_pc[thread]); | |
708 | } | |
709 | ||
710 | if (ps.pi_osigno || ps.pi_osigcode) | |
711 | { | |
712 | signal_stack++; | |
713 | signal_stack->pid = pid; | |
714 | signal_stack->thread = thread; | |
715 | signal_stack->signo = thread_signal[thread]; | |
716 | signal_stack->subsig = thread_sigcode[thread]; | |
717 | signal_stack->pc = thread_pc[thread]; | |
718 | } | |
719 | ||
720 | /* The following hackery is caused by a unix 7.1 feature: | |
721 | the inferior's fixed scheduling mode is cleared when | |
722 | it execs the shell (since the shell is not a parallel | |
723 | program). So, note the 5.4 trap we get when | |
724 | the shell does its exec, then catch the 5.0 trap | |
725 | that occurs when the debuggee starts, and set fixed | |
726 | scheduling mode properly. */ | |
727 | ||
728 | if (ps.pi_osigno == 5 && ps.pi_osigcode == 4) | |
729 | exec_trap_timer = 1; | |
730 | else | |
731 | exec_trap_timer--; | |
732 | ||
733 | if (ps.pi_osigno == 5 && exec_trap_timer == 0) | |
734 | set_fixed_scheduling (pid, parallel == 2); | |
735 | } | |
736 | } | |
737 | ||
738 | if (signal_stack_is_empty ()) | |
739 | error ("no active threads?!"); | |
740 | } | |
741 | ||
742 | /* Select the thread that stopped, and return *w saying why. */ | |
743 | ||
744 | select_thread (signal_stack->thread); | |
745 | ||
746 | stop_signal = signal_stack->signo; | |
747 | stop_sigcode = signal_stack->subsig; | |
748 | ||
749 | WSETSTOP (*w, signal_stack->signo); | |
750 | w->w_thread = signal_stack->thread; | |
751 | return (signal_stack--)->pid; | |
752 | } | |
753 | ||
754 | /* Select thread THREAD -- its registers, stack, per-thread memory. | |
755 | This is the only routine that may assign to inferior_thread | |
756 | or thread_regs[]. */ | |
757 | ||
758 | static void | |
759 | select_thread (thread) | |
760 | int thread; | |
761 | { | |
762 | if (thread == inferior_thread) | |
763 | return; | |
764 | ||
765 | bcopy (registers, thread_regs[inferior_thread], REGISTER_BYTES); | |
766 | ps.pi_thread = inferior_thread = thread; | |
767 | if (have_inferior_p ()) | |
768 | ioctl (inferior_fd, PISETRWTID, &ps); | |
769 | bcopy (thread_regs[thread], registers, REGISTER_BYTES); | |
770 | } | |
771 | ||
772 | /* Routine to set or clear a psw bit in the psw and also all psws | |
773 | saved on the stack. Quits when we get to a frame in which the | |
774 | saved psw is correct. */ | |
775 | ||
776 | static void | |
777 | scan_stack (bit, val) | |
778 | long bit, val; | |
779 | { | |
780 | long ps = read_register (PS_REGNUM); | |
781 | long fp; | |
782 | if (val ? !(ps & bit) : (ps & bit)) | |
783 | { | |
784 | ps ^= bit; | |
785 | write_register (PS_REGNUM, ps); | |
786 | ||
787 | fp = read_register (FP_REGNUM); | |
788 | while (fp & 0x80000000) | |
789 | { | |
790 | ps = read_memory_integer (fp + 4, 4); | |
791 | if (val ? (ps & bit) : !(ps & bit)) | |
792 | break; | |
793 | ps ^= bit; | |
794 | write_memory (fp + 4, &ps, 4); | |
795 | fp = read_memory_integer (fp + 8, 4); | |
796 | } | |
797 | } | |
798 | } | |
799 | ||
800 | /* Set fixed scheduling (alliant mode) of process PID to ARG (0 or 1). */ | |
801 | ||
802 | static void | |
803 | set_fixed_scheduling (pid, arg) | |
804 | int arg; | |
805 | { | |
806 | struct pattributes pattr; | |
807 | getpattr (pid, &pattr); | |
808 | pattr.pattr_pfixed = arg; | |
809 | setpattr (pid, &pattr); | |
810 | } | |
811 | \f | |
812 | void | |
813 | core_file_command (filename, from_tty) | |
814 | char *filename; | |
815 | int from_tty; | |
816 | { | |
817 | int n; | |
818 | ||
819 | /* Discard all vestiges of any previous core file | |
820 | and mark data and stack spaces as empty. */ | |
821 | ||
822 | if (corefile) | |
823 | free (corefile); | |
824 | corefile = 0; | |
825 | ||
826 | if (corechan >= 0) | |
827 | close (corechan); | |
828 | corechan = -1; | |
829 | ||
830 | data_start = 0; | |
831 | data_end = 0; | |
832 | stack_start = STACK_END_ADDR; | |
833 | stack_end = STACK_END_ADDR; | |
834 | n_core = 0; | |
835 | ||
836 | /* Now, if a new core file was specified, open it and digest it. */ | |
837 | ||
838 | if (filename) | |
839 | { | |
840 | filename = tilde_expand (filename); | |
841 | make_cleanup (free, filename); | |
842 | ||
843 | if (have_inferior_p ()) | |
844 | error ("To look at a core file, you must kill the inferior with \"kill\"."); | |
845 | corechan = open (filename, O_RDONLY, 0); | |
846 | if (corechan < 0) | |
847 | perror_with_name (filename); | |
848 | ||
849 | if (myread (corechan, &filehdr, sizeof filehdr) < 0) | |
850 | perror_with_name (filename); | |
851 | ||
852 | if (!IS_CORE_SOFF_MAGIC (filehdr.h_magic)) | |
853 | error ("%s: not a core file.\n", filename); | |
854 | ||
855 | if (myread (corechan, &opthdr, filehdr.h_opthdr) < 0) | |
856 | perror_with_name (filename); | |
857 | ||
858 | /* Read through the section headers. | |
859 | For text, data, etc, record an entry in the core file map. | |
860 | For context and tcontext, record the file address of | |
861 | the context blocks. */ | |
862 | ||
863 | lseek (corechan, (long) filehdr.h_scnptr, 0); | |
864 | ||
865 | n_threads = 0; | |
866 | for (n = 0; n < filehdr.h_nscns; n++) | |
867 | { | |
868 | if (myread (corechan, &scnhdr, sizeof scnhdr) < 0) | |
869 | perror_with_name (filename); | |
870 | if ((scnhdr.s_flags & S_TYPMASK) >= S_TEXT | |
871 | && (scnhdr.s_flags & S_TYPMASK) <= S_COMON) | |
872 | { | |
873 | core_map[n_core].mem_addr = scnhdr.s_vaddr; | |
874 | core_map[n_core].mem_end = scnhdr.s_vaddr + scnhdr.s_size; | |
875 | core_map[n_core].file_addr = scnhdr.s_scnptr; | |
876 | core_map[n_core].type = scnhdr.s_flags & S_TYPMASK; | |
877 | if (core_map[n_core].type != S_TBSS | |
878 | && core_map[n_core].type != S_TDATA | |
879 | && core_map[n_core].type != S_TTEXT) | |
880 | core_map[n_core].thread = -1; | |
881 | else if (n_core == 0 | |
882 | || core_map[n_core-1].mem_addr != scnhdr.s_vaddr) | |
883 | core_map[n_core].thread = 0; | |
884 | else | |
885 | core_map[n_core].thread = core_map[n_core-1].thread + 1; | |
886 | n_core++; | |
887 | } | |
888 | else if ((scnhdr.s_flags & S_TYPMASK) == S_CONTEXT) | |
889 | context_offset = scnhdr.s_scnptr; | |
890 | else if ((scnhdr.s_flags & S_TYPMASK) == S_TCONTEXT) | |
891 | tcontext_offset[n_threads++] = scnhdr.s_scnptr; | |
892 | } | |
893 | ||
894 | /* Read the context block, struct user, struct proc, | |
895 | and the comm regs. */ | |
896 | ||
897 | lseek (corechan, context_offset, 0); | |
898 | if (myread (corechan, &c, sizeof c) < 0) | |
899 | perror_with_name (filename); | |
900 | lseek (corechan, c.core_user_p, 0); | |
901 | if (myread (corechan, &u, sizeof u) < 0) | |
902 | perror_with_name (filename); | |
903 | lseek (corechan, c.core_proc_p, 0); | |
904 | if (myread (corechan, &pr, sizeof pr) < 0) | |
905 | perror_with_name (filename); | |
906 | comm_registers = pr.p_creg; | |
907 | ||
908 | /* Core file apparently is really there. Make it really exist | |
909 | for xfer_core_file so we can do read_memory on it. */ | |
910 | ||
911 | if (filename[0] == '/') | |
912 | corefile = savestring (filename, strlen (filename)); | |
913 | else | |
58ae87f6 | 914 | corefile = concat (current_directory, "/", filename, NULL); |
dd3b648e RP |
915 | |
916 | printf_filtered ("Program %s ", u.u_comm); | |
917 | ||
918 | /* Read the thread registers and fill in the thread_xxx[] data. */ | |
919 | ||
920 | for (n = 0; n < n_threads; n++) | |
921 | { | |
922 | select_thread (n); | |
923 | ||
924 | lseek (corechan, tcontext_offset[n], 0); | |
925 | if (myread (corechan, &tc, sizeof tc) < 0) | |
926 | perror_with_name (corefile); | |
927 | lseek (corechan, tc.core_thread_p, 0); | |
928 | if (myread (corechan, &th, sizeof th) < 0) | |
929 | perror_with_name (corefile); | |
930 | ||
931 | lseek (corechan, tc.core_syscall_context_p, 0); | |
932 | if (myread (corechan, registers, REGISTER_BYTES) < 0) | |
933 | perror_with_name (corefile); | |
934 | ||
935 | thread_signal[n] = th.t_cursig; | |
936 | thread_sigcode[n] = th.t_code; | |
937 | thread_state[n] = th.t_state; | |
938 | thread_pc[n] = read_pc (); | |
939 | ||
940 | if (thread_pc[n] > STACK_END_ADDR) | |
941 | { | |
942 | POP_FRAME; | |
943 | if (is_break_pc (thread_pc[n])) | |
944 | thread_pc[n] = read_pc () - 2; | |
945 | else | |
946 | thread_pc[n] = read_pc (); | |
947 | write_register (PC_REGNUM, thread_pc[n]); | |
948 | } | |
949 | ||
950 | printf_filtered ("thread %d received signal %d, %s\n", | |
951 | n, thread_signal[n], | |
4ace50a5 | 952 | safe_strsignal (thread_signal[n])); |
dd3b648e RP |
953 | } |
954 | ||
955 | /* Select an interesting thread -- also-rans died with SIGKILL, | |
956 | so find one that didn't. */ | |
957 | ||
958 | for (n = 0; n < n_threads; n++) | |
959 | if (thread_signal[n] != 0 && thread_signal[n] != SIGKILL) | |
960 | { | |
961 | select_thread (n); | |
962 | stop_signal = thread_signal[n]; | |
963 | stop_sigcode = thread_sigcode[n]; | |
964 | break; | |
965 | } | |
966 | ||
967 | core_aouthdr.a_magic = 0; | |
968 | ||
969 | flush_cached_frames (); | |
970 | set_current_frame (create_new_frame (read_register (FP_REGNUM), | |
971 | read_pc ())); | |
972 | select_frame (get_current_frame (), 0); | |
973 | validate_files (); | |
974 | ||
cadbb07a | 975 | print_stack_frame (selected_frame, selected_frame_level, -1); |
dd3b648e RP |
976 | } |
977 | else if (from_tty) | |
978 | printf_filtered ("No core file now.\n"); | |
979 | } |