Return to entry.c CVS log

Up to [CSRG BSD Unix] / 42BSD / ucb / pascal / pdx / runtime

Annotation of 42BSD/ucb/pascal/pdx/runtime/entry.c, revision 1.1

1.1     ! root        1: /* Copyright (c) 1982 Regents of the University of California */
        !             2: 
        !             3: static char sccsid[] = "@(#)entry.c 1.1 1/18/82";
        !             4: 
        !             5: /*
        !             6:  * routines to deal with the entry addresses of blocks
        !             7:  */
        !             8: 
        !             9: #include "defs.h"
        !            10: #include "runtime.h"
        !            11: #include "frame.rep"
        !            12: #include "machine.h"
        !            13: #include "process.h"
        !            14: #include "sym.h"
        !            15: #include "source.h"
        !            16: #include "object.h"
        !            17: #include "process/pxinfo.h"
        !            18: #include "process/process.rep"
        !            19: 
        !            20: /*
        !            21:  * Return the address of the beginning of the procedure/function
        !            22:  * associated with the given frame.
        !            23:  */
        !            24: 
        !            25: ADDRESS entry(frp)
        !            26: register FRAME *frp;
        !            27: {
        !            28:        return(frp->blockp - 2 - ENDOFF);
        !            29: }
        !            30: 
        !            31: /*
        !            32:  * Find the entry address of the caller of the current block.
        !            33:  * This is only called in connection with breakpoints.
        !            34:  *
        !            35:  * This routine assumes it is at the very beginning of the block.
        !            36:  */
        !            37: 
        !            38: ADDRESS caller_addr()
        !            39: {
        !            40:        FRAME *frp;
        !            41: 
        !            42:        if ((frp = curframe()) == NIL) {
        !            43:                panic("caller_addr(main program)");
        !            44:        }
        !            45:        frp = nextframe(frp);
        !            46:        if (frp == NIL) {
        !            47:                return(codeloc(program));
        !            48:        } else {
        !            49:                return(entry(frp));
        !            50:        }
        !            51: }
        !            52: 
        !            53: /*
        !            54:  * Find the return address of the current procedure/function.
        !            55:  *
        !            56:  * There are two special cases:
        !            57:  *
        !            58:  *     we're right at the beginning of the main program
        !            59:  *     we're right at the beginning of some procedure or function
        !            60:  *
        !            61:  * The first one is handled by returning the last instruction in
        !            62:  * the object code.  In the second case, we get the return address
        !            63:  * directly from the process' stack.
        !            64:  */
        !            65: 
        !            66: ADDRESS return_addr()
        !            67: {
        !            68:        ADDRESS addr;
        !            69:        FRAME *frp, frame;
        !            70: 
        !            71:        if (pc == codeloc(program)) {
        !            72:                addr = lastaddr();
        !            73:        } else {
        !            74:                frp = curframe();
        !            75:                if (frp == NIL) {
        !            76:                        dread(&frame, (ADDRESS) process->sp, sizeof(FRAME));
        !            77:                        addr = frame.save_pc - ENDOFF;
        !            78:                } else {
        !            79:                        addr = frp->save_pc;
        !            80:                }
        !            81:        }
        !            82:        return addr;
        !            83: }
        !            84: 
        !            85: /*
        !            86:  * Calculate the entry address for a procedure or function parameter,
        !            87:  * given the address of the descriptor.
        !            88:  */
        !            89: 
        !            90: ADDRESS fparamaddr(a)
        !            91: ADDRESS a;
        !            92: {
        !            93:        ADDRESS r;
        !            94: 
        !            95:        dread(&r, a, sizeof(r));
        !            96:        return (r - ENDOFF);
        !            97: }

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