Return to trace.h CVS log

Up to [MW Coherent from dump] / coherent / d / bin / db

Annotation of coherent/d/bin/db/trace.h, revision 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 */

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