new copyright; att/bsd/shared

[unix-history] / usr / src / usr.bin / pascal / pdx / breakpoint / bpact.c

/*-
* Copyright (c) 1980 The Regents of the University of California.
* All rights reserved.
*
* %sccs.include.redist.c%
*/

#ifndef lint
static char sccsid[] = "@(#)bpact.c     5.2 (Berkeley) %G%";
#endif /* not lint */

/*
* Routines for doing the right thing when a breakpoint is reached.
*/

#include "defs.h"
#include "breakpoint.h"
#include "sym.h"
#include "tree.h"
#include "source.h"
#include "mappings.h"
#include "runtime.h"
#include "process.h"
#include "machine.h"
#include "main.h"
#include "bp.rep"
#include "tree/tree.rep"

typedef enum { SAVE, NOSAVE } SAVEBP;

LOCAL SAVEBP handlebp();

/*
* A "delayed" breakpoint is one that has an action involving execution
* of code, e.g. at a CALL we want to step from the beginning of the
* procedure to the first line before printing parameters.
*/

LOCAL short delayed;

#define NONE 0
#define DELAY_CALL 1
#define DELAY_STOP 2

/*
* Take action at a breakpoint; if it's not a breakpoint return FALSE.
*
* As we go through the list of breakpoints, we have to remember
* the previous one so that "handlebp" can delete breakpoints on
* the fly if necessary.
*
* If the breakpoint is a STOP_BP, handlebp will set "isstopped".  After
* going through the loop, bpact checks if "isstopped" is set and calls
* printstatus if it is.  This is so multiple breakpoints at the same
* address, one of which is a STOP_BP, still work.
*/

#define isswitch(bptype) ( \
       bptype == ALL_ON || bptype == ALL_OFF || \
       bptype == TERM_ON || bptype == TERM_OFF || \
       bptype == BLOCK_ON || bptype == BLOCK_OFF || \
       bptype == STOP_ON || bptype == STOP_OFF \
)

BOOLEAN bpact()
{
       register BPINFO *p;
       BPINFO *prev, *next;
       BOOLEAN found;
       ADDRESS oldpc;

       delayed = NONE;
       found = FALSE;
       prev = NIL;
       for (p = bphead; p != NIL; p = next) {
               next = p->bpnext;
               if (p->bpaddr == pc) {
                       prbpfound(p);
                       found = TRUE;
                       if (p->bpcond == NIL || isswitch(p->bptype) || cond(p->bpcond)) {
                               prbphandled();
                               if (handlebp(p) == NOSAVE) {
                                       prbpnosave();
                                       if (prev == NIL) {
                                               bphead = next;
                                       } else {
                                               prev->bpnext = next;
                                       }
                                       dispose(p);
                               } else {
                                       prbpsave();
                                       prev = p;
                               }
                       } else {
                               prev = p;
                       }
               } else {
                       prev = p;
               }
       }
       if (delayed != NONE) {
               oldpc = pc;
               runtofirst();
               if ((delayed&DELAY_CALL) == DELAY_CALL) {
                       SYM *s, *t;

                       s = curfunc;
                       t = whatblock(return_addr());
                       if (t == NIL) {
                               panic("can't find block for caller addr %d", caller_addr());
                       }
                       printcall(s, t);
                       addbp(return_addr(), RETURN, s, NIL, NIL, 0);
               }
               if (pc != oldpc) {
                       bpact();
               }
               if (isstopped) {
                       printstatus();
               }
       } else {
               if (isstopped) {
                       printstatus();
               }
       }
       fflush(stdout);
       return(found);
}

/*
* Handle an expected breakpoint appropriately, return whether
* or not to save the breakpoint.
*/

