Return to rodata.c CVS log

Up to [CSRG BSD Unix] / 43BSDReno / bin / adb / adb.vax

Annotation of 43BSDReno/bin/adb/adb.vax/rodata.c, revision 1.1.1.1

1.1       root        1: #ifndef lint
                      2: static char sccsid[] = "@(#)rodata.c   5.1 (Berkeley) 1/16/89";
                      3: #endif
                      4: 
                      5: /*
                      6:  * adb - machine dependent read-only data
                      7:  */
                      8: 
                      9: #include "defs.h"
                     10: #include <machine/reg.h>
                     11: 
                     12: #define        N(arr)  (sizeof(arr) / sizeof(arr[0]))
                     13: 
                     14: /*
                     15:  * Registers.  The offset value is an offset from u.u_ar0 if negative,
                     16:  * or if positive, is an offset into the pcb in u.u_pcb.  PCC will not
                     17:  * let us scale the pcb offsets (grr) so instead we scale the ar0 offsets.
                     18:  *
                     19:  * The `address in pcb' is in the local copy of the kernel pcb, for use
                     20:  * with kernel dumps.
                     21:  *
                     22:  * The registers are printed in the order they are listed here.
                     23:  */
                     24: extern struct pcb pcb;
                     25: #define        pcboff(field)   (int)&((struct pcb *)0)->field
                     26: #define        ar0off(off)     off * 4
                     27: struct reglist reglist[] = {
                     28:        /* name         offset                  address in pcb */
                     29:        { "p1lr",       pcboff(pcb_p1lr),       &pcb.pcb_p1lr },
                     30:        { "p1br",       pcboff(pcb_p1br),       (int *)&pcb.pcb_p1br },
                     31:        { "p0lr",       pcboff(pcb_p0lr),       &pcb.pcb_p0lr },
                     32:        { "p0br",       pcboff(pcb_p0br),       (int *)&pcb.pcb_p0br },
                     33:        { "ksp",        pcboff(pcb_ksp),        &pcb.pcb_ksp },
                     34:        { "esp",        pcboff(pcb_esp),        &pcb.pcb_esp },
                     35:        { "ssp",        pcboff(pcb_ssp),        &pcb.pcb_ssp },
                     36:        { "psl",        ar0off(PS),             &pcb.pcb_psl },
                     37:        { "pc",         ar0off(PC),             &pcb.pcb_pc },
                     38:        { "usp",        ar0off(SP),             &pcb.pcb_usp },
                     39:        { "fp",         ar0off(FP),             &pcb.pcb_fp },
                     40:        { "ap",         ar0off(AP),             &pcb.pcb_ap },
                     41:        { "r11",        ar0off(R11),            &pcb.pcb_r11 },
                     42:        { "r10",        ar0off(R10),            &pcb.pcb_r10 },
                     43:        { "r9",         ar0off(R9),             &pcb.pcb_r9 },
                     44:        { "r8",         ar0off(R8),             &pcb.pcb_r8 },
                     45:        { "r7",         ar0off(R7),             &pcb.pcb_r7 },
                     46:        { "r6",         ar0off(R6),             &pcb.pcb_r6 },
                     47:        { "r5",         ar0off(R5),             &pcb.pcb_r5 },
                     48:        { "r4",         ar0off(R4),             &pcb.pcb_r4 },
                     49:        { "r3",         ar0off(R3),             &pcb.pcb_r3 },
                     50:        { "r2",         ar0off(R2),             &pcb.pcb_r2 },
                     51:        { "r1",         ar0off(R1),             &pcb.pcb_r1 },
                     52:        { "r0",         ar0off(R0),             &pcb.pcb_r0 },
                     53:        0
                     54: };
                     55: 
                     56: /* names for codes for illegal instruction */
                     57: char   *illinames[] = {
                     58:        " (reserved addressing fault)",
                     59:        " (priviliged instruction fault)",
                     60:        " (reserved operand fault)"
                     61: };
                     62: int    nillinames = N(illinames);
                     63: 
                     64: /* names for codes for floating point exception */
                     65: char   *fpenames[] = {
                     66:        "",
                     67:        " (integer overflow trap)",
                     68:        " (integer divide by zero trap)",
                     69:        " (floating overflow trap)",
                     70:        " (floating/decimal divide by zero trap)",
                     71:        " (floating underflow trap)",
                     72:        " (decimal overflow trap)",
                     73:        " (subscript out of range trap)",
                     74:        " (floating overflow fault)",
                     75:        " (floating divide by zero fault)",
                     76:        " (floating underflow fault)",
                     77: };
                     78: int    nfpenames = N(fpenames);

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.