Annotation of coherent/d/bin/db/trace.h, revision 1.1.1.1

1.1       root        1: /*
                      2:  * A debugger.
                      3:  * Header file.
                      4:  */
                      5: #include <sys/types.h>
                      6: #include "mtrace.h"
                      7: 
                      8: #if NOUT
                      9: typedef long tvaddr;
                     10: #else
                     11: typedef vaddr_t tvaddr;
                     12: #endif
                     13: 
                     14: /*
                     15:  * Adjustable constants.
                     16:  */
                     17: #ifndef INPBASE
                     18: #define INPBASE 16
                     19: #endif
                     20: 
                     21: #define NBPT   16                      /* Number of breakpoints */
                     22: #define        CCSSIZE 8                       /* C compiler symbol size */
                     23: #define        ARGSIZE 20                      /* Max number of args for `:e' */
                     24: #define VALSIZE        10                      /* Number of expressions allowed */
                     25: #define DISSIZE        64                      /* Terminal display size */
                     26: #define FORSIZE        64                      /* Size of format for segments */
                     27: #define COMSIZE        128                     /* Size of command sequence */
                     28: #define MISSIZE        256                     /* Size of miscellaneous buffer */
                     29: 
                     30: /*
                     31:  * Modes for single step.
                     32:  */
                     33: #define SNULL  0                       /* Do nothing */
                     34: #define SSTEP  1                       /* Single step */
                     35: #define SCONT  2                       /* Continuous step */
                     36: #define SCSET  3                       /* Continuous step setup */
                     37: #define SWAIT  4                       /* Wait for function return */
                     38: 
                     39: /*
                     40:  * Breakpoint flags.
                     41:  */
                     42: #define BBPT   1                       /* Breakpoint set */
                     43: #define BRET   2                       /* Breakpoint return set */
                     44: #define BSIN   4                       /* Breakpoint single continue set */
                     45: 
                     46: /*
                     47:  * Breakpoint table.
                     48:  */
                     49: typedef struct {
                     50:        int     b_flag;                 /* Flag word */
                     51:        vaddr_t b_badd;                 /* Breakpoint address */
                     52:        vaddr_t b_rfpt;                 /* Return frame pointer */
                     53:        vaddr_t b_sfpt;                 /* Single continue frame pointer */
                     54:        char    *b_bcom;                /* Breakpoint command */
                     55:        char    *b_rcom;                /* Return command */
                     56:        BIN     b_bins;                 /* Instruction we replaced */
                     57: } BPT;
                     58: 
                     59: /*
                     60:  * Segment definitions.
                     61:  */
                     62: #define NSEGM  3                       /* Number of segments */
                     63: #define        DSPACE  segmapl[0]              /* Data space */
                     64: #define ISPACE segmapl[1]              /* Instruction space */
                     65: #define USPACE segmapl[2]              /* User area */
                     66: 
                     67: /*
                     68:  * Segmentation map table structure.
                     69:  */
                     70: typedef struct map {
                     71:        struct  map *m_next;            /* Pointer to next */
                     72:        fsize_t m_base;                 /* Segmenation base */
                     73:        fsize_t m_bend;                 /* End of base */
                     74:        fsize_t m_offt;                 /* Offset */
                     75:        int     (*m_getf)();            /* Read function */
                     76:        int     (*m_putf)();            /* Write function */
                     77:        int     m_segi;                 /* Index for segment */
                     78: } MAP;
                     79: 
                     80: /*
                     81:  * Extension of symbols.
                     82:  */
                     83: #define        L_REG   11                      /* Register symbol type */
                     84: 
                     85: /*
                     86:  * Symbol in memory.
                     87:  */
                     88: typedef struct sym {
                     89:        unsigned char s_hash;           /* Hash value */
                     90:        unsigned char s_type;           /* Type */
                     91:        tvaddr s_sval;          /* Value of symbol */
                     92: } SYM;
                     93: 
                     94: /*
                     95:  * Flags in value.
                     96:  */
                     97: #define VNULL  1                       /* Value is null */
                     98: #define VLVAL  2                       /* Value is a left value */
                     99: 
                    100: /*
                    101:  * Value descriptor.
                    102:  */
                    103: typedef struct val {
                    104:        unsigned char v_flag;           /* Flag word */
                    105:        unsigned char v_segn;           /* Segment number */
                    106:        long     v_nval;                /* Value */
                    107: } VAL;
                    108: 
                    109: /*
                    110:  * Types of input.
                    111:  */
                    112: #define IFILE  1                       /* File I/O */
                    113: #define ICORE  2                       /* Core I/O */
                    114: 
                    115: /*
                    116:  * Next input stack.
                    117:  */
                    118: typedef union inp {
                    119:        struct {
                    120:                struct  inp *i_next;    /* Pointer to next */
                    121:                int     i_type;         /* Type of input */
                    122:                FILE    *i_filp;        /* File pointer */
                    123:        } inp1;
                    124:        struct {
                    125:                struct  inp *i_next;    /* Pointer to next */
                    126:                int     i_type;         /* Type of input */
                    127:                char    *i_strp;        /* String pointer */
                    128:        } inp2;
                    129: } INP;
                    130: 
                    131: /*
                    132:  * To find a structure offset.
                    133:  */
                    134: #define offset(s, m)   ((int) &(((struct s *) 0)->m))
                    135: 
                    136: /*
                    137:  * Functions defined by the machine dependent routines.
                    138:  */
                    139: vaddr_t        getpc(), getfp(), getsp();
                    140: 
                    141: /*
                    142:  * Function for the C compiler.
                    143:  */
                    144: int    armsint();                      /* trace1.c */
                    145: MAP    *setsmap();                     /* trace1.c */
                    146: MAP    *clrsmap();                     /* trace1.c */
                    147: FILE   *openfil();                     /* trace1.c */
                    148: int    getp();                         /* trace2.c */
                    149: int    putp();                         /* trace2.c */
                    150: char   *conescs();                     /* trace3.c */
                    151: char   *conform();                     /* trace3.c */
                    152: char   *getform();                     /* trace3.c */
                    153: char   *ctime();                       /* trace3.c */
                    154: char   *gettime();                     /* trace3.c */
                    155: char   *coninst();                     /* trace3.c */
                    156: char   *savecom();                     /* trace4.c */
                    157: long   lvalue();                       /* trace5.c */
                    158: long   rvalue();                       /* trace5.c */
                    159: int    getb();                         /* trace6.c */
                    160: int    putb();                         /* trace6.c */
                    161: int    getf();                         /* trace6.c */
                    162: int    putf();                         /* trace6.c */
                    163: MAP    *mapaddr();                     /* trace6.c */
                    164: char   *conaddr();                     /* trace6.c */
                    165: char   *nalloc();                      /* trace6.c */
                    166: char   *concons();                     /* trace6.c */
                    167: #if FORZ8001
                    168: extern long    size();
                    169: extern long    addr();
                    170: extern char    *conaddnum();           /* z8001b.c */
                    171: #else
                    172: #define        size( A)        (A)
                    173: #define        addr( A)        (A)
                    174: #define conaddnum( A, B) concons( A, B)
                    175: #endif
                    176: 
                    177: #define putx putchar
                    178: #define nfree free
                    179: 
                    180: /*
                    181:  * Variables defined by machine dependent routine.
                    182:  */
                    183: extern char    *signame[];             /* Names of signals */
                    184: 
                    185: /*
                    186:  * Global variables.
                    187:  */
                    188: extern BIN     bin;                    /* Breakpoint instruction */
                    189: extern BPT     bpt[NBPT];              /* Breakpoint table */
                    190: extern FILE    *cfp;                   /* Core file pointer */
                    191: extern FILE    *lfp;                   /* l.out file pointer */
                    192: extern FILE    *sfp;                   /* Symbol table file pointer */
                    193: extern INP     *inpp;                  /* Input pointer */
                    194: extern MAP     *endpure;               /* End of pure area */
                    195: extern MAP     *segmapl[NSEGM];        /* Segment descriptors */
                    196: extern SYM     *ssymp;                 /* Pointer to core symbol table */
                    197: extern char    *errrstr;               /* Last error */
                    198: extern char    *lfn;                   /* l.out file name */
                    199: extern char    *segname[NSEGM];        /* Names of segments */
                    200: extern char    *sinp;                  /* Command for single step */
                    201: extern char    *trapstr;               /* Fault type */
                    202: extern char    miscbuf[MISSIZE];       /* Miscellaneous buffer */
                    203: extern char    segform[NSEGM][FORSIZE];/* Formats for segments */
                    204: extern int     bitflag;                /* Single step next instruction */
                    205: extern int     cantype;                /* Canonization type */
                    206: extern int     cseg;                   /* Current segment */
                    207: extern int     excflag;                /* Program is in execution */
                    208: extern int     intflag;                /* Interrupt count */
                    209: extern int     lastc;                  /* Character for ungetn */
                    210: extern int     modsize;                /* Size of last display mode */
                    211: extern int     objflag;                /* Program can run */
                    212: extern int     pid;                    /* Current process id */
                    213: extern int     regflag;                /* Registers exist */
                    214: extern int     rflag;                  /* Read only flag */
                    215: extern int     sflag;                  /* Don't read symbol table */
                    216: extern int     hflag;                  /* debugging coherent */
                    217: extern int     sincmod;                /* Last mode ran (if single) */
                    218: extern int     sindecr;                /* Single step count */
                    219: extern int     sinmode;                /* Single step mode */
                    220: extern long    add;                    /* Address used by getb */
                    221: extern long    dot;                    /* Current address */
                    222: extern long    lad;                    /* Last address of dot */
                    223: extern fsize_t sbase;                  /* Base of symbols */
                    224: extern fsize_t snsym;                  /* Number of symbols */
                    225: extern int     dbase;                  /* input/reference addr base */
                    226: extern int     fflag;                  /* map as file */

unix.superglobalmegacorp.com

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