ac213aef7ddf2c68e4868ecf47cebba006d87447
1 /* Convex stuff for GDB.
2 Copyright (C) 1990, 1991 Free Software Foundation, Inc.
4 This file is part of GDB.
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.
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.
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. */
32 #include <sys/param.h>
35 #include <sys/ioctl.h>
36 #include <sys/pcntl.h>
37 #include <sys/thread.h>
45 exec_file_command (filename
, from_tty
)
53 /* Eliminate all traces of old exec file.
54 Mark text segment as empty. */
71 /* Now open and digest the file the user requested, if any. */
75 filename
= tilde_expand (filename
);
76 make_cleanup (free
, filename
);
78 execchan
= openp (getenv ("PATH"), 1, filename
, O_RDONLY
, 0,
81 perror_with_name (filename
);
83 if (myread (execchan
, &filehdr
, sizeof filehdr
) < 0)
84 perror_with_name (filename
);
86 if (! IS_SOFF_MAGIC (filehdr
.h_magic
))
87 error ("%s: not an executable file.", filename
);
89 if (myread (execchan
, &opthdr
, filehdr
.h_opthdr
) <= 0)
90 perror_with_name (filename
);
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. */
96 lseek (execchan
, (long) filehdr
.h_scnptr
, 0);
98 for (n
= 0; n
< filehdr
.h_nscns
; n
++)
100 if (myread (execchan
, &scnhdr
, sizeof scnhdr
) < 0)
101 perror_with_name (filename
);
103 if ((scnhdr
.s_flags
& S_TYPMASK
) >= S_TEXT
104 && (scnhdr
.s_flags
& S_TYPMASK
) <= S_COMON
)
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
;
112 if ((scnhdr
.s_flags
& S_TYPMASK
) == S_TEXT
)
114 text_start
= scnhdr
.s_vaddr
;
115 text_end
= scnhdr
.s_vaddr
+ scnhdr
.s_size
;
120 fstat (execchan
, &st_exec
);
121 exec_mtime
= st_exec
.st_mtime
;
126 printf_filtered ("No exec file now.\n");
128 /* Tell display code (if any) about the changed file name. */
129 if (exec_file_display_hook
)
130 (*exec_file_display_hook
) (filename
);
133 /* Read data from SOFF exec or core file.
134 Return 0 on success, EIO if address out of bounds. */
137 xfer_core_file (memaddr
, myaddr
, len
)
155 /* Determine which file the next bunch of addresses reside in,
156 and where in the file. Set the file's read/write pointer
157 to point at the proper place for the desired address
158 and set xferfile and xferchan for the correct file.
159 If desired address is nonexistent, leave them zero.
160 i is set to the number of bytes that can be handled
161 along with the next address. */
165 for (n
= 0; n
< n_core
; n
++)
167 if (memaddr
>= core_map
[n
].mem_addr
&& memaddr
< core_map
[n
].mem_end
168 && (core_map
[n
].thread
== -1
169 || core_map
[n
].thread
== inferior_thread
))
171 i
= min (len
, core_map
[n
].mem_end
- memaddr
);
172 fileptr
= core_map
[n
].file_addr
+ memaddr
- core_map
[n
].mem_addr
;
173 if (core_map
[n
].file_addr
)
175 xferfile
= &corefile
;
180 else if (core_map
[n
].mem_addr
>= memaddr
181 && core_map
[n
].mem_addr
< memaddr
+ i
)
182 i
= core_map
[n
].mem_addr
- memaddr
;
186 for (n
= 0; n
< n_exec
; n
++)
188 if (memaddr
>= exec_map
[n
].mem_addr
189 && memaddr
< exec_map
[n
].mem_end
)
191 i
= min (len
, exec_map
[n
].mem_end
- memaddr
);
192 fileptr
= exec_map
[n
].file_addr
+ memaddr
193 - exec_map
[n
].mem_addr
;
194 if (exec_map
[n
].file_addr
)
196 xferfile
= &execfile
;
201 else if (exec_map
[n
].mem_addr
>= memaddr
202 && exec_map
[n
].mem_addr
< memaddr
+ i
)
203 i
= exec_map
[n
].mem_addr
- memaddr
;
206 /* Now we know which file to use.
207 Set up its pointer and transfer the data. */
211 if (xferfile
== &execfile
)
212 error ("No program file to examine.");
214 error ("No core dump file or running program to examine.");
215 val
= lseek (xferchan
, fileptr
, 0);
217 perror_with_name (*xferfile
);
218 val
= myread (xferchan
, myaddr
, i
);
220 perror_with_name (*xferfile
);
222 /* If this address is for nonexistent memory,
223 read zeros if reading, or do nothing if writing. */
238 /* Here from info files command to print an address map. */
242 struct pmap ptrs
[200];
245 /* ID strings for core and executable file sections */
247 static char *idstr
[] =
249 "0", "text", "data", "tdata", "bss", "tbss",
250 "common", "ttext", "ctx", "tctx", "10", "11", "12",
253 for (n
= 0; n
< n_core
; n
++)
255 core_map
[n
].which
= 0;
256 ptrs
[n
] = core_map
[n
];
258 for (n
= 0; n
< n_exec
; n
++)
260 exec_map
[n
].which
= 1;
261 ptrs
[n_core
+n
] = exec_map
[n
];
264 qsort (ptrs
, n_core
+ n_exec
, sizeof *ptrs
, ptr_cmp
);
266 for (n
= 0; n
< n_core
+ n_exec
; n
++)
268 struct pmap
*p
= &ptrs
[n
];
271 if (p
->mem_addr
< ptrs
[n
-1].mem_end
)
272 p
->mem_addr
= ptrs
[n
-1].mem_end
;
273 if (p
->mem_addr
>= p
->mem_end
)
276 printf_filtered ("%08x .. %08x %-6s %s\n",
277 p
->mem_addr
, p
->mem_end
, idstr
[p
->type
],
278 p
->which
? execfile
: corefile
);
282 /* Compare routine to put file sections in order.
283 Sort into increasing order on address, and put core file sections
284 before exec file sections if both files contain the same addresses. */
286 static ptr_cmp (a
, b
)
289 if (a
->mem_addr
!= b
->mem_addr
) return a
->mem_addr
- b
->mem_addr
;
290 return a
->which
- b
->which
;
293 /* Trapped internal variables are used to handle special registers.
294 A trapped i.v. calls a hook here every time it is dereferenced,
295 to provide a new value for the variable, and it calls a hook here
296 when a new value is assigned, to do something with the value.
298 The vector registers are $vl, $vs, $vm, $vN, $VN (N in 0..7).
299 The communication registers are $cN, $CN (N in 0..63).
300 They not handled as regular registers because it's expensive to
301 read them, and their size varies, and they have too many names. */
304 /* Return 1 if NAME is a trapped internal variable, else 0. */
307 is_trapped_internalvar (name
)
310 if ((name
[0] == 'c' || name
[0] == 'C')
311 && name
[1] >= '0' && name
[1] <= '9'
313 || (name
[2] >= '0' && name
[2] <= '9'
314 && name
[3] == '\0' && name
[1] != '0'))
315 && atoi (&name
[1]) < 64) return 1;
317 if ((name
[0] == 'v' || name
[0] == 'V')
318 && (((name
[1] & -8) == '0' && name
[2] == '\0')
319 || !strcmp (name
, "vl")
320 || !strcmp (name
, "vs")
321 || !strcmp (name
, "vm")))
326 /* Return the value of trapped internal variable VAR */
329 value_of_trapped_internalvar (var
)
330 struct internalvar
*var
;
332 char *name
= var
->name
;
335 long len
= *read_vector_register (VL_REGNUM
);
336 if (len
<= 0 || len
> 128) len
= 128;
338 if (!strcmp (name
, "vl"))
340 val
= value_from_longest (builtin_type_int
,
341 (LONGEST
) *read_vector_register_1 (VL_REGNUM
));
343 else if (!strcmp (name
, "vs"))
345 val
= value_from_longest (builtin_type_int
,
346 (LONGEST
) *read_vector_register_1 (VS_REGNUM
));
348 else if (!strcmp (name
, "vm"))
352 bcopy (read_vector_register_1 (VM_REGNUM
), vm
, sizeof vm
);
353 type
= vector_type (builtin_type_int
, len
);
354 val
= allocate_value (type
);
355 p
= (long *) VALUE_CONTENTS (val
);
356 for (i
= 0; i
< len
; i
++)
357 *p
++ = !! (vm
[3 - (i
>> 5)] & (1 << (i
& 037)));
359 else if (name
[0] == 'V')
361 type
= vector_type (builtin_type_long_long
, len
);
362 val
= allocate_value (type
);
363 bcopy (read_vector_register_1 (name
[1] - '0'),
364 VALUE_CONTENTS (val
), TYPE_LENGTH (type
));
366 else if (name
[0] == 'v')
369 type
= vector_type (builtin_type_long
, len
);
370 val
= allocate_value (type
);
371 p1
= read_vector_register_1 (name
[1] - '0');
372 p2
= (long *) VALUE_CONTENTS (val
);
373 while (--len
>= 0) {p1
++; *p2
++ = *p1
++;}
376 else if (name
[0] == 'c')
377 val
= value_from_longest (builtin_type_int
,
378 read_comm_register (atoi (&name
[1])));
379 else if (name
[0] == 'C')
380 val
= value_from_longest (builtin_type_long_long
,
381 read_comm_register (atoi (&name
[1])));
383 VALUE_LVAL (val
) = lval_internalvar
;
384 VALUE_INTERNALVAR (val
) = var
;
388 /* Construct the type for a vector register's value --
389 array[LENGTH] of ELEMENT_TYPE. */
392 vector_type (element_type
, length
)
393 struct type
*element_type
;
396 struct type
*type
= (struct type
*) xmalloc (sizeof (struct type
));
397 bzero (type
, sizeof type
);
398 TYPE_CODE (type
) = TYPE_CODE_ARRAY
;
399 TYPE_TARGET_TYPE (type
) = element_type
;
400 TYPE_LENGTH (type
) = length
* TYPE_LENGTH (TYPE_TARGET_TYPE (type
));
404 /* Handle a new value assigned to a trapped internal variable */
407 set_trapped_internalvar (var
, val
, bitpos
, bitsize
, offset
)
408 struct internalvar
*var
;
410 int bitpos
, bitsize
, offset
;
412 char *name
= var
->name
;
413 long long newval
= value_as_long (val
);
415 if (!strcmp (name
, "vl"))
416 write_vector_register (VL_REGNUM
, 0, newval
);
417 else if (!strcmp (name
, "vs"))
418 write_vector_register (VS_REGNUM
, 0, newval
);
419 else if (name
[0] == 'c' || name
[0] == 'C')
420 write_comm_register (atoi (&name
[1]), newval
);
421 else if (!strcmp (name
, "vm"))
422 error ("can't assign to $vm");
425 offset
/= bitsize
/ 8;
426 write_vector_register (name
[1] - '0', offset
, newval
);
430 /* Print an integer value when no format was specified. gdb normally
431 prints these values in decimal, but the the leading 0x80000000 of
432 pointers produces intolerable 10-digit negative numbers.
433 If it looks like an address, print it in hex instead. */
435 decout (stream
, type
, val
)
442 switch (output_radix
)
445 if ((lv
== val
|| (unsigned) lv
== val
)
446 && ((lv
& 0xf0000000) == 0x80000000
447 || ((lv
& 0xf0000000) == 0xf0000000 && lv
< STACK_END_ADDR
)))
449 fprintf_filtered (stream
, "%#x", lv
);
454 fprintf_filtered (stream
, TYPE_UNSIGNED (type
) ? "%llu" : "%lld", val
);
458 if (TYPE_LENGTH (type
) <= sizeof lv
)
459 fprintf_filtered (stream
, "%#o", lv
);
461 fprintf_filtered (stream
, "%#llo", val
);
465 if (TYPE_LENGTH (type
) <= sizeof lv
)
466 fprintf_filtered (stream
, "%#x", lv
);
468 fprintf_filtered (stream
, "%#llx", val
);
473 /* Change the default output radix to 10 or 16, or set it to 0 (heuristic).
474 This command is mostly obsolete now that the print command allows
475 formats to apply to aggregates, but is still handy occasionally. */
478 set_base_command (arg
)
487 new_radix
= atoi (arg
);
488 if (new_radix
!= 10 && new_radix
!= 16 && new_radix
!= 8)
489 error ("base must be 8, 10 or 16, or null");
490 else output_radix
= new_radix
;
494 /* Turn pipelining on or off in the inferior. */
497 set_pipelining_command (arg
)
502 sequential
= !sequential
;
503 printf_filtered ("%s\n", sequential
? "off" : "on");
505 else if (!strcmp (arg
, "on"))
507 else if (!strcmp (arg
, "off"))
509 else error ("valid args are `on', to allow instructions to overlap, or\n\
510 `off', to prevent it and thereby pinpoint exceptions.");
513 /* Enable, disable, or force parallel execution in the inferior. */
516 set_parallel_command (arg
)
520 int prevparallel
= parallel
;
522 if (!strncmp (arg
, "fixed", strlen (arg
)))
524 else if (!strcmp (arg
, "on"))
526 else if (!strcmp (arg
, "off"))
528 else error ("valid args are `on', to allow multiple threads, or\n\
529 `fixed', to force multiple threads, or\n\
530 `off', to run with one thread only.");
532 if ((prevparallel
== 0) != (parallel
== 0) && inferior_pid
)
533 printf_filtered ("will take effect at next run.\n");
535 getrlimit (RLIMIT_CONCUR
, &rl
);
536 rl
.rlim_cur
= parallel
? rl
.rlim_max
: 1;
537 setrlimit (RLIMIT_CONCUR
, &rl
);
540 set_fixed_scheduling (inferior_pid
, parallel
== 2);
543 /* Add a new name for an existing command. */
549 static char *aliaserr
= "usage is `alias NEW OLD', no args allowed";
551 struct cmd_list_element
*new, *old
;
554 error_no_arg ("newname oldname");
556 new = lookup_cmd (&arg
, cmdlist
, "", -1);
557 if (new && !strncmp (newname
, new->name
, strlen (new->name
)))
561 || (*arg
>= 'a' && *arg
<= 'z')
562 || (*arg
>= 'A' && *arg
<= 'Z')
563 || (*arg
>= '0' && *arg
<= '9')))
570 || (*arg
>= 'a' && *arg
<= 'z')
571 || (*arg
>= 'A' && *arg
<= 'Z')
572 || (*arg
>= '0' && *arg
<= '9'))
574 if (*arg
!= ' ' && *arg
!= '\t')
580 old
= lookup_cmd (&arg
, cmdlist
, "", 0);
585 if (new && !strncmp (newname
, new->name
, strlen (new->name
)))
588 if (new->class == (int) class_user
|| new->class == (int) class_alias
)
589 tem
= "Redefine command \"%s\"? ";
591 tem
= "Really redefine built-in command \"%s\"? ";
592 if (!query (tem
, new->name
))
593 error ("Command \"%s\" not redefined.", new->name
);
596 add_com (newname
, class_alias
, old
->function
, old
->doc
);
601 /* Print the current thread number, and any threads with signals in the
608 if (have_inferior_p ())
610 ps
.pi_buffer
= (char *) &comm_registers
;
611 ps
.pi_nbytes
= sizeof comm_registers
;
613 ps
.pi_thread
= inferior_thread
;
614 ioctl (inferior_fd
, PIXRDCREGS
, &ps
);
617 printf_filtered ("Current thread %d stopped with signal %d.%d (%s).\n",
618 inferior_thread
, stop_signal
, stop_sigcode
,
619 subsig_name (stop_signal
, stop_sigcode
));
621 for (p
= signal_stack
; p
->pid
; p
--)
622 printf_filtered ("Thread %d stopped with signal %d.%d (%s).\n",
623 p
->thread
, p
->signo
, p
->subsig
,
624 subsig_name (p
->signo
, p
->subsig
));
626 if (iscrlbit (comm_registers
.crctl
.lbits
.cc
, 64+13))
627 printf_filtered ("New thread start pc %#x\n",
628 (long) (comm_registers
.crreg
.pcpsw
>> 32));
631 /* Return string describing a signal.subcode number */
634 subsig_name (signo
, subcode
)
637 static char *subsig4
[] = {
638 "error exit", "privileged instruction", "unknown",
639 "unknown", "undefined opcode",
641 static char *subsig5
[] = {0,
642 "breakpoint", "single step", "fork trap", "exec trap", "pfork trap",
643 "join trap", "idle trap", "last thread", "wfork trap",
644 "process breakpoint", "trap instruction",
646 static char *subsig8
[] = {0,
647 "int overflow", "int divide check", "float overflow",
648 "float divide check", "float underflow", "reserved operand",
649 "sqrt error", "exp error", "ln error", "sin error", "cos error",
651 static char *subsig10
[] = {0,
652 "invalid inward ring address", "invalid outward ring call",
653 "invalid inward ring return", "invalid syscall gate",
654 "invalid rtn frame length", "invalid comm reg address",
657 static char *subsig11
[] = {0,
658 "read access denied", "write access denied", "execute access denied",
659 "segment descriptor fault", "page table fault", "data reference fault",
660 "i/o access denied", "levt pte invalid",
663 static char **subsig_list
[] =
664 {0, 0, 0, 0, subsig4
, subsig5
, 0, 0, subsig8
, 0, subsig10
, subsig11
, 0};
669 if ((p
= strsignal (signo
)) == NULL
)
671 if (signo
>= (sizeof subsig_list
/ sizeof *subsig_list
)
672 || !subsig_list
[signo
])
674 for (i
= 1; subsig_list
[signo
][i
]; i
++)
676 return subsig_list
[signo
][subcode
];
681 /* Print a compact display of thread status, essentially x/i $pc
682 for all active threads. */
689 for (t
= 0; t
< n_threads
; t
++)
690 if (thread_state
[t
] == PI_TALIVE
)
692 printf_filtered ("%d%c %08x%c %d.%d ", t
,
693 (t
== inferior_thread
? '*' : ' '), thread_pc
[t
],
694 (thread_is_in_kernel
[t
] ? '#' : ' '),
695 thread_signal
[t
], thread_sigcode
[t
]);
696 print_insn (thread_pc
[t
], stdout
);
697 printf_filtered ("\n");
701 /* Change the current thread to ARG. */
703 set_thread_command (arg
)
714 thread
= parse_and_eval_address (arg
);
716 if (thread
< 0 || thread
> n_threads
|| thread_state
[thread
] != PI_TALIVE
)
717 error ("no such thread.");
719 select_thread (thread
);
721 stop_pc
= read_pc ();
722 flush_cached_frames ();
723 set_current_frame (create_new_frame (read_register (FP_REGNUM
),
725 select_frame (get_current_frame (), 0);
726 print_stack_frame (selected_frame
, selected_frame_level
, -1);
729 /* Here on CONT command; gdb's dispatch address is changed to come here.
730 Set global variable ALL_CONTINUE to tell resume() that it should
731 start up all threads, and that a thread switch will not blow gdb's
735 convex_cont_command (proc_count_exp
, from_tty
)
736 char *proc_count_exp
;
740 cont_command (proc_count_exp
, from_tty
);
743 /* Here on 1CONT command. Resume only the current thread. */
745 one_cont_command (proc_count_exp
, from_tty
)
746 char *proc_count_exp
;
749 cont_command (proc_count_exp
, from_tty
);
752 /* Print the contents and lock bits of all communication registers,
753 or just register ARG if ARG is a communication register,
754 or the 3-word resource structure in memory at address ARG. */
756 comm_registers_info (arg
)
763 if (sscanf (arg
, "$c%d", ®num
) == 1) {
765 } else if (sscanf (arg
, "$C%d", ®num
) == 1) {
768 regnum
= parse_and_eval_address (arg
);
774 error ("%s: invalid register name.", arg
);
776 /* if we got a (user) address, examine the resource struct there */
781 read_memory (regnum
, buf
, sizeof buf
);
782 printf_filtered ("%08x %08x%08x%s\n", regnum
, buf
[1], buf
[2],
783 buf
[0] & 0xff ? " locked" : "");
788 ps
.pi_buffer
= (char *) &comm_registers
;
789 ps
.pi_nbytes
= sizeof comm_registers
;
791 ps
.pi_thread
= inferior_thread
;
792 ioctl (inferior_fd
, PIXRDCREGS
, &ps
);
794 for (i
= 0; i
< 64; i
++)
795 if (!arg
|| i
== regnum
)
796 printf_filtered ("%2d 0x8%03x %016llx%s\n", i
, i
,
797 comm_registers
.crreg
.r4
[i
],
798 (iscrlbit (comm_registers
.crctl
.lbits
.cc
, i
)
815 static struct pswbit pswbit
[] =
817 { 0x80000000, -1, "A carry" },
818 { 0x40000000, -1, "A integer overflow" },
819 { 0x20000000, -1, "A zero divide" },
820 { 0x10000000, -1, "Integer overflow enable" },
821 { 0x08000000, -1, "Trace" },
822 { 0x06000000, 25, "Frame length" },
823 { 0x01000000, -1, "Sequential" },
824 { 0x00800000, -1, "S carry" },
825 { 0x00400000, -1, "S integer overflow" },
826 { 0x00200000, -1, "S zero divide" },
827 { 0x00100000, -1, "Zero divide enable" },
828 { 0x00080000, -1, "Floating underflow" },
829 { 0x00040000, -1, "Floating overflow" },
830 { 0x00020000, -1, "Floating reserved operand" },
831 { 0x00010000, -1, "Floating zero divide" },
832 { 0x00008000, -1, "Floating error enable" },
833 { 0x00004000, -1, "Floating underflow enable" },
834 { 0x00002000, -1, "IEEE" },
835 { 0x00001000, -1, "Sequential stores" },
836 { 0x00000800, -1, "Intrinsic error" },
837 { 0x00000400, -1, "Intrinsic error enable" },
838 { 0x00000200, -1, "Trace thread creates" },
839 { 0x00000100, -1, "Thread init trap" },
840 { 0x000000e0, 5, "Reserved" },
841 { 0x0000001f, 0, "Intrinsic error code" },
849 psw
= parse_and_eval_address (arg
);
851 psw
= read_register (PS_REGNUM
);
853 for (p
= pswbit
; p
->bit
; p
++)
856 printf_filtered ("%08x %s %s\n", p
->bit
,
857 (psw
& p
->bit
) ? "yes" : "no ", p
->text
);
859 printf_filtered ("%08x %3d %s\n", p
->bit
,
860 (psw
& p
->bit
) >> p
->pos
, p
->text
);
864 _initialize_convex_dep ()
866 add_com ("alias", class_support
, alias_command
,
867 "Add a new name for an existing command.");
869 add_cmd ("base", class_vars
, set_base_command
,
870 "Change the integer output radix to 8, 10 or 16\n\
871 or use just `set base' with no args to return to the ad-hoc default,\n\
872 which is 16 for integers that look like addresses, 10 otherwise.",
875 add_cmd ("pipeline", class_run
, set_pipelining_command
,
876 "Enable or disable overlapped execution of instructions.\n\
877 With `set pipe off', exceptions are reported with\n\
878 $pc pointing at the instruction after the faulting one.\n\
879 The default is `set pipe on', which runs faster.",
882 add_cmd ("parallel", class_run
, set_parallel_command
,
883 "Enable or disable multi-threaded execution of parallel code.\n\
884 `set parallel off' means run the program on a single CPU.\n\
885 `set parallel fixed' means run the program with all CPUs assigned to it.\n\
886 `set parallel on' means run the program on any CPUs that are available.",
889 add_com ("1cont", class_run
, one_cont_command
,
890 "Continue the program, activating only the current thread.\n\
891 Args are the same as the `cont' command.");
893 add_com ("thread", class_run
, set_thread_command
,
894 "Change the current thread, the one under scrutiny and control.\n\
895 With no arg, show the active threads, the current one marked with *.");
897 add_info ("threads", thread_info
,
898 "List status of active threads.");
900 add_info ("comm-registers", comm_registers_info
,
901 "List communication registers and their contents.\n\
902 A communication register name as argument means describe only that register.\n\
903 An address as argument means describe the resource structure at that address.\n\
904 `Locked' means that the register has been sent to but not yet received from.");
906 add_info ("psw", psw_info
,
907 "Display $ps, the processor status word, bit by bit.\n\
908 An argument means display that value's interpretation as a psw.");
910 add_cmd ("convex", no_class
, 0, "Convex-specific commands.\n\
911 32-bit registers $pc $ps $sp $ap $fp $a1-5 $s0-7 $v0-7 $vl $vs $vm $c0-63\n\
912 64-bit registers $S0-7 $V0-7 $C0-63\n\
914 info threads display info on stopped threads waiting to signal\n\
915 thread display list of active threads\n\
916 thread N select thread N (its registers, stack, memory, etc.)\n\
917 step, next, etc step selected thread only\n\
918 1cont continue selected thread only\n\
919 cont continue all threads\n\
920 info comm-registers display contents of comm register(s) or a resource struct\n\
921 info psw display processor status word $ps\n\
922 set base N change integer radix used by `print' without a format\n\
923 set pipeline off exceptions are precise, $pc points after the faulting insn\n\
924 set pipeline on normal mode, $pc is somewhere ahead of faulting insn\n\
925 set parallel off program runs on a single CPU\n\
926 set parallel fixed all CPUs are assigned to the program\n\
927 set parallel on normal mode, parallel execution on random available CPUs\n\
This page took 0.050125 seconds and 4 git commands to generate.