Trailing-Edge
-
PDP-10 Archives
-
fortv11
-
defpt.bli
There are 26 other files named defpt.bli in the archive. Click here to see a list.
!COPYRIGHT (c) DIGITAL EQUIPMENT CORPORATION 1972, 1987
!ALL RIGHTS RESERVED.
!
!THIS SOFTWARE IS FURNISHED UNDER A LICENSE AND MAY BE USED AND COPIED
!ONLY IN ACCORDANCE WITH THE TERMS OF SUCH LICENSE AND WITH THE
!INCLUSION OF THE ABOVE COPYRIGHT NOTICE. THIS SOFTWARE OR ANY OTHER
!COPIES THEREOF MAY NOT BE PROVIDED OR OTHERWISE MADE AVAILABLE TO ANY
!OTHER PERSON. NO TITLE TO AND OWNERSHIP OF THE SOFTWARE IS HEREBY
!TRANSFERRED.
!
!THE INFORMATION IN THIS SOFTWARE IS SUBJECT TO CHANGE WITHOUT NOTICE
!AND SHOULD NOT BE CONSTRUED AS A COMMITMENT BY DIGITAL EQUIPMENT
!CORPORATION.
!
!DIGITAL ASSUMES NO RESPONSIBILITY FOR THE USE OR RELIABILITY OF ITS
!SOFTWARE ON EQUIPMENT WHICH IS NOT SUPPLIED BY DIGITAL.
!AUTHOR NORMA ABEL/HPW/JNG/DCE/TFV/EGM/CKS/AHM/TJK/AlB/MEM
MODULE DEFPT(RESERVE(0,1,2,3),SREG=#17,VREG=#15,FREG=#16,DREGS=4)=
BEGIN
GLOBAL BIND DEFPTV = #11^24 + 0^18 + #4517; ! Version Date: 4-Oct-85
%(
***** Begin Revision History *****
92 ----- ----- GENERATE DEFPTS IN I/O LISTS
93 ----- ----- REMOVE 2ND PARAMTER TO GETDEF
94 ----- ----- MAKE SETGTRD GLOBAL AND RETURN A VALUE INSTEAD
OF SETTING GOTVAL
95 ----- ----- ADD ELIST HANDLING TO ALL LEVELS
96 ----- ----- PUT PARAMETER TO GETDEF BACK
97 ----- ----- FIX DEF1 TO PREVENT MOTION INTO DO LOOPS
THAT HAPPEN TO BE TOP[BUSY] = TOP[SRCLINK]
98 ----- ----- CALL IOSTDFPT FOR ENCODE/DECODE/READ/WRITE
99 ----- ----- EXTRACT CASE STATEMENT FROM SETGTRD AND
MAKE A GLOBAL ROUTINE READHERE
100 ----- ----- ADD REREDID TO I/O OPTIMIZATIONS
101 ----- ----- FIX SETONSUC SERIOUS CONCEPT PROBLEM
CAUSING INCORRECT MOTION
102 ----- ----- FIXES TO LOKELIST, READHERE, AND SETGTRD
FOR I/O OPTIMIZATION
103 ----- ----- SELECT AND SET VARIABLES ASSIGNED ON
THE I/O LIST
104 ----- ----- CLEAN UP AND CREATE DEFWORK
105 ----- ----- FIX 104
106 ----- ----- ADD CODE FOR MOTION OF SIMPLE ASSIGNMENTS
107 ----- ----- FIX 106
108 ----- ----- ADD CODE FOR ARRAY COMMON SUB EXPRESSIONS
109 ----- ----- MOVE CALL TO CLEABUP OUT OF DEFDRI INTO
PROPAGATE
110 ----- ----- FIX LABEL TEST IN SPECBRCHK
111 ----- ----- SORT MULTIPLY NODES FOR BETTER REDUCTION
112 ----- ----- MAKE DEF PT STUFF IN GENERAL AWARE OF THE
FACT THAT AN IMPLIED DO LOOP CHANGES THE
VALUE OF THE DO LOOP INDEX
113 ----- ----- SELECTIT, ETC. IS MISHANDLING LABELS
114 ----- ----- DEFWORK NOT TAKING ACCOUNT OF ASSIGN
STATEMENTS
115 235 FIX NAMELIST PROBLEM, (MD)
116 252 14967 SELECTIT NOT CHECKING FOR SPECOP AND POSSIBLY OTHER OPS,
(JNT)
117 315 16667 FIX VDEFPT TO RECOGNIZE ARRAYREFS WITH CONSTANT
SUBSCRIPTS, NOT OPTIMALLY, BUT AT LEAST NOT WRONG, (JNT)
118 453 19695 DON'T CONSIDER THE DEFPT OF VARIABLES MODIFIED
INSIDE LOOPS TO BE THE DO STATEMENT., (JNG)
***** Begin Version 5A *****
119 575 22820 MAKE ZAPLEVEL MORE CLEVER IN USE OF THE STACK
TO PREVENT STACK OVERFLOWS., (DCE)
120 671 NVT WHEN SWAPPING ARGS, SWAP DEF PTS TOO, (DCE)
***** Begin Version 6 *****
121 760 TFV 1-Oct-79 ------
Add handling for IOSTAT variable, it's an implicit assignment
Include all I/O statements in test for END/ERR= branching
122 763 EGM 24-Apr-80 13913
Cause ENTRY formals to take part in definition point determination
123 1010 EGM 12-Aug-80 10-29839
Make sure CHKNAML passes only the address of a NAMELIST entry, not the
full argument word.
124 1034 DCE 4-Dec-80 -----
Fix function call arguments so that arguments (especially nested
ones) which change get noticed. Example F(G(X)) may change X.
125 1113 CKS 17-Jun-81
Prevent code motion from moving CSEs to statements which have more
than one successor. To do this, modify SETONSUC to set ACC bits for
variables which are assigned in statement STMT in STMT's successors
and postdominator. See comments in SPECBRCHK.
126 1126 AHM 22-Sep-81 Q20-01654
Remove last vestiges of CALL DEFINE FILE in a comment.
***** Begin Version 7 *****
***** End V7 Development *****
***** End Revision History *****
***** Begin Version 10 *****
2204 TFV 20-Jun-83
Add definition point handling for INQUIRE and fix deficiencies
with I/O definition points. All I/O statements can have IOSTAT=
which is the definition point for its argument. Also must check
for function call arguments in the expressions for UNIT, FMT,
REC, and IOSTAT and all OPEN/CLOSE/INQUIRE specifiers. Most
INQUIRE arguments are also modified by the INQUIRE statement.
2372 TJK 14-Jun-84
Restructure to allow the SETSEL routines to handle SUBSTRING
and ARRAYREF nodes (as well as DATAOPRs). Use DEFPTSS for the
definition point of ARG4PTR in a SUBSTRING. Handle character
data. Fix many, many bugs, mostly involving missing checks
for function references with side effects. Fix problems with
edit 1034.
2427 AlB 17-Jul-84
Removed reference to IDCHOS in SELECTIT, and reference to IDUSED
in GETDEF. These fields were not being used anywhere else, and
thus do not need to be initialized.
2522 DCE 8-Mar-85 QAR 853010
Correct definition point algorithm for character assignment
statements. Since they are converted to CALL statements, it looked
as if all of COMMON had to be marked as being possibly redefined
for every assignment statement, by calling THROINCOMMON. This is a
very slow routine, especially when it is called mulitple number of
times. This edit does NOT call it for library functions, which the
character assignment statements are.
2525 DCE 19-Mar-85 QAR 853010
Speed up optimization of programs with very large symbol tables.
When the optimizer wants to mark variables in COMMON as potentially
changed (for a CALL statement, for example), the entire symbol
table gets searched for variables which are both in COMMON and in
the CHOSEN list (with DISPIX=1). This is too time-consuming. When
the CHOSEN list is set up, keep a CMNMASK word which indicates which
elements of the CHOSEN list represent COMMON blocks, and use this
mask to update the ACC field in THROINCOMMON instead of doing symbol
table walk(s).
***** End V10 Development *****
2550 MEM 11-Sep-85
Only parameters of a statement function were used to calculate the
definition points of variables, however, the body of the statement
function must be used in definition point calculations also. A
variable, other than a parameter to the statement function, may be
changed by itself being a parameter in a function call within the
statement function.
2555 MEM 31-Oct-85
Correction to edit 2550.
***** End Revision History *****
***** Begin Version 11 *****
4501 MEM 7-Jan-85
Modify macro RANDIO so that when it checks if IORECORD is non-zero,
it will also check if IOKEY is non-zero.
4502 MEM 7-Jan-85
Add a case for the DELETE statement to the case statement in DEFWORK.
4503 MEM 7-Jan-85
Add a case for the REWRITE statement to the case statement in DEFWORK.
4517 MEM 4-Oct-85
In DEFWORK if we have a 1-char asmnt then call SETSEL[.DISPIX] on
the arg under the CHAR node instead of on the whole LHEXP of the asmnt.
ENDV11
)%
SWITCHES NOLIST;
REQUIRE FIRST.BLI;
REQUIRE TABLES.BLI;
REQUIRE OPTMAC.BLI;
SWITCHES LIST;
FORWARD
LOKELIST(1),
SELECTIT(1),
CHKUNIQ(1),
THROINCOMMON,
ANPARMS(1),
RSORT(1),
FCNLOK(1),
ASSOCIA,
DEF0 ,
SETIT(1),
DEFCHANGE(1),
ONLYONEPRED(1),
ZAPLEVEL(1),
SWAMP,
DEF1 ,
SETGOTVAL(1),
READHERE(1),
SETGTRD(1),
HEREVALUED(2),
GETDEF(3),
VDEFPT(1),
DEFPT(1),
DEFDRIV,
CHKNAML(1),
SETONSUC(1),
SPECBRCHK,
%2204% DEFIO(1), ! Definition points for I/O specifiers
%2204% DEFOCI(1), ! Definition points for OPEN/CLOSE/INQUIRE specifiers
DEFWORK(1);
!THE CONTROLLING ROUTINE IN THIS MODULE IS DEFDRIV. IT IS
!CALLED FROM PHA2. IT DIRECTS THE CALLING OF ALL THE OTHER
!(LOCAL) ROUTINES IN THIS MODULE. THE READER SHOULD START WITH
!THE ROUTINE DEFDRIV. IT APPEARS AT THE END OF THE MODULE
!(SAVE FOR INITDEF).
EXTERNAL
BASE ASSOCPT, ! Used for linked list of ASSOCIATE variables
BOTTOM,
CHOSEN,
LENTRY,
LOOKUP,
LOOPNO,
PHAZ2 QQ,
%2372% SKERR, ! Used to ICE the compiler
TOP,
%2372% BASE TREEPTR; ! Used as a global. Moved EXTERNAL here.
OWN PEXPRNODE PCE;
OWN P,PA,PB,PC,HEAD,PAE;
OWN MOREFLG,LSTVAR,T;
MAP PHAZ2 P:PA:PB:PC:HEAD:PAE;
OWN MASK,CHNGLST;
OWN DISPIX; !PLIT DISPATCH INDEX
OWN GOTVAL, !FLAG FOR ASSIGNED HERE
!THAT IT GIT IT VALUE HERE
%2525% CMNMASK; ! Mask of COMMON blocks in CHOSEN
!DISPATCH TO USE FCNLOK TO BOTH SELECT AND SET BITS.
!A SPACE ECONOMY AT A SLIGHT TRADE OFF IN TIME.
BIND SETSEL = PLIT (
SELECTIT,
SETIT,
SETGOTVAL);
ROUTINE LOKELIST(EPTR)=
BEGIN
!EXAMINE E1 AND E2 LISTS AND CALL THE CORRECT
!SELSEL ROUTINE.
!EPTR POINTS TO THE ELIST NODE.
MAP BASE EPTR;
REGISTER BASE ELEM;
WHILE .EPTR NEQ 0 DO
BEGIN
ELEM_.EPTR[E2ARREFPTR];
%2372% (.SETSEL[.DISPIX])(.ELEM);
EPTR_.EPTR[CLINK];
END;
END; ! of LOKELIST
ROUTINE SELECTIT(VAR)=
BEGIN
EXTERNAL CORMAN,UNIQVAL,UNLIST,SAVSPACE;
MAP PHAZ2 CHNGLST:TOP:UNIQVAL;
MAP PEXPRNODE VAR;
!SELECT VARIABLES TO PARTICIPATE IN THE DEFINITION POINT
!IDDEF INDICATES THAT THE VARAIBLE HAS PARTICIPATED IN THE
!DEFINITION POINT COMPUTATION.
!32 VARIABLES ARE SELECTED. THERE ADDRESS ARE PUT INTO THE VECTOR CHOSEN.
!AS A VARIABLE IS CHOSEN IT IS ALSO ADDED TO THE LIST OF VARIABLES
!THAT ARE CHANGED IN THIS LOOP WHICH IS KEPT WITH THE DO LOOP
!AFTER PROCESSING AS IT GOES FORTH INTO THE OUTSIDE WORLD.
!THE VARIABLE LSTVAR IS USED TO HOLD THE PLACE OF THE ALGORITHM IN
!PROCESSING STATEMENTS IN CASE MORE THAN 32 EXIST.
!ALGORTHM
%2372% IF .VAR[OPRCLS] EQL SUBSTRING
%2372% THEN VAR = .VAR[ARG4PTR]; ! Get get full string
%2372%
%2372% IF .VAR[OPRCLS] EQL ARRAYREF
%2372% THEN VAR = .VAR[ARG1PTR]; ! Get array name
%2372%
%2372% IF .VAR[OPRCLS] NEQ DATAOPR
%2372% THEN RETURN;
%2372%
%2372% IF.VAR[OPERSP] EQL CONSTANT OR .VAR[OPERSP] EQL FORMLFN
%2372% THEN RETURN;
!HERE WE HAVE A SYMBOL TABLE ENTRY
!SO WE WILL PROCESS IT.
! VAR[IDCHOS]_.LOOPNO; %2427 removed%
IF .T LSS 32 AND NOT .VAR[IDDEF] THEN
BEGIN
!EQUIVALENCED VARIABLES ARE NOT HANDLED
IF .VAR[IDATTRIBUT(INEQV)] THEN RETURN;
IF .VAR[IDATTRIBUT(INCOM)] THEN
PC_.VAR[IDCOMMON] ELSE
PC_.VAR;
INCR K FROM 0 TO 31 DO
IF .CHOSEN[.K] EQL .PC THEN
BEGIN
CHKUNIQ(.PC);
RETURN;
END;
!IF WE ARE HERE THE VARIBALE IS NOT ALREADY
!SELECTED. SO WE WILL DO THAT NOW
CHOSEN[.T]_.PC;
%2525% ! Mark COMMON blocks in CMNMASK for use by THROINCOMMON
%2525% IF .VAR[IDATTRIBUT(INCOM)]
%2525% THEN CMNMASK = SETBIT(.CMNMASK,.T);
VAR[IDDEF]_1;
T_.T+1;
!ADD THIS VARIABLE TO THE LIST OF
!CHANGED IN THIS LOOP
PC_.CHNGLST;
NAME<LEFT>_CHNGSIZ;
CHNGLST_CORMAN();
IF .PC NEQ 0 THEN
PC[RIGHTP]_.CHNGLST
ELSE
TOP[DOCHNGL]_.CHNGLST;
CHNGLST[LEFTP]_.VAR;
IF .T EQL 32 THEN LSTVAR_.P;
!BUILD ITEM ON UNIQUE VALUE LIST TOO.
PC_.UNIQVAL;
NAME<LEFT>_UNIQSIZ;
UNIQVAL_CORMAN();
UNIQVAL[RIGHTP]_.PC;
!PUT VARIABLE IN IN ALL CASES
UNIQVAL[LEFTP]_.VAR;
!SAVE ISN
UNIQVAL[OPTISNVAL]_.ISN;
END ELSE
!THIS IS POTENTIALLY AN ADDITIONAL ASSIGNMENT AND WE NEED
!TO TAKE IT OFF THE UNIQUE VALUR LIST
CHKUNIQ(.VAR);
END; ! of SELECTIT
ROUTINE CHKUNIQ(VAR)=
BEGIN
EXTERNAL UNIQVAL,SAVSPACE,UNLIST;
MAP PHAZ2 UNIQVAL:PC:VAR;
!REMOVE VAR FROM UNIQUE VALUE LIST
PC_.UNIQVAL;
WHILE .PC NEQ 0 DO
BEGIN
!IF ITS ON THE LIST AND THE ISNS DO NOT MATCH
!TAKE IT OFF
IF .PC[LEFTP] EQL .VAR THEN
BEGIN
IF .PC[OPTISNVAL] NEQ .ISN THEN
IF UNLIST(.UNIQVAL,.VAR,UNIQSIZ)
THEN
BEGIN
PC_.UNIQVAL;
UNIQVAL_.UNIQVAL[RIGHTP];
SAVSPACE(UNIQSIZ-1,.PC);
END;
RETURN;
END;
PC_.PC[RIGHTP];
END;
END; ! of CHKUNIQ
ROUTINE THROINCOMMON=
BEGIN
!PUT COMMON VARIABLES ON THE CHOOSEN LIST
%2372% ! Note that a check for EQUIVALENCE is missing here. However,
%2372% ! GETDEF ends up using the current statement as the definition
%2372% ! point for variables in COMMON or EQUIVALENCE anyway, so this
%2372% ! whole routine is useless. But, it could be made useful
%2372% ! someday...
MAP BASE PCE;
!DONT DO IT FOR HEARVALUED STUFF (DISPIX=2)
IF .DISPIX EQL 2 THEN RETURN;
%2525% ! We may be trying to set bits in the ACC field (for
%2525% ! DISPIX=1). Rather than walking the entire symbol table,
%2525% ! use the saved bit mask of all COMMON blocks in CHOSEN
%2525% ! which we built up when DISPIX=0. This speeds up
%2525% ! compilation substantially for programs with large symbol
%2525% ! tables.
%2525% IF .DISPIX EQL 1
%2525% THEN
%2525% BEGIN
%2525% P[ACC] = .P[ACC] OR .CMNMASK;
%2525% RETURN
%2525% END;
INCR K FROM 0 TO SSIZ-1 DO
BEGIN
PCE_.SYMTBL[.K];
WHILE .PCE NEQ 0 DO
BEGIN
IF .PCE[IDATTRIBUT(INCOM)] THEN
(.SETSEL[.DISPIX])(.PCE);
PCE_.PCE[CLINK];
END;
END;
END; ! of THROINCOMMON
ROUTINE ANPARMS(ARGLSTPTR)=
BEGIN
%2372% ! Edit 1034 had a lot of problems. This edit is a rewrite of
%2372% ! this routine, and should correct those problems. Basically,
%2372% ! any parameter which may have its value altered must be noted
%2372% ! (by the SETSEL dispatch call), and nested function
%2372% ! references must be noted (by the FCNLOK call). Sorry, no
%2372% ! time to add a full routine header.
MAP ARGUMENTLIST ARGLSTPTR;
REGISTER BASE ARGPTR;
INCR I FROM 1 TO .ARGLSTPTR[ARGCOUNT]
DO
BEGIN ! For each argument
ARGPTR = .ARGLSTPTR[.I,ARGNPTR]; ! Get the argument
(.SETSEL[.DISPIX])(.ARGPTR); ! It may be changed
FCNLOK(.ARGPTR); ! Check for nested functions
END; ! For each argument
END; ! of ANPARMS
ROUTINE RSORT(CNODE)=
BEGIN
!SORT THIS MULTIPLY NODE SO THAT THE DO LOOP
!INDUCTION VARIABLE (INDVAR) IS ON THE TOP
!OF ANY NARY TREE. IT WILL ALSO PUT IT TO THE
!RIGHT ON BINARY TREES.
EXTERNAL SWAP2DOWN,INDVAR;
MAP BASE CNODE;
REGISTER BASE T;
!IS IT A BOTTOM MOST TREE
IF .CNODE[A1VALFLG] AND .CNODE[A2VALFLG] THEN
BEGIN
!SWITCH ARGS IF THE DO LOOP VARIABLE IS
!ARG1
IF .CNODE[ARG1PTR] EQL .INDVAR THEN
![671] WHEN SWAPPING ARGS, SWAP DEF PTS TOO
%671% (SWAPARGS(CNODE);
%671% T_.CNODE[DEFPT2];
%671% CNODE[DEFPT2]_.CNODE[DEFPT1];
%671% CNODE[DEFPT1]_.T);
END ELSE
BEGIN
!IT IS NOT A BOTTOM-MOST TREE. CHECK FOR NARY
!DOWNWARD
T_.CNODE[ARG1PTR];
IF NARYNODE(T,CNODE) THEN
BEGIN
!IF THE LOWER BRANCH IS A LEAF AND THE INDUCION
!VARIABLE THEN SWITCH THEM
IF .T[ARG2PTR] EQL .INDVAR THEN
SWAP2DOWN(.CNODE,.T);
END;
END;
END; ! of RSORT
ROUTINE FCNLOK(EXPR)=
BEGIN
!EXAMINE EXPRESSION EXPR FOR FUNCTION REFERENCES
!IF ANY ARE FOUND PUT COMMON AND THE PARAMETERS ON THE
!SELECTED LIST (THE VECTOR CHOSEN).
MAP BASE EXPR;
%2372% REGISTER ARGUMENTLIST ARGLSTPTR; ! Pointer to argument list
CASE .EXPR[OPRCLS] OF SET
!BOOLEAN
BEGIN
FCNLOK(.EXPR[ARG1PTR]);
FCNLOK(.EXPR[ARG2PTR]);
END;
!DATAOPR
RETURN;
!RELATIONAL
BEGIN
FCNLOK(.EXPR[ARG1PTR]);
FCNLOK(.EXPR[ARG2PTR]);
END;
!FNCALL
BEGIN
%2550% LOCAL BASE ARG1:SFNODE;
%2372% ARGLSTPTR = .EXPR[ARG2PTR];
IF .EXPR[OPERSP] NEQ LIBARY THEN
BEGIN
THROINCOMMON();
%2372% ANPARMS(.ARGLSTPTR);
%2550% ARG1 = .EXPR[ARG1PTR]; ! Function name
%2550% IF .ARG1[IDATTRIBUT(SFN)]
%2550% THEN
%2550% BEGIN
%2550% SFNODE = .ARG1[IDSFNODE]; ! SFN node
%2555% IF .SFNODE[USRFNREF]
%2555% THEN
%2555% BEGIN
%2555% SFNODE = .SFNODE[SFNEXPR]; ! ASMNT NODE
%2555% FCNLOK(.SFNODE[RHEXP]);
%2555% END;
%2550% END;
END
%2372% ELSE
%2372% BEGIN ! Check for nested functions
%2372%
%2372% INCR I FROM 1 TO .ARGLSTPTR[ARGCOUNT]
%2372% DO FCNLOK(.ARGLSTPTR[.I,ARGNPTR]);
%2372%
%2372% END; ! Check for nested functions
END;
!ARITHMETIC
BEGIN
FCNLOK(.EXPR[ARG1PTR]);
FCNLOK(.EXPR[ARG2PTR]);
!IF WE ARE SELECTING (DISPIX=0) THEN
!SORT MULTIPLIES TO IMPROVE REDUCTIONS
IF .DISPIX EQL 0 THEN
CASE .EXPR[OPERSP] OF SET
%ADD% ;
%SUB% ;
%MULTIPLY%
RSORT(.EXPR);
%DIV% ;
%EXP% BEGIN END
TES;
END;
!TYPECNV
FCNLOK(.EXPR[ARG2PTR]);
!ARRAYREF
IF .EXPR[ARG2PTR] NEQ 0 THEN
FCNLOK(.EXPR[ARG2PTR]);
!CMNSUB
RETURN;
!NEGNOT
FCNLOK(.EXPR[ARG2PTR]);
!SPECOP
FCNLOK(.EXPR[ARG1PTR]);
!FIELDREF
RETURN;
!STORECLS
RETURN;
!REGCONTENTS
RETURN;
!LABOP
RETURN;
!STATEMENT
RETURN;
!IOLSCLS
RETURN;
!INLINFIN
BEGIN
FCNLOK(.EXPR[ARG1PTR]);
IF .EXPR[ARG2PTR] NEQ 0 THEN
FCNLOK(.EXPR[ARG2PTR]);
END;
%2372% !SUBSTRING
%2372% BEGIN
%2372% FCNLOK(.EXPR[ARG1PTR]); ! Upper bound
%2372% FCNLOK(.EXPR[ARG2PTR]); ! Lower bound
%2372% FCNLOK(.EXPR[ARG4PTR]); ! ARRAYREF or DATAOPR
%2372% END;
%2372% !CONCATENATION
%2372% BEGIN
%2372% ARGLSTPTR = .EXPR[ARG2PTR];
%2372%
%2372% INCR I FROM 2 TO .ARGLSTPTR[ARGCOUNT] ! Skip first arg
%2372% DO FCNLOK(.ARGLSTPTR[.I,ARGNPTR]);
%2372% END;
TES;
END; ! of FCNLOK
ROUTINE ASSOCIA=
BEGIN
![1126] !LOOK AT LINKED LIST OF ASSOCIATE VARIABLES (FROM OPENS)
![1126] !AND SELECT SET OF INDICATE SET HERE FOR
!THESE VARIABLES. THE MODULE OWN DISPIX IS SET TO CALL THE
!CORRECT ROUTINE BY THE CALLER OF THIS ROUITNE.
REGISTER BASE LP;
LP_.ASSOCPT;
WHILE .LP NEQ 0 DO
BEGIN
(.SETSEL[.DISPIX])(.LP[LEFTP]);
LP_.LP[RIGHTP];
END;
END; ! of ASSOCIA
!MACRO TO TEST RANDOM ACCESS PROPERTY OF AN I/O STATEMENT
!POINTED TO BY P AND CALL THE CORRECT SETSEL ROUTINE
MACRO RANDIO(P)=
BEGIN
%4501% IF (.P[IORECORD] NEQ 0)
%4501% AND (.P[IOKEY] EQL 0)
%4501% THEN
BEGIN
ASSOCIA();
THROINCOMMON();
END;
END$;
ROUTINE DEF0=
!++
! DEF0 is used to select up to 32 variables on which to perform
! definition point analysis. It first zeros the global vector CHOSEN,
! which is used to hold pointers to the selected variables. It also
! initializes a few other globals and module OWNs. It then makes an
! explicit call to SELECTIT to select the DO-variable of the current
! DO-loop (if it hasn't already been processed). It then walks the
! statements of the current DO-loop in BUSY list order, calling DEFWORK
! (with DISPIX set to zero, indicating SELECTIT is to be called) for
! each statement. When 32 variables have been selected, it stops
! walking the statements and remembers where it left off so that it can
! start there when the next set of up to 32 variables are to be
! selected.
!--
!LOOK AT STATEMENTS THAT POTENTAILLY ASSIGN A VALUE TO A
!VARIABLE. CALL THE ROUTINE SELECTIT TO SELECT THE
!VARIABLE. FUNCTIONS WITH SIDE EFFECTS WILL PRODUCE
!BAD RESULTS.
BEGIN
EXTERNAL CSTMNT,ISN;
MAP BASE CSTMNT;
MAP BASE PCE;
MAP PHAZ2 TOP;
!SET DISPATCH INDEX TO EXECUTE SELECTIT
DISPIX_0;
LSTVAR_-1; !INITIALIZE LSTVAR
! Also initialize CHOSEN, which is used to hold pointers to the
! selected variables.
DECR I FROM 31 TO 0
DO CHOSEN[.I]_0;
%2525% CMNMASK_0; ! Initialize COMMON mask too.
!MAKE SURE WE GET THE INDUCTION VARIABLE
IF .TOP[SRCID] EQL DOID THEN
SELECTIT(.TOP[DOSYM]);
!PICK FIRST 32 UNIQUE LHS TO PROCESS
DO
BEGIN
CSTMNT_.P;
ISN_.P[SRCISN];
DEFWORK(.P);
!TEST FOR JUST HAVING FILLED UP THE 32
!IF WE DONT TEST NOW BY THE TIME WE UPDATE
!P WE WILL HAVE PASTED LSTVAR
IF .P EQL .LSTVAR THEN
BEGIN
MOREFLG_1;
RETURN;
END;
P_.P[BUSY];
END UNTIL .P EQL 0 OR .P EQL .LSTVAR;
IF .P EQL 0 THEN MOREFLG_0;
END; ! of DEF0
ROUTINE SETIT(VAR)=
BEGIN
!SET THE BIT IN THE ACC FIELD OF THE MODULE-OWN,P,
!TO INDICATE THAT THE VARIABLE VAR IS DEFINED AT
!SOME PREDECESSOR OF P.
MAP BASE VAR;
MAP PHAZ2 P;
LOCAL I;
%2372% IF .VAR[OPRCLS] EQL SUBSTRING
%2372% THEN VAR = .VAR[ARG4PTR]; ! Get get full string
%2372%
%2372% IF .VAR[OPRCLS] EQL ARRAYREF
%2372% THEN VAR = .VAR[ARG1PTR]; ! Get array name
%2372%
%2372% IF .VAR[OPRCLS] NEQ DATAOPR
%2372% THEN RETURN;
%2372%
%2372% IF.VAR[OPERSP] EQL CONSTANT OR .VAR[OPERSP] EQL FORMLFN
%2372% THEN RETURN;
IF .VAR[IDDEF] THEN !THIS VARIABLE IS ELIGIBLE FOR
!CONSIDERATION
BEGIN
I_LOOKUP(.VAR);
IF .I LSS 32 THEN
P[ACC]_SETBIT(.P[ACC],.I);
END;
END; ! of SETIT
ROUTINE DEFCHANGE(STMT)=
BEGIN
!EXAMINE STATEMENTS THAT CAUSE VALUES OF VARAIBLES TO CHANGE
!AND CALL SETIT OR SETREAD TO SET BITS IN THE MASK FOR THAT
!WORD. MASK EXPLAINED IN COMMENTS THAT GO WITH DEF1.
!NOTE:
!THE BIT WILL BE SET IN THE MASK ASSOCIATED WITH THE MODULE
!OWN P WI;HICH POINTS TO A STATEMENT.
MAP PHAZ2 STMT;
!SET MODULE OWN THAT IS INDEX TO DISPATCH
DISPIX_1;
DEFWORK(.STMT);
END; ! of DEFCHANGE
ROUTINE ONLYONEPRED(NODE)=
BEGIN
!A VERSION TWO ROUTINE TO CHECK IF A NODE
!HAS ONLY ONE PREDECESSOR. CURRENTLY ONLY USED IN
!CONJUNCTION WITH ZAPLEVEL (IMMEDIATELY FOLLOWING)
!IF THE NODE HAS A SINGLE PREDECOSSOR A POINTER
!TO THAT PREDECESSOR IS RETURN ELSE 0 IS RETURNED.
!THE GLOBAL QQ IS USED AS A TEMP.
EXTERNAL QQ;
REGISTER PHAZ2 T;
MAP PHAZ2 NODE:QQ;
T_.NODE[PREDPTR]; !START OF PREDECESSOR CHAIN
QQ_.T[CESLNK]; !LINK TO NEXT ON CHAIN
!IF QQ IS POINTING TO A ZERO WORD THERE IS ONLY ONE PREDECESSOR
IF .QQ[CESLNK] EQL 0 THEN
RETURN (.T[CESSOR]) !RETURN THAT PREDECESSOR
ELSE
RETURN 0
END; ! of ONLYONEPRED
ROUTINE ZAPLEVEL(PRED)=
BEGIN
!ROUTINE ZEROES THE LEVEL FIELD FOR ALL NODES ON ALL
!PATHS BETWEEN PRED (A STATEMENT NODE) AND .P[PREDOM].
!P IS SET UP EXTERNALLY TO THIS ROUTINE. AN EFFORT
!IS MADE NOT TO RECURSE FOR STRAIGHT LINE PATHS,
!THUS MINIMIZING THE STACK REQUIRED.
MAP PHAZ2 PRED;
OWN NODE,SINGLPRED;
MAP PHAZ2 NODE;
![575] REMOVE THE LOCAL SYMBOL PLSTPTR SO THAT LESS STACK SPACE
![575] WILL BE USED DURING RECURSIVE CALLS OF THIS ROUTINE. THE
![575] VARIABLE PRED WILL NOW DO DOUBLE DUTY - COMING IN AS THE
![575] STATEMENT NODE, AND BEING USED TO CYCLE THROUGH ALL OF THE
![575] PREDECESSORS OF THE ORIGINAL PARAMETER. THIS CHANGE
![575] REDUCES THE STACK SPACE USED FROM 4 TO 3 LOCATIONS PER CALL
![575] TO THIS ROUTINE.
%575% PRED_.PRED[PREDPTR];
![575] PRED IS NOW THE PTR TO THE PREDECESSOR LIST OF THE ORIGINAL PRED
!FOR EACH PREDECESSOR ON THE LIST
%575% WHILE .PRED[CESLNK] NEQ 0 DO
BEGIN
!POINTER TO AN ACTUAL PREDECESSOR
%575% NODE_.PRED[CESSOR];
!SET THE FLAG THAT HELPS US ITERATE INSTEAD OF RECURSING
SINGLPRED_1;
!NOW ITERATE
WHILE .SINGLPRED DO
BEGIN
!IS THIS NODE ELIGIBLE, I.E.
! IS IT NOT P[PREDOM]
! DOES THE LEVEL FIELD NEED TO BE ZEROED
IF .NODE NEQ .P[PREDOM] AND .NODE[LEVEL] NEQ 0 THEN
BEGIN
!YES TEH NODE IS ELIGIBLE
!ZERO THE LEVEL FIELD
NODE[LEVEL]_0;
!NOW SEE IF IT HAS A SINGLE PREDECESSOR
IF (QQ_ONLYONEPRED(.NODE)) NEQ 0 THEN
!SET NODE TO THE PREDECESSOR
!RETURNED BY ONLYONEPRED AND
!ITERATE
NODE_.QQ
ELSE
BEGIN
!THERE IS MORE THAN ONE
!PREDECESSOR, SO WE MUST RECURSE
ZAPLEVEL(.NODE);
!RESET THE FLAG INDICATING ITERATION
!RATHER THAN RECURSION.
SINGLPRED_0;
END;
END ELSE
!THE NODE IS NOT ELIGIBLE
!RESET FLAG TO STOP LOOP
SINGLPRED_0;
END; !WHILE ON SONGLPRED
!NOW LOOK AT THE NEXT PREDECESSOR ON THE LIST
%575% PRED_.PRED[CESLNK];
END; !WHILE THERE ARE PREDECESSORS
END; ! of ZAPLEVEL
ROUTINE SWAMP=
BEGIN
!MAKE AND FOLLOW A MOORE FLOOD ORDERING OF NODES BETWEEN
!P AND P[PREDOM] SETTING BITS IN THE MASK AT P FOR
!VARIABLES CHANGED AT ANY OF THE NODES TRAVERSED.
! The main thing to remember about SWAMP is that it simply
! follows predecessor pointers up from P, without looking at
! or backing up beyond the immediate pre-dominator of P. For
! each statement it visits, it sets ACC bits in P for all
! selected variables which potentially become redefined at
! that statement. It doesn't look at the immediate
! pre-dominator of P, nor does it look at P itself.
MAP PHAZ2 P:T;
OWN PHAZ2 TAIL;
TAIL_HEAD_.P;
!WHILE CONDITION WILL STOP ON ZERO OR THE FIELD SET TO 1 (PROCESSED MARK).
WHILE .HEAD GTR #1000 DO
BEGIN
!PROCESS THE PREDECESSORS OF HEAD
T_.HEAD[PREDPTR];
WHILE .T[CESLNK] NEQ 0 DO
BEGIN
PA_.T[CESSOR];
!PA IS NOW A REAL SUCCESSOR
!IF IT IS NOT ALREADY DONE OR THE PREDOMINAATOR OF P
!PROCESS IT
IF .PA NEQ .P[PREDOM] THEN
BEGIN
IF .PA[LEVEL] EQL 0 THEN
BEGIN
!NOTE PA PROCESSED BY SETTING LEVEL NON-ZERO
PA[LEVEL]_1;
!ADD IT TO THE END OF THE CHAIN
TAIL[LEVEL]_.PA;
!UPDATE THE TAIL OF THE CHAIN
TAIL_.PA;
!SET THE %&$#% BIT
DEFCHANGE(.PA);
END;
END;
T_.T[CESLNK];
END;
HEAD_.HEAD[LEVEL];
END; !WHILE ON HEAD;
!IF P'S PREDOMINATOR IS A DO STATEMENT WHICH ISN'T TOP, THEN
!SET THE BITS IN P FOR ALL VARS CHANGED IN THE LOOP.
PA_.P[PREDOM];
IF (.PA NEQ .TOP) AND (.PA[SRCID] EQL DOID) THEN
DEFCHANGE(.PA);
END; ! of SWAMP
ROUTINE DEF1=
!++
! DEF1 is used to set the ACC bits for each statement in the current
! DO-loop. Each ACC bit (bits 0-32 are used) corresponds to the
! variable pointed to by that entry in CHOSEN. These bits are later
! used by DEFPT to determine the actual definition points.
!
! The basic idea is that the ACC bit for a variable V in a statement S
! will be set if V can potentially become redefined along some path from
! the immediate pre-dominator of S to S. This path does not include the
! immediate pre-dominator of S, but it may include loops through S.
! However, it generally doesn't include S itself. This should become
! clearer when the actual algorithm is described.
!--
BEGIN
MAP PHAZ2 T;
!
!INITIALIZE ACC FOR DEFINITION POINT CALCULATION
!DETERMINE IF THERE IS AN INTERFERING
!ASSIGNMENT BETWEEN NODE AND IMMEDIATE
!PREDOMINATOR
!THE INITIALIZATION ALGORITHM IS:
!1. LOOK AT ALL IMMEDIATE PREDECESSORS OF A NODE
!2. IF THE PREDECESSOR IS NOT THE PREDOMINATOR THEN
! SET THE BIT IN THE MASK WHICH CORRESPOND TO ANY
! VARIABLE ASSIGNED A VALUE AT THAT PREDECESSOR.
!A SPECIAL CASE IS THE FIRST STATEMENT AFTER THE DO LOOP
!TO PREVENT COMPUTATIONS THAT ARE COMPOSED OF VARIABLES
!ASSIGNED IN THE LOOP FROM ERRONEOUSLY MOVING OUTSIDE THE LOOP
!THIS STATEMENT WILL HAVE THE BITS SET FOR ALL THE VARIABLES
!ON THE DOCHNGL LIST TOO.
MAP PHAZ2 TOP;
EXTERNAL CSTMNT,ISN;
LOCAL BASE ITM;
MAP BASE CSTMNT;
!
P_.TOP;
P[ACC]_0;
P_.TOP[BUSY];
! DEF1 first makes some special checks on TOP and the
! statement after it, setting ACC bits (by a call to SETIT) in
! the statement following the DO statement for all variables
! changed by the DO-loop (if there is one). This is to
! prevent illegal motion out of loops.
!THE SPECIAL CASE
IF .P EQL .TOP[SRCLINK] THEN
BEGIN
LOCAL SAVP;
SAVP_.P;
!A SPECIAL CASE OF THE SPECIAL CASE
!IF THIS IS A DO LOOP SET THE BITS ON THE
!CONTINUE AND NOT ON THE LOOP
IF .P[SRCID] EQL DOID THEN
BEGIN
P_.P[DOLBL];
P_.P[SNHDR];
END;
ITM_.TOP[DOCHNGL];
WHILE .ITM NEQ 0 DO
BEGIN
!DOCHNGL IS A LINKED LIST OF VARIABLES
!CHANGED IN THIS LOOP.
!THE LEFT HALF OF THE WORD
!POINTS TO THE VARIABLE, THE RIGHT
!HALF TO THE NEXT LIST ITEM. IT IS
!TERMINATED WITH A ZERO
SETIT(.ITM[LEFTP]);
ITM_.ITM[RIGHTP];
END;
IF .TOP[SRCID] EQL DOID THEN SETIT(.TOP[DOSYM]);
!RESTORE SAVED VALUE OF P AND PROCEED
P_.SAVP;
END;
! It then walks walks the module OWN P from TOP[BUSY] to the
! end of the BUSY list.
!THE CAST OF CHARACTERS FOR THE NEXT WHILE LOOP IS
!P THE STATEMENT ON WHICH MASK BITS ARE INITIALIZED
!IF THE PREDECESSOR IS THE PREDOMINATOR SET NO BITS
!IF NOT ZERO THE LEVEL FIELD OF THE
!OPTIMIZERS WORDS AND USE IT TO FLOOD AND SET BITS
!FOR ALL VARIABLES ASSIGNED AT ALL NON_PREDOMINATING
!PREDECESORS.
!FOR ALL STATEMENTS
DO
BEGIN
! If P points to a DO statement, it calls SETIT for
! each variable on the change-list (DOCHNGL) for that
! DO statement.
!FOR A DO LOOP THAT IS NOT TOP SET THE BITS ON THE
!DO LOOP TOO INCASE SOMETHING BELOW THE TERMINATOR
!IS NOT PREDOMINATED BY THE TERMINATOR
IF .P NEQ .TOP AND .P[SRCID] EQL DOID THEN
BEGIN
ITM_.P[DOCHNGL];
WHILE .ITM NEQ 0 DO
BEGIN
!DOCHNGL IS A LINKED LIST
!THE LEFT HALF OF THE WORD
!POINTS TO THE VARIABLE, THE RIGHT
!HALF TO THE NEXT LIST ITEM. IT IS
!TERMINATED WITH A ZERO
SETIT(.ITM[LEFTP]);
ITM_.ITM[RIGHTP];
END;
END;
! Then, regardless of what P points to, it does the
! following:
!TRY TO ELIMINATE SOME TIME AND EFFORT BY NOT
!DOING THIS FOR A NODE IF IT HAS 1 PREDECESSOR
!WHICH (BY DEFINITION) IS ITS PREDOMINATOR
!SET THE LEVEL FIELD OF P[PREDOM] TO BE NON-ZERO
! The LEVEL field of the immediate pre-dominator of P
! is set to 1.
T_.P[PREDOM];
T[LEVEL]_1;
!NOW START CHECKING ON PREDECESSORS
T_.P[PREDPTR];
!T IS A POINTER TO THE PREDECESSOR LIST
! The module OWN PA is set to the second predecessor
! link of P (i.e., the CESLNK field of the PREDPTR
! field of P).
PA_.T[CESLNK];
!PA POINTS TO THE NEXT LINK
T_.T[CESSOR];
!T POINTS TO FIRST PREDECESSOR OF P
! Make a test to see if we can avoid calling SWAMP
! (the routine which sets ACC bits in the general
! case). If T is the immediate pre-dominator of P,
! and if PA[CESLNK] is zero (meaning PA must point to
! RGRAPH and T is the only predecessor of P), then it
! can avoid calling SWAMP. In this case, it makes one
! more check to see if PA[CESLNK] is zero and T points
! to a DO statement. If so, it calls DEFCHANGE (which
! calls DEFWORK with DISPIX set to 1), passing it T.
!MAKE SURE THERE ARE NONE OTHERS
!PA POINTS TO NEXT LINK WORD. IF THERE IS ONLY ONE
!PA IS A POINTER TO A WORD OF ZEROES.
!THIS IS A DOUBLE SAFE CHECK. IF BLISS EVER DOES BETTER
!ON BOOLEANS IT WILL ELIMINATE BUMMERS FAST.
IF .T NEQ .P[PREDOM] OR .PA[CESLNK] NEQ 0
THEN
BEGIN
! If it cannot avoid the call to SWAMP, it first sets
! the LEVEL field of P to zero. It then calls
! ZAPLEVEL, which zeros the LEVEL field of all
! statements on all paths between the immediate
! pre-dominator of P and P. Finally, it calls SWAMP
! to actually set the ACC bits. To do this, SWAMP
! uses the LEVEL field to create a linked list, which
! is basically a reverse BUSY list which stops at the
! immediate pre-dominator of P. It first sets HEAD
! and TAIL to P. Then it loops. For each predecessor
! PA of HEAD which isn't the immediate pre-dominator
! of P and which has a zero LEVEL field (i.e., it
! hasn't been visited yet), it sets the LEVEL field to
! one and the LEVEL field of TAIL to point to PA, then
! resets TAIL to point to PA. Finally, it calls
! DEFCHANGE, which will set the ACC bits in P for all
! selected variables changed in PA (DEFCHANGE merely
! calls DEFWORK with DISPIX set to one). When it's
! finished with all predecessors of HEAD, it resets
! HEAD to HEAD[LEVEL] and loops. It decides it's
! finished when HEAD is less than or equal to 1000
! (octal). This is meant to distinguish pointers from
! the other values of LEVEL (which should be zero and
! 1, unless ZAPLEVEL isn't working properly).
! Finally, after it has finished looping, SWAMP checks
! to see if the immediate pre-dominator of P is a DO
! statement other than TOP. If so, it calls DEFCHANGE
! to set ACC bits in P for all variables potentially
! changed by that DO statement.
!TO INSURE AGAINST A FLUKE
P[LEVEL]_0;
ZAPLEVEL(.P);
SWAMP();
END
!ON THE OTHERHAND IF THIS IS A SINGLE PREDECESSOR
!AND IT IS THE PREDOMINATOR AND IT IS A DO LOOP
!WE WANT TO SET THE BITS FOR ALL VARIABLES IN THE LOOP
ELSE
IF .PA[CESLNK] EQL 0 AND .T[SRCID] EQL DOID THEN
DEFCHANGE(.T);
P_.P[BUSY];
END UNTIL .P EQL 0;
! After DEF1 has looped through all statements, it calls
! SPECBRCHK to set ACC bits under a number of special cases to
! prevent bad code from being generated.
!CALL ROUTINE TO CHECK BRANCHES THAT SET VALUES
!SEE COMMENTS IN CALLED ROUTINE FOR DETAILS
SPECBRCHK();
END; ! of DEF1
MAP PHAZ2 PB;
ROUTINE SETGOTVAL(VAR)=
BEGIN
!THE GLOBAL TREEPTR POINTS TO A SYMBOL TABLE ENTRY.
!IF IT EQUALS VAR THEN SET GOTVAL TO 1
%2372% MAP BASE VAR;
%2372% IF .VAR[OPRCLS] EQL SUBSTRING
%2372% THEN VAR = .VAR[ARG4PTR]; ! Get get full string
%2372%
%2372% IF .VAR[OPRCLS] EQL ARRAYREF
%2372% THEN VAR = .VAR[ARG1PTR]; ! Get array name
%2372%
%2372% IF .VAR[OPRCLS] NEQ DATAOPR
%2372% THEN RETURN;
%2372%
%2372% IF.VAR[OPERSP] EQL CONSTANT OR .VAR[OPERSP] EQL FORMLFN
%2372% THEN RETURN;
%2372%
%2372% IF .VAR EQL .TREEPTR THEN GOTVAL = 1;
END; ! of SETGOTVAL
GLOBAL ROUTINE READHERE(IOLSTT)=
%(**********************************************************************
ROUTINE TO DETERMINE IF A VARIABLE WAS INITIALIZED
AT THE IOLSCLS ELEMENT IOLSTT
**********************************************************************)%
BEGIN
EXTERNAL INPFLAG;
MAP BASE IOLSTT;
CASE .IOLSTT[OPERSP] OF SET
%DATACALL% BEGIN
LOCAL BASE ELEM;
ELEM_.IOLSTT[DCALLELEM];
%2372% IF .INPFLAG THEN (.SETSEL[.DISPIX])(.ELEM);
%2372% FCNLOK(.ELEM);
END;
%SLISTCALL% BEGIN
LOCAL BASE ELEM;
%1034% IF NOT .INPFLAG THEN RETURN;
ELEM_.IOLSTT[SCALLELEM];
%2372% (.SETSEL[.DISPIX])(.ELEM);
END;
%IOLSTCALL% BEGIN
LOCAL BASE IOELEM;
%1034% IF NOT .INPFLAG THEN RETURN;
IOELEM_.IOLSTT[IOLSTPTR];
WHILE .IOELEM NEQ 0 DO
BEGIN
READHERE(.IOELEM);
IOELEM_.IOELEM[CLINK]
END
END;
%E1LISTCALL% BEGIN
%1034% IF NOT .INPFLAG THEN RETURN;
LOKELIST(.IOLSTT[ELSTPTR])
END;
%E2LISTCALL% BEGIN
%1034% IF NOT .INPFLAG THEN RETURN;
LOKELIST(.IOLSTT[ELSTPTR])
END
TES
END; ! of READHERE
GLOBAL ROUTINE SETGTRD(IOLSTT)=
BEGIN
!EXAMINE THE IOLIST POINTED TO BY IOLSTT FOR
!A SINGLE VARIABLE TREEPTR.
EXTERNAL INPFLAG;
MAP BASE IOLSTT;
WHILE .IOLSTT NEQ 0 DO
BEGIN
IF .IOLSTT[OPRCLS] NEQ STATEMENT THEN
![1034] Don't forget function calls in I/O statements
%1034% READHERE(.IOLSTT)
ELSE
IF .IOLSTT[OPRS] EQL ASGNOS THEN
BEGIN
%2372% (.SETSEL[.DISPIX])(.IOLSTT[LHEXP]);
%2372%
%2372% ! The left hand side should never be an array
%2372% ! reference, but just in case this changes,
%2372% ! we'll check for function references anyway.
%2372% ! The right hand side should always be
%2372% ! checked.
%2372%
%2372% FCNLOK(.IOLSTT[LHEXP]); ! Check LHS just in case
%2372% FCNLOK(.IOLSTT[RHEXP]); ! RHS must always be checked
END ELSE
!TAKE NOTE OF THE FACT THAT THE DO LOOP
!INDEX CHANGES IF THIS IS A LOOP
IF .IOLSTT[OPRS] EQL DOOS THEN
(.SETSEL[.DISPIX])(.IOLSTT[DOSYM]);
IOLSTT_.IOLSTT[CLINK];
END
END; ! of SETGTRD
ROUTINE HEREVALUED(STMT,VAR)=
BEGIN
!SEE IF THE VARIABLE VAR GETS A VALUE AT STATEMENT STMT.
!IF SO RETURN 1 ELSE RETURN 0
MAP BASE VAR:STMT;
!SET TREEPTR TO VAR FOR USE IN DEEPER ROUTINES
TREEPTR_.VAR;
!INITIALIZE GOTVAL TO 0
GOTVAL_0;
!SET DISPIX
DISPIX_2;
DEFWORK(.STMT);
.GOTVAL
END; ! of HEREVALUED
GLOBAL ROUTINE GETDEF(CNODE,STMT,CDEFPT)=
BEGIN
EXTERNAL INDVAR; !THE DO INDUCTION VARIABLE
LOCAL PDE; !A TEMPORARY
REGISTER PHAZ2 TSTMT;
!COMPUTE ACTUAL DEFINITION POINT OF A LEAF NODE
!THIS ALGORITHM IS:
!LOOK UP THE VARIABLE IN QUESTION (CNODE)
!IF IT IS IN CHOSEN THEN CREATE A 36 BIT MASK WHICH HAS
!THE BIT CORRESPONDING TO THE VARIABLE ON IN THE MASK.
!STARTING WITH THE ACC OF THE CURRENT STATEMENT AND
!THIS MASK WITH SUCCESSIVE ACC FIELDS ON THE PREDOMINATOR
!CHAIN OF THE STATEMENT UNTIL THE MASK IS NOT ZERO. THIS
!INDICATES AN INTERFERRING ASSIGNMENT IN THAT INTERVAL.
!RETURN THE DEFINITION POINT AS THIS PLACE.
EXTERNAL PHAZ2 TOP;
MAP PHAZ2 CNODE;
!
IF .CNODE[OPRCLS] EQL REGCONTENTS THEN RETURN(.TOP);
IF .CNODE[OPRCLS] NEQ DATAOPR THEN RETURN(0)
ELSE
!IT SHOULD NOT BE A CONSTANT OR FORMAL FUNCTION
IF .CNODE[OPERSP] EQL CONSTANT OR
.CNODE[OPERSP] EQL FORMLFN THEN RETURN(.LENTRY);
IF .CNODE EQL .INDVAR THEN RETURN(.TOP);
IF NOT .CNODE[IDDEF] THEN
BEGIN
IF NOT .MOREFLG THEN
BEGIN
! CNODE[IDUSED]_1; %2427 removed%
IF .CNODE[IDATTRIBUT(INCOM)] OR
.CNODE[IDATTRIBUT(INEQV)] THEN
RETURN(.STMT)
ELSE
!IF THE DO STATEMENT IS LABELED
!WE MIGHT BE IN ROUTBLE IF WE SAY LENTRY
!SPECIALLY IF LENTRY IS AN ASSIGNMENT OF THAT
!VARIABLE TO A CONSTANT (I.E. IT WILL
!GET PROPAGATED.
RETURN(IF .TOP[SRCLBL] NEQ 0 THEN .TOP ELSE .LENTRY);
END;
END ELSE
BEGIN
!JUST TO MAKE SURE AVOID EQUIVALENCE LIKE THE PLAQUE.
!EQUIVALENCE LISTS ARE NOT PROCESSED UNTIL REGISTER
!ALLOCATION
IF .CNODE[IDATTRIBUT(INCOM)] THEN RETURN(.STMT);
IF .CNODE[IDATTRIBUT(INEQV)] THEN RETURN(.STMT);
PDE_LOOKUP(.CNODE);
IF .PDE GTR 32 THEN RETURN .CDEFPT;
MASK_0;
MASK_SETBIT(.MASK,.PDE);
TSTMT_.STMT; !PT TO STATEMENT
WHILE 1 DO
BEGIN
IF (.TSTMT[ACC] AND .MASK) NEQ 0 THEN RETURN(.TSTMT);
%2372% IF .TSTMT EQL .TOP
%2372% THEN
%2372% BEGIN ! We've reached TOP
%2372%
%2372% ! Check to see if the DO-loop control
%2372% ! expression might change CNODE (i.e., with a
%2372% ! function reference). If so, we can't return
%2372% ! LENTRY, but must instead return
%2372% ! TOP[SRCLINK], which is the CONTINUE
%2372% ! statement after TOP. Note that TOP may be a
%2372% ! CONTINUE if we're at the top-level, in which
%2372% ! case we're safe.
%2372%
%2372% IF .TOP[SRCID] EQL DOID
%2372% THEN
%2372% BEGIN ! TOP is a genuine DO statement
%2372%
%2372% TREEPTR = .CNODE; ! Test CNODE
%2372% GOTVAL = 0; ! Initialize result
%2372% DISPIX = 2; ! Use SETGOTVAL
%2372% FCNLOK(.TOP[DOLPCTL]); ! Look for FNCALLs
%2372% IF .GOTVAL THEN RETURN .TOP[SRCLINK];
%2372%
%2372% END; ! TOP is a genuine DO statement
%2372%
%2372% RETURN .LENTRY; ! Safe to return LENTRY
%2372%
%2372% END; ! We've reached TOP
IF HEREVALUED(.TSTMT,.CNODE) THEN RETURN(.TSTMT);
TSTMT_.TSTMT[PREDOM];
END;
END;
.CDEFPT !JUST IN CASE
END; ! of GETDEF
ROUTINE VDEFPT(PNODE)=
BEGIN
!WALK AN EXPRESSION TREE COMPUTING DEFINITION POINTS OF LEAFS (VARIABLES)
EXTERNAL ARGCONE;
REGISTER PHAZ2 P;
P_.PNODE;
CASE .P[OPRCLS] OF SET
!BOOLEAN
BEGIN
IF .P[A1VALFLG] THEN
P[DEFPT1]_GETDEF(.P[ARG1PTR],.PAE,.P[DEFPT1])
ELSE
VDEFPT(.P[ARG1PTR]);
IF .P[A2VALFLG] THEN
P[DEFPT2]_GETDEF(.P[ARG2PTR],.PAE,.P[DEFPT2])
ELSE
VDEFPT(.P[ARG2PTR]);
END;
!DATAOPR
BEGIN END;
!RELATIONAL
BEGIN
IF .P[A1VALFLG] THEN
P[DEFPT1]_GETDEF(.P[ARG1PTR],.PAE,.P[DEFPT1])
ELSE
VDEFPT(.P[ARG1PTR]);
IF .P[A2VALFLG] THEN
P[DEFPT2]_GETDEF(.P[ARG2PTR],.PAE,.P[DEFPT2])
ELSE
VDEFPT(.P[ARG2PTR]);
END;
!FNCALL
BEGIN
LOCAL ARGUMENTLIST AG;
AG_.P[ARG2PTR];
INCR I FROM 1 TO .AG[ARGCOUNT] DO
VDEFPT(.AG[.I,ARGNPTR]);
!GIVE ARG A DEFPT ON SINGLE
!ARGUMENT LIBRARY FUNCTIONS
IF ARGCONE(.P) THEN
P[DEFPT2]_GETDEF(.AG[1,ARGNPTR],.PAE,.P[DEFPT2]);
END;
!ARITHMETIC
BEGIN
IF .P[A1VALFLG] THEN
P[DEFPT1]_GETDEF(.P[ARG1PTR],.PAE,.P[DEFPT1])
ELSE
VDEFPT(.P[ARG1PTR]);
IF .P[A2VALFLG] THEN
P[DEFPT2]_GETDEF(.P[ARG2PTR],.PAE,.P[DEFPT2])
ELSE
VDEFPT(.P[ARG2PTR]);
END;
!TYPCNV
IF .P[A2VALFLG] THEN
P[DEFPT2]_GETDEF(.P[ARG2PTR],.PAE,.P[DEFPT2])
ELSE
VDEFPT(.P[ARG2PTR]);
!ARRAYREF
BEGIN
IF .P[A2VALFLG] THEN
IF .P[ARG2PTR] EQL 0 !IF ITS A CONSTANT SS
THEN !WE WOULD LIKE IT TO BE LENTRY
!BUT THAT BOMBS AND WE WANT THIS IN V4A
P[DEFPT2]_.PAE !SO SETTLE FOR WHAT WORKS
ELSE
P[DEFPT2]_GETDEF(.P[ARG2PTR],.PAE,.P[DEFPT2])
ELSE
VDEFPT(.P[ARG2PTR]);
!LOOK AT ARRAYNAME TOO
P[DEFPT1]_GETDEF(.P[ARG1PTR],.PAE,.P[DEFPT1]);
END;
!CMNSUB
IF .P[A2VALFLG] THEN
P[DEFPT2]_GETDEF(.P[ARG2PTR],.PAE,.P[DEFPT2])
ELSE
VDEFPT(.P[ARG2PTR]);
!NEGNOT
IF .P[A2VALFLG] THEN
P[DEFPT2]_GETDEF(.P[ARG2PTR],.PAE,.P[DEFPT2])
ELSE
VDEFPT(.P[ARG2PTR]);
!SPECOP
IF .P[A1VALFLG] THEN
P[DEFPT1]_GETDEF(.P[ARG1PTR],.PAE,.P[DEFPT1])
ELSE
VDEFPT(.P[ARG1PTR]);
!FIELDREF
BEGIN END; !NOT RELEASE 1
!STORECLS
BEGIN END;
!REGCONTENTS
!IT MUST BE THE INDUCTION VARIABLE
BEGIN END; !SHOULDNT GET HERE
!LABOP
BEGIN END;
!STATEMENT
BEGIN END;
!IOLSCLS
BEGIN END;
!INLINFN
BEGIN
IF .P[A1VALFLG] THEN
P[DEFPT1]_GETDEF(.P[ARG1PTR],.PAE,.P[DEFPT1])
ELSE
VDEFPT(.P[ARG1PTR]);
IF .P[ARG2PTR] NEQ 0 THEN
BEGIN
IF .P[A2VALFLG] THEN
P[DEFPT2]_GETDEF(.P[ARG2PTR],.PAE,.P[DEFPT2])
ELSE
VDEFPT(.P[ARG2PTR]);
END;
END;
%2372% !SUBSTRING
%2372% BEGIN
%2372% LOCAL BASE ARG4; ! Holds ARG4PTR
%2372%
%2372% IF .P[A1VALFLG]
%2372% THEN P[DEFPT1] = GETDEF(.P[ARG1PTR],.PAE,.P[DEFPT1])
%2372% ELSE VDEFPT(.P[ARG1PTR]);
%2372%
%2372% IF .P[A2VALFLG]
%2372% THEN P[DEFPT2] = GETDEF(.P[ARG2PTR],.PAE,.P[DEFPT2])
%2372% ELSE VDEFPT(.P[ARG2PTR]);
%2372%
%2372% ARG4 = .P[ARG4PTR];
%2372% IF .ARG4[OPRCLS] EQL DATAOPR
%2372% THEN P[DEFPTSS] = GETDEF(.ARG4,.PAE,.P[DEFPTSS])
%2372% ELSE VDEFPT(.ARG4);
%2372% END;
%2372% !CONCATENATION
%2372% BEGIN
%2372% LOCAL ARGUMENTLIST AG;
%2372% AG = .P[ARG2PTR];
%2372%
%2372% INCR I FROM 2 TO .AG[ARGCOUNT] ! Skip first argument
%2372% DO VDEFPT(.AG[.I,ARGNPTR]);
%2372% END;
TES;
END; ! of VDEFPT
ROUTINE DEFPT(STMT)=
BEGIN
!***************************************************************
! After interfering assignment information is collected, compute
! definition points for leaves and expressions under the
! statement. The defpts are recorded at the statement level.
! VDEFPT actually computes the defpts for the expressions and
! leaves.
!***************************************************************
%2204% ! Rewritten by TFV, on 20-Jun-83
EXTERNAL IOSTDFPT; !COMPUTE DEFPTS IN I/O LIST <IOPT>
REGISTER ARGUMENTLIST AG;
MAP
BASE TOP,
PHAZ2 STMT;
PAE = .STMT; !PAE USED IN LOWER ROUTINES
IF .STMT[SRCID] EQL ASGNID
THEN
BEGIN ! Assignment
P = .STMT[LHEXP];
%2372% IF .P[OPRCLS] NEQ DATAOPR
THEN VDEFPT(.P);
P = .STMT[RHEXP];
IF .P[OPRCLS] EQL DATAOPR
%2372% THEN STMT[OPDEF] = GETDEF(.P,.STMT,.STMT[OPDEF])
ELSE VDEFPT(.P);
END ! Assignment
ELSE IF .STMT[SRCID] EQL DOID
THEN
BEGIN ! DO
! Skip it if this is the current DO we are processing
IF NOT .STMT[FLCWD] AND .STMT[SRCOPT] NEQ 0
THEN
BEGIN
P = .STMT[DOLPCTL];
IF .P[OPRCLS] NEQ DATAOPR
THEN VDEFPT(.P);
END;
END ! DO
ELSE IF .STMT[SRCID] EQL IFLID
THEN
BEGIN ! Logical IF
P = .STMT[LIFEXPR];
IF .P[OPRCLS] NEQ DATAOPR
THEN VDEFPT(.P);
%2372% ! Note that STMT[LIFSTATE] is also on the BUSY list
END ! Logical IF
ELSE IF .STMT[SRCID] EQL IFAID
THEN
BEGIN ! Arithmetic IF
P = .STMT[AIFEXPR];
IF .P[OPRCLS] NEQ DATAOPR
THEN VDEFPT(.P);
END ! Arithmetic IF
ELSE IF .STMT[SRCID] EQL CALLID
THEN
BEGIN ! CALL
IF .STMT[CALLIST] NEQ 0
THEN
BEGIN
AG = .STMT[CALLIST];
INCR K FROM 1 TO .AG[ARGCOUNT] DO
BEGIN
PB = .AG[.K,ARGNPTR];
IF .PB[OPRCLS] NEQ DATAOPR
THEN VDEFPT(.PB);
END;
END;
END ! CALL
ELSE IF .STMT[SRCID] GEQ READID AND .STMT[SRCID] LEQ REREDID
THEN
BEGIN
IF .STMT[IOLIST] NEQ 0
THEN IOSTDFPT(.STMT);
END;
END; ! of DEFPT
GLOBAL ROUTINE DEFDRIV=
!++
! The top-level routine in DEFPT is DEFDRIV. This routine is called from
! MRP2 to calculate definition points for the current DO-loop. It requires
! the forward and reverse program graphs for the current DO-loop, as well
! as the pre- and post-dominators for the current DO-loop.
!
! There are basically three passes to the definition point algorithm. The
! first pass (DEF0) selects up to 32 variables for definition point
! analysis. The second pass (DEF1) sets the ACC bits in the optimizer
! words for each statement indicating which of those variables become
! redefined on some path between that statement's immediate pre-dominator
! and that statement (possibly passing through that statement more than
! once). The third pass (DEFPT) actually fills in the definition points.
! This three-pass process repeats for each set of 32 variables until all
! variables in the currentDO-loop have been processed.
!--
BEGIN
!CONTROLER FOR THE DEFINITION POINT ALGORITHM
EXTERNAL CSTMNT,ISN;
EXTERNAL UNIQVAL;
MAP PHAZ2 CSTMNT:TOP;
UNIQVAL_0;
CHNGLST_0;
MOREFLG_1;
P_.TOP[BUSY];
! If 32 variables were selected, loop back to step 2 to process the
! next set of 32.
WHILE .MOREFLG DO
BEGIN
T_0;
!EACH ROUTINE IS A SEPARATE PASS OVER THE
!ENCODED SOURCE FOR THE CURRENT LOOP
! Call DEF0 to select up to 32 variables. Each selected
! variable is added to the list of currently selected
! variables. It is also marked as having been selected so
! it never becomes selected again (for example, in the next
! batch of 32 variables that are selected).
DEF0(); !PICK 32 VARIALES
!IF THERE WERE NO VARIABLES (WRITE STATEMENT ONLY,
!FOR EXAMPLE, QUIT HERE
! If some variables were selected, call DEF1 to set the ACC
! bits indicating where they become redefined.
IF .T EQL 0 THEN
MOREFLG_0
ELSE
BEGIN
DEF1(); !INITIALIZE THE MASK
END;
!NOW WE ARE READY TO ACTUALLY GET DEFINITION POINTS
! Visit all statements in the current DO-loop in BUSY list
! order. For each statement, call DEFPT to fill in
! definition points for all selected variables and
! constants (this is done even if DEF1 is skipped so
! constants don't get missed).
CSTMNT_.TOP[BUSY]; !SKIP CURRENT LOOP
WHILE .CSTMNT NEQ 0 DO
BEGIN
ISN_.CSTMNT[SRCISN];
DEFPT(.CSTMNT);
CSTMNT_.CSTMNT[BUSY];
END;
P_.LSTVAR;
END;
END; ! of DEFDRIV
ROUTINE CHKNAML(NLPTR)=
BEGIN
!ROUTINE TO CHECK A NAME LIST.
!IT:
! 1. DETERMINES IF NLPTR POINTS TO A NAMELIST NAME
! SYMBOL TABLE ENTRY
! 2. IF SO, IT SEARCHS THE LINKED LIST OF NAMELIST
! STATEMENTS FOR THE MATCHING NAMELIST
! 3. IT THEN SETS THE BITS (SELECTIT,SETIT,SETGOTVAL)
! USING THE DISPIX SET UP BY THE CALLER
OWN BASE NPTR;
LABEL NLLOK;
MAP BASE NLPTR;
EXTERNAL NAMLPTR;
BIND M1RH=#000000777777; !-1 IN RIGHT HALF WORD
!FIRST SEE IF NLPTR POINTS TO A NAMELIST SYMBOL TABLE ENTRY
IF .NLPTR NEQ 0 AND .NLPTR NEQ M1RH THEN
BEGIN
IF .NLPTR[IDATTRIBUT(NAMNAM)] THEN
BEGIN
NPTR_.NLPTR[IDCOLINK]; !GET POINTER
!WE HAVE LOOKED AT LIST WE HAVE TO QUIT IF
!NPTR IS ZERO
IF .NPTR EQL 0 THEN RETURN;
!NPTR POINTS TO THE NAME LIST STATEMENT ENTRY
INCR I FROM 0 TO .NPTR[NAMCNT]-1 DO
%1010% (.SETSEL[.DISPIX])(.(.NPTR[NAMLIST]+.I)<RIGHT>);
END;
!ITS NOT A NAME LIST NAME
END;
END; ! of CHKNAML
ROUTINE SETONSUC(STMT)=
BEGIN
!COMPANION ROUITNE TO SPECBRCHK
!OR THE MASK OF STMT INTO EACH OF ITS SUCCESSORS IF IT IS NOT ZERO
REGISTER SUCLSTPTR,T;
MAP PHAZ2 STMT:SUCLSTPTR:T;
LOCAL PHAZ2 SAVEP;
LOCAL ACCSAVE;
%1113% ACCSAVE _ .STMT[ACC]; ! SAVE ACC BITS
%2372% ! Edit 1113 was making a bad test, since the last link in
%2372% ! every successor list is FGRAPH. This test has been removed.
%2372% ! Perhaps a better test will be added someday.
%1113% SAVEP _ .P; ! SAVE P, ARG TO DEFCHANGE
%1113% P _ .STMT; ! SET ACC BITS IN STMT FOR EACH
%1113% DEFCHANGE(.STMT); ! VARIABLE ASSIGNED BY STMT
%1113% P _ .SAVEP; ! RESTORE P
IF .STMT[ACC] NEQ 0 THEN
BEGIN
!SET IT ON THE POST DOMINATOR JUST TO BE 10000000%
!SURE
T_.STMT[POSTDOM];
T[ACC]_.T[ACC] OR .STMT[ACC];
SUCLSTPTR_.STMT[SUCPTR];
!FOLLOW SUCCESSOR CHAIN
WHILE .SUCLSTPTR[CESLNK] NEQ 0 DO
BEGIN
!LOOK AT ACTUAL SUCCESSOR
T_.SUCLSTPTR[CESSOR];
T[ACC]_.T[ACC] OR .STMT[ACC];
!NEXT SUCCESSOR
SUCLSTPTR_.SUCLSTPTR[CESLNK];
END; !WHILE
END;
%1113% STMT[ACC] _ .ACCSAVE;
END; ! of SETONSUC
ROUTINE SPECBRCHK=
BEGIN
!ROUTINE CHECKS ALL BRANCHING STATEMENTS.
!IF SOMETHING IS DEFINED AT A BRANCHING STATEMENT
!THE APPROPRIATE BIT MUST BE SET ON THE IMMEDIATE
!SUCCESSORS OF THE BRANCH IN ORDER TO ASSURE THAT
!CASES SUCH AS THE FOLLOWING DO NOT
!CAUSE INCORRECT CODE.
!EXAMPLE:
! A LOGICAL IF (CONTAINING A FUNCTION) CALL IS THE
! DEFINITION POINT OF AN ARGUMENT TO THE FUNCTION CALL.
! WITHOUT THIS ADDITIONAL PROCESSING, IF THE
! MOTION PLACE OF AN EXPRESSION WAS THE LOGICAL IF
! THE COMPUTATION WOULD BE INSERTED ONLY ON THE
! FALSE BRANCH. SETTING THE BITS ON THE SUCCESSORS
! INSURES THAT THE LOGICAL IF WILL NOT TURN OUT TO
! BE THE MOTION PLACE.
!
![1113] ADDITIONALLY, SET ACC BITS FOR EACH VARIABLE ASSIGNED
!BY THE BRANCHING STATEMENT ITSELF.
!
!THIS BUSINESS IS NECESSARY TO PREVENT A STATEMENT WHICH BOTH
!BRANCHES AND ASSIGNS VALUES FROM BECOMING THE DEF POINT FOR ANY
!VARIABLE. IF SUCH A STATEMENT WERE CHOSEN AS THE MOTION PLACE FOR A
!CSE, THE CSE CALCULATION WOULD HAVE TO BE PUT ON EACH SUCCESSOR OF THE
!STATEMENT. INSTEAD, THIS SCHEME PREVENTS A STATEMENT WITH MULTIPLE
!SUCCESSORS FROM BEING IDENTIFIED AS THE DEF POINT OF THE VARIABLES
!WHICH IT ASSIGNS. ACC BITS ARE SET IN EACH SUCCESSOR (SO THAT CSE
!MOVEMENT WILL STOP WHEN IT HITS THE SUCCESSOR) AND THE POSTDOMINATOR
!(SO THAT MOVEMENT OF CSES WHICH OCCUR AFTER THE POSTDOMINATOR WILL HIT
!THE POSTDOMINATOR AND STOP THERE).
LABEL L1;
MAP PHAZ2 P:TOP;
P_.TOP[BUSY];
WHILE .P NEQ 0 DO
BEGIN
!FIRST A GENERAL BRANCH
IF .P[SRCID] GEQ GOTOID AND .P[SRCID] LEQ IFLID THEN
SETONSUC(.P)
ELSE
!A CALL
!WITH LABLE ARGUMENTS
IF .P[SRCID] EQL CALLID THEN
BEGIN
LOCAL ARGUMENTLIST AG;
L1:
IF .P[CALLIST] NEQ 0 THEN
BEGIN
AG_.P[CALLIST];
INCR I FROM 1 TO .AG[ARGCOUNT] DO
BEGIN
REGISTER BASE T;
T_.AG[.I,ARGNPTR];
IF .T[OPRCLS] EQL LABOP THEN
BEGIN
SETONSUC(.P);
LEAVE L1;
END;
END;
END;
END ELSE
%760% IF (.P[SRCID] GEQ READID AND .P[SRCID] LEQ ENDFID) OR
%2204% .P[SRCID] EQL OPENID OR .P[SRCID] EQL INQUID
%760% THEN
!ITS AN I/O STATEMENT. IT IS A BRANCH IF THERE IS AN
!END OR ERR SPECIFIED
IF .P[IOERR] NEQ 0 OR .P[IOEND] NEQ 0 THEN
SETONSUC(.P);
!NEXT STATEMENT
P_.P[BUSY];
END; !WHILE
END; ! of SPECBRCHK
ROUTINE DEFIO(P)=
BEGIN
%2204% ! Written by TFV on 20-Jun-83
!***************************************************************
! Check definition points for UNIT, FMT, REC, and IOSTAT
! specifiers for an I/O statement. Look for function arguments
! that might be modified. The IOSTAT variable or arrayref is
! always modified.
!***************************************************************
REGISTER BASE TMP;
MAP PHAZ2 P;
! Check for function calls.
%2372% IF (TMP = .P[IOUNIT]) NEQ 0
%2372% THEN
%2372% BEGIN ! Non-zero UNIT
%2372%
%2372% FCNLOK(.TMP);
%2372%
%2372% IF .TMP[VALTYPE] EQL CHARACTER
%2372% THEN IF .P[SRCID] EQL WRITID
%2372% THEN (.SETSEL[.DISPIX])(.TMP); ! Internal file WRITE
%2372%
%2372% END; ! Non-zero UNIT
IF (TMP = .P[IOFORM]) NEQ 0
THEN IF .TMP NEQ #777777 ! Not list directed either
THEN FCNLOK(.TMP);
IF (TMP = .P[IORECORD]) NEQ 0 THEN FCNLOK(.TMP);
IF (TMP = .P[IOIOSTAT]) NEQ 0
THEN
BEGIN ! IOSTAT was specified
FCNLOK(.TMP); ! Check it for function calls
! It's always modified by the I/O statement
%2372% (.SETSEL[.DISPIX])(.TMP);
END; ! IOSTAT was specified
END; ! of DEFIO
ROUTINE DEFOCI(P)=
BEGIN
%2204% ! Written by TFV on 20-Jun-83
!***************************************************************
! Check definition points for OPEN, CLOSE, and INQUIRE
! specifiers. Look for function arguments that might be
! modified. The IOSTAT variable or arrayref is always modified.
! All INQUIRE specifiers except UNIT or FILE are also modified.
!***************************************************************
REGISTER
BASE TMP,
OPENLIST OPENL,
ISINQUIRE; ! Convenient flag
MAP PHAZ2 P;
! Check for function calls.
IF (TMP = .P[IOUNIT]) NEQ 0 THEN FCNLOK(.TMP);
IF (TMP = .P[IOFILE]) NEQ 0 THEN FCNLOK(.TMP);
IF (TMP = .P[IOIOSTAT]) NEQ 0
THEN
BEGIN ! IOSTAT was specified
FCNLOK(.TMP); ! Check it for function calls
! It's always modified by the I/O statement
%2372% (.SETSEL[.DISPIX])(.TMP);
END; ! IOSTAT was specified
OPENL = .P[OPLST]; ! pointer to other specifiers
ISINQUIRE = .P[SRCID] EQL INQUID; ! loop invariant test
DECR I FROM .P[OPSIZ] - 1 TO 0 DO
BEGIN ! Walk down specifier list
! Get specifier expression
IF (TMP = .OPENL[.I,OPENLPTR]) NEQ 0
THEN
BEGIN ! Non-zero specifier
FCNLOK(.TMP); ! Check it for function calls
%2372% ! INQUIRE always modifies the variable or
%2372% ! arrayref, and ASSOCIATE variables are always
%2372% ! modified.
%2372%
%2372% IF .ISINQUIRE OR .OPENL[.I,OPENLCODE] EQL OPNCASSOCIATE
%2372% THEN (.SETSEL[.DISPIX])(.TMP);
END; ! Non-zero specifier
END; ! Walk down specifier list
END; ! of DEFOCI
ROUTINE DEFWORK(P)=
BEGIN
!MAIN ROUTINE TO DO ALL THE DEFPOINT WORK.
!CALLED BY HEREVALUES, DEF0 AND DEFCHANGE
REGISTER BASE TMP;
%763% REGISTER ARGUMENTLIST ALST; ! FOR ENTRY FORMALS
MAP PHAZ2 P;
EXTERNAL CSTMNT,INPFLAG;
MAP BASE CSTMNT;
%2204% IF .P[SRCID] EQL CLOSID OR .P[SRCID] EQL OPENID OR
%2204% .P[SRCID] EQL INQUID
%2204% THEN
%2204% BEGIN ! OPEN, CLOSE, or INQUIRE
%2204% DEFOCI(.P); ! Check the specifiers
%2204% RETURN ! Done - leave now
%2204% END; ! OPEN, CLOSE, or INQUIRE
%2204% IF (.P[SRCID] GEQ READID AND .P[SRCID] LEQ ENDFID)
%2204% THEN DEFIO(.P); ! I/O statement - check the specifiers
CASE .P[SRCID] OF SET
BEGIN ! ASSIGNMENT
%4517% TMP = .P[LHEXP];
%4517% IF .TMP[OPR1] EQL CHARFNFL
%4517% THEN (.SETSEL[.DISPIX])(.TMP[ARG1PTR]) ! 1-char assignment
%4517% ELSE (.SETSEL[.DISPIX])(.TMP); ! non-char assignment
%2372% FCNLOK(.P[LHEXP]);
%2372% FCNLOK(.P[RHEXP]);
END; ! ASSIGNMENT
BEGIN ! ASSIGN
%2372% (.SETSEL[.DISPIX])(.P[ASISYM]);
END; ! ASSIGN
BEGIN ! CALL
%2372% ! Note that a special check for character assignments
%2372% ! would make them less pessimal. This should be added
%2372% ! if character definition points are ever used.
%2522% ! Put COMMON in the list if this is not a character
%2522% ! assignment statement, which would appear as a library
%2522% ! function. Library functions don't change COMMON!
%2522%
%2522% TMP = .P[CALSYM];
%2522% IF NOT .TMP[IDLIBFNFLG] THEN THROINCOMMON();
! Put PARAMETERs on the list
IF .P[CALLIST] NEQ 0 THEN ANPARMS(.P[CALLIST]);
END; ! CALL
BEGIN END; ! CONTINUE
BEGIN ! DO
FCNLOK(.P[DOLPCTL]);
!THIS MUST BE INNER TO THE ONE CURRENTLY BEING
!PROCESSED
!MAKE SURE THAT WE NOTE THE VARIABLES CHANGED IN IT
!IN THE ALGORITHM
TMP_.P[DOCHNGL];
WHILE .TMP NEQ 0 DO
BEGIN
(.SETSEL[.DISPIX])(.TMP[LEFTP]);
TMP_.TMP[RIGHTP];
END;
END; ! DO
%763% BEGIN ! ENTRY
%763% IF (ALST _ .P[ENTLIST]) NEQ 0 THEN
%763% BEGIN
%763% INCR K FROM 1 TO .ALST[ARGCOUNT] DO
%763% BEGIN
%2372% IF (TMP = .ALST[.K,ARGNPTR]) NEQ 0
%2372% THEN (.SETSEL[.DISPIX])(.TMP);
%763% END;
%763% END;
%763% END; ! ENTRY
BEGIN END; ! COMMON SUB
BEGIN END; ! GOTO
FCNLOK(.P[AGOTOLBL]); ! ASSIGNED GOTO
FCNLOK(.P[CGOTOLBL]); ! COMPUTED GOTO
FCNLOK(.P[AIFEXPR]); ! ARITHMETIC IF
FCNLOK(.P[LIFEXPR]); ! LOGICAL IF
IF .P[RETEXPR] NEQ 0 ! RETURN
THEN FCNLOK(.P[RETEXPR]);
BEGIN END; ! STOP
BEGIN ! READ
INPFLAG_1;
IF .P[IOLIST] NEQ 0 THEN
BEGIN
SETGTRD(.P[IOLIST]);
RANDIO(P);
END ELSE
CHKNAML(.P[IONAME]);
END; ! READ
BEGIN ! WRITE
! You are surprised to find a WRITE here. It is
! relevant if it is random access; in that case any
! associate vaiables must be considered, also common,
! also function call arguments may change value - hence
! the call to SETGTRD.
SETGTRD(.P[IOLIST]);
RANDIO(P);
END; ! WRITE
BEGIN ! DECODE
INPFLAG_1;
SETGTRD(.P[IOLIST]);
END; ! DECODE
BEGIN ! ENCODE
IF .P[IOVAR] NEQ 0 THEN
BEGIN
%2372% (.SETSEL[.DISPIX])(.P[IOVAR]);
SETGTRD(.P[IOLIST]);
END;
END; ! ENCODE
BEGIN ! REREAD
%2372% SKERR(); ! REREAD is really READ now.
END; ! REREAD
RANDIO(P); ! FIND
%4502% BEGIN END; ! CLOSE
%4502%
%4502% BEGIN ! DELETE
%4502% IF (.P[IOKEY] EQL 0)
%4502% THEN
%4502% BEGIN
%4502% ASSOCIA();
%4502% THROINCOMMON();
%4502% END;
%4502% END;
%4503% BEGIN ! REWRITE
%4503% SETGTRD(.P[IOLIST]);
%4503% END;
%4502% BEGIN END; ! BACKSPACE
%4502% BEGIN END; ! BACKFILE
%4502% BEGIN END; ! REWIND
%4502% BEGIN END; ! SKIPFILE
%4502% BEGIN END; ! SKIPRECORD
%4502% BEGIN END; ! UNLOAD
%4502% BEGIN END; ! ENDFILE
%4502% BEGIN END; ! END
%4502% BEGIN END; ! PAUSE
%4502% BEGIN END; ! OPEN
%4502% BEGIN END; ! STATEMENT FUNCTION
%4502% BEGIN END; ! FORMAT
%4502% BEGIN END; ! BLTID
%4502% BEGIN END; ! REGMARK
%4502% BEGIN END; ! INQUIRE
TES;
INPFLAG_0;
END; ! of DEFWORK
END
ELUDOM