gdb/convex-tdep.c

   1 /* Convex stuff for GDB.
   2    Copyright (C) 1990, 1991, 1996 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, 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
  31 #include "gdbcore.h"
  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 "gdb_stat.h"
  41 #include <sys/mman.h>
  42
  43 #include "gdbcmd.h"
  44
  45 exec_file_command (filename, from_tty)
  46      char *filename;
  47      int from_tty;
  48 {
  49   int val;
  50   int n;
  51   struct stat st_exec;
  52
  53   /* Eliminate all traces of old exec file.
  54      Mark text segment as empty.  */
  55
  56   if (execfile)
  57     free (execfile);
  58   execfile = 0;
  59   data_start = 0;
  60   data_end = 0;
  61   text_start = 0;
  62   text_end = 0;
  63   exec_data_start = 0;
  64   exec_data_end = 0;
  65   if (execchan >= 0)
  66     close (execchan);
  67   execchan = -1;
  68
  69   n_exec = 0;
  70
  71   /* Now open and digest the file the user requested, if any.  */
  72
  73   if (filename)
  74     {
  75       filename = tilde_expand (filename);
  76       make_cleanup (free, filename);
  77
  78       execchan = openp (getenv ("PATH"), 1, filename, O_RDONLY, 0,
  79                         &execfile);
  80       if (execchan < 0)
  81         perror_with_name (filename);
  82
  83       if (myread (execchan, &filehdr, sizeof filehdr) < 0)
  84         perror_with_name (filename);
  85
  86       if (! IS_SOFF_MAGIC (filehdr.h_magic))
  87         error ("%s: not an executable file.", filename);
  88
  89       if (myread (execchan, &opthdr, filehdr.h_opthdr) <= 0)
  90         perror_with_name (filename);
  91
  92       /* Read through the section headers.
  93          For text, data, etc, record an entry in the exec file map.
  94          Record text_start and text_end.  */
  95
  96       lseek (execchan, (long) filehdr.h_scnptr, 0);
  97
  98       for (n = 0; n < filehdr.h_nscns; n++)
  99         {
 100           if (myread (execchan, &scnhdr, sizeof scnhdr) < 0)
 101             perror_with_name (filename);
 102
 103           if ((scnhdr.s_flags & S_TYPMASK) >= S_TEXT
 104               && (scnhdr.s_flags & S_TYPMASK) <= S_COMON)
 105             {
 106               exec_map[n_exec].mem_addr = scnhdr.s_vaddr;
 107               exec_map[n_exec].mem_end = scnhdr.s_vaddr + scnhdr.s_size;
 108               exec_map[n_exec].file_addr = scnhdr.s_scnptr;
 109               exec_map[n_exec].type = scnhdr.s_flags & S_TYPMASK;
 110               n_exec++;
 111
 112               if ((scnhdr.s_flags & S_TYPMASK) == S_TEXT)
 113                 {
 114                   text_start = scnhdr.s_vaddr;
 115                   text_end =  scnhdr.s_vaddr + scnhdr.s_size;
 116                 }
 117             }
 118         }
 119
 120       fstat (execchan, &st_exec);
 121       exec_mtime = st_exec.st_mtime;
 122
 123       validate_files ();
 124     }
 125   else if (from_tty)
 126     printf_filtered ("No exec file now.\n");
 127
 128   /* Tell display code (if any) about the changed file name.  */
 129   if (exec_file_display_hook)
 130     (*exec_file_display_hook) (filename);
 131 }
 132
 133 #if 0
 134 /* Read data from SOFF exec or core file.
 135    Return 0 on success, EIO if address out of bounds. */
 136
 137 int
 138 xfer_core_file (memaddr, myaddr, len)
 139      CORE_ADDR memaddr;
 140      char *myaddr;
 141      int len;
 142 {
 143   register int i;
 144   register int n;
 145   register int val;
 146   int xferchan;
 147   char **xferfile;
 148   int fileptr;
 149   int returnval = 0;
 150
 151   while (len > 0)
 152     {
 153       xferfile = 0;
 154       xferchan = 0;
 155
 156       /* Determine which file the next bunch of addresses reside in,
 157          and where in the file.  Set the file's read/write pointer
 158          to point at the proper place for the desired address
 159          and set xferfile and xferchan for the correct file.
 160          If desired address is nonexistent, leave them zero.
 161          i is set to the number of bytes that can be handled
 162          along with the next address.  */
 163
 164       i = len;
 165
 166       for (n = 0; n < n_core; n++)
 167         {
 168           if (memaddr >= core_map[n].mem_addr && memaddr < core_map[n].mem_end
 169               && (core_map[n].thread == -1
 170                   || core_map[n].thread == inferior_thread))
 171             {
 172               i = min (len, core_map[n].mem_end - memaddr);
 173               fileptr = core_map[n].file_addr + memaddr - core_map[n].mem_addr;
 174               if (core_map[n].file_addr)
 175                 {
 176                   xferfile = &corefile;
 177                   xferchan = corechan;
 178                 }
 179               break;
 180             }
 181           else if (core_map[n].mem_addr >= memaddr
 182                    && core_map[n].mem_addr < memaddr + i)
 183             i = core_map[n].mem_addr - memaddr;
 184         }
 185
 186       if (!xferfile)
 187         for (n = 0; n < n_exec; n++)
 188           {
 189             if (memaddr >= exec_map[n].mem_addr
 190                 && memaddr < exec_map[n].mem_end)
 191               {
 192                 i = min (len, exec_map[n].mem_end - memaddr);
 193                 fileptr = exec_map[n].file_addr + memaddr
 194                   - exec_map[n].mem_addr;
 195                 if (exec_map[n].file_addr)
 196                   {
 197                     xferfile = &execfile;
 198                     xferchan = execchan;
 199                   }
 200                 break;
 201               }
 202             else if (exec_map[n].mem_addr >= memaddr
 203                      && exec_map[n].mem_addr < memaddr + i)
 204               i = exec_map[n].mem_addr - memaddr;
 205           }
 206
 207       /* Now we know which file to use.
 208          Set up its pointer and transfer the data.  */
 209       if (xferfile)
 210         {
 211           if (*xferfile == 0)
 212             if (xferfile == &execfile)
 213               error ("No program file to examine.");
 214             else
 215               error ("No core dump file or running program to examine.");
 216           val = lseek (xferchan, fileptr, 0);
 217           if (val < 0)
 218             perror_with_name (*xferfile);
 219           val = myread (xferchan, myaddr, i);
 220           if (val < 0)
 221             perror_with_name (*xferfile);
 222         }
 223       /* If this address is for nonexistent memory,
 224          read zeros if reading, or do nothing if writing.  */
 225       else
 226         {
 227           memset (myaddr, '\0', i);
 228           returnval = EIO;
 229         }
 230
 231       memaddr += i;
 232       myaddr += i;
 233       len -= i;
 234     }
 235   return returnval;
 236 }
 237 #endif
 238
 239 /* Here from info files command to print an address map.  */
 240
 241 print_maps ()
 242 {
 243   struct pmap ptrs[200];
 244   int n;
 245
 246   /* ID strings for core and executable file sections */
 247
 248   static char *idstr[] =
 249     {
 250       "0", "text", "data", "tdata", "bss", "tbss",
 251       "common", "ttext", "ctx", "tctx", "10", "11", "12",
 252     };
 253
 254   for (n = 0; n < n_core; n++)
 255     {
 256       core_map[n].which = 0;
 257       ptrs[n] = core_map[n];
 258     }
 259   for (n = 0; n < n_exec; n++)
 260     {
 261       exec_map[n].which = 1;
 262       ptrs[n_core+n] = exec_map[n];
 263     }
 264
 265   qsort (ptrs, n_core + n_exec, sizeof *ptrs, ptr_cmp);
 266
 267   for (n = 0; n < n_core + n_exec; n++)
 268     {
 269       struct pmap *p = &ptrs[n];
 270       if (n > 0)
 271         {
 272           if (p->mem_addr < ptrs[n-1].mem_end)
 273             p->mem_addr = ptrs[n-1].mem_end;
 274           if (p->mem_addr >= p->mem_end)
 275             continue;
 276         }
 277       printf_filtered ("%08x .. %08x  %-6s  %s\n",
 278                        p->mem_addr, p->mem_end, idstr[p->type],
 279                        p->which ? execfile : corefile);
 280     }
 281 }
 282
 283 /* Compare routine to put file sections in order.
 284    Sort into increasing order on address, and put core file sections
 285    before exec file sections if both files contain the same addresses.  */
 286
 287 static ptr_cmp (a, b)
 288      struct pmap *a, *b;
 289 {
 290   if (a->mem_addr != b->mem_addr) return a->mem_addr - b->mem_addr;
 291   return a->which - b->which;
 292 }
 293 \f
 294 /* Trapped internal variables are used to handle special registers.
 295    A trapped i.v. calls a hook here every time it is dereferenced,
 296    to provide a new value for the variable, and it calls a hook here
 297    when a new value is assigned, to do something with the value.
 298
 299    The vector registers are $vl, $vs, $vm, $vN, $VN (N in 0..7).
 300    The communication registers are $cN, $CN (N in 0..63).
 301    They not handled as regular registers because it's expensive to
 302    read them, and their size varies, and they have too many names.  */
 303
 304
 305 /* Return 1 if NAME is a trapped internal variable, else 0. */
 306
 307 int
 308 is_trapped_internalvar (name)
 309      char *name;
 310 {
 311     if ((name[0] == 'c' || name[0] == 'C')
 312         && name[1] >= '0' && name[1] <= '9'
 313         && (name[2] == '\0'
 314             || (name[2] >= '0' && name[2] <= '9'
 315                 && name[3] == '\0' && name[1] != '0'))
 316         && atoi (&name[1]) < 64) return 1;
 317
 318   if ((name[0] == 'v' || name[0] == 'V')
 319       && (((name[1] & -8) == '0' && name[2] == '\0')
 320           || STREQ (name, "vl")
 321           || STREQ (name, "vs")
 322           || STREQ (name, "vm")))
 323     return 1;
 324   else return 0;
 325 }
 326
 327 /* Return the value of trapped internal variable VAR */
 328
 329 value
 330 value_of_trapped_internalvar (var)
 331      struct internalvar *var;
 332 {
 333   char *name = var->name;
 334   value val;
 335   struct type *type;
 336   struct type *range_type;
 337   long len = *read_vector_register (VL_REGNUM);
 338   if (len <= 0 || len > 128) len = 128;
 339
 340   if (STREQ (name, "vl"))
 341     {
 342       val = value_from_longest (builtin_type_int,
 343                              (LONGEST) *read_vector_register_1 (VL_REGNUM));
 344     }
 345   else if (STREQ (name, "vs"))
 346     {
 347       val = value_from_longest (builtin_type_int,
 348                              (LONGEST) *read_vector_register_1 (VS_REGNUM));
 349     }
 350   else if (STREQ (name, "vm"))
 351     {
 352       long vm[4];
 353       long i, *p;
 354       memcpy (vm, read_vector_register_1 (VM_REGNUM), sizeof vm);
 355       range_type =
 356         create_range_type ((struct type *) NULL, builtin_type_int, 0, len - 1);
 357       type =
 358         create_array_type ((struct type *) NULL, builtin_type_int, range_type);
 359       val = allocate_value (type);
 360       p = (long *) VALUE_CONTENTS (val);
 361       for (i = 0; i < len; i++)
 362         *p++ = !! (vm[3 - (i >> 5)] & (1 << (i & 037)));
 363     }
 364   else if (name[0] == 'V')
 365     {
 366       range_type =
 367         create_range_type ((struct type *) NULL, builtin_type_int 0, len - 1);
 368       type =
 369         create_array_type ((struct type *) NULL, builtin_type_long_long,
 370                            range_type);
 371       val = allocate_value (type);
 372       memcpy (VALUE_CONTENTS (val),
 373              read_vector_register_1 (name[1] - '0'),
 374              TYPE_LENGTH (type));
 375     }
 376   else if (name[0] == 'v')
 377     {
 378       long *p1, *p2;
 379       range_type =
 380         create_range_type ((struct type *) NULL, builtin_type_int 0, len - 1);
 381       type =
 382         create_array_type ((struct type *) NULL, builtin_type_long,
 383                            range_type);
 384       val = allocate_value (type);
 385       p1 = read_vector_register_1 (name[1] - '0');
 386       p2 = (long *) VALUE_CONTENTS (val);
 387       while (--len >= 0) {p1++; *p2++ = *p1++;}
 388     }
 389
 390   else if (name[0] == 'c')
 391     val = value_from_longest (builtin_type_int,
 392                            read_comm_register (atoi (&name[1])));
 393   else if (name[0] == 'C')
 394     val = value_from_longest (builtin_type_long_long,
 395                            read_comm_register (atoi (&name[1])));
 396
 397   VALUE_LVAL (val) = lval_internalvar;
 398   VALUE_INTERNALVAR (val) = var;
 399   return val;
 400 }
 401
 402 /* Handle a new value assigned to a trapped internal variable */
 403
 404 void
 405 set_trapped_internalvar (var, val, bitpos, bitsize, offset)
 406      struct internalvar *var;
 407      value val;
 408      int bitpos, bitsize, offset;
 409 {
 410   char *name = var->name;
 411   long long newval = value_as_long (val);
 412
 413   if (STREQ (name, "vl"))
 414     write_vector_register (VL_REGNUM, 0, newval);
 415   else if (STREQ (name, "vs"))
 416     write_vector_register (VS_REGNUM, 0, newval);
 417   else if (name[0] == 'c' || name[0] == 'C')
 418     write_comm_register (atoi (&name[1]), newval);
 419   else if (STREQ (name, "vm"))
 420     error ("can't assign to $vm");
 421   else
 422     {
 423       offset /= bitsize / 8;
 424       write_vector_register (name[1] - '0', offset, newval);
 425     }
 426 }
 427
 428 /* Print an integer value when no format was specified.  gdb normally
 429    prints these values in decimal, but the the leading 0x80000000 of
 430    pointers produces intolerable 10-digit negative numbers.
 431    If it looks like an address, print it in hex instead.  */
 432
 433 decout (stream, type, val)
 434      FILE *stream;
 435      struct type *type;
 436      LONGEST val;
 437 {
 438   long lv = val;
 439
 440   switch (output_radix)
 441     {
 442     case 0:
 443       if ((lv == val || (unsigned) lv == val)
 444           && ((lv & 0xf0000000) == 0x80000000
 445               || ((lv & 0xf0000000) == 0xf0000000 && lv < STACK_END_ADDR)))
 446         {
 447           print_longest (stream, "x", 0, val);
 448           return;
 449         }
 450
 451     case 10:
 452       print_longest (stream, TYPE_UNSIGNED (type) ? "u" : "d", 0, val);
 453       return;
 454
 455     case 8:
 456       print_longest (stream, "o", 0, val);
 457       return;
 458
 459     case 16:
 460       print_longest (stream, "x", 0, val);
 461       return;
 462     }
 463 }
 464
 465 /* Change the default output radix to 10 or 16, or set it to 0 (heuristic).
 466    This command is mostly obsolete now that the print command allows
 467    formats to apply to aggregates, but is still handy occasionally.  */
 468
 469 static void
 470 set_base_command (arg)
 471     char *arg;
 472 {
 473   int new_radix;
 474
 475   if (!arg)
 476     output_radix = 0;
 477   else
 478     {
 479       new_radix = atoi (arg);
 480       if (new_radix != 10 && new_radix != 16 && new_radix != 8)
 481         error ("base must be 8, 10 or 16, or null");
 482       else output_radix = new_radix;
 483     }
 484 }
 485
 486 /* Turn pipelining on or off in the inferior. */
 487
 488 static void
 489 set_pipelining_command (arg)
 490     char *arg;
 491 {
 492   if (!arg)
 493     {
 494       sequential = !sequential;
 495       printf_filtered ("%s\n", sequential ? "off" : "on");
 496     }
 497   else if (STREQ (arg, "on"))
 498     sequential = 0;
 499   else if (STREQ (arg, "off"))
 500     sequential = 1;
 501   else error ("valid args are `on', to allow instructions to overlap, or\n\
 502 `off', to prevent it and thereby pinpoint exceptions.");
 503 }
 504
 505 /* Enable, disable, or force parallel execution in the inferior.  */
 506
 507 static void
 508 set_parallel_command (arg)
 509      char *arg;
 510 {
 511   struct rlimit rl;
 512   int prevparallel = parallel;
 513
 514   if (!strncmp (arg, "fixed", strlen (arg)))
 515     parallel = 2;
 516   else if (STREQ (arg, "on"))
 517     parallel = 1;
 518   else if (STREQ (arg, "off"))
 519     parallel = 0;
 520   else error ("valid args are `on', to allow multiple threads, or\n\
 521 `fixed', to force multiple threads, or\n\
 522 `off', to run with one thread only.");
 523
 524   if ((prevparallel == 0) != (parallel == 0) && inferior_pid)
 525     printf_filtered ("will take effect at next run.\n");
 526
 527   getrlimit (RLIMIT_CONCUR, &rl);
 528   rl.rlim_cur = parallel ? rl.rlim_max : 1;
 529   setrlimit (RLIMIT_CONCUR, &rl);
 530
 531   if (inferior_pid)
 532     set_fixed_scheduling (inferior_pid, parallel == 2);
 533 }
 534
 535 /* Add a new name for an existing command.  */
 536
 537 static void
 538 alias_command (arg)
 539     char *arg;
 540 {
 541     static char *aliaserr = "usage is `alias NEW OLD', no args allowed";
 542     char *newname = arg;
 543     struct cmd_list_element *new, *old;
 544
 545     if (!arg)
 546       error_no_arg ("newname oldname");
 547
 548     new = lookup_cmd (&arg, cmdlist, "", -1);
 549     if (new && !strncmp (newname, new->name, strlen (new->name)))
 550       {
 551         newname = new->name;
 552         if (!(*arg == '-'
 553               || (*arg >= 'a' && *arg <= 'z')
 554               || (*arg >= 'A' && *arg <= 'Z')
 555               || (*arg >= '0' && *arg <= '9')))
 556           error (aliaserr);
 557       }
 558     else
 559       {
 560         arg = newname;
 561         while (*arg == '-'
 562                || (*arg >= 'a' && *arg <= 'z')
 563                || (*arg >= 'A' && *arg <= 'Z')
 564                || (*arg >= '0' && *arg <= '9'))
 565           arg++;
 566         if (*arg != ' ' && *arg != '\t')
 567           error (aliaserr);
 568         *arg = '\0';
 569         arg++;
 570       }
 571
 572     old = lookup_cmd (&arg, cmdlist, "", 0);
 573
 574     if (*arg != '\0')
 575       error (aliaserr);
 576
 577     if (new && !strncmp (newname, new->name, strlen (new->name)))
 578       {
 579         char *tem;
 580         if (new->class == (int) class_user || new->class == (int) class_alias)
 581           tem = "Redefine command \"%s\"? ";
 582         else
 583           tem = "Really redefine built-in command \"%s\"? ";
 584         if (!query (tem, new->name))
 585           error ("Command \"%s\" not redefined.", new->name);
 586       }
 587
 588     add_com (newname, class_alias, old->function, old->doc);
 589 }
 590
 591
 592
 593 /* Print the current thread number, and any threads with signals in the
 594    queue.  */
 595
 596 thread_info ()
 597 {
 598   struct threadpid *p;
 599
 600   if (have_inferior_p ())
 601     {
 602       ps.pi_buffer = (char *) &comm_registers;
 603       ps.pi_nbytes = sizeof comm_registers;
 604       ps.pi_offset = 0;
 605       ps.pi_thread = inferior_thread;
 606       ioctl (inferior_fd, PIXRDCREGS, &ps);
 607     }
 608
 609   /* FIXME: stop_signal is from target.h but stop_sigcode is a
 610      convex-specific thing.  */
 611   printf_filtered ("Current thread %d stopped with signal %d.%d (%s).\n",
 612                    inferior_thread, stop_signal, stop_sigcode,
 613                    subsig_name (stop_signal, stop_sigcode));
 614
 615   for (p = signal_stack; p->pid; p--)
 616     printf_filtered ("Thread %d stopped with signal %d.%d (%s).\n",
 617                      p->thread, p->signo, p->subsig,
 618                      subsig_name (p->signo, p->subsig));
 619
 620   if (iscrlbit (comm_registers.crctl.lbits.cc, 64+13))
 621     printf_filtered ("New thread start pc %#x\n",
 622                      (long) (comm_registers.crreg.pcpsw >> 32));
 623 }
 624
 625 /* Return string describing a signal.subcode number */
 626
 627 static char *
 628 subsig_name (signo, subcode)
 629      int signo, subcode;
 630 {
 631   static char *subsig4[] = {
 632     "error exit", "privileged instruction", "unknown",
 633     "unknown", "undefined opcode",
 634     0};
 635   static char *subsig5[] = {0,
 636     "breakpoint", "single step", "fork trap", "exec trap", "pfork trap",
 637     "join trap", "idle trap", "last thread", "wfork trap",
 638     "process breakpoint", "trap instruction",
 639     0};
 640   static char *subsig8[] = {0,
 641     "int overflow", "int divide check", "float overflow",
 642     "float divide check", "float underflow", "reserved operand",
 643     "sqrt error", "exp error", "ln error", "sin error", "cos error",
 644     0};
 645   static char *subsig10[] = {0,
 646     "invalid inward ring address", "invalid outward ring call",
 647     "invalid inward ring return", "invalid syscall gate",
 648     "invalid rtn frame length", "invalid comm reg address",
 649     "invalid trap gate",
 650     0};
 651   static char *subsig11[] = {0,
 652     "read access denied", "write access denied", "execute access denied",
 653     "segment descriptor fault", "page table fault", "data reference fault",
 654     "i/o access denied", "levt pte invalid",
 655     0};
 656
 657   static char **subsig_list[] =
 658     {0, 0, 0, 0, subsig4, subsig5, 0, 0, subsig8, 0, subsig10, subsig11, 0};
 659
 660   int i;
 661   char *p;
 662
 663   if ((p = strsignal (signo)) == NULL)
 664     p = "unknown";
 665   if (signo >= (sizeof subsig_list / sizeof *subsig_list)
 666       || !subsig_list[signo])
 667     return p;
 668   for (i = 1; subsig_list[signo][i]; i++)
 669     if (i == subcode)
 670       return subsig_list[signo][subcode];
 671   return p;
 672 }
 673
 674
 675 /* Print a compact display of thread status, essentially x/i $pc
 676    for all active threads.  */
 677
 678 static void
 679 threadstat ()
 680 {
 681   int t;
 682
 683   for (t = 0; t < n_threads; t++)
 684     if (thread_state[t] == PI_TALIVE)
 685       {
 686         printf_filtered ("%d%c %08x%c %d.%d ", t,
 687                          (t == inferior_thread ? '*' : ' '), thread_pc[t],
 688                          (thread_is_in_kernel[t] ? '#' : ' '),
 689                          thread_signal[t], thread_sigcode[t]);
 690         print_insn (thread_pc[t], stdout);
 691         printf_filtered ("\n");
 692       }
 693 }
 694
 695 /* Change the current thread to ARG.  */
 696
 697 set_thread_command (arg)
 698      char *arg;
 699 {
 700     int thread;
 701
 702     if (!arg)
 703       {
 704         threadstat ();
 705         return;
 706       }
 707
 708     thread = parse_and_eval_address (arg);
 709
 710     if (thread < 0 || thread > n_threads || thread_state[thread] != PI_TALIVE)
 711       error ("no such thread.");
 712
 713     select_thread (thread);
 714
 715     stop_pc = read_pc ();
 716     flush_cached_frames ();
 717     select_frame (get_current_frame (), 0);
 718     print_stack_frame (selected_frame, selected_frame_level, -1);
 719 }
 720
 721 /* Here on CONT command; gdb's dispatch address is changed to come here.
 722    Set global variable ALL_CONTINUE to tell resume() that it should
 723    start up all threads, and that a thread switch will not blow gdb's
 724    mind.  */
 725
 726 static void
 727 convex_cont_command (proc_count_exp, from_tty)
 728      char *proc_count_exp;
 729      int from_tty;
 730 {
 731   all_continue = 1;
 732   cont_command (proc_count_exp, from_tty);
 733 }
 734
 735 /* Here on 1CONT command.  Resume only the current thread.  */
 736
 737 one_cont_command (proc_count_exp, from_tty)
 738      char *proc_count_exp;
 739      int from_tty;
 740 {
 741   cont_command (proc_count_exp, from_tty);
 742 }
 743
 744 /* Print the contents and lock bits of all communication registers,
 745    or just register ARG if ARG is a communication register,
 746    or the 3-word resource structure in memory at address ARG.  */
 747
 748 comm_registers_info (arg)
 749     char *arg;
 750 {
 751   int i, regnum;
 752
 753   if (arg)
 754     {
 755              if (sscanf (arg, "$c%d", &regnum) == 1) {
 756         ;
 757       } else if (sscanf (arg, "$C%d", &regnum) == 1) {
 758         ;
 759       } else {
 760         regnum = parse_and_eval_address (arg);
 761         if (regnum > 0)
 762           regnum &= ~0x8000;
 763       }
 764
 765       if (regnum >= 64)
 766         error ("%s: invalid register name.", arg);
 767
 768       /* if we got a (user) address, examine the resource struct there */
 769
 770       if (regnum < 0)
 771         {
 772           static int buf[3];
 773           read_memory (regnum, buf, sizeof buf);
 774           printf_filtered ("%08x  %08x%08x%s\n", regnum, buf[1], buf[2],
 775                            buf[0] & 0xff ? " locked" : "");
 776           return;
 777         }
 778     }
 779
 780   ps.pi_buffer = (char *) &comm_registers;
 781   ps.pi_nbytes = sizeof comm_registers;
 782   ps.pi_offset = 0;
 783   ps.pi_thread = inferior_thread;
 784   ioctl (inferior_fd, PIXRDCREGS, &ps);
 785
 786   for (i = 0; i < 64; i++)
 787     if (!arg || i == regnum)
 788       printf_filtered ("%2d 0x8%03x %016llx%s\n", i, i,
 789                        comm_registers.crreg.r4[i],
 790                        (iscrlbit (comm_registers.crctl.lbits.cc, i)
 791                         ? " locked" : ""));
 792 }
 793
 794 /* Print the psw */
 795
 796 static void
 797 psw_info (arg)
 798     char *arg;
 799 {
 800   struct pswbit
 801     {
 802       int bit;
 803       int pos;
 804       char *text;
 805     };
 806
 807   static struct pswbit pswbit[] =
 808     {
 809       { 0x80000000, -1, "A carry" },
 810       { 0x40000000, -1, "A integer overflow" },
 811       { 0x20000000, -1, "A zero divide" },
 812       { 0x10000000, -1, "Integer overflow enable" },
 813       { 0x08000000, -1, "Trace" },
 814       { 0x06000000, 25, "Frame length" },
 815       { 0x01000000, -1, "Sequential" },
 816       { 0x00800000, -1, "S carry" },
 817       { 0x00400000, -1, "S integer overflow" },
 818       { 0x00200000, -1, "S zero divide" },
 819       { 0x00100000, -1, "Zero divide enable" },
 820       { 0x00080000, -1, "Floating underflow" },
 821       { 0x00040000, -1, "Floating overflow" },
 822       { 0x00020000, -1, "Floating reserved operand" },
 823       { 0x00010000, -1, "Floating zero divide" },
 824       { 0x00008000, -1, "Floating error enable" },
 825       { 0x00004000, -1, "Floating underflow enable" },
 826       { 0x00002000, -1, "IEEE" },
 827       { 0x00001000, -1, "Sequential stores" },
 828       { 0x00000800, -1, "Intrinsic error" },
 829       { 0x00000400, -1, "Intrinsic error enable" },
 830       { 0x00000200, -1, "Trace thread creates" },
 831       { 0x00000100, -1, "Thread init trap" },
 832       { 0x000000e0,  5, "Reserved" },
 833       { 0x0000001f,  0, "Intrinsic error code" },
 834       {0, 0, 0},
 835     };
 836
 837   long psw;
 838   struct pswbit *p;
 839
 840   if (arg)
 841     psw = parse_and_eval_address (arg);
 842   else
 843     psw = read_register (PS_REGNUM);
 844
 845   for (p = pswbit; p->bit; p++)
 846     {
 847       if (p->pos < 0)
 848         printf_filtered ("%08x  %s  %s\n", p->bit,
 849                          (psw & p->bit) ? "yes" : "no ", p->text);
 850       else
 851         printf_filtered ("%08x %3d   %s\n", p->bit,
 852                          (psw & p->bit) >> p->pos, p->text);
 853     }
 854 }
 855 \f
 856 #include "symtab.h"
 857
 858 /* reg (fmt_field, inst_field) --
 859    the {first,second,third} operand of instruction as fmt_field = [ijk]
 860    gets the value of the field from the [ijk] position of the instruction */
 861
 862 #define reg(a,b) ((char (*)[3])(op[fmt->a]))[inst.f0.b]
 863
 864 /* lit (fmt_field) -- field [ijk] is a literal (PSW, VL, eg) */
 865
 866 #define lit(i) op[fmt->i]
 867
 868 /* aj[j] -- name for A register j */
 869
 870 #define aj ((char (*)[3])(op[A]))
 871 \f
 872 union inst {
 873     struct {
 874         unsigned   : 7;
 875         unsigned i : 3;
 876         unsigned j : 3;
 877         unsigned k : 3;
 878         unsigned   : 16;
 879         unsigned   : 32;
 880     } f0;
 881     struct {
 882         unsigned   : 8;
 883         unsigned indir : 1;
 884         unsigned len : 1;
 885         unsigned j : 3;
 886         unsigned k : 3;
 887         unsigned   : 16;
 888         unsigned   : 32;
 889     } f1;
 890     unsigned char byte[8];
 891     unsigned short half[4];
 892     char signed_byte[8];
 893     short signed_half[4];
 894 };
 895
 896 struct opform {
 897     int mask;                   /* opcode mask */
 898     int shift;                  /* opcode align */
 899     struct formstr *formstr[3]; /* ST, E0, E1 */
 900 };
 901
 902 struct formstr {
 903     unsigned lop:8, rop:5;      /* opcode */
 904     unsigned fmt:5;             /* inst format */
 905     unsigned i:5, j:5, k:2;     /* operand formats */
 906 };
 907
 908 #include "opcode/convex.h"
 909
 910 CONST unsigned char formdecode [] = {
 911     1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
 912     9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
 913     1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
 914     1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
 915     2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
 916     2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
 917     3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,
 918     4,4,4,4,4,4,4,4,5,5,5,5,6,6,7,8,
 919     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 920     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 921     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 922     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 923     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 924     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 925     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 926     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 927 };
 928
 929 CONST struct opform opdecode[] = {
 930     0x7e00, 9, format0, e0_format0, e1_format0,
 931     0x3f00, 8, format1, e0_format1, e1_format1,
 932     0x1fc0, 6, format2, e0_format2, e1_format2,
 933     0x0fc0, 6, format3, e0_format3, e1_format3,
 934     0x0700, 8, format4, e0_format4, e1_format4,
 935     0x03c0, 6, format5, e0_format5, e1_format5,
 936     0x01f8, 3, format6, e0_format6, e1_format6,
 937     0x00f8, 3, format7, e0_format7, e1_format7,
 938     0x0000, 0, formatx, formatx, formatx,
 939     0x0f80, 7, formatx, formatx, formatx,
 940     0x0f80, 7, formatx, formatx, formatx,
 941 };
 942 \f
 943 /* Print the instruction at address MEMADDR in debugged memory,
 944    on STREAM.  Returns length of the instruction, in bytes.  */
 945
 946 int
 947 convex_print_insn (memaddr, stream)
 948      CORE_ADDR memaddr;
 949      FILE *stream;
 950 {
 951   union inst inst;
 952   struct formstr *fmt;
 953   register int format, op1, pfx;
 954   int l;
 955
 956   read_memory (memaddr, &inst, sizeof inst);
 957
 958   /* Remove and note prefix, if present */
 959
 960   pfx = inst.half[0];
 961   if ((pfx & 0xfff0) == 0x7ef0)
 962     {
 963       pfx = ((pfx >> 3) & 1) + 1;
 964       *(long long *) &inst = *(long long *) &inst.half[1];
 965     }
 966   else pfx = 0;
 967
 968   /* Split opcode into format.op1 and look up in appropriate table */
 969
 970   format = formdecode[inst.byte[0]];
 971   op1 = (inst.half[0] & opdecode[format].mask) >> opdecode[format].shift;
 972   if (format == 9)
 973     {
 974       if (pfx)
 975         fmt = formatx;
 976       else if (inst.f1.j == 0)
 977         fmt = &format1a[op1];
 978       else if (inst.f1.j == 1)
 979         fmt = &format1b[op1];
 980       else
 981         fmt = formatx;
 982     }
 983   else
 984     fmt = &opdecode[format].formstr[pfx][op1];
 985
 986   /* Print it */
 987
 988   if (fmt->fmt == xxx)
 989     {
 990       /* noninstruction */
 991       fprintf (stream, "0x%04x", pfx ? pfx : inst.half[0]);
 992       return 2;
 993     }
 994
 995   if (pfx)
 996     pfx = 2;
 997
 998   fprintf (stream, "%s%s%s", lop[fmt->lop], rop[fmt->rop],
 999            &"        "[strlen(lop[fmt->lop]) + strlen(rop[fmt->rop])]);
1000
1001   switch (fmt->fmt)
1002     {
1003     case rrr:                   /* three register */
1004       fprintf (stream, "%s,%s,%s", reg(i,i), reg(j,j), reg(k,k));
1005       return pfx + 2;
1006
1007     case rr:                    /* two register */
1008       fprintf (stream, "%s,%s", reg(i,j), reg(j,k));
1009       return pfx + 2;
1010
1011     case rxr:                   /* two register, reversed i and j fields */
1012       fprintf (stream, "%s,%s", reg(i,k), reg(j,j));
1013       return pfx + 2;
1014
1015     case r:                     /* one register */
1016       fprintf (stream, "%s", reg(i,k));
1017       return pfx + 2;
1018
1019     case nops:                  /* no operands */
1020       return pfx + 2;
1021
1022     case nr:                    /* short immediate, one register */
1023       fprintf (stream, "#%d,%s", inst.f0.j, reg(i,k));
1024       return pfx + 2;
1025
1026     case pcrel:                 /* pc relative */
1027       print_address (memaddr + 2 * inst.signed_byte[1], stream);
1028       return pfx + 2;
1029
1030     case lr:                    /* literal, one register */
1031       fprintf (stream, "%s,%s", lit(i), reg(j,k));
1032       return pfx + 2;
1033
1034     case rxl:                   /* one register, literal */
1035       fprintf (stream, "%s,%s", reg(i,k), lit(j));
1036       return pfx + 2;
1037
1038     case rlr:                   /* register, literal, register */
1039       fprintf (stream, "%s,%s,%s", reg(i,j), lit(j), reg(k,k));
1040       return pfx + 2;
1041
1042     case rrl:                   /* register, register, literal */
1043       fprintf (stream, "%s,%s,%s", reg(i,j), reg(j,k), lit(k));
1044       return pfx + 2;
1045
1046     case iml:                   /* immediate, literal */
1047       if (inst.f1.len)
1048         {
1049           fprintf (stream, "#%#x,%s",
1050                    (inst.signed_half[1] << 16) + inst.half[2], lit(i));
1051           return pfx + 6;
1052         }
1053       else
1054         {
1055           fprintf (stream, "#%d,%s", inst.signed_half[1], lit(i));
1056           return pfx + 4;
1057         }
1058
1059     case imr:                   /* immediate, register */
1060       if (inst.f1.len)
1061         {
1062           fprintf (stream, "#%#x,%s",
1063                    (inst.signed_half[1] << 16) + inst.half[2], reg(i,k));
1064           return pfx + 6;
1065         }
1066       else
1067         {
1068           fprintf (stream, "#%d,%s", inst.signed_half[1], reg(i,k));
1069           return pfx + 4;
1070         }
1071
1072     case a1r:                   /* memory, register */
1073       l = print_effa (inst, stream);
1074       fprintf (stream, ",%s", reg(i,k));
1075       return pfx + l;
1076
1077     case a1l:                   /* memory, literal  */
1078       l = print_effa (inst, stream);
1079       fprintf (stream, ",%s", lit(i));
1080       return pfx + l;
1081
1082     case a2r:                   /* register, memory */
1083       fprintf (stream, "%s,", reg(i,k));
1084       return pfx + print_effa (inst, stream);
1085
1086     case a2l:                   /* literal, memory */
1087       fprintf (stream, "%s,", lit(i));
1088       return pfx + print_effa (inst, stream);
1089
1090     case a3:                    /* memory */
1091       return pfx + print_effa (inst, stream);
1092
1093     case a4:                    /* system call */
1094       l = 29; goto a4a5;
1095     case a5:                    /* trap */
1096       l = 27;
1097     a4a5:
1098       if (inst.f1.len)
1099         {
1100           unsigned int m = (inst.signed_half[1] << 16) + inst.half[2];
1101           fprintf (stream, "#%d,#%d", m >> l, m & (-1 >> (32-l)));
1102           return pfx + 6;
1103         }
1104       else
1105         {
1106           unsigned int m = inst.signed_half[1];
1107           fprintf (stream, "#%d,#%d", m >> l, m & (-1 >> (32-l)));
1108           return pfx + 4;
1109         }
1110     }
1111 }
1112
1113
1114 /* print effective address @nnn(aj), return instruction length */
1115
1116 int print_effa (inst, stream)
1117      union inst inst;
1118      FILE *stream;
1119 {
1120   int n, l;
1121
1122   if (inst.f1.len)
1123     {
1124       n = (inst.signed_half[1] << 16) + inst.half[2];
1125       l = 6;
1126     }
1127   else
1128     {
1129       n = inst.signed_half[1];
1130       l = 4;
1131     }
1132
1133   if (inst.f1.indir)
1134     printf ("@");
1135
1136   if (!inst.f1.j)
1137     {
1138       print_address (n, stream);
1139       return l;
1140     }
1141
1142   fprintf (stream, (n & 0xf0000000) == 0x80000000 ? "%#x(%s)" : "%d(%s)",
1143            n, aj[inst.f1.j]);
1144
1145   return l;
1146 }
1147
1148 \f
1149 void
1150 _initialize_convex_dep ()
1151 {
1152   add_com ("alias", class_support, alias_command,
1153            "Add a new name for an existing command.");
1154
1155   add_cmd ("base", class_vars, set_base_command,
1156            "Change the integer output radix to 8, 10 or 16\n\
1157 or use just `set base' with no args to return to the ad-hoc default,\n\
1158 which is 16 for integers that look like addresses, 10 otherwise.",
1159            &setlist);
1160
1161   add_cmd ("pipeline", class_run, set_pipelining_command,
1162            "Enable or disable overlapped execution of instructions.\n\
1163 With `set pipe off', exceptions are reported with\n\
1164 $pc pointing at the instruction after the faulting one.\n\
1165 The default is `set pipe on', which runs faster.",
1166            &setlist);
1167
1168   add_cmd ("parallel", class_run, set_parallel_command,
1169            "Enable or disable multi-threaded execution of parallel code.\n\
1170 `set parallel off' means run the program on a single CPU.\n\
1171 `set parallel fixed' means run the program with all CPUs assigned to it.\n\
1172 `set parallel on' means run the program on any CPUs that are available.",
1173            &setlist);
1174
1175   add_com ("1cont", class_run, one_cont_command,
1176            "Continue the program, activating only the current thread.\n\
1177 Args are the same as the `cont' command.");
1178
1179   add_com ("thread", class_run, set_thread_command,
1180            "Change the current thread, the one under scrutiny and control.\n\
1181 With no arg, show the active threads, the current one marked with *.");
1182
1183   add_info ("threads", thread_info,
1184             "List status of active threads.");
1185
1186   add_info ("comm-registers", comm_registers_info,
1187             "List communication registers and their contents.\n\
1188 A communication register name as argument means describe only that register.\n\
1189 An address as argument means describe the resource structure at that address.\n\
1190 `Locked' means that the register has been sent to but not yet received from.");
1191
1192   add_info ("psw", psw_info,
1193             "Display $ps, the processor status word, bit by bit.\n\
1194 An argument means display that value's interpretation as a psw.");
1195
1196   add_cmd ("convex", no_class, 0, "Convex-specific commands.\n\
1197 32-bit registers  $pc $ps $sp $ap $fp $a1-5 $s0-7 $v0-7 $vl $vs $vm $c0-63\n\
1198 64-bit registers  $S0-7 $V0-7 $C0-63\n\
1199 \n\
1200 info threads        display info on stopped threads waiting to signal\n\
1201 thread              display list of active threads\n\
1202 thread N            select thread N (its registers, stack, memory, etc.)\n\
1203 step, next, etc     step selected thread only\n\
1204 1cont               continue selected thread only\n\
1205 cont                continue all threads\n\
1206 info comm-registers display contents of comm register(s) or a resource struct\n\
1207 info psw            display processor status word $ps\n\
1208 set base N          change integer radix used by `print' without a format\n\
1209 set pipeline off    exceptions are precise, $pc points after the faulting insn\n\
1210 set pipeline on     normal mode, $pc is somewhere ahead of faulting insn\n\
1211 set parallel off    program runs on a single CPU\n\
1212 set parallel fixed  all CPUs are assigned to the program\n\
1213 set parallel on     normal mode, parallel execution on random available CPUs\n\
1214 ",
1215            &cmdlist);
1216
1217 }