/* Stack manipulation */ /* $Id$ */ #include #include #include "logging.h" #include "nofloat.h" #include "global.h" #include "log.h" #include "warn.h" #include "trap.h" #include "alloc.h" #include "memdirect.h" #include "mem.h" #include "shadow.h" #include "rsb.h" #define STACKSIZE 1000L /* initial stack size */ extern size maxstack; /* from main.c */ #ifdef LOGGING char *stack_sh; /* stadowbytes */ char *stackML_sh; /* speed up access of stadowbytes */ #endif /* LOGGING */ PRIVATE warn_stbits(); init_stack() { ML = max_addr; /* set Memory Limit */ SP = ML + 1; /* initialize Stack Pointer */ SL = ML + 1; /* initialize Stack Limit */ LB = ML + 1; /* initialize Local Base */ AB = ML + 1; /* initialize Actual Base */ SL = ML + 1 - STACKSIZE; /* initialize Stack Limit */ stack = Malloc(STACKSIZE, "stack space"); stackML = stack + ML; #ifdef LOGGING stack_sh = Malloc(STACKSIZE, "shadowspace for stack"); stackML_sh = stack_sh + ML; st_clear_area(ML, SL); #endif /* LOGGING */ } /************************************************************************ * EM-register division. * ************************************************************************ * * * newSP(p) - check and adjust StackPointer. * * incSP(n) - increment stack pointer. n already checked * * decSP(n) - decrement stack pointer. n already checked * * newLB(p) - check and adjust Local Base and Actual Base * * * ************************************************************************/ newSP(ap) ptr ap; { register ptr p = ap; LOG(("@s6 newSP(%lu), ML = %lu, SP = %lu", p, ML, SP)); if (LB < p) { wtrap(WSPGTLB, ESTACK); } if (!is_wordaligned(p)) { wtrap(WSPODD, ESTACK); } if (p < SP) { if (p < HP) { wtrap(WSPINHEAP, ESTACK); } if (maxstack) { /* more than allowed on command line */ if (ML - p > maxstack) { warning(WESTACK); trap(ESTACK); } } if (p < SL) { /* extend stack space */ register size stacksize = ML + 1 - p; stacksize = allocfrac(stacksize); SL = ML + 1 - stacksize; stack = Realloc(stack, (size)(stacksize), "stack space"); stackML = stack + ML; #ifdef LOGGING stack_sh = Realloc(stack_sh, (size)(stacksize), "shadowspace for stack"); stackML_sh = stack_sh + ML; #endif /* LOGGING */ } #ifdef LOGGING st_clear_area(SP - 1, p); #endif /* LOGGING */ } SP = p; } incSP(n) #ifdef LOGGING register #endif size n; { register ptr p = SP - n; if (p < HP || maxstack || p < SL) newSP(p); else { LOG(("@s6 newSP(%lu), ML = %lu, SP = %lu", p, ML, SP)); #ifdef LOGGING /* inline version of st_clear_area. */ SP = p; { while (n--) { st_undef(p); p++; } } #endif } } decSP(n) size n; { register ptr p = SP + n; if (LB < p) newSP(p); else { LOG(("@s6 newSP(%lu), ML = %lu, SP = %lu", p, ML, SP)); SP = p; } } newLB(p) ptr p; { if (!in_stack(p)) { wtrap(WLBOUT, ESTACK); } if (!is_wordaligned(p)) { wtrap(WLBODD, ESTACK); } if (!is_LB(p)) { wtrap(WLBRSB, ESTACK); } LB = p; AB = LB + rsbsize; } /************************************************************************ * Stack store division. * ************************************************************************ * * * st_stdp(addr, p) - STore Data Pointer. * * st_stip(addr, p) - STore Instruction Pointer. * * st_stn(addr, l, n) - STore N byte integer. * * st_stw(addr, l) - STore wordsize integer. * * st_stf(addr, f, n) - STore Floating point number. * * * ************************************************************************/ st_stdp(addr, ap) register ptr addr; ptr ap; { register int i; register long p = (long) ap; LOG(("@s6 st_stdp(%lu, %lu)", addr, p)); ch_in_stack(addr, psize); ch_wordaligned(addr); for (i = (int) psize; i > 0; i--, addr++) { ch_st_prot(addr); stack_loc(addr) = (char) (p); st_dp(addr); p = p>>8; } } st_stip(addr, ap) register ptr addr; ptr ap; { register int i; register long p = (long) ap; LOG(("@s6 st_stip(%lu, %lu)", addr, p)); ch_in_stack(addr, psize); ch_wordaligned(addr); for (i = (int) psize; i > 0; i--, addr++) { ch_st_prot(addr); stack_loc(addr) = (char) (p); st_ip(addr); p = p>>8; } } st_stn(addr, al, n) register ptr addr; long al; size n; { register int i; register long l = al; #ifdef LOGGING /* a psize zero is ambiguous */ int sh_flags = (l == 0 && n == psize) ? (SH_INT|SH_DATAP) : SH_INT; #endif LOG(("@s6 st_stn(%lu, %ld, %lu)", addr, l, n)); ch_in_stack(addr, n); ch_aligned(addr, n); /* store the bytes */ for (i = (int) n; i > 0; i--, addr++) { ch_st_prot(addr); stack_loc(addr) = (char) l; #ifdef LOGGING st_sh(addr) = sh_flags; #endif /* LOGGING */ l = l>>8; } } st_stw(addr, al) register ptr addr; long al; { register int i; register long l = al; #ifdef LOGGING /* a psize zero is ambiguous */ int sh_flags = (l == 0 && wsize == psize) ? (SH_INT|SH_DATAP) : SH_INT; #endif LOG(("@s6 st_stw(%lu, %ld)", addr, l)); ch_w_in_stack(addr); ch_wordaligned(addr); /* store the bytes */ for (i = (int) wsize; i > 0; i--, addr++) { ch_st_prot(addr); stack_loc(addr) = (char) l; #ifdef LOGGING st_sh(addr) = sh_flags; #endif /* LOGGING */ l = l>>8; } } #ifndef NOFLOAT st_stf(addr, f, n) register ptr addr; double f; size n; { register char *cp = (char *) &f; float fl; register int i; LOG(("@s6 st_stf(%lu, %g, %lu)", addr, f, n)); ch_in_stack(addr, n); ch_wordaligned(addr); if ((int) n == 4) { fl = f; cp = (char *) &fl; } for (i = (int) n; i > 0; i--, addr++) { ch_st_prot(addr); stack_loc(addr) = *(cp++); st_fl(addr); } } #endif /* NOFLOAT */ /************************************************************************ * Stack load division. * ************************************************************************ * * * st_lddp(addr) - LoaD Data Pointer from stack. * * st_ldip(addr) - LoaD Instruction Pointer from stack. * * st_ldu(addr, n) - LoaD n Unsigned bytes from stack. * * st_lduw(addr) - LoaD wsize Unsigned bytes from stack. * * st_lds(addr, n) - LoaD n Signed bytes from stack. * * st_ldsw(addr) - LoaD wsize Signed bytes from stack. * * st_ldf(addr, n) - LoaD Floating point number from stack. * * * ************************************************************************/ ptr st_lddp(addr) register ptr addr; { register ptr p; LOG(("@s6 st_lddp(%lu)", addr)); ch_in_stack(addr, psize); ch_wordaligned(addr); #ifdef LOGGING if (!is_st_set(addr, psize, SH_DATAP)) { warning(WLDPEXP); warn_stbits(addr, psize); } #endif /* LOGGING */ p = p_in_stack(addr); LOG(("@s6 st_lddp() returns %lu", p)); return (p); } ptr st_ldip(addr) register ptr addr; { register ptr p; LOG(("@s6 st_ldip(%lu)", addr)); ch_in_stack(addr, psize); ch_wordaligned(addr); #ifdef LOGGING if (!is_st_set(addr, psize, SH_INSP)) { warning(WLIPEXP); warn_stbits(addr, psize); } #endif /* LOGGING */ p = p_in_stack(addr); LOG(("@s6 st_ldip() returns %lu", p)); return (p); } unsigned long st_ldu(addr, n) register ptr addr; size n; { register int i; register unsigned long u = 0; LOG(("@s6 st_ldu(%lu, %lu)", addr, n)); ch_in_stack(addr, n); ch_aligned(addr, n); #ifdef LOGGING if (!is_st_set(addr, n, SH_INT)) { warning(n == 1 ? WLCEXP : WLIEXP); warn_stbits(addr, n); } #endif /* LOGGING */ addr += n-1; for (i = (int) n-1; i >= 0; i--, addr--) { u = (u<<8) | (btou(stack_loc(addr))); } LOG(("@s6 st_ldu() returns %ld", u)); return (u); } unsigned long st_lduw(addr) register ptr addr; { register int i; register unsigned long u = 0; LOG(("@s6 st_lduw(%lu)", addr)); ch_w_in_stack(addr); ch_wordaligned(addr); #ifdef LOGGING if (!is_st_set(addr, wsize, SH_INT)) { warning(WLIEXP); warn_stbits(addr, wsize); } #endif /* LOGGING */ addr += wsize - 1; for (i = (int) wsize-1; i >= 0; i--, addr--) { u = (u<<8) | (btou(stack_loc(addr))); } LOG(("@s6 st_lduw() returns %ld", u)); return (u); } long st_lds(addr, n) register ptr addr; size n; { register int i; register long l; LOG(("@s6 st_lds(%lu, %lu)", addr, n)); ch_in_stack(addr, n); ch_aligned(addr, n); #ifdef LOGGING if (!is_st_set(addr, n, SH_INT)) { warning(n == 1 ? WLCEXP : WLIEXP); warn_stbits(addr, n); } #endif /* LOGGING */ addr += n - 2; l = btos(stack_loc(addr + 1)); for (i = n - 2; i >= 0; i--, addr--) { l = (l<<8) | btol(stack_loc(addr)); } LOG(("@s6 st_lds() returns %ld", l)); return (l); } long st_ldsw(addr) register ptr addr; { register int i; register long l; LOG(("@s6 st_ldsw(%lu)", addr)); ch_w_in_stack(addr); ch_wordaligned(addr); #ifdef LOGGING if (!is_st_set(addr, wsize, SH_INT)) { warning(WLIEXP); warn_stbits(addr, wsize); } #endif /* LOGGING */ addr += wsize - 2; l = btos(stack_loc(addr+1)); for (i = wsize - 2; i >= 0; i--, addr--) { l = (l<<8) | btol(stack_loc(addr)); } LOG(("@s6 st_ldsw() returns %ld", l)); return (l); } #ifndef NOFLOAT double st_ldf(addr, n) register ptr addr; size n; { double f; float fl; register char *cp; register int i; LOG(("@s6 st_ldf(%lu, %lu)", addr, n)); if ((int)n == 4) { cp = (char *) &fl; } else { cp = (char *) &f; } ch_in_stack(addr, n); ch_wordaligned(addr); #ifdef LOGGING if (!is_st_set(addr, n, SH_FLOAT)) { warning(WLFEXP); warn_stbits(addr, n); } #endif /* LOGGING */ for (i = (int) n; i > 0; i--, addr++) { *(cp++) = stack_loc(addr); } if ((int)n == 4) { f = fl; } return (f); } #endif /* NOFLOAT */ /************************************************************************ * Stack move division * ************************************************************************ * * * st_mvs(s2, s1, n) - Move n bytes in stack from s1 to s2. * * st_mvd(s, d, n) - Move n bytes from d in data to s in stack. * * * * st_mvs(): The intention is to copy the contents of addresses * * s1, s1+1....s1-(n-1) to addresses s2, s2+1....s2+(n-1). * * All addresses are expected to be in the stack. This condition * * is checked for. The shadow bytes of the bytes to be filled in, * * are marked identical to the source-shadow bytes. * * * * st_mvd(), dt_mvd() and dt_mvs() act identically (see data.c). * * * ************************************************************************/ st_mvs(s2, s1, n) /* s1 -> s2 */ register ptr s2, s1; size n; { register int i; ch_in_stack(s1, n); ch_wordaligned(s1); ch_in_stack(s2, n); ch_wordaligned(s2); for (i = (int) n; i > 0; i--, s1++, s2++) { ch_st_prot(s2); ch_st_prot(s1); stack_loc(s2) = stack_loc(s1); #ifdef LOGGING st_sh(s2) = st_sh(s1) & ~SH_PROT; #endif /* LOGGING */ } } st_mvd(s, d, n) /* d -> s */ register ptr s, d; size n; { register int i; ch_in_data(d, n); ch_wordaligned(d); ch_in_stack(s, n); ch_wordaligned(s); for (i = (int) n; i > 0; i--, s++, d++) { ch_st_prot(s); stack_loc(s) = data_loc(d); #ifdef LOGGING st_sh(s) = dt_sh(d) & ~SH_PROT; #endif /* LOGGING */ } } /************************************************************************ * Stack pop division. * ************************************************************************ * * * dppop() - pop a data ptr, return a ptr. * * upop(n) - pop n unsigned bytes, return a long. * * uwpop() - pop wsize unsigned bytes, return a long. * * spop(n) - pop n signed bytes, return a long. * * swpop() - pop wsize signed bytes, return a long. * * pop_dt(d, n) - pop n bytes, store at address d in data. * * popw_dt(d) - pop wsize bytes, store at address d in data. * * pop_st(s, n) - pop n bytes, store at address s in stack. * * popw_st(s) - pop wsize bytes, store at address s in stack. * * fpop() - pop a floating point number. * * wpop() - pop a signed word, don't care about any type. * * * ************************************************************************/ ptr dppop() { register ptr p; p = st_lddp(SP); decSP(psize); LOG(("@s7 dppop(), return: %lu", p)); return (p); } unsigned long upop(n) size n; { register unsigned long l; l = st_ldu(SP, n); decSP(max(n, wsize)); LOG(("@s7 upop(), return: %lu", l)); return (l); } unsigned long uwpop() { register unsigned long l; l = st_lduw(SP); decSP(wsize); LOG(("@s7 uwpop(), return: %lu", l)); return (l); } long spop(n) size n; { register long l; l = st_lds(SP, n); decSP(max(n, wsize)); LOG(("@s7 spop(), return: %ld", l)); return (l); } long swpop() { register long l; l = st_ldsw(SP); decSP(wsize); LOG(("@s7 swpop(), return: %ld", l)); return (l); } pop_dt(d, n) ptr d; size n; { if (n < wsize) dt_stn(d, (long) upop(n), n); else { dt_mvs(d, SP, n); decSP(n); } } popw_dt(d) ptr d; { dt_mvs(d, SP, wsize); decSP(wsize); } pop_st(s, n) ptr s; size n; { if (n < wsize) st_stn(s, (long) upop(n), n); else { st_mvs(s, SP, n); decSP(n); } } popw_st(s) ptr s; { st_mvs(s, SP, wsize); decSP(wsize); } #ifndef NOFLOAT double fpop(n) size n; { double d; d = st_ldf(SP, n); decSP(n); return (d); } #endif /* NOFLOAT */ long wpop() { register long l; l = w_in_stack(SP); decSP(wsize); return (l); } /************************************************************************ * Stack push division. * ************************************************************************ * * * dppush(p) - push a data ptr, load from p. * * wpush(l) - push a word, load from l. * * npush(l, n) - push n bytes, load from l. * * push_dt(d, n) - push n bytes, load from address d in data. * * pushw_dt(d) - push wsize bytes, load from address d in data.* * push_st(s, n) - push n bytes, load from address s in stack. * * pushw_st(s) - push wsize bytes, load from address s in stack.* * fpush(f, n) - push a floating point number, of size n. * * * ************************************************************************/ dppush(p) ptr p; { incSP(psize); st_stdp(SP, p); } wpush(l) long l; { incSP(wsize); st_stw(SP, l); } npush(l, n) register long l; register size n; { if (n <= wsize) { incSP(wsize); if (n == 1) l &= MASK1; else if (n == 2) l &= MASK2; st_stw(SP, l); } else { incSP(n); st_stn(SP, l, n); } } push_dt(d, n) ptr d; size n; { if (n < wsize) { npush((long) dt_ldu(d, n), n); } else { incSP(n); st_mvd(SP, d, n); } } pushw_dt(d) ptr d; { incSP(wsize); st_mvd(SP, d, wsize); } push_st(s, n) ptr s; size n; { if (n < wsize) { npush((long) st_ldu(s, n), n); } else { incSP(n); st_mvs(SP, s, n); } } pushw_st(s) ptr s; { incSP(wsize); st_mvs(SP, s, wsize); } #ifndef NOFLOAT fpush(f, n) double f; size n; { incSP(n); st_stf(SP, f, n); } #endif /* NOFLOAT */ #ifdef LOGGING PRIVATE warn_stbits(addr, n) register ptr addr; register size n; { register int or_bits = 0; register int and_bits = 0xff; while (n--) { or_bits |= st_sh(addr); and_bits &= st_sh(addr); addr++; } if (or_bits != and_bits) { /* no use trying to diagnose */ warningcont(WWASMISC); return; } if (or_bits == 0) warningcont(WWASUND); if (or_bits & SH_INT) warningcont(WWASINT); if (or_bits & SH_FLOAT) warningcont(WWASFLOAT); if (or_bits & SH_DATAP) warningcont(WWASDATAP); if (or_bits & SH_INSP) warningcont(WWASINSP); } #endif /* LOGGING */