! 05/06/84 reject sr vars which have neglits floating around (EXAMINE) ! 04/06/84 change format of USEF & size of TINITSZ ! local variables inserted in print routines ! 22/01/84 BIT STRIP ADDRESSES NOW RELATIVE TO ABLOCKS ! 30/10/83 COPIED FROM ERCS06.REL90_SREDB12 !* %INCLUDE "host_host" !* %INCLUDE "targ_target" !* %INCLUDE "pf_version" !* %INCLUDE "bits_fmts" !* %INCLUDE "bits_optspecs" !* %INCLUDE "bits_optfmts" ! %INCLUDE "bits_consts" !* %INCLUDE "bits_triadops" !* %INCLUDE "pf_optfill" !* %EXTERNALROUTINE STRENGTHRED ! ! %ROUTINESPEC IDENTIFY %INTEGERFUNCTIONSPEC COLLECT %INTEGERFUNCTIONSPEC RTENTRY %ROUTINESPEC RUENTRY %INTEGERFUNCTIONSPEC EXAMINE %ROUTINESPEC REDUCE %ROUTINESPEC TARGHK (%RECORD (RESF) OPD) %ROUTINESPEC SUBTEMP %INTEGERFUNCTIONSPEC SCAN %ROUTINESPEC IREPL %ROUTINESPEC SRENTRY (%INTEGER SFLAG) %ROUTINESPEC REPLACE %INTEGERFUNCTIONSPEC BOEX (%INTEGER IDPTR) %INTEGERFUNCTIONSPEC CREATEBTAB (%INTEGER A) %ROUTINESPEC PRINTRD %ROUTINESPEC PRINTRUSE %ROUTINESPEC PRINTRDEF %ROUTINESPEC PRINTRTEST %ROUTINESPEC PRINTUSESTACK ! %EXTERNALINTEGERFUNCTIONSPEC CREATETAB (%INTEGER A) ! !************************************************************************* !* GIVEN A LOOP, PERFORMS THE STANDARD OPTIMATIONS * !* STRENGTH REDUCTION * !* TEST REPLACEMENT * !* DEAD DEFINITION ELIMINATION * !************************************************************************* ! ! %RECORDFORMAT RDF (%RECORD (RESF) VAR,%HALFINTEGER TRIAD,BLOCK) %RECORDFORMAT RUSEF (%INTEGER TRIAD,CHAIN, %HALFINTEGER PREV,BLOCK) %RECORDFORMAT RTESTF (%HALFINTEGER TRIAD,BLOCK) %RECORDFORMAT RDEFF (%HALFINTEGER ASSTRIAD,INCTRIAD,INCPREV,BLOCK,SIGN,FILL, (%INTEGER LITINC %OR %RECORD (RESF) INC)) %RECORDFORMAT USEF (%HALFINTEGER TRIAD,BLOCK, %RECORD (RESF) RV, %INTEGER USES, %BYTEINTEGERARRAY SIGN (0:3), %HALFINTEGER TEMP,FILL, (%INTEGERARRAY LITINC (1:3) %OR %C %RECORD (RESF) %ARRAY INC (1:3))) %RECORDFORMAT TINRECF (%INTEGER TRIAD,OPD,REF) ! ! %RECORD (CLOOPRECF) %NAME CL %RECORD (BLRECF) %NAME BB %RECORD (RDF) %NAME RR %RECORD (RUSEF) %NAME RU %RECORD (RTESTF) %NAME RT %RECORD (RDEFF) %NAME RD %RECORD (PRECF) %NAME DD %RECORD (TRIADF) %NAME TT,TT1 %RECORD (USEF) %NAME US %RECORD (SREDF) %NAME SR %RECORD (LOOPRECF) %NAME LO %RECORD (CONRECF) %NAME CN %RECORD (TINRECF) %NAME TI ! %CONSTINTEGER INFIN = X'80000001' %CONSTINTEGER LITBIT = X'80' %CONSTINTEGER NOTLITBIT = X'7F' %CONSTINTEGER LITSHIFT = 7 ! %INTEGER CLOOPPTR,COORD,BOEXKEEP,BITS,EFLAG,NRFLAG,NRUSECT,MAXTEMP,MAXWEIGHT %INTEGER RDSTART,RDPTR,RDEND,RUSESTART,RUSEPTR,RUSEHEAD,RUSECH,RUSEEND %INTEGER SRTABS,RTESTSTART,RTESTPTR,RTESTEND,RTESTMAX,RTESTCT %INTEGER RDEFSTART,RDEFPTR,RDEFEND,RDEFMAX,SRPTR %INTEGER TOUS,USESTACKSTART,USESTACKPTR,I,BLOCK,PTR,CHAIN %INTEGER SCOP1,SCOP2,BIT,OPN ! %RECORD (RESF) CURRVAR,QTOUS ! ! !************************************************************************** !* STAGE 1. OUTER LEVEL OF LOOP SCANNED FOR ACCEPTABLE RECURSIVE * !* DEFINITIONS OF INTEGER VARIABLES. * !* RD TABLE CONSTRUCTED CONTAINING AN ENTRY FOR EACH REC * !* DEFN, OF THE FORM * !* VAR: RESF RECORD FOR THE RECURSIVE VARIABLE * !* TRIAD: TEXT INDEX FOR THE RD ASSIGNMENT * !* BLOCK: BLOCK INDEX FOR THE RD ASSIGNMENT * !************************************************************************** ! ! !* CREATE TABLE SPACE FOR FIXED LENGTH TABLES RTEST,RDEF, TO BE SET UP !* BY COLLECT FREETABS = (FREETABS + 3) & X'FFFFFFFC' SRTABS = CREATETAB (3*RTESTSZ + 3*RDEFSZ) RTESTSTART = SRTABS RDEFSTART = SRTABS + 3*RTESTSZ ! IDENTIFY ! !* SCAN THROUGH TEXT IN ALL ALREADY-PROCESSED INNER LOOPS, IN ORDER TO !* REMOVE REFS TO REPL'S IN THE OUTER LEVEL. CLOOPPTR = PLOOPHEAD %WHILE CLOOPPTR # 0 %CYCLE CL == RECORD (ATABS + CLOOPPTR) BB == RECORD (ABLOCKS + CL_BLOCK * BLSIZE) CURRTRIAD = BB_TEXT %CYCLE %REPEAT %UNTIL NEXTTRIAD = 0 CLOOPPTR = CL_PDCHAIN %REPEAT ! %FOR RDPTR = RDSTART,RDSZ,RDEND %CYCLE RR == RECORD (ATABS + RDPTR) CURRVAR = RR_VAR %UNLESS CURRVAR_FORM = NULL %OR CURRVAR_MODE = CHARMODE %THENSTART !**************************************************************************** !* STAGE 2. FOR THE RD IDENTIFIED BY RDPTR, COLLECT ALL INFO ABOUT USES, * !* TESTS, & DEFNS INTO RUSE, RTEST, RDEF. * !* IF COLLECT DETECTS A CONDITION WHICH MAKES THE RV UNSUITABLE * !* FOR REDUCTION, IT RETURNS FALSE. * !* COLLECT ALSO LOOKS FOR OTHER ENTRIES IN RD TAB FOR THE SAME * !* IDENT, SETTING THEIR RR_VAR_FORM FIELD TO NULL. * !**************************************************************************** DD == RECORD (ADICT + CURRVAR_H0 << DSCALE) COORD = DD_COORD RUSESTART = FREETABS RUSEHEAD = 0 RUSECH = ADDR (RUSEHEAD) BOEXKEEP = BOEX (CURRVAR_H0) ! %IF COLLECT # 0 %THENSTART %UNLESS SRFLAGS & 1 = 0 %THENSTART PRINTRD PRINTRUSE PRINTRDEF PRINTRTEST %FINISH !*************************************************************************** !* STAGE 3. THE REDUCTION PROCESS. * !*************************************************************************** BITS = 0;! BACKTARG BITS FOR I NOT YET UPDATED. NRFLAG = 0;! NO NON-REDUCIVE USES OF I IN THIS BLOCK. NRUSECT = 0;! COUNT OF ALL NON-REDUCIVE USES. MAXTEMP = 0;! BEST-TEMP-SO-FAR MAXWEIGHT = INFIN - 1;! INFORMATION. USESTACKSTART = FREETABS RUSEPTR = RUSEHEAD %WHILE RUSEPTR # 0 %CYCLE RU == RECORD (ATABS + RUSEPTR) CHAIN = RU_CHAIN CURRTRIAD = RU_TRIAD %UNLESS CURRTRIAD = 0 %THENSTART PREVTRIAD = RU_PREV TT == RECORD (ATRIADS + PREVTRIAD * TRIADLENGTH) BB == RECORD (ABLOCKS + RU_BLOCK * BLSIZE) %UNLESS TT_CHAIN = CURRTRIAD %THENSTART PREVTRIAD = BB_TEXT TT == RECORD (ATRIADS + PREVTRIAD * TRIADLENGTH) %WHILE TT_CHAIN # CURRTRIAD %CYCLE PREVTRIAD = TT_CHAIN TT == RECORD (ATRIADS + PREVTRIAD * TRIADLENGTH) %REPEAT %FINISH %IF OPT = 1 %AND BB_FLAGS & ARTICBIT = 0 %THENSTART NRUSECT = NRUSECT + 1 NRFLAG = 1 %FINISHELSESTART FREETABS = USESTACKSTART USESTACKPTR = CREATETAB (USESZ) US == RECORD (ATABS + USESTACKPTR) US_BLOCK = RU_BLOCK US_TRIAD = CURRTRIAD US_RV = CURRVAR US_TEMP = 0 US_USES = 1 TOUS = CURRVAR_H0 QTOUS = CURRVAR RDEFPTR = RDEFSTART %FOR I = 1,1,3 %CYCLE RD == RECORD (ATABS + RDEFPTR) US_SIGN (I) = RD_SIGN US_LITINC(I) = RD_LITINC RDEFPTR = RDEFPTR + RDEFSZ %IF RDEFPTR>RDEFEND %THEN %EXIT %REPEAT !* EXAMINE THE USE OF T-O-US IN CURRTRIAD TO SEE IF IT IS REDUCIVE. {LSR_EXAM} %CYCLE %IF EXAMINE = 1 %THEN REDUCE %ELSESTART {LSR_NONRED} %IF QTOUS_W = CURRVAR_W %THENSTART NRUSECT = NRUSECT + 1 NRFLAG = 1 %EXIT %FINISH EFLAG = 0 {LSR_SUBT} L1: SUBTEMP;! GENERATE A TEMP & SUBSTITUTE FOR T-O-US. %IF US_USES = 0 %THENSTART FREETABS = FREETABS - USESZ USESTACKPTR = USESTACKPTR - USESZ %IF USESTACKPTR < USESTACKSTART %THEN %EXIT US == RECORD (ATABS + USESTACKPTR) TOUS = US_RV_H0 QTOUS = US_RV %FINISH %FINISH {LSR_SCAN} %IF SCAN = 0 %THENSTART EFLAG = 1;! STILL LOOKING FOR FURTHER USES. -> L1 %FINISH %REPEAT %FINISH %FINISH !* REDUCTION (OR NOT) OF THIS RUSE ENTRY NOW COMPLETE, EXCEPT FOR BITSTRIPS. !* IF CURRENT ENTRY WAS LAST IN BLOCK & ALL ENTRIES HAVE BEEN REDUCED, !* WE UNSET ALL BITS FOR I. {LSR_RP5} BLOCK = RU_BLOCK RU == RECORD (ATABS + CHAIN) %IF CHAIN = 0 %OR RU_BLOCK # BLOCK %THENSTART %IF NRFLAG = 0 %THENSTART BB == RECORD (ABLOCKS + BLOCK * BLSIZE) CLEARBIT (ABLOCKS+BB_USE,COORD) CLEARBIT (ABLOCKS+BB_DEF,COORD) CLEARBIT (ABLOCKS+BB_BOE,COORD) %FINISHELSE NRFLAG = 0 %FINISH RUSEPTR = CHAIN %REPEAT !*************************************************************************** !* STAGE 4. THE REPLACEMENT PROCESS. IF BUSY-ON-EXIT WE CANNOT DO ANY * !* REPLACEMENT OF USES, SO DON'T DO TEST REPLACEMENT EITHER. * !* IF I NOT B-O-EX, WE KNOW IT WILL BE REMOVED COMPLETELY, & WE * !* CLEAR BIT STRIPS FOR BLOCKS CONTAINING TESTS & DEFNS. * !*************************************************************************** {LSR_REP} %FOR RDEFPTR = RDEFSTART,RDEFSZ,RDEFEND %CYCLE RD == RECORD (ATABS + RDEFPTR) BB == RECORD (ABLOCKS + RD_BLOCK * BLSIZE) PUTBIT (ABLOCKS+BB_USE,COORD,BOEXKEEP) PUTBIT (ABLOCKS+BB_DEF,COORD,BOEXKEEP) PUTBIT (ABLOCKS+BB_BOE,COORD,BOEXKEEP) %REPEAT %FOR RTESTPTR = RTESTSTART,RTESTSZ,RTESTEND %CYCLE RT == RECORD (ATABS + RTESTPTR) BB == RECORD (ABLOCKS + RT_BLOCK * BLSIZE) PUTBIT (ABLOCKS+BB_USE,COORD,BOEXKEEP) PUTBIT (ABLOCKS+BB_BOE,COORD,BOEXKEEP) %REPEAT %IF BOEXKEEP = 0 %THENSTART IREPL;! REPLACE ALL NON-REDUCED USES OF I. !* REPLACE TESTS OF I BY TESTS OF TEMP. %IF RTESTEND >= RTESTSTART %THEN REPLACE !* RD'S OF I CAN NOW BE REMOVED AS THEY ARE THE ONLY REMAINING REFERENCES. %FOR RDEFPTR = RDEFSTART,RDEFSZ,RDEFEND %CYCLE RD == RECORD (ATABS +RDEFPTR) DELUSE (RD_ASSTRIAD) %REPEAT %FINISH {LSR_RP1} %FINISH FREETABS = RUSESTART %FINISH %REPEAT FREETABS = SRTABS ! ! ! ! ! %ROUTINE IDENTIFY ! !*************************************************************************** !* ALL ACCEPTABLE DEFINITIONS FOUND IN THE LOOP ARE RECORDED IN RD TABLE. * !* LOOKS FOR TRIADS AT TOP LEVEL OF LOOP, OF THE FORM:- * !* @N: I <- @M * !* WHERE I IS INT4 & * !* NOT DEFINED IN ANY INNER LOOP & * !* NOT EQUIVALENCED. * !* AND @M IS ONE OF I + LOOP CONSTANT * !* I - LOOP CONSTANT * !* LOOP CONSTANT + I * !*************************************************************************** ! %INTEGER OPN,OP2,BLOCK %RECORD (RESF) OPD ! RDSTART = FREETABS RDPTR=FREETABS-RDSZ CLOOPPTR = DLOOPHEAD %WHILE CLOOPPTR#0 %CYCLE CL == RECORD (ATABS + CLOOPPTR) BLOCK = CL_BLOCK BB == RECORD (ABLOCKS + BLOCK * BLSIZE) CURRTRIAD = BB_TEXT %WHILE NEXTTRIAD = 1 %CYCLE TT == RECORD (ATRIADS + CURRTRIAD * TRIADLENGTH) %UNLESS TT_OP = ASMT %THEN %CONTINUE %UNLESS TT_QOPD2 & TEXTMASK # 0 %THEN %CONTINUE OP2 = TT_OPD2 %IF TT_QOPD1 & IDMASK = 0 %THEN %CONTINUE %UNLESS TT_MODE = INT4 %THEN %CONTINUE CURRVAR = TT_RES1 DD == RECORD (ADICT + TT_OPD1 << DSCALE) %IF DD_X1 & EQUIVBIT # 0 %THEN %CONTINUE GETBIT (ADDR(PLOOPDEF(0)),DD_COORD,BIT) %IF BIT # 0 %THEN %CONTINUE TT == RECORD (ATRIADS + OP2 * TRIADLENGTH) OPN = TT_OP %UNLESS OPN = ADD %OR OPN = SUB %THEN %CONTINUE %UNLESS TT_RES1_W = CURRVAR_W %AND LOOPCON2(OP2) = 1 %THENSTART %UNLESS TT_RES2_W = CURRVAR_W %AND OPN = ADD %C %AND LOOPCON1 (OP2) = 1 %THEN %CONTINUE %ELSESTART OPD = TT_RES2 TT_RES2 = TT_RES1 TT_RES1 = OPD %FINISH %FINISH !* CREATE AN ENTRY IN RD TABLE. RDPTR = CREATETAB (RDSZ) RR == RECORD (ATABS + RDPTR) RR_VAR = CURRVAR RR_TRIAD = CURRTRIAD RR_BLOCK = BLOCK %REPEAT CLOOPPTR = CL_PDCHAIN %REPEAT RDEND = RDPTR ! %END;! IDENTIFY ! ! ! ! %INTEGERFUNCTION COLLECT ! !**************************************************************************** !* COLLECTS AS MUCH INFORMATION AS POSSIBLE ABOUT THE RECURSIVE VARIABLE * !* INDICATED BY RDPTR. IF ANYTHING RENDERS IT UNSUITABLE, WE EXIT FALSE, * !* ABORTING REDUCTION OF THIS VARIABLE. OTHERWISE 3 TABLES ARE BUILT: * !* RDEF, CONTAINING AN ENTRY FOR EACH RECURSIVE DEFN OF THE VAR (MAX 3) * !* RTEST, CONTAINING AN ENTRY FOR EACH TEST AGAINST A LOOP CONST (MAX 3) * !* RUSE, CONTAINING AN ENTRY FOR EACH OTHER USE. * !**************************************************************************** ! %INTEGER BIT1,BIT2,OPN,CONST,UFLAG,RDENT,NEWTR,SIGN ! !* ALL THE RECURSIVE DEFNS OF THE VAR ARE PICKED UP BY SCANNING THE REMAINDER !* OF RD TABLE, AND SKELETON ENTRIES PLACED ON RDEF TABLE. RDEFEND = RDEFSTART - RDEFSZ RDEFMAX = RDEFSTART + 2 * RDEFSZ %FOR RDENT = RDPTR,RDSZ,RDEND %CYCLE RR == RECORD (ATABS + RDENT) %IF RR_VAR_W = CURRVAR_W %THENSTART RR_VAR_FORM = NULL RDEFEND = RDEFEND + RDEFSZ %UNLESS RDEFEND > RDEFMAX %THENSTART RD == RECORD (ATABS + RDEFEND) RD_BLOCK = RR_BLOCK RD_ASSTRIAD = RR_TRIAD TT == RECORD (ATRIADS + RR_TRIAD * TRIADLENGTH) RD_INCTRIAD = TT_OPD2 %FINISH %FINISH %REPEAT %IF RDEFEND > RDEFMAX %THEN %RESULT = 0;! MORE THAN 3 DEFNS. !* SCAN THROUGH EVERY BLOCK IN DLOOP WITH A BIT FOR I SET, WITH 2 OBJECTS IN !* MIND: TO FIND REASONS TO DISQUALIFY I, AND TO FIND ALL USES OF I. RTESTEND = RTESTSTART -RTESTSZ RTESTMAX = RTESTSTART + 2 * RTESTSZ RTESTCT = 0 CLOOPPTR = DLOOPHEAD %WHILE CLOOPPTR#0 %CYCLE CL == RECORD (ATABS + CLOOPPTR) BLOCK = CL_BLOCK BB == RECORD (ABLOCKS + BLOCK * BLSIZE) GETBIT (ABLOCKS+BB_USE,COORD,BIT1) GETBIT (ABLOCKS+BB_DEF,COORD,BIT2) %IF BIT1 # 0 %OR BIT2 # 0 %THENSTART UFLAG = 0 CURRTRIAD = BB_TEXT %WHILE NEXTTRIAD = 1 %CYCLE %IF DD_CLASS & CMNBIT # 0 %AND ALLDEF (CURRTRIAD) = -1 %C %THEN %RESULT = 0 TT == RECORD (ATRIADS + CURRTRIAD * TRIADLENGTH) OPN = TT_OP %IF OPN=IOITEM %OR OPN=DIOITEM %THEN %RESULT=0 %IF TT_RES1_W = CURRVAR_W %THENSTART UFLAG = 1 %IF OPN = ASMT %THENSTART RDEFPTR = RDEFSTART %CYCLE RD == RECORD (ATABS + RDEFPTR) %IF RD_ASSTRIAD = CURRTRIAD %THEN %EXIT RDEFPTR = RDEFPTR + RDEFSZ %IF RDEFPTR > RDEFEND %THEN %RESULT = 0 %REPEAT !* FIND INCREMENT TRIAD IN RUSE. MUST ALWAYS BE THERE. %FOR RUSEPTR = RUSEEND,-RUSESZ,RUSESTART %CYCLE RU == RECORD (ATABS + RUSEPTR) %IF RU_TRIAD = RD_INCTRIAD %THEN %EXIT %REPEAT TT == RECORD (ATRIADS + RU_TRIAD * TRIADLENGTH) %IF TT_USE = 1 %THENSTART !* IF INCREMENT TRIAD DOESN'T IMMEDIATELY PRECEDE ASMT, RECHAIN IT SO IT DOES. %IF TT_CHAIN = CURRTRIAD %THENSTART RD_INCPREV = RU_PREV %FINISHELSESTART RD_INCPREV = PREVTRIAD TT1 == RECORD (ATRIADS + RU_PREV * TRIADLENGTH) TT1_CHAIN = TT_CHAIN TT_CHAIN = CURRTRIAD TT1 == RECORD (ATRIADS + PREVTRIAD * TRIADLENGTH) TT1_CHAIN = RU_TRIAD %FINISH RU_TRIAD = 0 %FINISHELSESTART !* IF USE CT. OF INCREMENT TRIAD > 1, CREATE A NEW TRIAD WITH USE CT = 1. TT_USE = TT_USE - 1 NEWTR = GETTRIAD TT1 == RECORD (ATRIADS + CURRTRIAD * TRIADLENGTH) TT1_OPD2 = NEWTR TT1 == RECORD (ATRIADS + PREVTRIAD * TRIADLENGTH) TT1_CHAIN = NEWTR RD_INCTRIAD = NEWTR RD_INCPREV = PREVTRIAD TT1 == RECORD (ATRIADS + NEWTR * TRIADLENGTH) TT1 = TT TT1_USE = 1 TT1_CHAIN = CURRTRIAD %IF TT1_QOPD2 & TEXTMASK # 0 %THENSTART TT1 == RECORD (ATRIADS + TT1_OPD2 * TRIADLENGTH) TT1_USE = TT1_USE + 1 %FINISH %FINISH TT1 == RECORD ( ATRIADS + RD_INCTRIAD * TRIADLENGTH) %IF TT1_OP = ADD %THEN SIGN = 0 %ELSE SIGN = 1 %IF TT1_QOPD2 & CONSTMASK = 0 %THENSTART RD_INC = TT1_RES2 RD_SIGN = SIGN %FINISHELSESTART CONST = CONOUT (TT1_RES2) %IF CONST < 0 %THENSTART SIGN = SIGN !! 1 CONST = -CONST %FINISH RD_LITINC = CONST RD_SIGN = SIGN ! LITBIT %FINISH %FINISHELSEIF OPN = ASGN %THEN %RESULT = 0 %C %ELSEIF OPN = DIOITEM %THEN %RESULT = 0 %C %ELSEIF OPN = DARG %THEN %RESULT = 0 %C %ELSEUNLESS GT <= OPN <= LE %C %AND LOOPCON2 (CURRTRIAD) = 1 %C %AND RTENTRY = 1 %THENSTART RUENTRY %IF OPN # ADD %AND TT_RES2_W = CURRVAR_W %THEN RUENTRY %FINISH %FINISHELSESTART !* IF OPD 1 WASN'T I AND OPD 2 IS: !* IF DEFARG: NON-RECURSIVE DEFN SO ABORT !* IF COMPARISON AGAINST LOOP CONST: CREATE RTEST ENTRY IF POSS !* ELSE: CREATE RUSE ENTRY AS ABOVE. %IF TT_RES2_W = CURRVAR_W %THENSTART UFLAG = 1 %IF OPN = DARG %THEN %RESULT = 0 %C %ELSEUNLESS GT <= OPN <= LE %C %AND LOOPCON1 (CURRTRIAD) = 1 %C %AND RTENTRY = 1 %THEN RUENTRY %FINISH %FINISH %REPEAT %IF UFLAG = 0 %THENSTART ;! A BIT STRIP WAS SET UNNECESSARILY, SO CLEAR THEM. CLEARBIT (ABLOCKS+BB_USE,COORD) CLEARBIT (ABLOCKS+BB_DEF,COORD) CLEARBIT (ABLOCKS+BB_BOE,COORD) %FINISH %FINISH CLOOPPTR = CL_PDCHAIN %REPEAT %RESULT = 1 ! %END;! COLLECT ! ! ! ! %INTEGERFUNCTION RTENTRY ! !************************************************************************* !* IF THERE IS ROOM IN THE FIXED-SIZE TABLE RTEST, A NEW ENTRY IS * !* ADDED, FILLED WITH THE RELEVANT VALUES, AND TRUE IS RETURNED. * !* IF NOT, FALSE IS RETURNED. * !************************************************************************* ! %IF RTESTEND = RTESTMAX %THEN %RESULT = 0 RTESTEND = RTESTEND + RTESTSZ RT == RECORD (ATABS + RTESTEND) RT_TRIAD = CURRTRIAD RT_BLOCK = BLOCK RTESTCT = RTESTCT + 1 %RESULT = 1 ! %END;! RTENTRY ! ! ! ! %ROUTINE RUENTRY ! !************************************************************************** !* CREATES A NEW RUSE ENTRY, AND FILLS WITH THE RELEVANT VALUES. * !************************************************************************** ! RUSEEND = CREATETAB (RUSESZ) RU == RECORD (ATABS + RUSEEND) RU_PREV = PREVTRIAD RU_TRIAD = CURRTRIAD RU_BLOCK = BLOCK RU_CHAIN = 0 INTEGER (RUSECH) = RUSEEND RUSECH = ADDR (RU_CHAIN) ! %END;! RUENTRY ! ! ! ! %INTEGERFUNCTION EXAMINE ! !**************************************************************************** !* EXAMINES THE TRIAD 'CURRTRIAD', TO SEE WHETHER IT IS A REDUCIVE USE OF * !* TOP-OF-USE-STACK. IF SO RETURNS TRUE, ELSE FALSE. * !* ALSO RETURNS USEFUL INFO ABOUT OPDS 1 & 2 IN SCOP1 & SCOP2. * !**************************************************************************** ! %INTEGER OPD ! !* STEP 1. CLASSIFY THE OPERATOR. TT == RECORD (ATRIADS + CURRTRIAD * TRIADLENGTH) OPN = TT_OP %UNLESS ADD <= OPN <= MULT %OR OPN = NEG %OR %C OPN = BRK %THEN %RESULT = 0 !* STEP 2. CLASSIFY OPD 1. %IF TT_RES1_W = QTOUS_W %THEN SCOP1 = 1 %C %ELSEIF TT_RES1_W = CURRVAR_W %THEN SCOP1 = 2 %C %ELSEIF TT_QOPD1 & CONSTMASK # 0 %THENSTART %IF CONOUT(TT_RES1)<0 %THEN %RESULT=0 SCOP1 = 4 %FINISHELSEIF TT_QOPD1 & IDMASK # 0 %THENSTART DD == RECORD (ADICT + TT_OPD1 << DSCALE) GETBIT (ADDR(CLOOPDEF(0)),DD_COORD,BIT) %UNLESS BIT = 0 %THEN %RESULT = 0 SCOP1 = 5 %FINISHELSESTART %UNLESS TT_QOPD1 & TEXTMASK # 0 %THEN %RESULT = 0 TT1 == RECORD (ATRIADS + TT_OPD1 * TRIADLENGTH) %IF TT1_OP & BMBIT = 0 %THEN %RESULT = 0 SCOP1 = 6 %FINISH !* STEP 3. CLASSIFY OPD2 (DISQUALIFYING QTOUS-OP-QTOUS, UNLESS QTOUS=CURRVAR) OPD = TT_RES2_W %IF OPD = CURRVAR_W %THENSTART %IF OPD = QTOUS_W %THEN SCOP2 = 1 %ELSE SCOP2 = 2 %FINISHELSEIF OPD = QTOUS_W %THENSTART %IF SCOP1 = 1 %THEN %RESULT = 0 %ELSE SCOP2 = 1 %FINISHELSESTART OPD = TT_QOPD2 %IF OPD & CONSTMASK # 0 %THEN SCOP2 = 4 %C %ELSEIF OPD & IDMASK # 0 %THENSTART DD == RECORD (ADICT + TT_OPD2 << DSCALE) GETBIT (ADDR(CLOOPDEF(0)),DD_COORD,BIT) %UNLESS BIT = 0 %THEN %RESULT = 0 SCOP2 = 5 %FINISHELSEIF OPD & TEXTMASK # 0 %THENSTART TT1 == RECORD (ATRIADS + TT_OPD2 * TRIADLENGTH) %IF TT1_OP & BMBIT = 0 %THEN %RESULT = 0 SCOP2 = 6 %FINISHELSEIF OPD = SRTEMP %THEN %RESULT = 0 %ELSE SCOP2 = 7 %FINISH !* STEP 4. DISQUALIFY TOUS*I, I*I, I*TOUS. %IF OPN = MULT %AND SCOP1 + SCOP2 <= 4 %THEN %RESULT = 0 %C %ELSE %RESULT = 1 ! %END;! EXAMINE ! ! ! ! %ROUTINE REDUCE ! !**************************************************************************** !* A REDUCIVE USE OF THE CURRENT TOP-OF-USE-STACK HAS BEEN DETECTED IN * !* TRIAD 'CURRTRIAD'. THIS IS REDUCED BY (A) CHAINING IT INTO THE BACK * !* TARGET FOR SUBSEQUENT USE IN A TEMPORARY INITIALISATION SEQUENCE, AND * !* (B) CONSIDERING CURRTRIAD AS A RECURSIVE VARIABLE & ADDING IT TO * !* USESTACK WITH APPROPRIATE INCREMENT & SIGN. * !**************************************************************************** ! %ROUTINESPEC GENROP ! %INTEGER BLK,PTR,OLDUSEPTR,NEGM,CONST,LITSW,SIGN,CONST2,LITSW2,SIGN2,OPN2,I %RECORD (RESF) OPD %RECORD (USEF) %NAME US1 ! !* STAGE 1. CHAIN CURRTRIAD INTO BACK TARG. TT == RECORD (ATRIADS + CURRTRIAD * TRIADLENGTH) TT1 == RECORD (ATRIADS + PREVTRIAD * TRIADLENGTH) TT1_CHAIN = TT_CHAIN TT1 == RECORD (ATRIADS + BTARGTRIAD * TRIADLENGTH) TT_CHAIN = TT1_CHAIN TT1_CHAIN = CURRTRIAD BTARGTRIAD = CURRTRIAD CURRTRIAD = PREVTRIAD BB == RECORD (ABLOCKS + BACKTARG * BLSIZE) !* IF EITHER OPD IS IDENT, SET BTARG BIT STRIPS. %IF SCOP1 = 5 %OR SCOP2 = 5 %THENSTART %IF SCOP1 = 5 %THEN DD == RECORD (ADICT + TT_OPD1 << DSCALE) %C %ELSE DD == RECORD (ADICT + TT_OPD2 << DSCALE) SETBIT (ABLOCKS+BB_USE,DD_COORD) GETBIT (ABLOCKS+BB_DEF,DD_COORD,BIT) %IF BIT = 0 %THEN SETBIT (ABLOCKS+BB_BOE,DD_COORD) %FINISH !* IF 1ST TIME THRO' FOR THIS REC VAR, SET ITS BTARG BIT STRIPS. %IF BITS = 0 %THENSTART BITS = 1 SETBIT (ABLOCKS+BB_USE,COORD) GETBIT (ABLOCKS+BB_DEF,COORD,BIT) %IF BIT = 0 %THEN SETBIT (ABLOCKS+BB_BOE,COORD) %FINISH !* IF THIS IS A USE OF THE ORIGINAL RECURSIVE VAR THE RUSE ENTRY IS DELETED. !* IF NOT THE R.V.'S USE CT MUST BE INCREMENTED BY 1. %IF QTOUS_W = CURRVAR_W %THEN RU_TRIAD = 0 %ELSESTART TT1 == RECORD (ATRIADS + TOUS * TRIADLENGTH) TT1_USE = TT1_USE + 1 %FINISH !* SCAN THRO' REMAINDER OF RUSE TO CHECK THAT CHAINED-OUT TRIAD WASN'T !* PREVTRIAD FOR ANOTHER ENTRY. %FOR PTR = RUSEPTR+RUSESZ,RUSESZ,RUSEEND %CYCLE RU == RECORD (ATABS + PTR) %IF RU_PREV = BTARGTRIAD %THEN RU_PREV = CURRTRIAD %REPEAT !* IF WE HAVE THE REDUCIVE FORM TOUS + I (TOUS # I), THE RUSE ENTRY FOR THE !* I MUST BE DELETED & THE BIT STRIPS ADJUSTED. (I + I YIELDS ONLY !* ONE RUSE ENTRY.) %IF SCOP1 + SCOP2 = 3 %THENSTART %FOR PTR = RUSEPTR+RUSESZ,RUSESZ,RUSEEND %CYCLE RU == RECORD (ATABS + PTR) %IF RU_TRIAD = BTARGTRIAD %THEN %EXIT %REPEAT RU_TRIAD = 0 BLK = RU_BLOCK RU == RECORD (ATABS + PTR-RUSESZ) %UNLESS RU_BLOCK = BLK %THENSTART PTR = PTR + RUSESZ RU == RECORD (ATABS + PTR) %IF PTR > RUSEEND %OR RU_BLOCK # BLK %THENSTART BB == RECORD (ABLOCKS + BLK * BLSIZE) CLEARBIT (ABLOCKS+BB_USE,COORD) CLEARBIT (ABLOCKS+BB_DEF,COORD) CLEARBIT (ABLOCKS+BB_BOE,COORD) %FINISH %FINISH %FINISH !* STAGE 2. SET UP THE NEW USESTACK ENTRY. (IF USES FIELD OF OLD ENTRY HAS REACHED !* 0 THEN NEW ENTRY OVERWRITES OLD.) OLDUSEPTR = USESTACKPTR BLK = US_BLOCK US_USES = US_USES - 1 %IF US_USES # 0 %THENSTART US_TRIAD = CURRTRIAD USESTACKPTR = CREATETAB (USESZ) US == RECORD (ATABS + USESTACKPTR) %FOR I =1,1,3 %CYCLE US_SIGN(I) = 0 US_LITINC(I) = 0 %REPEAT %FINISH TOUS = BTARGTRIAD QTOUS_H0 = BTARGTRIAD QTOUS_FORM = TRIAD QTOUS_MODE = INT4 US_RV = QTOUS US_TRIAD = CURRTRIAD US_BLOCK = BLK US_USES = TT_USE TT_USE = 0 US_TEMP = 0 US1 == RECORD (ATABS + OLDUSEPTR) I = 1 %FOR RDEFPTR = RDEFSTART,RDEFSZ,RDEFEND %CYCLE NEGM = 0 CONST = US1_LITINC(I) SIGN = US1_SIGN(I) & NOTLITBIT LITSW = US1_SIGN(I) >> LITSHIFT %IF SCOP1 + SCOP2 > 3 %THENSTART !* NORMAL REDUCIVE CASE. %IF OPN = MULT %THENSTART %IF SCOP1 > 3 %THEN OPD = TT_RES1 %C %ELSE OPD = TT_RES2 SIGN2 = 0 %IF OPD_FORM & CONSTMASK # 0 %THENSTART CONST2 = CONOUT (OPD) LITSW2 = 1 %FINISHELSESTART NEGM = 2 CONST2 = OPD_W LITSW2 = 0 %FINISH %IF LITSW = 1 %AND CONST = 1 %THENSTART;! IF OLD TOUS INCT = 1. CONST = CONST2 LITSW = LITSW2 %FINISHELSESTART %IF LITSW = LITSW2 = 1 %THENSTART !* IF BOTH KNOWN CONSTANTS, EVALUATE NEW INCT. CONST = CONVAL (CONST,CONST2,MULT,INT4) %IF CONST < 0 %THENSTART CONST = -CONST NEGM = 1 %FINISH %FINISHELSESTART OPN2 = MULT GENROP %FINISH %FINISH %FINISH %FINISHELSESTART !* SCOP1 +SCOP2 <= 3. I.E. 'TOUS +- I' OR 'I +- TOUS' RD == RECORD (ATABS + RDEFPTR) OPN2 = ((RD_SIGN !! SIGN) & 1 ) !! OPN;! SWAPS ADD OR SUB IF SIGNS ARE DIFFERENT. LITSW2 = RD_SIGN >> LITSHIFT CONST2 = RD_LITINC %IF LITSW2 & LITSW # 0 %THENSTART !* IF BOTH KNOWN CONSTANTS, EVALUATE NEW INCT. CONST = CONVAL (CONST,RD_LITINC,OPN2,INT4) LITSW = 1 %FINISHELSE GENROP %FINISH US_LITINC(I) = CONST %IF (SCOP2 = 1 %AND OPN = SUB) %OR OPN = NEG %OR NEGM = 1 %THENSTART %IF SIGN <= 1 %THEN SIGN = SIGN !! 1 %C %ELSE SIGN = SIGN + 1 %FINISHELSE SIGN = SIGN + NEGM US_SIGN(I) = SIGN ! (LITSW << LITSHIFT) I = I + 1 %REPEAT %UNLESS SRFLAGS & 2 = 0 %THEN PRINTUSESTACK ! ! ! ! %ROUTINE GENROP ! !*************************************************************************** !* GENERATE A TRIAD IN THE BACK TARGET TO COMPUTE THE INCREMENT FOR THE * !* NEW T-O-US. CALL TARGHK FOR EACH OPERAND TO ADJUST BIT STRIPS ETC. * !* ON ENTRY TWO OPERANDS ARE IN LITSW, CONST * !* LITSW2, CONST2 * !* (IF LITSW = 0, CONST IS A RESF RECORD, * !* IF LITSW = 1, CONST IS A 32-BIT VALUE.) * !* OPERATION TO BE PERFORMED IS IN OPN2. * !* RETURNS TEXT POINTER IN CONST, & LITSW = 0. * !*************************************************************************** ! %INTEGER NEWTRIAD %RECORD (RESF) OPND1,OPND2 ! %IF LITSW = 0 %THENSTART OPND1_W = CONST TARGHK (OPND1) %FINISHELSE OPND1_W = CONIN (CONST) %IF LITSW2 = 0 %THENSTART OPND2_W = CONST2 TARGHK (OPND2) %FINISHELSE OPND2_W = CONIN (CONST2) NEWTRIAD = GETTRIAD TT == RECORD (ATRIADS + NEWTRIAD * TRIADLENGTH) TT_USE = 0 TT_OP = OPN2 TT_RES1 = OPND1 TT_RES2 = OPND2 TT1 == RECORD (ATRIADS + BTARGTRIAD * TRIADLENGTH) TT_CHAIN = TT1_CHAIN TT1_CHAIN = NEWTRIAD BTARGTRIAD = NEWTRIAD OPND1_H0 = NEWTRIAD OPND1_FORM = TRIAD CONST = OPND1_W LITSW = 0 ! %END;! GENROP ! %END;! REDUCE ! ! ! ! %ROUTINE TARGHK (%RECORD (RESF) OPD) ! !*************************************************************************** !* WHEN ADDING AN OPERAND TO THE BACK TARGET (AS PART OF CALCULATION OF * !* NEW INCREMENT): * !* A) IF IDENT, UPDATE BIT STRIPS * !* B) IF A TEXT POINTER, UPDATE THE USE COUNT. * !*************************************************************************** ! %IF OPD_FORM & IDMASK # 0 %THENSTART DD == RECORD (ADICT + OPD_H0 << DSCALE) BB == RECORD (ABLOCKS + BACKTARG * BLSIZE) SETBIT (ABLOCKS+BB_USE,DD_COORD) GETBIT (ABLOCKS+BB_DEF,DD_COORD,BIT) %IF BIT = 0 %THEN SETBIT (ABLOCKS+BB_BOE,DD_COORD) %FINISHELSEIF OPD_FORM & TEXTMASK # 0 %THENSTART TT == RECORD (ATRIADS + OPD_H0 * TRIADLENGTH) TT_USE = TT_USE + 1 %FINISH ! %END;! TARGHK ! ! ! ! %ROUTINE SUBTEMP ! !***************************************************************************** !* REPLACE A USE (OR USES) OF T-O-US BY AN APPROPRIATE TEMPORARY, ACCORDING * !* TO THE SETTING OF EFLAG. * !* EFLAG = 0 => A NON-REDUCIVE USE OF T-O-US HAS BEEN FOUND, SO REPLACE IT* !* EFLAG = 1 => END OF OUTER LEVEL OF LOOP HAS BEEN REACHED BEFORE ALL * !* USES OF T-O-US HAVE BEEN PROCESSED, SO REPLACE ALL USES * !* IN INNER LOOPS. * !***************************************************************************** ! %INTEGER I ! !* STAGE 1. IF NECESSARY, GENERATE A NEW TEMPORARY. %IF US_TEMP = 0 %THEN SRENTRY (0) %C %ELSE SRPTR = US_TEMP SR == RECORD (ABLOCKS + SRPTR << SRSCALE) %FOR I = 1,1,SR_USECT %CYCLE %IF SR_USE(I) = 0 %THEN %EXIT %REPEAT %IF EFLAG = 0 %THENSTART !* STAGE 2A. REPLACE THE USE OF T-O-US IN CURRTRIAD BY A USE OF THE SR TEMP. US_USES = US_USES - 1 SR_USE(I) = CURRTRIAD TT == RECORD (ATRIADS + CURRTRIAD * TRIADLENGTH) %IF TT_RES1_W = QTOUS_W %THENSTART TT_QOPD1 = SRTEMP TT_OPD1 = SRPTR US_TRIAD = PREVTRIAD %FINISHELSESTART TT_QOPD2 = SRTEMP TT_OPD2 = SRPTR %IF TT_OP = ARR %OR TT_OP = DEFARR %THENSTART %IF CMPLX8 <= TT_MODE <= CMPLX32 %C %THEN SR_WEIGHT = SR_WEIGHT + 2 %C %ELSE SR_WEIGHT = SR_WEIGHT + 1 %FINISH %FINISH %FINISHELSESTART !* STAGE 2B. REPLACE ALL OUTSTANDING USES OF T-O-US IN INNER LOOPS BY USES OF !* THE SR TEMP. THERE MAY BE SEVERAL USES, DEFINED BY US_USES. !* MUST ALL BE THERE IN PLOOP LIST. THESE USES DON'T AFFECT WEIGHTINGS. CLOOPPTR = PLOOPHEAD %WHILE CLOOPPTR # 0 %CYCLE CL == RECORD (ATABS + CLOOPPTR) BB == RECORD (ABLOCKS + CL_BLOCK * BLSIZE) CURRTRIAD = BB_TEXT %WHILE NEXTTRIAD = 1 %CYCLE TT == RECORD (ATRIADS + CURRTRIAD * TRIADLENGTH) %IF TT_RES1_W = QTOUS_W %THENSTART SR_USE(I) = CURRTRIAD I = I + 1 TT_OPD1 = SRPTR TT_QOPD1 = SRTEMP US_USES = US_USES - 1 %IF US_USES = 0 %THEN -> L1 %FINISH %UNLESS TT_RES2_W = QTOUS_W %THEN %CONTINUE SR_USE(I) = CURRTRIAD I = I + 1 TT_OPD2 = SRPTR TT_QOPD2 = SRTEMP US_USES = US_USES - 1 %IF US_USES = 0 %THEN -> L1 %REPEAT CLOOPPTR = CL_PDCHAIN %REPEAT %FINISH !* STAGE 3. COMPARE WEIGHT OF THIS TEMP WITH CURRENT MAXIMUM, & UPDATE IF NECESSARY. L1: %IF SR_WEIGHT > MAXWEIGHT %THENSTART MAXWEIGHT = SR_WEIGHT MAXTEMP = SRPTR %FINISH ! %END;! SUBTEMP ! ! ! ! %INTEGERFUNCTION SCAN ! !**************************************************************************** !* SCANS THE TOP LEVEL OF THE LOOP FOR THE NEXT USE OF TOP-OF-USE-STACK. * !* RETURNS TRUE IF A USE IS FOUND, ELSE FALSE. * !**************************************************************************** ! US == RECORD (ATABS + USESTACKPTR) CURRTRIAD = US_TRIAD !* STAGE 1. LOOK FOR THE NEXT USE IN THE CURRENT BLOCK. %WHILE NEXTTR = 1 %CYCLE TT == RECORD (ATRIADS + CURRTRIAD * TRIADLENGTH) %UNLESS TT_RES1_W = QTOUS_W %OR TT_RES2_W = QTOUS_W %THEN %CONTINUE %UNLESS TT_OP = REPL %THENSTART US_TRIAD = CURRTRIAD %RESULT = 1 %FINISH US_USES = US_USES + TT_USE - 1 %REPEAT !* STAGE 2. IDENTIFY WHICH BLOCK FROM DLOOP LIST WE HAVE JUST COME TO THE END OF. CLOOPPTR = DLOOPHEAD %CYCLE CL == RECORD (ATABS + CLOOPPTR) CLOOPPTR = CL_PDCHAIN %IF CL_BLOCK = US_BLOCK %THEN %EXIT %REPEAT !* STAGE 3. SCAN EACH OF REMAINING BLOCKS IN DLOOP LIST UNTIL A USE IS FOUND. %WHILE CLOOPPTR # 0 %CYCLE CL == RECORD (ATABS + CLOOPPTR) BB == RECORD (ABLOCKS + CL_BLOCK * BLSIZE) CURRTRIAD = BB_TEXT %WHILE NEXTTR = 1 %CYCLE TT == RECORD (ATRIADS + CURRTRIAD * TRIADLENGTH) %UNLESS TT_RES1_W = QTOUS_W %OR TT_RES2_W = QTOUS_W %THEN %CONTINUE %IF TT_OP # REPL %THENSTART US_TRIAD = CURRTRIAD US_BLOCK = CL_BLOCK %RESULT = 1 %FINISH US_USES = US_USES + TT_USE - 1 %REPEAT CLOOPPTR = CL_PDCHAIN %REPEAT %RESULT = 0 ! %END;! SCAN ! ! ! ! %ROUTINE IREPL ! !******************************************************************** !* REPLACES ALL USES OF THE RECURSIVE VARIABLE I WHICH * !* 1. HAVE NOT BEEN REDUCED * !* 2. ARE NOT RECURSIVE DEFNS IN RDEF TABLE * !* 3. ARE NOT TESTS IN RTEST TABLE * !* BY USES OF THE NEW SR TEMPORARY. * !******************************************************************** ! %RECORD (RESF) OPD ! !* STAGE 1. ALL BLOCKS IN INNER LOOPS ARE SCANNED FOR USES OF I, WHICH !* ARE THEN ADDED TO RUSE TABLE. (RUSE ALREADY HAS !* ENTRIES FOR ALL USES IN THE TOP LEVEL.) GETBIT (ADDR(PLOOPUSE(0)),COORD,BIT) %UNLESS BIT = 0 %THENSTART CLOOPPTR = PLOOPHEAD %WHILE CLOOPPTR # 0 %CYCLE CL == RECORD (ATABS + CLOOPPTR) BLOCK = CL_BLOCK;! REQUIRED BY RUENTRY. BB == RECORD (ABLOCKS + BLOCK * BLSIZE) GETBIT (ABLOCKS+BB_USE,COORD,BIT) %UNLESS BIT = 0 %THENSTART CLEARBIT (ABLOCKS+BB_USE,COORD) CLEARBIT (ABLOCKS+BB_BOE,COORD) CURRTRIAD = BB_TEXT %WHILE NEXTTRIAD = 1 %CYCLE TT == RECORD (ATRIADS + CURRTRIAD * TRIADLENGTH) %UNLESS TT_RES1_W = CURRVAR_W %OR TT_RES2_W = CURRVAR_W %C %THEN %CONTINUE RUENTRY NRUSECT = NRUSECT + 1 %REPEAT %FINISH CLOOPPTR = CL_PDCHAIN %REPEAT %FINISH !* STAGE 2. IF THERE ARE ANY USES TO REPLACE, A NEW SR TEMP IS GENERATED, !* AND ITS USE AND WEIGHT FIELDS FILLED. !* (EVEN IF NO NON-REDUCIVE USES, WE NEED A NEW TEMP IF NONE OF THE !* PRESENT TEMPS IS SUITABLE FOR TEST REPLACEMENT, AND THERE ARE !* SOME TESTS TO REPLACE.) %IF NRUSECT # 0 %OR %C (MAXWEIGHT < 0 %AND RTESTEND >= RTESTSTART) %THENSTART SRENTRY (1) I = 1 RUSEPTR = RUSEHEAD %WHILE RUSEPTR # 0 %CYCLE RU == RECORD (ATABS + RUSEPTR) %UNLESS RU_TRIAD = NULL %THENSTART SR_USE(I) = RU_TRIAD I = I + 1 TT == RECORD (ATRIADS + RU_TRIAD * TRIADLENGTH) OPD_FORM = SRTEMP OPD_H0 = SRPTR OPD_MODE = INT4 %IF TT_RES1_W = CURRVAR_W %THEN TT_RES1 = OPD %IF TT_RES2_W = CURRVAR_W %THEN TT_RES2 = OPD BB == RECORD (ABLOCKS + RU_BLOCK * BLSIZE) %IF (TT_OP = ARR %OR TT_OP = DEFARR) %C %AND BB_DEPTH = LOOPDEPTH %THENSTART %IF CMPLX8 <= TT_MODE <= CMPLX32 %C %THEN SR_WEIGHT = SR_WEIGHT + 2 %C %ELSE SR_WEIGHT = SR_WEIGHT + 1 %FINISH CLEARBIT (ABLOCKS+BB_USE,COORD) CLEARBIT (ABLOCKS+BB_DEF,COORD) CLEARBIT (ABLOCKS+BB_BOE,COORD) %FINISH RUSEPTR = RU_CHAIN %REPEAT %IF SR_WEIGHT >= MAXWEIGHT %THENSTART MAXWEIGHT = SR_WEIGHT MAXTEMP = SRPTR %FINISH %FINISH ! %END;! IREPL ! ! ! ! %ROUTINE SRENTRY (%INTEGER SFLAG) ! !**************************************************************************** !* CREATES A NEW ENTRY IN TABLE OF STRENGTH REDUCTION TEMPORARIES, * !* INITIALISING ALL FIELDS EXCEPT USES & TESTS. RETURNS SCALED POINTER * !* IN SRPTR. * !* CALLED EITHER FROM SUBTEMP, WITH SFLAG = 0, IN WHICH CASE WE OBTAIN * !* INFO ABOUT INCREMENT, SIGN, ETC FROM CURRENT T-O-US, OR FROM IREPL, * !* WITH SFLAG = 1, WHERE NON-REDUCIVE USES OF THE ORIGINAL RECURSIVE * !* VAR ARE TO BE REPLACED BY THE NEW TEMP, & WE GET THE INFO FROM RDTAB * !**************************************************************************** ! %INTEGER NEWTRIAD,TRID,SIGN,WEIGHT,WW,LITSW,LITINC,USES ! !* CONSIDER EFFECT OF INIT TRIAD ON BACK TARGET: !* T - INIT - I => BIT STRIPS MUST BE ADJUSTED !* T - INIT - TRIAD => USE CT OF TRIAD MUST BE UPDATED. %IF SFLAG = 0 %THENSTART TT == RECORD (ATRIADS + TOUS * TRIADLENGTH) TT_USE = TT_USE + 1 USES = US_USES %FINISHELSESTART %IF BITS = 0 %THENSTART BITS = 1 BB == RECORD (ABLOCKS + BACKTARG * BLSIZE) SETBIT (ABLOCKS+BB_USE,COORD) GETBIT (ABLOCKS+BB_DEF,COORD,BIT) %IF BIT = 0 %THEN SETBIT (ABLOCKS+BB_BOE,COORD) %FINISH USES = NRUSECT %FINISH !* CREATE NEW ENTRY. IF FIRST SR ENTRY FOR LOOP, PUT POINTER IN LOOP TABLE ENTRY. SRPTR = CREATEBTAB ((SRFIXED + USES * SRUSESZ + 3) & X'FFFFFFFC') SR == RECORD (ABLOCKS + SRPTR) SRPTR = SRPTR >> SRSCALE SR_CHAIN = 0 %UNLESS SRHEAD=0 %THEN SRCH=SRCH+ABLOCKS INTEGER (SRCH) = SRPTR SRCH = ADDR (SR_CHAIN)-ABLOCKS LO == RECORD (ALOOPS + LOOP) %IF LO_ST = 0 %THEN LO_ST = SRPTR %IF SFLAG = 0 %THEN US_TEMP = SRPTR SR_LOOP = LOOP SR_USECT = USES SR_IDENT = CURRVAR_H0 SR_MODE = INT4 SR_WEIGHT = 0 RD == RECORD (ATABS + RDEFSTART) !* SET FLAG IF TESTS MUST BE REVERSED. %IF SFLAG = 0 %AND (US_SIGN(1) & 1) # (RD_SIGN & 1) %C %THEN SR_FLAGS = REVTESTBIT %C %ELSE SR_FLAGS = 0 SR_DUMP = 0 %FOR I = 1,1,3 %CYCLE SR_INCR(I) = 0 SR_TEST(I) = 0 %REPEAT %FOR I = 1,1,USES %CYCLE SR_USE(I) = 0 %REPEAT !* GENERATE THE INIT TRIAD FOR THE NEW TEMPORARY. NEWTRIAD = GETTRIAD TT == RECORD (ATRIADS + NEWTRIAD * TRIADLENGTH) SR_INIT = NEWTRIAD TT1 == RECORD (ATRIADS + BTARGTRIAD * TRIADLENGTH) TT_CHAIN = TT1_CHAIN TT1_CHAIN = NEWTRIAD BTARGTRIAD = NEWTRIAD TT_OP = INIT TT_QOPD1 = SRTEMP TT_OPD1 = SRPTR TT_MODE = INT4 %IF SFLAG = 0 %THEN TT_RES2 = QTOUS %C %ELSE TT_RES2 = CURRVAR !* FOR EACH RDEF ENTRY, GENERATE AN APPROPRIATE INCR OR DECR TRIAD. I = 1 %FOR RDEFPTR = RDEFSTART,RDEFSZ,RDEFEND %CYCLE RD == RECORD (ATABS + RDEFPTR) NEWTRIAD = GETTRIAD TT == RECORD (ATRIADS + NEWTRIAD * TRIADLENGTH) TT_OPD1 = SRPTR TT_QOPD1 = SRTEMP TT_MODE = INT4 TT_CHAIN = RD_INCTRIAD TT_USE = 0 TT1 == RECORD (ATRIADS + RD_INCPREV * TRIADLENGTH) %UNLESS TT1_CHAIN = RD_INCTRIAD %THENSTART BB == RECORD (ABLOCKS + RD_BLOCK * BLSIZE) TRID = BB_TEXT %CYCLE TT1 == RECORD (ATRIADS + TRID * TRIADLENGTH) %IF TT1_CHAIN = RD_INCTRIAD %THEN %EXIT TRID = TT1_CHAIN %REPEAT %FINISH TT1_CHAIN = NEWTRIAD RD_INCPREV = NEWTRIAD !* INCR OR DECR? DEPENDS ON SIGN OF INCREMENT. %IF SFLAG = 0 %THENSTART SIGN = US_SIGN(I) & NOTLITBIT %IF SIGN < 2 %THEN -> L2 WEIGHT = INFIN %FINISHELSESTART SIGN = RD_SIGN & NOTLITBIT L2: WEIGHT = 0 WW = SIGN !! 1 %FINISH %IF SIGN & 1 = 0 %THEN TT_OP = INCR %C %ELSE TT_OP = DECR !* WHAT IS INCREMENT? EITHER A LITERAL CONSTANT, A LOOP CONSTANT IDENT, OR A !* TRIAD IN THE BACK TARGET. %IF SFLAG = 0 %THENSTART LITSW = US_SIGN(I) >> LITSHIFT LITINC = US_LITINC(I) %FINISHELSESTART LITSW = RD_SIGN >> LITSHIFT LITINC = RD_LITINC %FINISH %IF LITSW = 0 %THENSTART TT_RES2_W = LITINC %IF TT_QOPD2 & TEXTMASK # 0 %THENSTART TT1 == RECORD (ATRIADS + TT_OPD2 * TRIADLENGTH) TT1_USE = TT1_USE + 1 %FINISHELSEIF TT_QOPD2 & IDMASK # 0 %THENSTART DD == RECORD (ADICT + TT_OPD2 << DSCALE) BB == RECORD (ABLOCKS + RD_BLOCK * BLSIZE) SETBIT (ABLOCKS+BB_USE,DD_COORD) SETBIT (ABLOCKS+BB_BOE,DD_COORD) %FINISH %FINISHELSESTART %IF LITINC = 1 %THEN WEIGHT = WEIGHT + WW TT_RES2_W = CONIN (LITINC) %FINISH SR_INCR(I) = NEWTRIAD %UNLESS WEIGHT = INFIN %THEN SR_WEIGHT = SR_WEIGHT + WEIGHT + 2 %C %ELSE SR_WEIGHT = INFIN I = I + 1 %REPEAT ! %END;! SRENTRY ! ! ! ! %ROUTINE REPLACE ! !*************************************************************************** !* THE TESTS INDICATED BY RTEST ARE REPLACED BY TESTS OF MAXTEMP * !* AGAINST K, WHERE K IS: * !* A) THE ORIGINAL CONSTANT IF MAXTEMP DIRECTLY REPLACES I * !* B) THE LAST TRIAD OF A BACK TARGET SEQUENCE, CONSISTING OF THE * !* INITIALISATION SEQUENCE FOR MAXTEMP, WITH THE ORIGINAL * !* CONSTANT REPLACING ALL USES OF I. * !* FOR CASE B WE CONSTRUCT A TABLE TINIT, WITH AN ENTRY FOR EACH TRIAD * !* IN THE INITIALISATION SEQUENCE (STARTING FROM TOP OF TREE). * !* TINIT FIELDS ARE: * !* TRIAD = POINTER TO TRIAD IN INITIALISATION SEQUENCE FOR MAXTEMP * !* OPD = 0 IF NEITHER OPERAND IS I * !* 1 IF OPD1 IS I * !* 2 IF OPD2 IS I * !* 3 IF BOTH OPDS ARE I. * !* REF = 0 IF THIS IS LAST ENTRY IN THIS SEQUENCE * !* 1 IF OPD1 POINTS TO NEXT TRIAD IN SEQUENCE * !* 2 IF OPD2 POINTS TO NEXT TRIAD IN SEQUENCE. * !*************************************************************************** ! %INTEGER TINITSTART,TINITPTR,TINITEND,CONUSE,TRID,FLAGS ! %RECORD (RESF) TESTCON,OPD,OPD2 ! %CONSTINTEGER TINITSZ = 3< MAXBLOCKS B = FREEBLOCKS FILL(A,ABLOCKS+B,0,0) FREEBLOCKS = FREEBLOCKS + A %RESULT = B ! %END;! CREATEBTAB ! ! ! ! %ROUTINE PRINTRD ! !************************************************************************ !* PRINT CONTENTS OF RD TABLE. * !************************************************************************ ! %RECORD(RDF)%NAME RR %INTEGER RDPTR NEWLINE PRINTSTRING ("RECURSIVE DEFINITIONS") NEWLINE PRINTSTRING (" VAR TRIAD BLOCK") NEWLINE %FOR RDPTR = RDSTART,RDSZ,RDEND %CYCLE RR == RECORD (ATABS + RDPTR) WRITE (RR_VAR_FORM,3) PRINTSTRING ("/") WRITE (RR_VAR_H0,4) WRITE (RR_TRIAD,8) WRITE (RR_BLOCK,8) NEWLINE %REPEAT ! %END;! PRINTRD ! ! ! ! %ROUTINE PRINTRUSE ! !**************************************************** !* PRINT CONTENTS OF RUSE TABLE. * !**************************************************** ! %RECORD(RUSEF)%NAME RU %INTEGER RUSEPTR NEWLINE PRINTSTRING ("USES") NEWLINE PRINTSTRING (" TRIAD PREV BLOCK") NEWLINE RUSEPTR = RUSEHEAD %WHILE RUSEPTR # 0 %CYCLE RU == RECORD (ATABS + RUSEPTR) WRITE (RU_TRIAD,7) WRITE (RU_PREV,7) WRITE (RU_BLOCK,7) NEWLINE RUSEPTR = RU_CHAIN %REPEAT ! %END;! PRINTRUSE ! ! ! ! %ROUTINE PRINTRDEF ! !*************************************************** !* PRINT CONTENTS OF RDEF TABLE. * !*************************************************** ! %RECORD(RDEFF)%NAME RD %INTEGER RDEFPTR NEWLINE PRINTSTRING ("DEFINITIONS") NEWLINE PRINTSTRING (" ASMT INCT PREV BLOCK SIGN LITINC") NEWLINE %FOR RDEFPTR = RDEFSTART,RDEFSZ,RDEFEND %CYCLE RD == RECORD (ATABS + RDEFPTR) WRITE (RD_ASSTRIAD,7) WRITE (RD_INCTRIAD,7) WRITE (RD_INCPREV,7) WRITE (RD_BLOCK,7) WRITE (RD_SIGN,7) WRITE (RD_LITINC,7) NEWLINE %REPEAT ! %END;! PRINTRDEF ! ! ! ! %ROUTINE PRINTRTEST ! !****************************************************** !* PRINT CONTENTS OF RTEST TABLE. * !****************************************************** ! %RECORD(RTESTF)%NAME RT %INTEGER RTESTPTR NEWLINE PRINTSTRING ("TESTS") NEWLINE PRINTSTRING (" TRIAD BLOCK") NEWLINE %FOR RTESTPTR = RTESTSTART,RTESTSZ,RTESTEND %CYCLE RT == RECORD (ATABS + RTESTPTR) WRITE (RT_TRIAD,8) WRITE (RT_BLOCK,7) NEWLINE %REPEAT ! %END;! PRINTRTEST ! ! ! ! %ROUTINE PRINTUSESTACK ! !*************************************************** !* PRINT CONTENTS OF USE STACK. * !*************************************************** ! %RECORD(USEF)%NAME US %INTEGER PTR NEWLINE PRINTSTRING ("USE STACK") NEWLINE PRINTSTRING (" TRIAD BLOCK RV") PRINTSTRING(" USES SIGNS TEMP LIT1 LIT2 LIT3") NEWLINE %FOR PTR = USESTACKSTART,USESZ,USESTACKPTR %CYCLE US == RECORD (ATABS + PTR) WRITE (US_TRIAD,6) WRITE (US_BLOCK,6) WRITE (US_RV_FORM,4) PRINTSTRING ("/") WRITE (US_RV_H0,4) WRITE (US_USES,6) WRITE (US_SIGN(1),4) WRITE (US_SIGN(2),3) WRITE (US_SIGN(3),3) WRITE (US_TEMP,5) WRITE (US_LITINC(1),6) WRITE (US_LITINC(2),6) WRITE (US_LITINC(3),6) NEWLINE %REPEAT ! %END;! PRINTUSESTACK ! %END ;! STRENGTHRED ! %ENDOFFILE