Return to sym.c CVS log

Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / usr / src / bin / adb

Annotation of cci/usr/src/bin/adb/sym.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  * adb - symbol table routines
                      3:  */
                      4: #include "defs.h"
                      5: #include <stab.h>
                      6: 
                      7: /*
                      8:  * Lookup a symbol by name.
                      9:  */
                     10: struct nlist *
                     11: lookup(symstr)
                     12:        char *symstr;
                     13: {
                     14:        register struct nlist *sp;
                     15: 
                     16:        cursym = 0;
                     17:        if (symtab)
                     18:        for (sp = symtab; sp < esymtab; sp++)
                     19:                /* SHOULD DO SOME OF EQSYM INLINE TO SAVE TIME */
                     20:                if ((sp->n_type&N_STAB)==0 && eqsym(sp->n_un.n_name, symstr, '_'))
                     21:                        return(cursym = sp);
                     22:        return (0);
                     23: }
                     24: 
                     25: /*
                     26:  * Find the closest symbol to val, and return
                     27:  * the difference between val and the symbol found.
                     28:  * Leave a pointer to the symbol found as cursym.
                     29:  */
                     30: findsym(val, type)
                     31:        register val;
                     32:        int type;
                     33: {
                     34:        register diff;
                     35:        register struct nlist *sp;
                     36: 
                     37:        cursym = 0;
                     38:        diff = MAXINT;
                     39:        if (type == NSYM || symtab == 0)
                     40:                return (diff);
                     41:        for (sp = symtab; sp < esymtab; sp++) {
                     42:                if (sp->n_type&N_STAB || (sp->n_type&N_EXT)==0)
                     43:                        continue;
                     44:                if (val - sp->n_value < diff && val >= sp->n_value) {
                     45:                        diff = val - sp->n_value;
                     46:                        cursym = sp;
                     47:                        if (diff == 0)
                     48:                                break;
                     49:                }
                     50:        }
                     51:        return (diff);
                     52: }
                     53: 
                     54: /*
                     55:  * Advance cursym to the next local variable.
                     56:  * Leave its value in localval as a side effect.
                     57:  * Return 0 at end of file.
                     58:  */
                     59: localsym(cframe)
                     60:        ADDR cframe;
                     61: {
                     62:        register int type;
                     63:        register struct nlist *sp;
                     64: 
                     65:        if (cursym)
                     66:        for (sp = cursym; ++sp < esymtab; ) {
                     67:                type = sp->n_type;
                     68:                if (sp->n_un.n_name[0] =='_' || type == N_FN)
                     69:                        return (0);
                     70:                switch (type) {
                     71: 
                     72:                case N_TEXT:
                     73:                case N_TEXT|N_EXT:
                     74:                case N_DATA:
                     75:                case N_DATA|N_EXT:
                     76:                case N_BSS:
                     77:                case N_BSS|N_EXT:
                     78:                        localval = sp->n_value;
                     79:                        cursym = sp;
                     80:                        return (1);
                     81: 
                     82:                case N_LSYM:
                     83:                        localval = cframe - sp->n_value;
                     84:                        cursym = sp;
                     85:                        return (1);
                     86: 
                     87:                case N_PSYM:
                     88:                case N_ABS:
                     89:                        localval = cframe + sp->n_value;
                     90:                        cursym = sp;
                     91:                        return (1);
                     92:                }
                     93:        }
                     94:        cursym = 0;
                     95:        return (0);
                     96: }
                     97: 
                     98: /*
                     99:  * Print value v and then the string s.
                    100:  * If v is not zero, then we look for a nearby symbol
                    101:  * and print name+offset if we find a symbol for which
                    102:  * offset is small enough.
                    103:  *
                    104:  * For values which are just into kernel address space
                    105:  * that they match exactly or that they be more than maxoff
                    106:  * bytes into kernel space.
                    107:  */
                    108: psymoff(v, type, s)
                    109:        register v;
                    110:        int type;
                    111:        char *s;
                    112: {
                    113:        register w;
                    114: 
                    115:        if (v) 
                    116:                w = findsym(v, type);
                    117:        if (v==0 || w >= maxoff)
                    118:                printf(LPRMODE, v);
                    119:        else {
                    120:                printf("%s", cursym->n_un.n_name);
                    121:                if (w)
                    122:                        printf(OFFMODE, w);
                    123:        }
                    124:        printf(s);
                    125: }
                    126: 
                    127: /*
                    128:  * Print value v symbolically if it has a reasonable
                    129:  * interpretation as name+offset.  If not, print nothing.
                    130:  * Used in printing out registers $r.
                    131:  */
                    132: valpr(v, idsp)
                    133: {
                    134:        register off_t d;
                    135: 
                    136:        d = findsym(v, idsp);
                    137:        if (d >= maxoff)
                    138:                return;
                    139:        printf("%s", cursym->n_un.n_name);
                    140:        if (d)
                    141:                printf(OFFMODE, d);
                    142: }

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