LOCAL SAVEBP handlebp(p)
BPINFO *p;
{
       register SYM *s, *t;
       SAVEBP r;

       r = SAVE;
       switch(p->bptype) {
               case ALL_ON:
                       curfunc = p->bpblock;
                       addcond(TRPRINT, p->bpcond);
                       if (p->bpline >= 0) {
                               tracing++;
                       } else {
                               inst_tracing++;
                       }
                       addbp(return_addr(), ALL_OFF, curfunc, p->bpcond, NIL, 0);
                       break;

               case ALL_OFF:
                       r = NOSAVE;
                       if (p->bpline >= 0) {
                               tracing--;
                       } else {
                               inst_tracing--;
                       }
                       delcond(TRPRINT, p->bpcond);
                       curfunc = p->bpblock;
                       break;

               case STOP_ON:
                       var_tracing++;
                       curfunc = p->bpblock;
                       if (p->bpnode != NIL) {
                               addvar(TRSTOP, p->bpnode, p->bpcond);
                       } else if (p->bpcond != NIL) {
                               addcond(TRSTOP, p->bpcond);
                       }
                       addbp(return_addr(), STOP_OFF, curfunc, p->bpcond, p->bpnode, 0);
                       break;

               case STOP_OFF:
                       r = NOSAVE;
                       delcond(TRSTOP, p->bpcond);
                       var_tracing--;
                       curfunc = p->bpblock;
                       break;

               case INST:
                       curline = p->bpline;
                       if (curline > 0) {
                               printf("trace:  ");
                               printlines(curline, curline);
                       } else {
                               printf("inst trace:     ");
                               printinst(pc, pc);
                       }
                       break;

               case STOP_BP:
                       if (p->bpblock != NIL) {
                               delayed |= DELAY_STOP;
                               curfunc = p->bpblock;
                       }
                       curline = p->bpline;
                       isstopped = TRUE;
                       break;

               case BLOCK_ON: {
                       BPINFO *nbp;

                       s = p->bpblock;
                       t = p->bpnode->nameval;
                       nbp = newbp(codeloc(t), CALL, t, p->bpcond, NIL, 0);
                       addbp(return_addr(), BLOCK_OFF, (SYM *) nbp, NIL, NIL, 0);
                       break;
               }

               case BLOCK_OFF: {
                       BPINFO *oldbp;

                       r = NOSAVE;
                       oldbp = (BPINFO *) p->bpblock;
                       delbp(oldbp->bpid);
                       break;
               }

               case CALL:
                       delayed |= DELAY_CALL;
                       curfunc = p->bpblock;
                       break;

               case RETURN:
                       r = NOSAVE;
                       s = p->bpblock;
                       printrtn(s);
                       break;

               case TERM_ON: {
                       ADDRESS addr;

                       curfunc = p->bpblock;
                       addvar(TRPRINT, p->bpnode, p->bpcond);
                       addr = return_addr();
                       addbp(addr, TERM_OFF, curfunc, p->bpcond, p->bpnode, 0);
                       var_tracing++;
                       break;
               }

               case TERM_OFF:
                       r = NOSAVE;
                       var_tracing--;
                       delvar(TRPRINT, p->bpnode, p->bpcond);
                       curfunc = p->bpblock;
                       break;

               case AT_BP:
                       printf("at line %d: ", p->bpline);
                       eval(p->bpnode);
                       prtree(p->bpnode);
                       printf(" = ");
                       printval(p->bpnode->nodetype);
                       putchar('\n');
                       break;

               /*
                * Returning from a called procedure.
                * Further breakpoint processing is not done, since if
                * there were any it wouldn't be associated with the call.
                */
               case CALLPROC:
                       procreturn(p->bpblock);
                       delbp(p->bpid);
                       erecover();
                       /* NOTREACHED */

               case END_BP:
                       r = NOSAVE;
                       endprogram();

               default:
                       panic("unknown bptype %d in cont", p->bptype);
                       /* NOTREACHED */
       }
       return(r);
}

/*
* Internal trace routines.
*/

LOCAL char *prbptype[] ={
       "ALL_ON", "ALL_OFF", "INST", "CALL", "RETURN", "BLOCK_ON", "BLOCK_OFF",
       "TERM_ON", "TERM_OFF", "AT_BP", "STOP_BP", "CALLPROC", "END_BP",
       "STOP_ON", "STOP_OFF",
};

LOCAL prbpfound(p)
BPINFO *p;
{
       if (option('b')) {
               printf("%s breakpoint found at pc %d, line %d -- ",
                       prbptype[(int) p->bptype], p->bpaddr, p->bpline);
       }
}

LOCAL prbphandled()
{
       if (option('b')) {
               printf("handled, ");
       }
}

LOCAL prbpnosave()
{
       if (option('b')) {
               printf("not saved\n");
               fflush(stdout);
       }
}

LOCAL prbpsave()
{
       if (option('b')) {
               printf("saved\n");
               fflush(stdout);
       }
}