Initial creation of sourceware repository
[deliverable/binutils-gdb.git] / 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 executable 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 GDB_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 }
This page took 0.058137 seconds and 4 git commands to generate.