{File name: MoreLispDefs.dfn Description: Definitions for Dandelion Lisp Microcode, Created: 24-Apr-84 11:45:51 Last Edited: 24-Apr-84 11:45:58 - charnley } { L0 return values for WLMapFixB2 } Set[L0.DLMap, 1];{DrawLine} Set[L0.RedoFtARG, 2];{FFT} Set[L0.RedoFtAB, 3];{FFT} Set[L0.RedoFtCD, 4];{FFT} { L0 return values for RLMapFixB2 } Set[L0.xRedoFtFF, 1];{FFT} Set[L0.RedofptGet, 2];{GetFPT} Set[L0.RedoCreate, 5];{FloatIt subr} Set[L0.RedoFLFix, 6];{FloatIt subr} Set[L0.RedoPOLY0, 3];{polynomial} Set[L0.RedoPOLY1, 4];{polynomial} { L1 fix values for RWTrap } Set[L1.DLFixesB2, 1];{DrawLine} Set[L1.NoFixesB2, 2];{FFT} Set[L1.RestoreTosB2, 3]; Set[L1.FFTFixesB2, 4];{FFT} { LispMatrix stuff} RegDef[rA, R, 6],{Rx} RegDef[rB, R, 0],{TOS} RegDef[rC, R, 1],{TOSH} RegDef[rhrA, RH, 6],{Rx} RegDef[rhrB, RH, 0],{TOS} RegDef[rhrC, RH, 1],{TOSH} RegDef[urAVlo, U, 002], {Low VA of matrix A} RegDef[urAVhi, U, 003], {High VA of matrix A} RegDef[urBVlo, U, 060], {Low VA of matrix B} RegDef[urBVhi, U, 005], {High VA of matrix B} RegDef[urCVlo, U, 006], {Low VA of matrix C} RegDef[urCVhi, U, 007], {High VA of matrix C} RegDef[uNinit, U, 008], {Initial value of nCOUNT} RegDef[uKinit, U, 00A], {Initial value of kCOUNT} RegDef[umCOUNT, U, 00B], {Current value of mCOUNT} RegDef[ukCOUNT, U, 00C], {Current value of kCOUNT} RegDef[unCOUNT, U, 041], {Current value of nCOUNT, when saved} RegDef[udeltaA1, U, 031], {-2(N-1)} RegDef[udeltaB0, U, 033], {+2K} RegDef[udeltaB1, U, 035], {-2(N-1)(K)+2} RegDef[udeltaB2, U, 037], {-2(N)(K)+2} Set[L0.delta0, 0], Set[L0.delta1, 1], Set[L0.delta2, 2], Set[L0.deltaI, 3], Set[L1.mxnotfirst, 1], Set[L1.mxfirst, 2], {Set[L1.matufn, 7],} Set[ib.poly, 0], Set[ib.333, 1], Set[ib.444, 2], Set[ib.133, 3], Set[ib.331, 4], Set[ib.144, 5], Set[ib.441, 6]; { DRAWLINE stuff} RegDef[umXX0, U, 02];{move to fZ=0 before using} {TWiddle factor 4 word complex float} RegDef[ulXX, U, 03]; RegDef[umYY0, U, 04];{move to fZ=0 before using; STK points here} RegDef[ulYY0, U, 05];{fp chip doesn't like ulYY here for some STRANGE reason} RegDef[uFFvH, U, 06];{Virtual Address of source (From) array base.} RegDef[uFFvL, U, 07]; RegDef[uABvH, U, 08];{Virtual Address of destination array base.} RegDef[uABvL, U, 09]; RegDef[uCDvH, U, 0A];{Virtual Address of midpoint in destination array base.} RegDef[uCDvL, U, 0B]; RegDef[uTCnt, U, 0C];{count of butterflies with same twiddle (x4)} RegDef[uHCnt, U, 0D];{high portion of count of butterflies remaining (x4)} Set[ft.twiddle.offset, 4 ]; Set[ft.twiddle.delta.offset, 20'd ];{Twiddle Delta(8 words): address of complex zero followed by packed complex root of unity to change twiddle} Set[ft.HCnt.offset, 11'd ]; RegDef[umXX, U, 50]; {umXX,FTimes{0}} RegDef[umYY, U, 60];{uRx} {umYY,FTimes{0}} RegDef[ulYY, U, 51];{alternate home for ulYY see ulYY0} RegDef[uArgH, U, 68];{virtual address of argument record} RegDef[uArgL, U, 69];{rA=Rx} RegDef[ulCC, U, 4]; {ulCC, STK{FPlus}} RegDef[umYW, U, 4]; {umYW, STK{FPlus}} RegDef[FF, R, 3];{PV} {Real address in "From" array. Equal to Source + 2*(HCnt + RCnt) } RegDef[rhFF, RH, 3]; RegDef[AB, R, 4];{S} {Real address in destination array. Equal to Dest + HCnt + WCnt) } RegDef[rhAB, RH, 4]; RegDef[CD, R, 1];{TOSH}{Real address in destination array. Equal to Dest + HCnt + WCnt) } RegDef[rhCD, RH, 1]; RegDef[rmAW, R, 2];{TT} RegDef[rlBW2, R, 2];{TT} RegDef[rTCnt, R, 2];{TT} RegDef[rmBW, R, 6];{Rx} RegDef[rlDY, R, 6];{Rx} {RegDef[rmCY, R, 6];{Rx}{remove eventually}} RegDef[rRCnt, R, 2];{TT}{uRCnt, rRCnt, FMinus} RegDef[uRCnt, U, 26];{uPV}{low portion of count of butterflies remaining to Read(x4)} RegDef[uWCnt, U, 47];{low portion of count of butterflies remaining to Write(x4)} RegDef[ulDY, U, 54]; {RegDef[TOS, R, 0];} {RegDef[rmDY, R, 0];} {RegDef[rlCY, R, 0];{remove eventually}} RegDef[rmYW, R, 0]; RegDef[rmAA, R, 0]; RegDef[rlDW, R, 0]; RegDef[rmDW, R, 0]; RegDef[rlCW2, R, 0]; {RegDef[PC, R, 5];} RegDef[rlDD, R, 5]; RegDef[rlBW, R, 5]; RegDef[rmCW, R, 5]; RegDef[umCW, U, 58]; {rmCW,umCW} RegDef[rlCC, R, 5]; RegDef[rlCW, R, 5]; RegDef[ulCW, U, 52]; {rlCW,ulCW} RegDef[rHCnt, R, 5]; RegDef[rlAW, R, 5]; RegDef[rmDY, R, 5]; {rmDY,umDY} RegDef[umDY, U, 56]; {umDY,FMinus{6}} {RegDef[rlDY, R, 5];}{moved to 6=Rx} RegDef[rlBB, R, 5]; RegDef[ulBB, U, 53]; RegDef[rlYW, R, 5]; RegDef[rlAA, R, 5]; RegDef[ulAA, U, 55]; {rlAA,ulAA,FMinusB{5}} { reg defs for polynomial} RegDef[uAinitH, U, 57]; {A(0) H} RegDef[uAinitL, U, 58]; {A(0) L} RegDef[uXHi, U, 30]; {X H} RegDef[uXLo, U, 05]; {X L} RegDef[uDegree, U, 42]; {The degree of polynomial} RegDef[uTTtmp, U, 43]; {Virtual address, tmp} RegDef[uAnxtH, U, 44]; {New A, H word, tmp} MacroDef[fpUMS, FloatUMS]; MacroDef[fpULS, FloatULS]; MacroDef[fpUMP, FloatUMP]; MacroDef[fpULP, FloatULP]; MacroDef[FloatR, FloatResult]; MacroDef[FTimes, FLTimes.A.B]; MacroDef[FPlus, FLPlus]; MacroDef[FMinus, FLBMinusA]; MacroDef[FMinusB, FLAMinusB]; RegDef[uBlock0, UY, 0]; Set[L2.init, 3 ]; Set[L2.start, 7{2} ]; Set[L2.middle, 1 ]; Set[L2.finish, 0 ]; { for LISP FLOAT ARRAY} RegDef[Kount, R, 0],{TOS} RegDef[S1, R, 1],{TOSH} RegDef[rhS1, RH, 1], RegDef[Zorch, R, 2],{TT} RegDef[rhZorch, RH, 2], RegDef[S2, R, 3],{PV}; {init to 0 to force remap} RegDef[rhS2, RH, 3], RegDef[uStemp, U, 53]; RegDef[D, R, 4],{S} {init to 0 to force remap} RegDef[rhD, RH, 4], RegDef[Stemp, R, 5],{PC} RegDef[Stemp2, R, 6],{Rx} RegDef[Zimph, R, 6], RegDef[uDLo, U, 02], RegDef[uDHi, U, 03], RegDef[uS1Lo, U, 30], RegDef[uS1Hi, U, 35], RegDef[uS2Lo, U, 38], RegDef[uS2Hi, U, 07], {RegDef[uTOS, U, 0D],} {RegDef[uTOSH, U, 1D],} RegDef[uS, U, 04B], RegDef[urhS, U, 051], RegDef[uPVx, U, 03B], RegDef[urhPV, U, 034], {RegDef[uPC, U, 05B],} {RegDef[ufloat, U, 042],{fZ value for Float}} RegDef[uXdisp, U, 041],{LMG} RegDef[uWidth, U, 042],{LMG} RegDef[uICount, U, 043],{LMG} RegDef[uNBits, U, 044],{LMG} RegDef[umask, U, 045],{LMG} RegDef[uShiftedPattLo, U, 03A],{LMG} RegDef[uShiftedPattHi, U, 037],{LMG} { from LispMakeGraph} RegDef[umaskrealLo, U, 045], RegDef[umaskrealHi, U, 046]; { from LFAM.mc} RegDef[uFLAmB, U, 35]; { RestoreRegsRet} Set[L1.LFApf, 1], Set[L1.LFAexit, 3], Set[L1.LFGexit, 4], Set[L1.matufn, 7],{because of CANCELBR's} Set[L1.matexit, 0A];{LispMatrix} { LFASaveRegsRet} Set[L1.LFA2prep, 3], Set[L1.LFA1prep, 4], Set[L1.LMGprep, 5], Set[L1.lm, 9];{LispMatrix} {RegDef[TOS, R, 0],{TOS} RegDef[TOSH, R, 1],{TOSH} RegDef[TT, R, 2],{TT} RegDef[PV, R, 3],{PV} RegDef[rhPV, R, 3],{PV} RegDef[S, R, 4],{S} RegDef[rhS, RH, 4],{S} RegDef[PC, R, 5],{PC} RegDef[Rx, R, 6],{Rx} } {S2 remap returns} Set[L0.S2timeslooptimes, 01],{uses 3 also} Set[L0.S2timesloopplus, 05],{uses 7 also} Set[L0.S2timesloopminus, 09],{uses 0B also} Set[L0.PERM, 04], Set[L0.lfam.s2a, 02], Set[L0.S2mag0, 06], {S1 remap returns} Set[L0.S1init2, 1], Set[L0.S1timesloop, 2], {Set[L0.PERM, 4],{uses 5 also} } Set[L0.EXP, 6], Set[L0.COMPLEX, 7], Set[L0.FLOAT, 8], Set[L0.MAGx, 9], Set[L0.FLOATx, 03], Set[L0.lfam.s1a, 0C], Set[L0.S1mag0, 0D], {Set[L0.MAGD2, 0A],} Set[L0.MAG, 0B], {D remap returns} Set[L0.Dtimesloop, 1], {Set[L0.PERM, 4],} {Set[L0.EXP, 6],} {Set[L0.COMPLEX, 7],} {Set[L0.FLOAT, 8],} Set[L0.MAGD1, 9], Set[L0.MAGD2, 0A], Set[L0.MAGD3, 0], Set[L0.COMPLEXx, 3], Set[L0.lfam.di, 05], Set[L0.lfam.da, 0C], Set[L0.lfam.db, 0D], Set[L0.lfam.dd, 0E], Set[L0.lfam.df, 02], {Set[L0.MAG, 0B],} Set[L2.Xtimes, 0], Set[L2.perm, 1], Set[L2.Xplus, 2], Set[L2.minus, 3], Set[L2.magic, 04], Set[L2.Triple, 5];{TripleCheck} Set[L2.exp1, 00], Set[L2.mag1, 01], Set[L2.float1, 02], Set[L2.complex1, 03], Set[L2.exp, 08], Set[L2.mag, 09], Set[L2.float, 0A], Set[L2.complex, 0B], {for TripleCheck} Set[L0.trS2i, 1]; Set[L0.trS1i, 2]; Set[L0.trDi, 3]; Set[L0.trS2, 4]; Set[L0.trS1, 5]; Set[L0.trD, 6]; {for LispMakeGraph} { LMGremapDret} Set[L0.LMGDinit, 4], Set[L0.LMGD1, 2], Set[L0.LMGD2, 3], Set[L0.LMGD3, 5], { LMGremapS1ret} Set[L0.LMGS1init, 4], Set[L0.LMGS1S2, 6], { LMGremapS2ret} {Set[L0.LMGS1S2, 6],} { AllignRet} {Set[L0.LMGS1S2, 6],} {GetFPT remap returns} Set[L2.btou, 1], ;{ E N D }