Return to runtime.c CVS log

Up to [CSRG BSD Unix] / 43BSD / ucb / dbx

Annotation of 43BSD/ucb/dbx/runtime.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * Copyright (c) 1983 Regents of the University of California.
        !             3:  * All rights reserved.  The Berkeley software License Agreement
        !             4:  * specifies the terms and conditions for redistribution.
        !             5:  */
        !             6: 
        !             7: #ifndef lint
        !             8: static char sccsid[] = "@(#)runtime.c  5.2 (Berkeley) 1/10/86";
        !             9: #endif not lint
        !            10: 
        !            11: static char rcsid[] = "$Header: runtime.c,v 1.5 84/12/26 10:41:52 linton Exp $";
        !            12: 
        !            13: /*
        !            14:  * Runtime organization dependent routines, mostly dealing with
        !            15:  * activation records.
        !            16:  */
        !            17: 
        !            18: #include "defs.h"
        !            19: #include "runtime.h"
        !            20: #include "process.h"
        !            21: #include "machine.h"
        !            22: #include "events.h"
        !            23: #include "mappings.h"
        !            24: #include "symbols.h"
        !            25: #include "tree.h"
        !            26: #include "eval.h"
        !            27: #include "operators.h"
        !            28: #include "object.h"
        !            29: #include <sys/param.h>
        !            30: 
        !            31: #ifndef public
        !            32: typedef struct Frame *Frame;
        !            33: 
        !            34: #include "machine.h"
        !            35: #endif
        !            36: 
        !            37: #define NSAVEREG 12
        !            38: 
        !            39: struct Frame {
        !            40:     integer condition_handler;
        !            41:     integer mask;
        !            42:     Address save_ap;           /* argument pointer */
        !            43:     Address save_fp;           /* frame pointer */
        !            44:     Address save_pc;           /* program counter */
        !            45:     Word save_reg[NSAVEREG];   /* not necessarily there */
        !            46: };
        !            47: 
        !            48: private Frame curframe = nil;
        !            49: private struct Frame curframerec;
        !            50: private Boolean walkingstack = false;
        !            51: 
        !            52: #define frameeq(f1, f2) ((f1)->save_fp == (f2)->save_fp)
        !            53: 
        !            54: #define isstackaddr(addr) \
        !            55:     (((addr) < 0x80000000) and ((addr) > 0x80000000 - 0x200 * UPAGES))
        !            56: 
        !            57: typedef struct {
        !            58:     Node callnode;
        !            59:     Node cmdnode;
        !            60:     boolean isfunc;
        !            61: } CallEnv;
        !            62: 
        !            63: private CallEnv endproc;
        !            64: 
        !            65: /*
        !            66:  * Set a frame to the current activation record.
        !            67:  */
        !            68: 
        !            69: private getcurframe(frp)
        !            70: Frame frp;
        !            71: {
        !            72:     register int i;
        !            73: 
        !            74:     checkref(frp);
        !            75:     frp->mask = reg(NREG);
        !            76:     frp->save_ap = reg(ARGP);
        !            77:     frp->save_fp = reg(FRP);
        !            78:     frp->save_pc = reg(PROGCTR);
        !            79:     for (i = 0; i < NSAVEREG; i++) {
        !            80:        frp->save_reg[i] = reg(i);
        !            81:     }
        !            82: }
        !            83: 
        !            84: /*
        !            85:  * Get the saved registers from one frame to another
        !            86:  * given mask specifying which registers were actually saved.
        !            87:  */
        !            88: 
        !            89: #define bis(b, n) ((b & (1 << (n))) != 0)
        !            90: 
        !            91: private getsaveregs (newfrp, frp, mask)
        !            92: Frame newfrp, frp;
        !            93: integer mask;
        !            94: {
        !            95:     integer i, j;
        !            96: 
        !            97:     j = 0;
        !            98:     for (i = 0; i < NSAVEREG; i++) {
        !            99:        if (bis(mask, i)) {
        !           100:            newfrp->save_reg[i] = frp->save_reg[j];
        !           101:            ++j;
        !           102:        }
        !           103:     }
        !           104: }
        !           105: 
        !           106: /*
        !           107:  * Return a pointer to the next activation record up the stack.
        !           108:  * Return nil if there is none.
        !           109:  * Writes over space pointed to by given argument.
        !           110:  */
        !           111: 
        !           112: private Frame nextframe(frp)
        !           113: Frame frp;
        !           114: {
        !           115:     Frame newfrp;
        !           116:     struct Frame frame;
        !           117:     integer mask;
        !           118:     Address prev_frame, callpc; 
        !           119:     static integer ntramp = 0;
        !           120: 
        !           121:     newfrp = frp;
        !           122:     prev_frame = frp->save_fp;
        !           123: 
        !           124: /*
        !           125:  *  The check for interrupt generated frames is taken from adb with only
        !           126:  *  partial understanding.  If you're in "sub" and on a sigxxx "sigsub"
        !           127:  *  gets control, then the stack does NOT look like <main, sub, sigsub>.
        !           128:  *
        !           129:  *  As best I can make out it looks like:
        !           130:  *
        !           131:  *     <main, (machine check exception block + sub), sysframe, sigsub>.
        !           132:  *
        !           133:  *  When the signal occurs an exception block and a frame for the routine
        !           134:  *  in which it occured are pushed on the user stack.  Then another frame
        !           135:  *  is pushed corresponding to a call from the kernel to sigsub.
        !           136:  *
        !           137:  *  The addr in sub at which the exception occured is not in sub.save_pc
        !           138:  *  but in the machine check exception block.  It is at the magic address
        !           139:  *  fp + 84.
        !           140:  *
        !           141:  *  The current approach ignores the sys_frame (what adb reports as sigtramp)
        !           142:  *  and takes the pc for sub from the exception block.  This allows the
        !           143:  *  "where" command to report <main, sub, sigsub>, which seems reasonable.
        !           144:  */
        !           145: 
        !           146: nextf:
        !           147:     dread(&frame, prev_frame, sizeof(struct Frame));
        !           148:     if (ntramp == 1) {
        !           149:        dread(&callpc, prev_frame + 84, sizeof(callpc));
        !           150:     } else {
        !           151:        callpc = frame.save_pc;
        !           152:     }
        !           153:     if (frame.save_fp == nil or frame.save_pc == (Address) -1) {
        !           154:        newfrp = nil;
        !           155:     } else if (isstackaddr(callpc)) {
        !           156:        ntramp++;
        !           157:        prev_frame = frame.save_fp;
        !           158:        goto nextf;
        !           159:     } else {
        !           160:        frame.save_pc = callpc;
        !           161:         ntramp = 0;
        !           162:        mask = ((frame.mask >> 16) & 0x0fff);
        !           163:        getsaveregs(newfrp, &frame, mask);
        !           164:        newfrp->condition_handler = frame.condition_handler;
        !           165:        newfrp->mask = mask;
        !           166:        newfrp->save_ap = frame.save_ap;
        !           167:        newfrp->save_fp = frame.save_fp;
        !           168:        newfrp->save_pc = frame.save_pc;
        !           169:     }
        !           170:     return newfrp;
        !           171: }
        !           172: 
        !           173: /*
        !           174:  * Get the current frame information in the given Frame and store the
        !           175:  * associated function in the given value-result parameter.
        !           176:  */
        !           177: 
        !           178: private getcurfunc (frp, fp)
        !           179: Frame frp;
        !           180: Symbol *fp;
        !           181: {
        !           182:     getcurframe(frp);
        !           183:     *fp = whatblock(frp->save_pc);
        !           184: }
        !           185: 
        !           186: /*
        !           187:  * Return the frame associated with the next function up the call stack, or
        !           188:  * nil if there is none.  The function is returned in a value-result parameter.
        !           189:  * For "inline" functions the statically outer function and same frame
        !           190:  * are returned.
        !           191:  */
        !           192: 
        !           193: public Frame nextfunc (frp, fp)
        !           194: Frame frp;
        !           195: Symbol *fp;
        !           196: {
        !           197:     Symbol t;
        !           198:     Frame nfrp;
        !           199: 
        !           200:     t = *fp;
        !           201:     checkref(t);
        !           202:     if (isinline(t)) {
        !           203:        t = container(t);
        !           204:        nfrp = frp;
        !           205:     } else {
        !           206:        nfrp = nextframe(frp);
        !           207:        if (nfrp == nil) {
        !           208:            t = nil;
        !           209:        } else {
        !           210:            t = whatblock(nfrp->save_pc);
        !           211:        }
        !           212:     }
        !           213:     *fp = t;
        !           214:     return nfrp;
        !           215: }
        !           216: 
        !           217: /*
        !           218:  * Return the frame associated with the given function.
        !           219:  * If the function is nil, return the most recently activated frame.
        !           220:  *
        !           221:  * Static allocation for the frame.
        !           222:  */
        !           223: 
        !           224: public Frame findframe(f)
        !           225: Symbol f;
        !           226: {
        !           227:     Frame frp;
        !           228:     static struct Frame frame;
        !           229:     Symbol p;
        !           230:     Boolean done;
        !           231: 
        !           232:     frp = &frame;
        !           233:     getcurframe(frp);
        !           234:     if (f != nil) {
        !           235:        if (f == curfunc and curframe != nil) {
        !           236:            *frp = *curframe;
        !           237:        } else {
        !           238:            done = false;
        !           239:            p = whatblock(frp->save_pc);
        !           240:            do {
        !           241:                if (p == f) {
        !           242:                    done = true;
        !           243:                } else if (p == program) {
        !           244:                    done = true;
        !           245:                    frp = nil;
        !           246:                } else {
        !           247:                    frp = nextfunc(frp, &p);
        !           248:                    if (frp == nil) {
        !           249:                        done = true;
        !           250:                    }
        !           251:                }
        !           252:            } while (not done);
        !           253:        }
        !           254:     }
        !           255:     return frp;
        !           256: }
        !           257: 
        !           258: /*
        !           259:  * Set the registers according to the given frame pointer.
        !           260:  */
        !           261: 
        !           262: public getnewregs (addr)
        !           263: Address addr;
        !           264: {
        !           265:     struct Frame frame;
        !           266:     integer i, j, mask;
        !           267: 
        !           268:     dread(&frame, addr, sizeof(frame));
        !           269:     setreg(ARGP, frame.save_ap);
        !           270:     setreg(FRP, frame.save_fp);
        !           271:     setreg(PROGCTR, frame.save_pc);
        !           272:     mask = ((frame.mask >> 16) & 0x0fff);
        !           273:     j = 0;
        !           274:     for (i = 0; i < NSAVEREG; i++) {
        !           275:        if (bis(mask, i)) {
        !           276:            setreg(i, frame.save_reg[j]);
        !           277:            ++j;
        !           278:        }
        !           279:     }
        !           280:     pc = frame.save_pc;
        !           281:     setcurfunc(whatblock(pc));
        !           282: }
        !           283: 
        !           284: /*
        !           285:  * Find the return address of the current procedure/function.
        !           286:  */
        !           287: 
        !           288: public Address return_addr()
        !           289: {
        !           290:     Frame frp;
        !           291:     Address addr;
        !           292:     struct Frame frame;
        !           293: 
        !           294:     frp = &frame;
        !           295:     getcurframe(frp);
        !           296:     frp = nextframe(frp);
        !           297:     if (frp == nil) {
        !           298:        addr = 0;
        !           299:     } else {
        !           300:        addr = frp->save_pc;
        !           301:     }
        !           302:     return addr;
        !           303: }
        !           304: 
        !           305: /*
        !           306:  * Push the value associated with the current function.
        !           307:  */
        !           308: 
        !           309: public pushretval(len, isindirect)
        !           310: integer len;
        !           311: boolean isindirect;
        !           312: {
        !           313:     Word r0;
        !           314: 
        !           315:     r0 = reg(0);
        !           316:     if (isindirect) {
        !           317:        rpush((Address) r0, len);
        !           318:     } else {
        !           319:        switch (len) {
        !           320:            case sizeof(char):
        !           321:                push(char, r0);
        !           322:                break;
        !           323: 
        !           324:            case sizeof(short):
        !           325:                push(short, r0);
        !           326:                break;
        !           327: 
        !           328:            default:
        !           329:                if (len == sizeof(Word)) {
        !           330:                    push(Word, r0);
        !           331:                } else if (len == 2*sizeof(Word)) {
        !           332:                    push(Word, r0);
        !           333:                    push(Word, reg(1));
        !           334:                } else {
        !           335:                    error("[internal error: bad size %d in pushretval]", len);
        !           336:                }
        !           337:                break;
        !           338:        }
        !           339:     }
        !           340: }
        !           341: 
        !           342: /*
        !           343:  * Return the base address for locals in the given frame.
        !           344:  */
        !           345: 
        !           346: public Address locals_base(frp)
        !           347: Frame frp;
        !           348: {
        !           349:     return (frp == nil) ? reg(FRP) : frp->save_fp;
        !           350: }
        !           351: 
        !           352: /*
        !           353:  * Return the base address for arguments in the given frame.
        !           354:  */
        !           355: 
        !           356: public Address args_base(frp)
        !           357: Frame frp;
        !           358: {
        !           359:     return (frp == nil) ? reg(ARGP) : frp->save_ap;
        !           360: }
        !           361: 
        !           362: /*
        !           363:  * Return saved register n from the given frame.
        !           364:  */
        !           365: 
        !           366: public Word savereg(n, frp)
        !           367: integer n;
        !           368: Frame frp;
        !           369: {
        !           370:     Word w;
        !           371: 
        !           372:     if (frp == nil) {
        !           373:        w = reg(n);
        !           374:     } else {
        !           375:        switch (n) {
        !           376:            case ARGP:
        !           377:                w = frp->save_ap;
        !           378:                break;
        !           379: 
        !           380:            case FRP:
        !           381:                w = frp->save_fp;
        !           382:                break;
        !           383: 
        !           384:            case STKP:
        !           385:                w = reg(STKP);
        !           386:                break;
        !           387: 
        !           388:            case PROGCTR:
        !           389:                w = frp->save_pc;
        !           390:                break;
        !           391: 
        !           392:            default:
        !           393:                assert(n >= 0 and n < NSAVEREG);
        !           394:                w = frp->save_reg[n];
        !           395:                break;
        !           396:        }
        !           397:     }
        !           398:     return w;
        !           399: }
        !           400: 
        !           401: /*
        !           402:  * Return the nth argument to the current procedure.
        !           403:  */
        !           404: 
        !           405: public Word argn(n, frp)
        !           406: integer n;
        !           407: Frame frp;
        !           408: {
        !           409:     Word w;
        !           410: 
        !           411:     dread(&w, args_base(frp) + (n * sizeof(Word)), sizeof(w));
        !           412:     return w;
        !           413: }
        !           414: 
        !           415: /*
        !           416:  * Print a list of currently active blocks starting with most recent.
        !           417:  */
        !           418: 
        !           419: public wherecmd()
        !           420: {
        !           421:     walkstack(false);
        !           422: }
        !           423: 
        !           424: /*
        !           425:  * Print the variables in the given frame or the current one if nil.
        !           426:  */
        !           427: 
        !           428: public dump (func)
        !           429: Symbol func;
        !           430: {
        !           431:     Symbol f;
        !           432:     Frame frp;
        !           433: 
        !           434:     if (func == nil) {
        !           435:        f = curfunc;
        !           436:        if (curframe != nil) {
        !           437:            frp = curframe;
        !           438:        } else {
        !           439:            frp = findframe(f);
        !           440:        }
        !           441:     } else {
        !           442:        f = func;
        !           443:        frp = findframe(f);
        !           444:     }
        !           445:     showaggrs = true;
        !           446:     printcallinfo(f, frp);
        !           447:     dumpvars(f, frp);
        !           448: }
        !           449: 
        !           450: /*
        !           451:  * Dump all values.
        !           452:  */
        !           453: 
        !           454: public dumpall ()
        !           455: {
        !           456:     walkstack(true);
        !           457: }
        !           458: 
        !           459: /*
        !           460:  * Walk the stack of active procedures printing information
        !           461:  * about each active procedure.
        !           462:  */
        !           463: 
        !           464: private walkstack(dumpvariables)
        !           465: Boolean dumpvariables;
        !           466: {
        !           467:     Frame frp;
        !           468:     boolean save;
        !           469:     Symbol f;
        !           470:     struct Frame frame;
        !           471: 
        !           472:     if (notstarted(process) or isfinished(process)) {
        !           473:        error("program is not active");
        !           474:     } else {
        !           475:        save = walkingstack;
        !           476:        walkingstack = true;
        !           477:        showaggrs = dumpvariables;
        !           478:        frp = &frame;
        !           479:        getcurfunc(frp, &f);
        !           480:        for (;;) {
        !           481:            printcallinfo(f, frp);
        !           482:            if (dumpvariables) {
        !           483:                dumpvars(f, frp);
        !           484:                putchar('\n');
        !           485:            }
        !           486:            frp = nextfunc(frp, &f);
        !           487:            if (frp == nil or f == program) {
        !           488:                break;
        !           489:            }
        !           490:        }
        !           491:        if (dumpvariables) {
        !           492:            printf("in \"%s\":\n", symname(program));
        !           493:            dumpvars(program, nil);
        !           494:            putchar('\n');
        !           495:        }
        !           496:        walkingstack = save;
        !           497:     }
        !           498: }
        !           499: 
        !           500: /*
        !           501:  * Print out the information about a call, i.e.,
        !           502:  * routine name, parameter values, and source location.
        !           503:  */
        !           504: 
        !           505: private printcallinfo (f, frp)
        !           506: Symbol f;
        !           507: Frame frp;
        !           508: {
        !           509:     Lineno line;
        !           510:     Address savepc;
        !           511: 
        !           512:     savepc = frp->save_pc;
        !           513:     if (frp->save_fp != reg(FRP)) {
        !           514:        savepc -= 1;
        !           515:     }
        !           516:     printname(stdout, f);
        !           517:     if (not isinline(f)) {
        !           518:        printparams(f, frp);
        !           519:     }
        !           520:     line = srcline(savepc);
        !           521:     if (line != 0) {
        !           522:        printf(", line %d", line);
        !           523:        printf(" in \"%s\"\n", srcfilename(savepc));
        !           524:     } else {
        !           525:        printf(" at 0x%x\n", savepc);
        !           526:     }
        !           527: }
        !           528: 
        !           529: /*
        !           530:  * Set the current function to the given symbol.
        !           531:  * We must adjust "curframe" so that subsequent operations are
        !           532:  * not confused; for simplicity we simply clear it.
        !           533:  */
        !           534: 
        !           535: public setcurfunc (f)
        !           536: Symbol f;
        !           537: {
        !           538:     curfunc = f;
        !           539:     curframe = nil;
        !           540: }
        !           541: 
        !           542: /*
        !           543:  * Return the frame for the current function.
        !           544:  * The space for the frame is allocated statically.
        !           545:  */
        !           546: 
        !           547: public Frame curfuncframe ()
        !           548: {
        !           549:     static struct Frame frame;
        !           550:     Frame frp;
        !           551: 
        !           552:     if (curframe == nil) {
        !           553:        frp = findframe(curfunc);
        !           554:        curframe = &curframerec;
        !           555:        *curframe = *frp;
        !           556:     } else {
        !           557:        frp = &frame;
        !           558:        *frp = *curframe;
        !           559:     }
        !           560:     return frp;
        !           561: }
        !           562: 
        !           563: /*
        !           564:  * Set curfunc to be N up/down the stack from its current value.
        !           565:  */
        !           566: 
        !           567: public up (n)
        !           568: integer n;
        !           569: {
        !           570:     integer i;
        !           571:     Symbol f;
        !           572:     Frame frp;
        !           573:     boolean done;
        !           574: 
        !           575:     if (not isactive(program)) {
        !           576:        error("program is not active");
        !           577:     } else if (curfunc == nil) {
        !           578:        error("no current function");
        !           579:     } else {
        !           580:        i = 0;
        !           581:        f = curfunc;
        !           582:        frp = curfuncframe();
        !           583:        done = false;
        !           584:        do {
        !           585:            if (frp == nil) {
        !           586:                done = true;
        !           587:                error("not that many levels");
        !           588:            } else if (i >= n) {
        !           589:                done = true;
        !           590:                curfunc = f;
        !           591:                curframe = &curframerec;
        !           592:                *curframe = *frp;
        !           593:                showaggrs = false;
        !           594:                printcallinfo(curfunc, curframe);
        !           595:            } else if (f == program) {
        !           596:                done = true;
        !           597:                error("not that many levels");
        !           598:            } else {
        !           599:                frp = nextfunc(frp, &f);
        !           600:            }
        !           601:            ++i;
        !           602:        } while (not done);
        !           603:     }
        !           604: }
        !           605: 
        !           606: public down (n)
        !           607: integer n;
        !           608: {
        !           609:     integer i, depth;
        !           610:     Frame frp, curfrp;
        !           611:     Symbol f;
        !           612:     struct Frame frame;
        !           613: 
        !           614:     if (not isactive(program)) {
        !           615:        error("program is not active");
        !           616:     } else if (curfunc == nil) {
        !           617:        error("no current function");
        !           618:     } else {
        !           619:        depth = 0;
        !           620:        frp = &frame;
        !           621:        getcurfunc(frp, &f);
        !           622:        if (curframe == nil) {
        !           623:            curfrp = findframe(curfunc);
        !           624:            curframe = &curframerec;
        !           625:            *curframe = *curfrp;
        !           626:        }
        !           627:        while ((f != curfunc or !frameeq(frp, curframe)) and f != nil) {
        !           628:            frp = nextfunc(frp, &f);
        !           629:            ++depth;
        !           630:        }
        !           631:        if (f == nil or n > depth) {
        !           632:            error("not that many levels");
        !           633:        } else {
        !           634:            depth -= n;
        !           635:            frp = &frame;
        !           636:            getcurfunc(frp, &f);
        !           637:            for (i = 0; i < depth; i++) {
        !           638:                frp = nextfunc(frp, &f);
        !           639:                assert(frp != nil);
        !           640:            }
        !           641:            curfunc = f;
        !           642:            *curframe = *frp;
        !           643:            showaggrs = false;
        !           644:            printcallinfo(curfunc, curframe);
        !           645:        }
        !           646:     }
        !           647: }
        !           648: 
        !           649: /*
        !           650:  * Find the entry point of a procedure or function.
        !           651:  */
        !           652: 
        !           653: public findbeginning (f)
        !           654: Symbol f;
        !           655: {
        !           656:     if (isinternal(f)) {
        !           657:        f->symvalue.funcv.beginaddr += 15;
        !           658:     } else {
        !           659:        f->symvalue.funcv.beginaddr += 2;
        !           660:     }
        !           661: }
        !           662: 
        !           663: /*
        !           664:  * Return the address corresponding to the first line in a function.
        !           665:  */
        !           666: 
        !           667: public Address firstline(f)
        !           668: Symbol f;
        !           669: {
        !           670:     Address addr;
        !           671: 
        !           672:     addr = codeloc(f);
        !           673:     while (linelookup(addr) == 0 and addr < objsize) {
        !           674:        ++addr;
        !           675:     }
        !           676:     if (addr == objsize) {
        !           677:        addr = -1;
        !           678:     }
        !           679:     return addr;
        !           680: }
        !           681: 
        !           682: /*
        !           683:  * Catcher drops strike three ...
        !           684:  */
        !           685: 
        !           686: public runtofirst()
        !           687: {
        !           688:     Address addr;
        !           689: 
        !           690:     addr = pc;
        !           691:     while (linelookup(addr) == 0 and addr < objsize) {
        !           692:        ++addr;
        !           693:     }
        !           694:     if (addr < objsize) {
        !           695:        stepto(addr);
        !           696:     }
        !           697: }
        !           698: 
        !           699: /*
        !           700:  * Return the address corresponding to the end of the program.
        !           701:  *
        !           702:  * We look for the entry to "exit".
        !           703:  */
        !           704: 
        !           705: public Address lastaddr()
        !           706: {
        !           707:     Symbol s;
        !           708: 
        !           709:     s = lookup(identname("exit", true));
        !           710:     if (s == nil) {
        !           711:        panic("can't find exit");
        !           712:     }
        !           713:     return codeloc(s);
        !           714: }
        !           715: 
        !           716: /*
        !           717:  * Decide if the given function is currently active.
        !           718:  *
        !           719:  * We avoid calls to "findframe" during a stack trace for efficiency.
        !           720:  * Presumably information evaluated while walking the stack is active.
        !           721:  */
        !           722: 
        !           723: public Boolean isactive(f)
        !           724: Symbol f;
        !           725: {
        !           726:     Boolean b;
        !           727: 
        !           728:     if (isfinished(process)) {
        !           729:        b = false;
        !           730:     } else {
        !           731:        if (walkingstack or f == program or
        !           732:          (ismodule(f) and isactive(container(f)))) {
        !           733:            b = true;
        !           734:        } else {
        !           735:            b = (Boolean) (findframe(f) != nil);
        !           736:        }
        !           737:     }
        !           738:     return b;
        !           739: }
        !           740: 
        !           741: /*
        !           742:  * Evaluate a call to a procedure.
        !           743:  */
        !           744: 
        !           745: public callproc(exprnode, isfunc)
        !           746: Node exprnode;
        !           747: boolean isfunc;
        !           748: {
        !           749:     Node procnode, arglist;
        !           750:     Symbol proc;
        !           751:     integer argc;
        !           752: 
        !           753:     procnode = exprnode->value.arg[0];
        !           754:     arglist = exprnode->value.arg[1];
        !           755:     if (procnode->op != O_SYM) {
        !           756:        beginerrmsg();
        !           757:        fprintf(stderr, "can't call \"");
        !           758:        prtree(stderr, procnode);
        !           759:        fprintf(stderr, "\"");
        !           760:        enderrmsg();
        !           761:     }
        !           762:     assert(procnode->op == O_SYM);
        !           763:     proc = procnode->value.sym;
        !           764:     if (not isblock(proc)) {
        !           765:        error("\"%s\" is not a procedure or function", symname(proc));
        !           766:     }
        !           767:     endproc.isfunc = isfunc;
        !           768:     endproc.callnode = exprnode;
        !           769:     endproc.cmdnode = topnode;
        !           770:     pushenv();
        !           771:     pc = codeloc(proc);
        !           772:     argc = pushargs(proc, arglist);
        !           773:     beginproc(proc, argc);
        !           774:     event_once(
        !           775:        build(O_EQ, build(O_SYM, pcsym), build(O_SYM, retaddrsym)),
        !           776:        buildcmdlist(build(O_PROCRTN, proc))
        !           777:     );
        !           778:     isstopped = false;
        !           779:     if (not bpact()) {
        !           780:        isstopped = true;
        !           781:        cont(0);
        !           782:     }
        !           783:     /*
        !           784:      * bpact() won't return true, it will call printstatus() and go back
        !           785:      * to command input if a breakpoint is found.
        !           786:      */
        !           787:     /* NOTREACHED */
        !           788: }
        !           789: 
        !           790: /*
        !           791:  * Push the arguments on the process' stack.  We do this by first
        !           792:  * evaluating them on the "eval" stack, then copying into the process'
        !           793:  * space.
        !           794:  */
        !           795: 
        !           796: private integer pushargs(proc, arglist)
        !           797: Symbol proc;
        !           798: Node arglist;
        !           799: {
        !           800:     Stack *savesp;
        !           801:     int argc, args_size;
        !           802: 
        !           803:     savesp = sp;
        !           804:     if (varIsSet("$unsafecall")) {
        !           805:        argc = unsafe_evalargs(proc, arglist);
        !           806:     } else {
        !           807:        argc = evalargs(proc, arglist);
        !           808:     }
        !           809:     args_size = sp - savesp;
        !           810:     setreg(STKP, reg(STKP) - args_size);
        !           811:     dwrite(savesp, reg(STKP), args_size);
        !           812:     sp = savesp;
        !           813:     return argc;
        !           814: }
        !           815: 
        !           816: /*
        !           817:  * Check to see if an expression is correct for a given parameter.
        !           818:  * If the given parameter is false, don't worry about type inconsistencies.
        !           819:  *
        !           820:  * Return whether or not it is ok.
        !           821:  */
        !           822: 
        !           823: private boolean chkparam (actual, formal, chk)
        !           824: Node actual;
        !           825: Symbol formal;
        !           826: boolean chk;
        !           827: {
        !           828:     boolean b;
        !           829: 
        !           830:     b = true;
        !           831:     if (chk) {
        !           832:        if (formal == nil) {
        !           833:            beginerrmsg();
        !           834:            fprintf(stderr, "too many parameters");
        !           835:            b = false;
        !           836:        } else if (not compatible(formal->type, actual->nodetype)) {
        !           837:            beginerrmsg();
        !           838:            fprintf(stderr, "type mismatch for %s", symname(formal));
        !           839:            b = false;
        !           840:        }
        !           841:     }
        !           842:     if (b and formal != nil and
        !           843:        isvarparam(formal) and not isopenarray(formal->type) and
        !           844:        not (
        !           845:            actual->op == O_RVAL or actual->nodetype == t_addr or
        !           846:            (
        !           847:                actual->op == O_TYPERENAME and
        !           848:                (
        !           849:                    actual->value.arg[0]->op == O_RVAL or
        !           850:                    actual->value.arg[0]->nodetype == t_addr
        !           851:                )
        !           852:            )
        !           853:        )
        !           854:     ) {
        !           855:        beginerrmsg();
        !           856:        fprintf(stderr, "expected variable, found \"");
        !           857:        prtree(stderr, actual);
        !           858:        fprintf(stderr, "\"");
        !           859:        b = false;
        !           860:     }
        !           861:     return b;
        !           862: }
        !           863: 
        !           864: /*
        !           865:  * Pass an expression to a particular parameter.
        !           866:  *
        !           867:  * Normally we pass either the address or value, but in some cases
        !           868:  * (such as C strings) we want to copy the value onto the stack and
        !           869:  * pass its address.
        !           870:  *
        !           871:  * Another special case raised by strings is the possibility that
        !           872:  * the actual parameter will be larger than the formal, even with
        !           873:  * appropriate type-checking.  This occurs because we assume during
        !           874:  * evaluation that strings are null-terminated, whereas some languages,
        !           875:  * notably Pascal, do not work under that assumption.
        !           876:  */
        !           877: 
        !           878: private passparam (actual, formal)
        !           879: Node actual;
        !           880: Symbol formal;
        !           881: {
        !           882:     boolean b;
        !           883:     Address addr;
        !           884:     Stack *savesp;
        !           885:     integer actsize, formsize;
        !           886: 
        !           887:     if (formal != nil and isvarparam(formal) and
        !           888:        (not isopenarray(formal->type))
        !           889:     ) {
        !           890:        addr = lval(actual->value.arg[0]);
        !           891:        push(Address, addr);
        !           892:     } else if (passaddr(formal, actual->nodetype)) {
        !           893:        savesp = sp;
        !           894:        eval(actual);
        !           895:        actsize = sp - savesp;
        !           896:        setreg(STKP,
        !           897:            reg(STKP) - ((actsize + sizeof(Word) - 1) & ~(sizeof(Word) - 1))
        !           898:        );
        !           899:        dwrite(savesp, reg(STKP), actsize);
        !           900:        sp = savesp;
        !           901:        push(Address, reg(STKP));
        !           902:        if (formal != nil and isopenarray(formal->type)) {
        !           903:            push(integer, actsize div size(formal->type->type));
        !           904:        }
        !           905:     } else if (formal != nil) {
        !           906:        formsize = size(formal);
        !           907:        savesp = sp;
        !           908:        eval(actual);
        !           909:        actsize = sp - savesp;
        !           910:        if (actsize > formsize) {
        !           911:            sp -= (actsize - formsize);
        !           912:        }
        !           913:     } else {
        !           914:        eval(actual);
        !           915:     }
        !           916: }
        !           917: 
        !           918: /*
        !           919:  * Evaluate an argument list left-to-right.
        !           920:  */
        !           921: 
        !           922: private integer evalargs(proc, arglist)
        !           923: Symbol proc;
        !           924: Node arglist;
        !           925: {
        !           926:     Node p, actual;
        !           927:     Symbol formal;
        !           928:     Stack *savesp;
        !           929:     integer count;
        !           930:     boolean chk;
        !           931: 
        !           932:     savesp = sp;
        !           933:     count = 0;
        !           934:     formal = proc->chain;
        !           935:     chk = (boolean) (not nosource(proc));
        !           936:     for (p = arglist; p != nil; p = p->value.arg[1]) {
        !           937:        assert(p->op == O_COMMA);
        !           938:        actual = p->value.arg[0];
        !           939:        if (not chkparam(actual, formal, chk)) {
        !           940:            fprintf(stderr, " in call to %s", symname(proc));
        !           941:            sp = savesp;
        !           942:            enderrmsg();
        !           943:        }
        !           944:        passparam(actual, formal);
        !           945:        if (formal != nil) {
        !           946:            formal = formal->chain;
        !           947:        }
        !           948:        ++count;
        !           949:     }
        !           950:     if (chk) {
        !           951:        if (formal != nil) {
        !           952:            sp = savesp;
        !           953:            error("not enough parameters to %s", symname(proc));
        !           954:        }
        !           955:     }
        !           956:     return count;
        !           957: }
        !           958: 
        !           959: /*
        !           960:  * Evaluate an argument list without concern for matching the formal
        !           961:  * parameters of a function in type or quantity.  Useful for functions
        !           962:  * like C's printf().
        !           963:  */
        !           964: 
        !           965: private integer unsafe_evalargs(proc, arglist)
        !           966: Symbol proc;
        !           967: Node arglist;
        !           968: {
        !           969:     Node p;
        !           970:     Integer count;
        !           971: 
        !           972:     count = 0;
        !           973:     for (p = arglist; p != nil; p = p->value.arg[1]) {
        !           974:        assert(p->op == O_COMMA);
        !           975:        eval(p->value.arg[0]);
        !           976:        ++count;
        !           977:     }
        !           978:     return count;
        !           979: }
        !           980: 
        !           981: public procreturn(f)
        !           982: Symbol f;
        !           983: {
        !           984:     integer retvalsize;
        !           985:     Node tmp;
        !           986:     char *copy;
        !           987: 
        !           988:     flushoutput();
        !           989:     popenv();
        !           990:     if (endproc.isfunc) {
        !           991:        retvalsize = size(f->type);
        !           992:        if (retvalsize > sizeof(long)) {
        !           993:            pushretval(retvalsize, true);
        !           994:            copy = newarr(char, retvalsize);
        !           995:            popn(retvalsize, copy);
        !           996:            tmp = build(O_SCON, copy);
        !           997:        } else {
        !           998:            tmp = build(O_LCON, (long) (reg(0)));
        !           999:        }
        !          1000:        tmp->nodetype = f->type;
        !          1001:        tfree(endproc.callnode);
        !          1002:        *(endproc.callnode) = *(tmp);
        !          1003:        dispose(tmp);
        !          1004:        eval(endproc.cmdnode);
        !          1005:     } else {
        !          1006:        putchar('\n');
        !          1007:        printname(stdout, f);
        !          1008:        printf(" returns successfully\n", symname(f));
        !          1009:     }
        !          1010:     erecover();
        !          1011: }
        !          1012: 
        !          1013: /*
        !          1014:  * Push the current environment.
        !          1015:  */
        !          1016: 
        !          1017: private pushenv()
        !          1018: {
        !          1019:     push(Address, pc);
        !          1020:     push(Lineno, curline);
        !          1021:     push(String, cursource);
        !          1022:     push(Boolean, isstopped);
        !          1023:     push(Symbol, curfunc);
        !          1024:     push(Frame, curframe);
        !          1025:     push(struct Frame, curframerec);
        !          1026:     push(CallEnv, endproc);
        !          1027:     push(Word, reg(PROGCTR));
        !          1028:     push(Word, reg(STKP));
        !          1029: }
        !          1030: 
        !          1031: /*
        !          1032:  * Pop back to the real world.
        !          1033:  */
        !          1034: 
        !          1035: public popenv()
        !          1036: {
        !          1037:     String filename;
        !          1038: 
        !          1039:     setreg(STKP, pop(Word));
        !          1040:     setreg(PROGCTR, pop(Word));
        !          1041:     endproc = pop(CallEnv);
        !          1042:     curframerec = pop(struct Frame);
        !          1043:     curframe = pop(Frame);
        !          1044:     curfunc = pop(Symbol);
        !          1045:     isstopped = pop(Boolean);
        !          1046:     filename = pop(String);
        !          1047:     curline = pop(Lineno);
        !          1048:     pc = pop(Address);
        !          1049:     setsource(filename);
        !          1050: }
        !          1051: 
        !          1052: /*
        !          1053:  * Flush the debuggee's standard output.
        !          1054:  *
        !          1055:  * This is VERY dependent on the use of stdio.
        !          1056:  */
        !          1057: 
        !          1058: public flushoutput()
        !          1059: {
        !          1060:     Symbol p, iob;
        !          1061:     Stack *savesp;
        !          1062: 
        !          1063:     p = lookup(identname("fflush", true));
        !          1064:     while (p != nil and not isblock(p)) {
        !          1065:        p = p->next_sym;
        !          1066:     }
        !          1067:     if (p != nil) {
        !          1068:        iob = lookup(identname("_iob", true));
        !          1069:        if (iob != nil) {
        !          1070:            pushenv();
        !          1071:            pc = codeloc(p);
        !          1072:            savesp = sp;
        !          1073:            push(long, address(iob, nil) + sizeof(struct _iobuf));
        !          1074:            setreg(STKP, reg(STKP) - sizeof(long));
        !          1075:            dwrite(savesp, reg(STKP), sizeof(long));
        !          1076:            sp = savesp;
        !          1077:            beginproc(p, 1);
        !          1078:            stepto(return_addr());
        !          1079:            popenv();
        !          1080:        }
        !          1081:     }
        !          1082: }

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