Return to mchframe.c CVS log

Up to [Research Unix] / researchv9 / cmd / adb / 11v

Annotation of researchv9/cmd/adb/11v/mchframe.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * machine-dependent code for
        !             3:  * looking in stack frames
        !             4:  * vax version
        !             5:  */
        !             6: 
        !             7: #include "defs.h"
        !             8: #include "regs.h"
        !             9: #include "sym.h"
        !            10: #include "space.h"
        !            11: 
        !            12: int maxargs = 20;
        !            13: 
        !            14: /*
        !            15:  * PDP-11 C stack frame
        !            16:  */
        !            17: 
        !            18: #define        F_FP    0       /* link to next frame */
        !            19: #define        F_PC    2       /* return pc */
        !            20: 
        !            21: #define        EVEN(x) ((x)&~1)
        !            22: 
        !            23: /*
        !            24:  * return an address for a local variable
        !            25:  * no register vars, unfortunately, as we can't provide an address
        !            26:  * gn is the procedure; ln the local name
        !            27:  */
        !            28: 
        !            29: localaddr(gn, ln)
        !            30: char *gn, *ln;
        !            31: {
        !            32:        WORD fp;
        !            33:        extern WORD expv;
        !            34:        extern int expsp;
        !            35:        ADDR laddr();
        !            36: 
        !            37:        if (gn) {
        !            38:                if (findrtn(gn) == 0)
        !            39:                        error("function not found");
        !            40:        }
        !            41:        else {
        !            42:                findsym((WORD)atow(rget(PC)), INSTSP);
        !            43:                if (cursym == NULL)
        !            44:                        error("function not found");
        !            45:        }
        !            46:        if (findframe(&fp) == 0)
        !            47:                error("stack frame not found");
        !            48:        if (ln == NULL) {
        !            49:                expsp = 0;
        !            50:                expv = fp;
        !            51:                return;
        !            52:        }
        !            53:        while (localsym()) {
        !            54:                if (strcmp(ln, cursym->y_name) != 0)
        !            55:                        continue;
        !            56:                expv = laddr(cursym, fp);
        !            57:                if (cursym->y_ltype == S_RSYM)
        !            58:                        expsp = REGSP;
        !            59:                else
        !            60:                        expsp = NOSP;
        !            61:                return;
        !            62:        }
        !            63:        error("bad local variable");
        !            64:        /* NOTREACHED */
        !            65: }
        !            66: 
        !            67: /*
        !            68:  * print a stack traceback
        !            69:  * give locals if possible
        !            70:  */
        !            71: 
        !            72: ctrace(modif)
        !            73: char modif;
        !            74: {
        !            75:        register ADDR fp, callpc;
        !            76: 
        !            77:        if (adrflg) {
        !            78:                fp = EVEN(adrval);
        !            79:                callpc = atow(aget(fp + F_PC, CORF|DATASP));
        !            80:        } else {
        !            81:                fp = (ADDR)EVEN(rtow(rget(R5)));
        !            82:                callpc = (ADDR)rtow(rget(PC));
        !            83:        }
        !            84:        clrraddr();
        !            85:        while (cntval--) {
        !            86:                chkerr();
        !            87:                findsym(callpc, INSTSP);
        !            88:                if (cursym == NULL)
        !            89:                        printf("?(");
        !            90:                else
        !            91:                        printf("%s(", cursym->y_name);
        !            92:                /* args stuff */
        !            93:                printf(") from %R\n", callpc);
        !            94:                if (modif == 'C')
        !            95:                        locals(fp);
        !            96:                callpc = atow(aget(fp + F_PC, CORF|DATASP));
        !            97:                setraddr(fp);
        !            98:                fp = EVEN(atow(aget(fp + F_FP, CORF|DATASP)));
        !            99:                if (fp == 0)
        !           100:                        break;
        !           101:        }
        !           102:        clrraddr();
        !           103: }
        !           104: 
        !           105: static
        !           106: locals(fp)
        !           107: ADDR fp;
        !           108: {
        !           109:        WORD val;
        !           110:        register int sp;
        !           111:        ADDR laddr();
        !           112: 
        !           113:        while (localsym()) {
        !           114:                sp = CORF | DATASP;
        !           115:                if (cursym->y_ltype == S_RSYM)
        !           116:                        sp = CORF | REGSP;
        !           117:                val = ltow(lget(laddr(cursym, fp), sp));
        !           118:                if (errflg == 0)
        !           119:                        printf("%8t%s/%10t%R\n", cursym->y_name, val);
        !           120:                else {
        !           121:                        printf("%8t%s/%10t?\n", cursym->y_name);
        !           122:                        errflg = 0;
        !           123:                }
        !           124:        }
        !           125: }
        !           126: 
        !           127: static ADDR
        !           128: laddr(sp, fp)
        !           129: struct sym *sp;
        !           130: ADDR fp;
        !           131: {
        !           132: 
        !           133:        switch (sp->y_ltype) {
        !           134:        case S_STSYM:
        !           135:                return (sp->y_value);
        !           136: 
        !           137:        case S_LSYM:
        !           138:        case S_PSYM:
        !           139:                return (fp + (short)sp->y_value);
        !           140: 
        !           141:        case S_RSYM:
        !           142:                return (sp->y_value * SZREG);
        !           143:        }
        !           144:        error("bad local symbol");
        !           145:        /* NOTREACHED */
        !           146: }
        !           147: 
        !           148: static int
        !           149: findframe(fpp)
        !           150: ADDR *fpp;
        !           151: {
        !           152:        register ADDR fp, pc;
        !           153:        register int fl;
        !           154:        struct sym *svcur;
        !           155: 
        !           156:        svcur = cursym;
        !           157:        fp = EVEN(rtow(rget(R5)));
        !           158:        pc = rtow(rget(PC));
        !           159:        if (errflg)
        !           160:                return (0);
        !           161:        clrraddr();
        !           162:        for (;;) {
        !           163:                findsym(pc, INSTSP);
        !           164:                if (cursym == svcur)
        !           165:                        break;
        !           166:                setraddr(fp);
        !           167:                pc = atow(aget(fp + F_PC, CORF|DATASP));
        !           168:                fp = EVEN(atow(aget(fp + F_FP, CORF|DATASP)));
        !           169:                if (errflg) {
        !           170:                        clrraddr();
        !           171:                        return (0);
        !           172:                }
        !           173:        }
        !           174:        *fpp = fp;
        !           175:        return (1);
        !           176: }
        !           177: 
        !           178: /*
        !           179:  * set addresses for saved registers for this frame
        !           180:  */
        !           181: 
        !           182: static
        !           183: setraddr(fp)
        !           184: register ADDR fp;
        !           185: {
        !           186:        register int r;
        !           187:        register int i;
        !           188:        extern ADDR raddr[];
        !           189: 
        !           190:        /* all wrong */
        !           191: }
        !           192: 
        !           193: static
        !           194: clrraddr()
        !           195: {
        !           196:        register int i;
        !           197:        extern ADDR raddr[];
        !           198: 
        !           199:        for (i = 0; i <= MAXREG - MINREG; i++)
        !           200:                raddr[i] = 0;
        !           201: }

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