! 02/07/84 - change OPTSAB(CMPLX) entry to X'06' ! 11/04/84 - don't word align FREETABS in BMOVHECK ! 10/04/84 - scaling correction in bmovecheck ! 31/01/84 - UPDATE OPSTAB FOR DCMPLX & INTRIN ! 18/01/84 - ADJUST BIT STRIP ADDRESSES ! 17/01/84 - MAKE CALLS OF CREATETAB CONSISTTENT ! 23/11/83 call EDUMPTRACE in OP2A; set up LDUMPTRACE & BMTRACE ! 22/11/82 call CDUMPTRACE in OP2A ! 27/10/83 COPIED FROM ERCS06.REL90_OP2B13 !* %INCLUDE "host_host" %INCLUDE "targ_target" %INCLUDE "pf_version" !* %INCLUDE "bits_fmts" %INCLUDE "bits_optspecs" %INCLUDE "bits_consts" %INCLUDE "bits_optfmts" ! %INCLUDE "bits_triadops" !* %OWNINTEGER TRACE=0,BMTRACE=0 ! %EXTERNALROUTINESPEC PRINTTR(%INTEGER INDEX,ADICT,ANAMES,LEVEL, %RECORD(TRIADF)%NAME TRIAD) %ROUTINESPEC BACKMOVE ! ! %ROUTINE LDUMPTRACE TRACE=LDUMP&OPTFLAGS %END ! %ROUTINE SETBMTRACE BMTRACE=CDUMP&OPTFLAGS %END ! %EXTERNALROUTINE OP2 ! ! %EXTERNALROUTINESPEC GLOBSUBS %EXTERNALROUTINESPEC SUBSUM %EXTERNALROUTINESPEC SUBSEOB %EXTERNALROUTINESPEC EXPELIM %EXTERNALROUTINESPEC CONELIM %EXTERNALROUTINESPEC OPTDIV %EXTERNALROUTINESPEC OPTNEG %EXTERNALROUTINESPEC OPTCVT %EXTERNALROUTINESPEC OPTFUN %EXTERNALROUTINESPEC OPTEXP %EXTERNALROUTINESPEC FACTORISE %EXTERNALROUTINESPEC LINEARISE %EXTERNALROUTINESPEC EXPELBTARG %EXTERNALROUTINESPEC FLOWOFCONT %EXTERNALROUTINESPEC STRENGTHRED ! %ROUTINESPEC OP2A %ROUTINESPEC LOOPSEL (%INTEGER L) %ROUTINESPEC LOOPBUILD ! %RECORDFORMAT ARTICF (%INTEGER BLOCK) %INTEGERARRAYFORMAT TABF (0:1000) %INTEGERARRAYFORMAT BF (0:15) %INTEGERARRAYFORMAT BS (0:1000) %INTEGERARRAYNAME B1,B2,BLKBS,ENTBTAB %RECORD (BLRECF) %NAME BB %RECORD (LOOPRECF) %NAME LL %RECORD (CLOOPRECF) %NAME CL %RECORD (TRIADF) %NAME TT %RECORD (ARTICF) %NAME AR %RECORD (CONRECF) %NAME CN ! %INTEGER PLOOPCH,DLOOPCH %INTEGER I,J,NEWENT,BLOCK %INTEGER BLKBSLENGTH,SAVEPTR,BLKBITS,BIT ! ! !******************************************************************** !* FOR EACH PROGRAM LOOP IN TURN, BUILD UP ALL NECESSARY DATA & * !* TABLES, AND THEN CALL ALL THE VARIOUS OPTIMISATION PROCESSES. * !******************************************************************** ! ! BLKBSLENGTH = (NEXTBLOCK + 31) >> 5; ! LENGTH IN 32BIT WORDS FREEBLOCKS = (NEXTBLOCK + 1) * BLSIZE SRHEAD = 0 SRCH = ADDR (SRHEAD) FREETABS = (FREETABS + 3) & X'FFFFFFFC' BLKBITS = CREATETAB (BLKBSLENGTH << BSCALE) + ATABS BLKBS == ARRAY (BLKBITS,BS) LDUMPTRACE %IF INHIBMASK & INHIBSUBSUM = 0 %THEN GLOBSUBS ! LOOPSEL (0) %UNLESS FREELOOPS = 0 ! LOOP = X'FFFF' LOOPDEPTH = 0 BACKTARG = 0 BTARGTRIAD = 0 OLDBTARGTRIAD = 0 %FOR I = 0,1,BSWORDS-1 %CYCLE DLOOPUSE(I) = 0 DLOOPDEF(I) = 0 %REPEAT SAVEPTR = FREETABS PLOOPCH = ADDR (PLOOPHEAD) DLOOPCH = ADDR (DLOOPHEAD) PLOOPHEAD = 0 DLOOPHEAD = 0 PLOOPTAIL = 0 DLOOPTAIL = 0 BLKBS(I) = 0 %FOR I = 0,1,BLKBSLENGTH-1 ENTBTAB == ARRAY (ATABS + ENTBPTR,TABF) %FOR J = 1,1,ENTBTAB(0) %CYCLE NEWENT = CREATETAB (CLOOPSZ) BLOCK = ENTBTAB(J) CL == RECORD (ATABS + NEWENT) CL_BLOCK = BLOCK BB == RECORD (ABLOCKS+ BLOCK*BLSIZE) B1 == ARRAY (ABLOCKS+BB_USE,BF) B2 == ARRAY (ABLOCKS+BB_DEF,BF) %FOR I = 0,1,BSWORDS-1 %CYCLE DLOOPUSE(I) = DLOOPUSE(I) ! B1(I) DLOOPDEF(I) = DLOOPDEF(I) ! B2(I) %REPEAT SETBIT (BLKBITS,BLOCK) INTEGER (DLOOPCH) = NEWENT DLOOPCH = ADDR (CL_PDCHAIN) CL_PDCHAIN = 0 CL_PDBACKCHAIN = DLOOPTAIL DLOOPTAIL = NEWENT %REPEAT CLOOPHEAD = DLOOPHEAD ! %IF CLOOPHEAD#0 %THEN LOOPBUILD ! ! CODE NEEDED HERE TO OPTIMISE COPYING OF ARGUMENTS IN PROLOGUES ! & EPILOGUES ! ! ! ! %ROUTINE LOOPSEL (%INTEGER L) ! !*********************************************************************** !* OBTAIN NEXT LOOP TO BE OPTIMISED FROM LOOPTAB * !* AND CALL LOOPBUILD TO BUILD THE NECESSARY TABLES. * !* RECURSIVE ROUTINE, SO AS TO PRESENT DEEPEST LOOPS FIRST. * !*********************************************************************** ! %INTEGER DOWN,LOOPPTR ! LOOPPTR = L %CYCLE LL == RECORD (ALOOPS + LOOPPTR) DOWN = LL_DOWN %UNLESS DOWN = 0 %THENSTART LOOPSEL (DOWN) LL == RECORD (ALOOPS + LOOPPTR) %FINISH SAVEPTR = FREETABS LOOP = LOOPPTR NEWENT = CREATETAB (CLOOPSZ) CL == RECORD (ATABS + NEWENT) LOOPENT = LL_BLOCK CL_BLOCK = LOOPENT CL_PDCHAIN = 0 CL_PDBACKCHAIN = 0 CLOOPHEAD = NEWENT DLOOPHEAD = NEWENT PLOOPHEAD = 0 DLOOPTAIL = NEWENT PLOOPTAIL = 0 DLOOPCH = ADDR (CL_PDCHAIN) PLOOPCH = ADDR (PLOOPHEAD) BLKBS(I) = 0 %FOR I = 0,1,BLKBSLENGTH-1 SETBIT (BLKBITS,LOOPENT) BB == RECORD (ABLOCKS + LOOPENT*BLSIZE) LOOPDEPTH = BB_DEPTH BACKTARG = BB_BTARG B1 == ARRAY (ABLOCKS+BB_USE,BF) B2 == ARRAY (ABLOCKS+BB_DEF,BF) %FOR I = 0,1,BSWORDS-1 %CYCLE DLOOPUSE(I) = B1(I) DLOOPDEF(I) = B2(I) %REPEAT BB == RECORD (ABLOCKS + BACKTARG*BLSIZE) OLDBTARGTRIAD = BB_TEXT ! LOOPBUILD ! LOOPPTR = LL_ACROSS %REPEAT %UNTIL LOOPPTR = 0 %END;! LOOPSEL ! ! ! ! %ROUTINE LOOPBUILD ! !******************************************************************* !* BUILD CLOOPTAB & ASSOCIATED BIT STRIPS. * !* IDENTIFY ARTICULATION BLOCKS. * !* CALL OP2A & OP2B. * !******************************************************************* ! %INTEGER EXITCT,EXITBLK,I,J %INTEGER FCON,CLOOPPTR,LEB %INTEGER STACKPTR,TABSTART,TABLEEND,TAB2PTR,TABLE2 %INTEGER ARTI,ARTJ,ARTK ! %FOR I = 0,1,BSWORDS-1 %CYCLE PLOOPUSE(I) = 0 PLOOPDEF(I) = 0 %REPEAT EXITCT = 0 EXITBLK = 0 CLOOPPTR = CLOOPHEAD !* ADD INTO CLOOP ALL FCONS OF ALL CLOOP ENTRIES, PROVIDED INSIDE THE LOOP, !* AND NOT ALREADY IN CLOOP. %WHILE CLOOPPTR < FREETABS %CYCLE CL == RECORD (ATABS + CLOOPPTR) BB == RECORD (ABLOCKS + CL_BLOCK*BLSIZE) FCON = BB_FCON&X'7FFFFFFF' %UNLESS FCON = 0 %THENSTART CN == RECORD (ATABS + FCON) %FOR J = 1,1,CN_COUNT %CYCLE BLOCK = CN_BLOCK(J) %UNLESS BLOCK = 0 %THENSTART BB == RECORD (ABLOCKS + BLOCK*BLSIZE) %IF BB_DEPTH < LOOPDEPTH %THENSTART EXITCT = EXITCT + 1 EXITBLK = CL_BLOCK %FINISHELSESTART !* USE BITSTRIP TO TEST WHETHER THIS BLOCK ALREADY IN CLOOP. GETBIT (BLKBITS,BLOCK,BIT) %IF BIT = 0 %THENSTART SETBIT (BLKBITS,BLOCK) NEWENT = CREATETAB (CLOOPSZ) CL == RECORD (ATABS + NEWENT) CL_BLOCK = BLOCK CL_PDCHAIN = 0 B1 == ARRAY (ABLOCKS+BB_USE,BF) B2 == ARRAY (ABLOCKS+BB_DEF,BF) %IF BB_DEPTH = LOOPDEPTH %THENSTART INTEGER (DLOOPCH) = NEWENT DLOOPCH = ADDR (CL_PDCHAIN) CL_PDBACKCHAIN = DLOOPTAIL DLOOPTAIL = NEWENT %FOR I = 0,1,BSWORDS-1 %CYCLE DLOOPUSE(I) = DLOOPUSE(I) ! B1(I) DLOOPDEF(I) = DLOOPDEF(I) ! B2(I) %REPEAT %FINISHELSESTART INTEGER (PLOOPCH) = NEWENT PLOOPCH = ADDR (CL_PDCHAIN) CL_PDBACKCHAIN = PLOOPTAIL PLOOPTAIL = NEWENT %FOR I = 0,1,BSWORDS-1 %CYCLE PLOOPUSE(I) = PLOOPUSE(I) ! B1(I) PLOOPDEF(I) = PLOOPDEF(I) ! B2(I) %REPEAT %FINISH %FINISH %FINISH %FINISH %REPEAT %FINISH CLOOPPTR = CLOOPPTR + CLOOPSZ %REPEAT CLOOPTAIL = FREETABS - CLOOPSZ %FOR I = 0,1,BSWORDS-1 %CYCLE CLOOPUSE(I) = DLOOPUSE(I) ! PLOOPUSE(I) CLOOPDEF(I) = DLOOPDEF(I) ! PLOOPDEF(I) %REPEAT !************************************************************* !* IDENTIFY & FLAG ARTICULATION BLOCKS. * !************************************************************* !* STACK ALL BACK CONNECTIONS (INSIDE LOOP) OF LOOP ENTRY BLOCK. %UNLESS BACKTARG = 0 %THENSTART TABSTART = FREETABS LL == RECORD (ALOOPS + LOOP) LEB = LL_BLOCK BB == RECORD (ABLOCKS + LEB*BLSIZE) CN == RECORD (ATABS + BB_BCON) NEWENT = CREATETAB (ARTICSZ) AR == RECORD (ATABS + NEWENT) AR_BLOCK = 0 %FOR I = 1,1,CN_COUNT %CYCLE BLOCK = CN_BLOCK(I) BB == RECORD (ABLOCKS + BLOCK*BLSIZE) %UNLESS BB_DEPTH < LOOPDEPTH %THENSTART NEWENT = CREATETAB (ARTICSZ) AR == RECORD (ATABS + NEWENT) AR_BLOCK = BLOCK %FINISH %REPEAT STACKPTR = NEWENT - ARTICSZ BLOCK = AR_BLOCK TABLE2 = FREETABS %IF STACKPTR = TABSTART %THEN ARTI = BLOCK %ELSESTART !* IF MORE THAN ONE BACK CONNECTION, FIND THE COMMON NODE. !* BUILD BACK DOMINATOR CHAIN OF ONE OF BACK CONNECTIONS. NEWENT = CREATETAB (ARTICSZ) AR == RECORD (ATABS + NEWENT) AR_BLOCK = BLOCK %WHILE BLOCK # LEB %CYCLE BB == RECORD (ABLOCKS + BLOCK*BLSIZE) BLOCK = BB_BDOM NEWENT = CREATETAB (ARTICSZ) AR_BLOCK = BLOCK %REPEAT TABLEEND = FREETABS ARTK = TABLE2 %WHILE STACKPTR # TABSTART %CYCLE AR == RECORD (ATABS + STACKPTR) STACKPTR = STACKPTR - ARTICSZ ARTI = AR_BLOCK %CYCLE TAB2PTR = ARTK %WHILE TAB2PTR # TABLEEND %CYCLE AR == RECORD (ATABS + TAB2PTR) -> L1 %IF AR_BLOCK = ARTI TAB2PTR = TAB2PTR + ARTICSZ %REPEAT BB == RECORD (ABLOCKS + ARTI*BLSIZE) ARTI = BB_BDOM %REPEAT L1: ARTK = TAB2PTR %REPEAT %FINISH !* ARTI IS NOW COMMON DOMINATOR. !* NOW BUILD STACK OF DOMINATOR BLOCKS WHICH ARE ARTICULATION CANDIDATES. FREETABS = TABSTART + ARTICSZ %WHILE ARTI # LEB %CYCLE BB == RECORD (ABLOCKS + ARTI*BLSIZE) %UNLESS BB_DEPTH > LOOPDEPTH %THENSTART NEWENT = CREATETAB (ARTICSZ) AR == RECORD (ATABS +NEWENT) AR_BLOCK = ARTI ARTI = BB_BDOM %FINISHELSE ARTI = BB_BTARG %REPEAT STACKPTR = FREETABS - ARTICSZ TABLE2 = FREETABS AR == RECORD (ATABS + TABSTART + ARTICSZ) !* TEST FOR NORMAL LOOP, I.E. ONLY ONE EXIT. %IF EXITCT = 1 %AND EXITBLK = AR_BLOCK %THENSTART BB == RECORD (ABLOCKS + LEB*BLSIZE) BB_FLAGS = BB_FLAGS ! ARTICBIT STACKPTR = TABSTART + ARTICSZ %WHILE STACKPTR # FREETABS %CYCLE AR == RECORD (ATABS + STACKPTR) BB == RECORD (ABLOCKS + AR_BLOCK*BLSIZE) BB_FLAGS = BB_FLAGS ! ARTICBIT STACKPTR = STACKPTR + ARTICSZ %REPEAT %FINISHELSESTART %CYCLE BB == RECORD (ABLOCKS + ARTI*BLSIZE) BB_FLAGS = BB_FLAGS ! ARTICBIT FREETABS = TABLE2 %EXIT %IF STACKPTR = TABSTART AR == RECORD (ATABS + STACKPTR) STACKPTR = STACKPTR - ARTICSZ ARTJ = AR_BLOCK NEWENT = CREATETAB (ARTICSZ*2) AR == RECORD (ATABS + NEWENT) AR_BLOCK = ARTJ ARTK = NEWENT + ARTICSZ AR == RECORD (ATABS + ARTK) AR_BLOCK = ARTI %CYCLE BLOCK = AR_BLOCK BB == RECORD (ABLOCKS + BLOCK*BLSIZE) -> L4 %IF BB_DEPTH < LOOPDEPTH CN == RECORD (ATABS + BB_FCON) !* ADD ALL FCONS TO TABLE, UNLESS ALREADY THERE. %FOR I = 1,1,CN_COUNT %CYCLE FCON = CN_BLOCK(I) TAB2PTR = TABLE2 %CYCLE AR == RECORD (ATABS + TAB2PTR) -> L3 %IF AR_BLOCK = FCON TAB2PTR = TAB2PTR + ARTICSZ %REPEAT %UNTIL TAB2PTR = FREETABS NEWENT = CREATETAB (ARTICSZ) AR == RECORD (ATABS + NEWENT) AR_BLOCK = FCON L3: %REPEAT ARTK = ARTK + ARTICSZ %REPEAT %UNTIL ARTK = FREETABS ARTI = ARTJ %REPEAT %FINISH L4: FREETABS = TABSTART %FINISH ! !* DIAGNOSTICS FOR EACH LOOP IDENTIFIED. %IF TRACE # 0 %THENSTART NEWLINE PRINTSTRING ("LOOPDATA BEFORE OP2A") NEWLINE NEWLINE PRINTSTRING ("CLOOP (* = ARTIC): ") %FOR CLOOPPTR = CLOOPHEAD,CLOOPSZ,CLOOPTAIL %CYCLE CL == RECORD (ATABS + CLOOPPTR) BLOCK = CL_BLOCK WRITE (BLOCK,4) BB == RECORD (ABLOCKS + BLOCK*BLSIZE) PRINTSTRING ("*") %IF BB_FLAGS & ARTICBIT # 0 %REPEAT NEWLINE PRINTSTRING ("DLOOP: ") CLOOPPTR = DLOOPHEAD %WHILE CLOOPPTR # 0 %CYCLE CL == RECORD (ATABS + CLOOPPTR) WRITE (CL_BLOCK,4) CLOOPPTR = CL_PDCHAIN %REPEAT NEWLINE PRINTSTRING ("PLOOP: ") CLOOPPTR = PLOOPHEAD %WHILE CLOOPPTR # 0 %CYCLE CL == RECORD (ATABS + CLOOPPTR) WRITE (CL_BLOCK,4) CLOOPPTR = CL_PDCHAIN %REPEAT NEWLINE PRINTSTRING ("LOOP= ") WRITE (LOOP,3) PRINTSTRING (" BACKTARG= ") WRITE (BACKTARG,3) PRINTSTRING (" LOOPDEPTH= ") WRITE (LOOPDEPTH,2) PRINTSTRING (" LOOPENT= ") WRITE (LOOPENT,3) NEWLINE PRINTSTRING ("CLOOPUSE: ") PRINTBS (CLOOPUSE) PRINTSTRING ("CLOOPDEF: ") PRINTBS (CLOOPDEF) %FINISH ! %IF INHIBMASK & INHIBOP2A = 0 %THEN OP2A ! !* MORE LOOP-LEVEL DIAGNOSTICS. %IF TRACE # 0 %THENSTART NEWLINE NEWLINE PRINTSTRING ("BACK TARGET & CLOOP BLOCKS AFTER OP2A") NEWLINE NEWLINE %UNLESS BACKTARG = 0 %THENSTART PRBLOCK (BACKTARG) PRBLTRIADS (BACKTARG) %FINISH %FOR CLOOPPTR = CLOOPHEAD,CLOOPSZ,CLOOPTAIL %CYCLE CL == RECORD (ATABS + CLOOPPTR) PRBLOCK (CL_BLOCK) PRBLTRIADS (CL_BLOCK) %REPEAT %FINISH ! %UNLESS BACKTARG = 0 %THENSTART ! STRENGTHRED ! !* AND YET MORE LOOP-LEVEL DIAGNOSTICS. %IF SRFLAGS & 4 # 0 %THENSTART NEWLINE NEWLINE PRINTSTRING (" BACK TARGET & CLOOP BLOCKS AFTER OP2B") NEWLINE NEWLINE PRBLOCK (BACKTARG) PRBLTRIADS (BACKTARG) %FOR CLOOPPTR = CLOOPHEAD,CLOOPSZ,CLOOPTAIL %CYCLE CL == RECORD (ATABS + CLOOPPTR) PRBLOCK (CL_BLOCK) PRBLTRIADS (CL_BLOCK) %REPEAT %FINISH %FINISH ! FREETABS = SAVEPTR;! DELETE ALL OP2 TABLES. ! %END;! LOOPBUILD ! ! ! ! %ROUTINE OP2A ! !**************************************************************** !* HAVING BUILT UP ALL THE DATA FOR A LOOP, INVOKE THE VARIOUS * !* OPTIMISATION PROCESSES IN OP2A. * !**************************************************************** ! %EXTERNALROUTINESPEC EDUMPTRACE %EXTERNALROUTINESPEC CDUMPTRACE ! %INTEGER OP,I,NEXT,STOB ! %RECORD (PRECF) %NAME DD ! DLOOPPTR = DLOOPHEAD %CYCLE CL == RECORD (ATABS + DLOOPPTR) CURRBLK = CL_BLOCK %UNLESS OLDBTARGTRIAD = 0 %THENSTART NEXT = OLDBTARGTRIAD TT == RECORD (ATRIADS + NEXT*TRIADLENGTH) %CYCLE BTARGTRIAD = NEXT NEXT = TT_CHAIN TT == RECORD (ATRIADS + NEXT*TRIADLENGTH) %REPEAT %UNTIL TT_OP = GOTO %OR %C (TT_OP = STMT %AND TT_USE & SOB # 0) OLDBTARGTRIAD = BTARGTRIAD %FINISH BB == RECORD (ABLOCKS + CURRBLK*BLSIZE) STOB = BB_TEXT ! !* FIRST DO SUBSUMPTION FOR WHOLE BLOCK. CURRTRIAD = STOB %WHILE NEXTTRIAD = 1 %CYCLE TT == RECORD (ATRIADS + CURRTRIAD*TRIADLENGTH) TT_OP = TT_OP & BMBITOFF ;! CLEAR BACKMOVED FLAG %IF INHIBMASK & INHIBSUBSUM = 0 %THEN SUBSUM %REPEAT %IF INHIBMASK & INHIBSUBSUM = 0 %THEN SUBSEOB CURRDEF(I) = 0 %FOR I = 0,1,BSWORDS-1 ! !* NOW ALL THE EXPRESSION OPTIMISATIONS FOR WHOLE BLOCK. SETBMTRACE CDUMPTRACE CURRTRIAD = STOB %WHILE NEXTTRIAD = 1 %CYCLE %IF INHIBMASK & INHIBEXPOPTS = 0 %THENSTART TT == RECORD (ATRIADS + CURRTRIAD*TRIADLENGTH) OP = TT_OP %IF OP = DIV %THENSTART OPTDIV TT == RECORD (ATRIADS + CURRTRIAD*TRIADLENGTH) OP = TT_OP %FINISH %IF OP = ADD %OR OP = SUB %OR OP = MULT %THENSTART CONELIM FACTORISE LINEARISE TT == RECORD (ATRIADS + CURRTRIAD*TRIADLENGTH) OP = TT_OP %FINISH %IF OP = NEG %THENSTART OPTNEG %FINISHELSEIF OP = CVT %THENSTART OPTCVT %FINISHELSEIF JIT <= OP <= JIZ %THENSTART FLOWOFCONT %FINISHELSEIF OP = EXP %THENSTART OPTEXP %FINISHELSEIF OP = IFUN %THENSTART OPTFUN ;! LIBRARY FUNCTIONS ONLY. %FINISH %FINISH %IF INHIBMASK & INHIBBMOVE = 0 %THENSTART BACKMOVE %UNLESS BACKTARG = 0 %FINISH UPDATECURRDEF %REPEAT ! !* FINALLY DO EXPRESSION ELIMINATION FOR THE WHOLE BLOCK (BUT FIRST !* FOR THE BACK TARG BLOCK IF THIS EXISTS & HAS BEEN ADDED TO). EDUMPTRACE EXPELBTARG %UNLESS OLDBTARGTRIAD = 0 %OR %C OLDBTARGTRIAD = BTARGTRIAD CURRTRIAD = STOB CURRDEF(I) = 0 %FOR I = 0,1,BSWORDS-1 EXPELIM DLOOPPTR = CL_PDCHAIN %REPEAT %UNTIL DLOOPPTR = 0 ! %END;! OP2A ! %END;! OP2 ! ! ! ! !* !*********************************************************************** !* * !*********************************************************************** !* * !* B A C K M O V E * !* * !*********************************************************************** !* * !*********************************************************************** ! ! %EXTERNALROUTINE BACKMOVE ! %ROUTINESPEC MOVEOP (%RECORD (RESF) %NAME OPD) %ROUTINESPEC BTBITS (%INTEGER ID) %INTEGERFUNCTIONSPEC BMOVCHECK %INTEGERFUNCTIONSPEC BREAKOUT (%INTEGER TR) %INTEGERFUNCTIONSPEC BREAKIN (%INTEGER TR) %INTEGERFUNCTIONSPEC LCON (%RECORD (RESF) OPD) %INTEGERFUNCTIONSPEC BREAKCHECK (%INTEGER TR) %INTEGERFUNCTIONSPEC BRNEW %INTEGERFUNCTIONSPEC OPSCOM %ROUTINESPEC SWAP ! ! ! %CONSTBYTEINTEGERARRAY OPSTAB (0:116) = %C X'00', X'00', X'47', X'47', { NULL (01) ADD SUB X'47', X'07', X'05', X'33', { MULT DIV NEG ASMT X'03', X'13', X'00', X'00', { CVT ARR ARR1 BOP X'00', X'00', X'07', X'07', { ASGN (0D) EXP EXP3 X'07', X'07', X'05', X'07', { AND OR NOT EQUIV X'07', X'07', X'07', X'07', { NEQ GT LT NE X'07', X'07', X'07', X'00', { EQ GE LE SUBSTR X'00', X'00', X'00', X'00', { CHAR CONCAT CHHEAD (1F) X'00', X'00', X'00', X'00', { STOD1 STOD2 STODA (23) X'00', X'00', X'00', X'00', { EOD1 EOD2 EODA EODB X'07', X'11', X'07', X'07', { BRK DEFARR RSUB RDIV X'00', X'07', X'00', X'00', { DCHAR ASH (2E) X'00', X'00', X'00', X'00', { STRTIO IOITEM IODO IOSPEC X'00', X'00', X'00', X'00', { IO DIOITEM (36) X'00', X'03', X'02', X'00', { (38) ARGARR INIT INCR X'00', X'00', X'00', X'00', { DECR DINIT PINCR (3F) X'00', X'21', X'00', X'01', { NOOP FUN SUBR ARG X'00', X'00', X'00', X'21', { STRTSF ENDSF CALLSF IFUN X'00', X'01', X'00', X'01', { DARG IARG REPL REF X'00', X'00', X'01', X'00', { LOADB STOREB MOO (4F) X'04', X'04', X'04', X'04', { JIT JIF JINN JINP X'04', X'04', X'04', X'04', { JINZ JIN JIP JIZ X'04', X'04', X'00', X'00', { CGT GOTO RET STOP X'00', X'00', X'07', X'07', { PAUSE EOT NINT ANINT X'00', X'00', X'00', X'00', { STMT ITS PA TOCHAR X'07', X'07', X'07', X'07', { DIM DMULT AINT ABS X'07', X'07', X'07', X'07', { MOD SIGN MIN MAX X'07', X'07', X'06', X'07', { REALL IMAG CMPLX CONJG X'07', X'07', X'07', X'07', { LEN ICHAR CHIND DCMPLX X'21' { INTRIN ! ! %RECORD (BLRECF) %NAME BB %RECORD (TRIADF) %NAME TT,TT1,TT2 %RECORD (PRECF) %NAME DD %RECORD (CLOOPRECF) %NAME CL %RECORD (CONRECF) %NAME CN %RECORD (RESF) OPD ! ! %INTEGER LINK,ACTNO,LINKPREV,LINKCHAIN,CONSTRIDS %INTEGER NEWENT,CONFLAG,OP,ACTION %INTEGER OPS,CLASS,COORD,TEXT,ID,WOPD,OLDOP2,LCON1,LCON2 %INTEGER DEF,BLOCK,BITS1,BITS2,VAL1,VAL2,CNBLOCK %INTEGER DLOOPPTR,I,SAVEPTR,TABPTR,TABPTR2,TRID %CONSTINTEGER IDBIT = 16 ! ! !****************************************************************** !* MOVE LOOP-CONSTANT TRIADS INTO BACK TARGET BLOCK. * !****************************************************************** ! ACTION = BMOVCHECK TT == RECORD (ATRIADS + CURRTRIAD*TRIADLENGTH) %IF ACTION = 1 %THENSTART ! !* TRIAD CANNOT BE BACKWARD MOVED. TRY TO MOVE A SINGLE OPERAND !* WHICH IS A LOOP CONSTANT COMMON VARIABLE. ! %IF OPS & 4 # 0 %AND TT_QOPD1 = CSCALID %AND %C TT_MODE # CHARMODE %THENSTART %IF LOOPCON1 (CURRTRIAD) = 1 %THEN MOVEOP (TT_RES1) %FINISH %IF OPS & 2 # 0 %AND TT_QOPD2 = CSCALID %AND %C TT_MODE # CHARMODE %THENSTART %IF LOOPCON2 (CURRTRIAD) = 1 %THEN MOVEOP (TT_RES2) %FINISH %FINISHELSEUNLESS ACTION = 0 %THENSTART ! !* PERFORM BACKWARD MOVEMENT. UPDATE BITSTRIPS & RECHAIN TRIAD. ! %IF ACTION = 2 %AND TT_QOPD1 & IDBIT # 0 %THEN BTBITS (TT_OPD1) %IF TT_QOPD2 & IDBIT # 0 %THEN BTBITS (TT_OPD2) TT_OP = TT_OP ! BMBIT TT2 == RECORD (ATRIADS + PREVTRIAD*TRIADLENGTH) TT2_CHAIN =TT_CHAIN TT2 == RECORD (ATRIADS + BTARGTRIAD*TRIADLENGTH) TT_CHAIN = TT2_CHAIN TT2_CHAIN = CURRTRIAD BTARGTRIAD = CURRTRIAD %IF BMTRACE#0 %START PRINTSTRING("TRIAD HAS BEEN BACKWARD MOVED - ") NEWLINE PRINTTR(BTARGTRIAD,ADICT,ANAMES,0,TT) %FINISH CURRTRIAD = PREVTRIAD %FINISH ! ! ! ! %INTEGERFUNCTION BMOVCHECK ! !*********************************************************************** !* CHECK WHETHER BACKWARD MOVEMENT IS POSSIBLE, AND RETURN ONE * !* OF FOUR VALUES: * !* 0. NO BACKWARD MOVEMENT POSSIBLE. * !* 1. TRIAD CANNOT BE MOVED. TRY ONE OF OPERANDS. * !* 2. MOVE THE TRIAD. * !* 3. MOVE TRIAD (ASGN OR ASMT) * !*********************************************************************** ! BB == RECORD (ABLOCKS + CURRBLK*BLSIZE) %IF OPT = 1 %AND BB_FLAGS & ARTICBIT = 0 %THEN %RESULT = 0 TT == RECORD (ATRIADS + CURRTRIAD*TRIADLENGTH) !************************************************************************* !* PICK UP CLASS OF TRIAD FROM TABLE: * !* B5 = OPD 1 CANDIDATE FOR COMMON VARIABLE REMOVAL * !* B6 = OPD 2 CANDIDATE FOR COMMON VARIABLE REMOVAL * !* B7 = CANDIDATE FOR BACKWARD MOVEMENT, WITH B0-3 CONTAINING * !* SUBCLASSIFICATION * !************************************************************************* OPS = OPSTAB(TT_OP) %UNLESS OPS & X'F1' # 0 %THEN %RESULT = 1 !* !* TRIAD IS A CANDIDATE FOR BACKWARD MOVEMENT. DO FURTHER CHECKS ACCORDING !* TO SUBCLASS. ! CLASS = OPS >> 4 %IF BMTRACE#0 %THENSTART PRINTSTRING("CURRTRIAD IS A CANDIDATE FOR BACKWARD MOVEMENT - ") NEWLINE PRINTTR(CURRTRIAD,ADICT,ANAMES,0,TT) %FINISH %IF CLASS = 0 %THENSTART ! !* UNCLASSIFIED TRIAD ! ------------------ %IF LOOPCON1 (CURRTRIAD) = 1 %AND LOOPCON2 (CURRTRIAD) = 1 %THENSTART %IF TT_MODE=CHARMODE %AND NEQ<=TT_OP<=LE %THEN %RESULT = 1 %ELSE %RESULT = 2 %FINISH %ELSE %RESULT=1 %FINISH %IF CLASS = 1 %THENSTART ! !* ARR OR DEFARR TRIAD ! ------------------- %IF LOOPCON2 (CURRTRIAD) = 1 %THENSTART %IF LOOPCON1 (CURRTRIAD) = 1 {%OR TT_OP = DEFARR} %C %THEN %RESULT = 2 %ELSE %RESULT = 0 %FINISH !* OPD 2 IS VARIABLE, & SO A CANDIDATE FOR BREAK UP !* (IF A TEXT POINTER, AND NOT COMPLEX). %IF TT_QOPD2 & TEXTMASK = 0 %OR %C CMPLX8 <= TT_MODE <= CMPLX32 %THEN %RESULT = 0 CONFLAG = 0 %UNLESS BREAKCHECK (TT_OPD2) = 1 %AND CONFLAG = 1 %THEN %RESULT = 0 TT2 == RECORD (ATRIADS + CURRTRIAD*TRIADLENGTH) WOPD = BREAKOUT (TT2_OPD2) NEWENT = BRNEW TT == RECORD (ATRIADS + NEWENT*TRIADLENGTH) TT_RES2_W = WOPD TT_OP = DEFARR ! BMBIT TT_RES1 = TT2_RES1 %IF TT_QOPD1 & IDBIT # 0 %THEN BTBITS (TT_OPD1) %IF TT_QOPD2 & IDBIT # 0 %THEN BTBITS (TT_OPD2) TT2_QOPD1 = TRIAD TT2_OPD1 = NEWENT OLDOP2 = TT2_OPD2 %IF BMTRACE#0 %THENSTART PRINTSTRING("BMOVCHECK:PLANT TRIAD IN BACK TARGET - ") NEWLINE PRINTTR(NEWENT,ADICT,ANAMES,0,TT) %FINISH TT2_RES2_W = BREAKIN (OLDOP2) %IF TT2_QOPD2 & TEXTMASK # 0 %THENSTART TT == RECORD (ATRIADS + TT2_OPD2*TRIADLENGTH) TT_USE = TT_USE + 1 %FINISH DELUSE (OLDOP2) %IF BMTRACE#0 %THENSTART PRINTSTRING("CURRTRIAD BECOMES - ") NEWLINE PRINTTR(CURRTRIAD,ADICT,ANAMES,0,TT2) %FINISH %RESULT = 0 %FINISH %IF CLASS = 2 %THENSTART ! !* FUN OR IFUN TRIAD ! ----------------- DD == RECORD (ADICT + TT_OPD1 << DSCALE) %IF DD_X0 & 3 = 0 %THEN %RESULT = 0 ;! USER FUN. %IF LOOPCON2 (CURRTRIAD) = 1 %THEN %RESULT = 2 ;! LIB FUN, CONST ARG %RESULT = 1 %FINISH %IF CLASS = 3 %THENSTART ! !* ASGN OR ASMT TRIAD ! ------------------ %UNLESS LOOPCON2 (CURRTRIAD) = 1 %THEN %RESULT = 0 %IF BB_FLAGS & ARTICBIT = 0 %THEN %RESULT = 1 %IF TT_QOPD1 & TEXTMASK # 0 %THENSTART ;! MUST BE DEFARR. %UNLESS LOOPCON1 (CURRTRIAD) = 1 %THEN %RESULT = 1 TEXT = TT_OPD1 TT == RECORD (ATRIADS + TEXT*TRIADLENGTH) %FINISH ID = TT_OPD1 DD == RECORD (ADICT + ID< LOOPDEPTH %THENSTART CNBLOCK = BB_BTARG -> L1 %FINISH %IF BB_DEPTH = LOOPDEPTH %THENSTART %FOR TABPTR2 = SAVEPTR,W1,FREETABS-W1 %CYCLE %IF INTEGER (TABPTR2+ATABS) = CNBLOCK %THEN -> L2 %REPEAT TABPTR2 = CREATETAB (W1) INTEGER (TABPTR2+ATABS) = CNBLOCK %FINISH L2: %FINISH %REPEAT %FINISH %IF TABPTR = FREETABS %THENSTART FREETABS = SAVEPTR BB == RECORD (ABLOCKS + BACKTARG*BLSIZE) SETBIT (ABLOCKS+BB_DEF,COORD) BB == RECORD (ABLOCKS + CURRBLK*BLSIZE) CLEARBIT (ABLOCKS+BB_DEF,COORD) GETBIT (ABLOCKS+BB_USE,COORD,VAL1) %IF VAL1 = 1 %THEN SETBIT (ABLOCKS+BB_BOE,COORD) %RESULT = 3 %FINISH BB == RECORD (ABLOCKS + BLOCK*BLSIZE) GETBIT (ABLOCKS+BB_USE,COORD,VAL1) %IF VAL1 = 0 %THENSTART FREETABS = SAVEPTR %RESULT = 1 %FINISH BLOCK = INTEGER (TABPTR+ATABS) TABPTR = TABPTR + W1 %REPEAT %FINISH %IF CLASS = 4 %THENSTART ! !* ADD, SUB, MULT, MAX, MIN TRIADS ! ------------------------------- CONSTRIDS = (LOOPCON1 (CURRTRIAD) << 1) + LOOPCON2 (CURRTRIAD) %UNLESS CONSTRIDS = 0 %THENSTART %IF CONSTRIDS = 3 %THEN %RESULT = 2;! BOTH CONST. DO BACK MOVE. %IF CONSTRIDS = 2 %THENSTART %IF TT_QOPD2 & TEXTMASK = 0 %THEN %RESULT = 1;! NO LINK TRIAD. TRY TO MOVE OPD. LINK = TT_OPD2 ACTNO = 2 %FINISHELSESTART %IF TT_QOPD1 & TEXTMASK = 0 %THEN %RESULT = 1 LINK = TT_OPD1 ACTNO = 0 %FINISH ! !* ONE CONST OPD & ONE TRIAD PTR. TRY FOR BACKWARD MOVEMENT BY ASSOCIATION. !* (VAR + CONST1) + CONST2: TRY TO SWAP VAR & CONST2. TT1 == RECORD (ATRIADS + LINK*TRIADLENGTH) %IF TT1_USE # 1 %THEN %RESULT = 1 %IF OPSCOM = 0 %THEN %RESULT = 1;! INVALID COMBINATION OF OPERATORS. %IF LOOPCON2 (LINK) = 0 %THENSTART %IF LOOPCON1 (LINK) = 0 %THEN %RESULT = 1 ACTNO = ACTNO ! 1 %FINISH SWAP ;! SWAPS OPERANDS ACCORDING TO VALUE OF ACTNO. !* LINK NOW CONTAINS TWO CONSTANTS. CHAIN INTO BACK TARGET. LINKPREV = BB_TEXT %CYCLE TT == RECORD (ATRIADS + LINKPREV*TRIADLENGTH) %IF TT_CHAIN = LINK %THEN %EXIT LINKPREV = TT_CHAIN %REPEAT TT1_OP = TT1_OP ! BMBIT TT_CHAIN =TT1_CHAIN TT == RECORD (ATRIADS +BTARGTRIAD*TRIADLENGTH) TT1_CHAIN = TT_CHAIN TT_CHAIN = LINK BTARGTRIAD = LINK %IF TT1_QOPD1 & IDBIT # 0 %THEN BTBITS (TT1_OPD1) %IF TT1_QOPD2 & IDBIT # 0 %THEN BTBITS (TT1_OPD2) %IF BMTRACE#0 %THENSTART PRINTSTRING("BMOVCHECK:MOVE TRIAD TO BACK TARGET - ") NEWLINE PRINTTR(LINK,ADICT,ANAMES,0,TT1) %FINISH %RESULT = 0 %FINISH ! !* BOTH OPERANDS VARIABLE. TRY FOR CONSTANT DESCENT. !* (CONST + VAR1) + VAR2: TRY TO SWAP CONST & VAR2. %IF TT_QOPD1 & TEXTMASK # 0 %THENSTART %IF TT_QOPD2 & TEXTMASK # 0 %THEN %RESULT = 0 LINK = TT_OPD1 ACTNO = 0 OPD = TT_RES2 %FINISHELSESTART %IF TT_QOPD2 & TEXTMASK = 0 %THEN %RESULT = 0 LINK = TT_OPD2 ACTNO = 2 OPD = TT_RES1 %FINISH TT1 == RECORD (ATRIADS + LINK*TRIADLENGTH) %IF TT1_USE # 1 %THEN %RESULT = 0 %IF OPSCOM = 0 %THEN %RESULT = 0 %IF LOOPCON1 (LINK) = 0 %THENSTART %IF LOOPCON2 (LINK) = 0 %THEN %RESULT = 0 ACTNO = ACTNO + 1 %FINISH %IF OPD_FORM & IDBIT # 0 %THENSTART DD == RECORD (ADICT + OPD_H0 << DSCALE) COORD = DD_COORD !* CHECK THAT WE ARE NOT TRYING TO MOVE A USE OF A LOOP VARIABLE !* BACKWARDS OVER ITS DEFINITION. LINKCHAIN = TT1_CHAIN %WHILE LINKCHAIN # CURRTRIAD %CYCLE DEF = ALLDEF (LINKCHAIN) %UNLESS DEF = 0 %THENSTART %IF DEF < 0 %THENSTART %IF COORD = 1 %THEN %RESULT = 0 %C %ELSE DEF = - DEF %FINISH %IF DEF = COORD %THEN %RESULT = 0 %IF DEF = 1 %AND DD_CLASS & CMNBIT # 0 %THEN %RESULT = 0 %FINISH TT2 == RECORD (ATRIADS + LINKCHAIN*TRIADLENGTH) LINKCHAIN = TT2_CHAIN %REPEAT %FINISH SWAP ;! SWAPS OPERANDS ACCORDING TO SETTING OF ACTNO. %RESULT = 0 %FINISH ! %END ;! BMOVCHECK ! ! ! ! %ROUTINE MOVEOP (%RECORD (RESF) %NAME OPD) ! !******************************************************************* !* MOVE A LOOP CONSTANT COMMON OPERAND TO THE BACK TARGET. * !******************************************************************* NEWENT = BRNEW TT1 == RECORD (ATRIADS + NEWENT*TRIADLENGTH) TT1_OP = REF ! BMBIT TT1_RES1_W = OPD_W TT1_RES2_W = 0 BTBITS (OPD_H0) OPD_H0 = BTARGTRIAD OPD_FORM = TRIAD TREVERSE(CURRTRIAD) %IF BMTRACE#0 %THENSTART PRINTSTRING("MOVEOP:PLANT TRIAD IN BACK TARGET - ") NEWLINE PRINTTR(NEWENT,ADICT,ANAMES,0,TT1) PRINTSTRING("CURRTRIAD BECOMES - ") NEWLINE PRINTTR(CURRTRIAD,ADICT,ANAMES,0,TT) %FINISH ! %END;! MOVEOP ! ! ! ! %ROUTINE BTBITS (%INTEGER ID) ! !********************************************************************* !* SET RELEVANT BITS IN THE BACK TARGET BIT STRIPS. * !********************************************************************* ! DD == RECORD (ADICT + ID< CURRTRIAD * !* TT1 -> LINK. * !* RETURNS 1 IF OPERATORS ARE A VALID COMBINATION, ELSE 0 * !*********************************************************************** ! %INTEGER OP ! OP = TT_OP %IF OP = TT1_OP %THENSTART %IF OP = SUB %THEN ACTNO = ACTNO ! 12 %RESULT = 1 %FINISH %IF OP = ADD %AND TT1_OP = SUB %THENSTART ACTNO = ACTNO ! 4 %RESULT = 1 %FINISH %IF OP # SUB %OR TT1_OP # ADD %THEN %RESULT = 0 ACTNO =ACTNO ! 8 %RESULT = 1 ! %END ;! OPSCOM ! ! ! ! %ROUTINE SWAP ! !******************************************************************************** !* INTERCHANGE OPERANDS FOR CONSTANT DESCENT, ADJUSTING OPERATORS AS NECESSARY. * !* ON ENTRY TT -> CURRTRIAD * !* TT1 -> LINK * !* ACTNO: 1-BIT SET TO SWAP OPD2 OF LINK (ELSE OPD1) * !* 2-BIT SET TO SWAP OPD1 OF CURRTRIAD (ELSE OPD2) * !* 4-BIT SET FOR A + (B - C) * !* 8-BIT SET FOR A - (B + C) * !* 4 & 8 BITS SET FOR A - (B - C). * !******************************************************************************** ! %INTEGER OP %INTEGERNAME AD %RECORD (RESF) OPD %CONSTBYTEINTEGERARRAY ACTS (5:15) = 1,0,9,17,1,10,26,12,0,12,0 ! %IF ACTNO & 1 = 0 %THENSTART OPD = TT1_RES1 AD == TT1_RES1_W %FINISHELSESTART OPD = TT1_RES2 AD == TT1_RES2_W %FINISH %IF ACTNO & 2 = 0 %THENSTART AD = TT_RES2_W TT_RES2 = OPD %FINISHELSESTART AD = TT_RES1_W TT_RES1 = OPD %FINISH ! !* SOME COMBINATIONS OF OPERATORS REQUIRE SWAPPING OF EITHER OPERATORS !* OR OPERANDS, AS DEFINED IN A SECOND SET OF ACTIONS. %UNLESS ACTNO < 5 %THENSTART ACTNO = ACTS (ACTNO) %IF ACTNO & 1 # 0 %THENSTART ;! SWAP OPERATORS BETWEEN CURR & LINK OP = TT_OP TT_OP = TT1_OP TT1_OP = OP %FINISHELSEIF ACTNO & 2 # 0 %THEN TT1_OP = SUB %C %ELSEIF ACTNO & 4 # 0 %THEN TT1_OP = ADD %IF ACTNO & 8 # 0 %THENSTART ;! SWAP OPERANDS OF CURR. OPD = TT_RES1 TT_RES1 = TT_RES2 TT_RES2 = OPD %FINISH %IF ACTNO & 16 # 0 %THENSTART ;! SWAP OPERANDS OF LINK. OPD = TT1_RES1 TT1_RES1 = TT1_RES2 TT1_RES2 = OPD %FINISH %FINISH !* ENSURE NEW OPERANDS ARE IN CORRECT ORDER OF PRECEDENCE TREVERSE(CURRTRIAD) TREVERSE(LINK) %IF BMTRACE#0 %THENSTART PRINTSTRING("SWAP:LINK TRIAD BECOMES - ") NEWLINE PRINTTR(LINK,ADICT,ANAMES,0,TT1) PRINTSTRING("CURRTRIAD BECOMES - ") NEWLINE PRINTTR(CURRTRIAD,ADICT,ANAMES,0,TT) %FINISH ! %END ;! SWAP ! ! %END;! BACKMOVE ! %ENDOFFILE