gdb/convex-xdep.c

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