Trailing-Edge
-
PDP-10 Archives
-
BB-H138A-BM
-
3a-sources/gt1n.bli
There are 18 other files named gt1n.bli in the archive. Click here to see a list.
!THIS SOFTWARE IS FURNISHED UNDER A LICENSE AND MAY ONLY BE USED
! OR COPIED IN ACCORDANCE WITH THE TERMS OF SUCH LICENSE.
!
!COPYRIGHT (C) 1977,1978 BY DIGITAL EQUIPMENT CORPORATION
!FILENAME: H1GTRE.BLI
!DATE: 24 MAY 73 MGM/FLD
%3.% GLOBAL BIND H1GTV=2; !MODULE VERSION NUMBER
! REVISION HISTORY:
!
! 9-19-77 ROUTINE GENGRAPH IS MODIFIED TO FIX BUG#46,
! NESTED IF THEN ELSE EXPRESSIONS.(COMMON SUB-
! EXPRESSIONS).
!
! 6-2-77 ROUTINE GTGOTM IS MODIFIED TO FIX BUG #11
! IN BLISS10.DOC.GADD AND GSTO WAS REPLACED
! BY GOTM AND DID NO GOOD. THIS WAS DONE FOR OPTIMIZATION.
! NOW IN THIS CASE FORGET ABOUT OPTIMIZATION.
! CASE IS X[]_.X[]+2;.
!
! GRAPH TABLE GENERATION AND INTERPRETATION ROUTINES
!----------------------------------------------------
ROUTINE TREGP(X)= (((.X AND NOT(#37^16)) EQL 0) AND (.X<RTEF> GEQ 16));
%3.1% GLOBAL ROUTINE FIXOCCF(L,F,T)=
BEGIN LOCAL YR;
! THIS ROUTINE FIXES THE <OCCF> AND <USEF> FIELDS
! IN THOSE CASES WHERE A NODE IS RE-FOUND BEFORE ITS
! USE HAS GONE TO ZERO.
INCR I FROM .F TO .T DO
IF .GT[.L,.I]<LEFTHALF> EQL GTLEX THEN
BEGIN
GT[.GT[.L,.I]<LINKF>,0]<OCCF> _
MAXER(.GT[.GT[.L,.I]<LINKF>,0]<OCCF>-1,0);
IF .GT[.GT[.L,.I]<LINKF>,0]<RESULTF> THEN
IF (YR_TREGNUM(.GT[.GT[.L,.I]<LINKF>,1])) GEQ 16 THEN
DUN(.YR);
END
ELSE IF(YR_TREGNUM(.GT[.L,.I])) GEQ 16 THEN DUN(.YR);
END;
ROUTINE FIXALLOCCF(L)=
BEGIN LOCAL N; N_.GT[.L,0]<SUBNF>+2;
INCR I FROM 3 TO .N DO
IF .GT[.L,.I]<LEFTHALF> EQL GTLEX THEN
IF NOT .GT[.GT[.L,.I]<LINKF>,0]<RESULTF> THEN
FIXALLOCCF(.GT[.L,.I]<LINKF>);
FIXOCCF(.L,3,.N)
END;
%3.1% GLOBAL ROUTINE MAKGT(N,OP,PTR,DIR)=
BEGIN LOCAL S,L,GTL;
! THIS ROUTINE BUILDS A GRAPH-TABLE ENTRY IN CASE THERE
! WASN'T ONE. THE SUBNODE ENTRIES ARE POINTED TO BY THE
! VARIABLE PTR -- THERE DIRECTION RELATIVE TO PTR IS KEPT
! IN DIR.
S_2+.N/2;
GT[L_GETSPACE(.S),0]_ .GRAPHHEAD[GTL_GTHASH(.OP)];
GRAPHHEAD[.GTL]_.L;
GT[.L,0]<OCCF>_1;
GT[.L,0]<SUBNF>_.N;
GT[.L,1]_0;
GT[.L,2]_.OP;
INCR I FROM 0 TO .N-1 DO
GT[.L,.I+3]_@(.PTR+.I*.DIR);
.L
END;
ROUTINE GTGOTM(O1,O2,OP)=
BEGIN LOCAL L1,L2,L3,L4,L5; BIND NNDM=7^33;
!
! THIS ROUTINE ATTEMPTS TO RECOGNIZE AND OPTIMIZE THE
! CASES IN WHICH A 'TO-MEMORY' OPERATOR MAY BE
! GENERATED. A SPECIAL GT-NODE IS BUILT IN THESE CASES
! SO THAT A SPECIAL CODE GENERATOR, 'GOTM', WILL BE
! BE CALLED.
!
ROUTINE OKOP(X)=(.X<HPRIORITY> GTR #21 AND .X<HPRIORITY> LSS #37
AND .X<HPRIORITY> NEQ #30);
ROUTINE NNTYPE(X)=(.X<LEFTHALF> EQL HNEG OR .X<LEFTHALF> EQL HNOT);
ROUTINE DOTTYPE(X)= .X<HPRIORITY>EQL #21;
FUNCTION FIND(E,ATT)=
BEGIN
IF NNTYPE(.GT[.ATT,2]) THEN
IF .GT[.ATT,3]<LEFTHALF> NEQ GTLEX
THEN RETURN 0 ELSE ATT_.GT[.ATT,3]<LINKF>;
L5_IF .GT[.ATT,3]<LEFTHALF> EQL GTLEX
THEN .GT[.ATT,3]<LINKF> ELSE 0;
IF DOTTYPE(.GT[.ATT,2]) THEN
(IF .L5 NEQ 0 THEN NOT DOTTYPE(.GT[.L5,2]) ELSE 1) AND
(.GT[.ATT,3] EQL .E)
ELSE 0
END;
IF .OP<LEFTHALF> EQL HSTO THEN
IF (.O1 AND NNDM) EQL 0 THEN
IF .O2<LEFTHALF> EQL GTLEX THEN
IF OKOP(.GT[L1_.O2<LINKF>,2]) THEN
IF NOT(.GT[.L1,0]<RESULTF>) THEN
BEGIN L4_4-.GT[.L1,2]<HUNARY>;
IF .GT[.L1,.L4]<LEFTHALF> EQL GTLEX THEN
IF FIND(.O1,.GT[.L1,.L4]<LINKF>) THEN
BEGIN ! PHEW--WE GOT ONE
! DONOT BOTHER TO OPTIMIZE X[1]_.X[1]+5
! BECAUSE IT DOES NOT ANYWAY.
!IT GOES TO GOTM,GADD,GSTO AND GOING TO GOTM UNNECESSARY
! 5_27_77
IF .STUTYPE EQL 1 AND .O1<LEFTHALF> EQL GTLEX
THEN (STUTYPE_0; RETURN 0);
L2_MAKGT(4,NGOTM<0,0>,GT[.L1,2],+1);
GT[.L2,4]_ IF .GT[.L1,.L4]<LEFTHALF> EQL GTLEX
THEN .GT[.GT[.L1,.L4]<LINKF>,0]<OCCF> LEQ 1 ELSE 1;
GT[.L2,4]<LEFTHALF>_.L5;
GT[.L2,5]_.GT[.L1,.L4];
GT[.L2,6]_ IF .OP<HUNARY>
THEN 0 ELSE .GT[.L1,3];
GT[.L1,0]<OCCF>_MAXER(.GT[.L1,0]<OCCF>-1,0);
RETURN (GTLEX^18 + .L2)
END;
END;
END;
%3.1% GLOBAL ROUTINE GENGRAPH(OP,N)=
BEGIN LOCAL S,GTL,L,X,XR,YR;
EXTERNAL NOIFOPT;
!
! THIS ROUTINE GENERATES THE GRAPH TABLE AND RETURNS A
! GRAPH-TABLE LEXEME FOR THE (SUB) TREE(S). BEFORE A
! NEW ENTRY IS MADE THE EXISTING TABLE IS SEARCHED
! FOR A COMMON SUB-EXPRESSION, AND, IF FOUND, THE LEXEME
! FOR THIS ENTRY IS RETURNED AFTEN APPROPRIATE ADJUSTMENT
! OF THE OCCURRENCE COUNTS.
!
IDCHECKER(OP,.N);
IF NOT(.CODETOG) THEN RETURN LITLEXEME(0);
IF NOT .NOIFOPT %9-19-77%
THEN
BEGIN
L_.GRAPHHEAD[GTL_GTHASH(.OP)];
IF (X_GTGOTM(@(OP-2),@(OP-1),@OP)) NEQ 0 THEN RETURN .X;
WHILE .L NEQ 0 DO
BEGIN
IF .OP EQL .GT[.L,2] THEN
BEGIN
X_ INCR I FROM 1 TO .N DO
IF @(OP-.I) NEQ .GT[.L,.I+2] THEN BREAK 0
ELSE IF TREGP(@(OP-.I)) THEN BREAK 0;
IF .X NEQ 0 THEN
!SUCCESS, WE HAVE FOUND A MATCHING ENTRY.
BEGIN
IF (GT[.L,0]<OCCF>_.GT[.L,0]<OCCF>+1) GTR 1^8-1 THEN ERROR(.NSYM,#773);
IF .GT[.L,0]<RESULTF> THEN
IF (XR_TREGNUM(.GT[.L,1])) GEQ 16 THEN
INCRUSEN(.XR);
IF .GT[.L,0]<RESULTF> THEN FIXALLOCCF(.L) ELSE
IF .GT[.L,0]<OCCF> GTR 1 THEN FIXOCCF(.L,3,.N+2);
RETURN (GTLEX^18+.L)
END
END;
L_.GT[.L,0]<LINKF>;
END;
END;
!IF WE REACH THIS POINT WE HAVE SEARCHED THE ENTIRE GRAPH TABLE (SUB-LIST)
! AND HAVE NOT FOUND A COMMON SUBEXPRESSION. THEREFORE WE CREATE
! A GRAPH TABLE ENTRY AND LINK IT INTO THE LIST.
!
MAKGT(.N,.OP,OP-1,-1)+GTLEX^18
END;
%3.1% GLOBAL ROUTINE GTPURGE(TOG)=
BEGIN LOCAL L,L1,L2;
!
! THIS ROUTINE PURGES THE GRAPH TABLE OF ALL ENTRIES WHICH
! DO NOT HAVE VALID RESULTS STILL HELD IN REGISTERS OR
! ARE CONSTITUENTS OF SUCH RESULTS. IT OPERATES BY FIRST
! MARKING ALL SUCH ENTRIES AND THEN RELEASING ALL UNMARKED
! ENTRIES.
!
! DEPENDING ON THE VALUE OF 'TOG' WE DO A MORE OR
! LESS DRASTIC PURGE (2=>MORE, 0=>LESS). IN PARTICULAR
! TOG=0: WE SAVE ANY ENTRY WITH A RESULT
! STILL CONTAINED IN A REG.
! TOG=1: WE SAVE ONLT THOSE ENTRIES WITH A NON-ZERO
! 'SAVE' FIELD -- IE, THOSE ENTRIES BEING
! PRESERVED ACROSS A 'FORK'.
! TOG=2: WE SAVE ONLY THOSE ENTRIES WITH A
! SAVE FIELD VALUE GREATER THAN ONE,
! THIS IS USUALLY THE CASE JUST BEFIRE
! TERMINATING A FORK.
!
ROUTINE GTMARK(GTE)=
BEGIN LOCAL F;
!
! THIS ROUTINE PROPAGATES MARK BITS DOWN AND
! FUNNYBITS BACK UP TO PARENTS.
!
F_.GT[.GTE,0]<FUNNYBIT>;
IF .GT[.GTE,0]<MARKBIT> THEN RETURN .F;
INCR I FROM 3 TO .GT[.GTE,0]<SUBNF>+2 DO
IF .GT[.GTE,.I]<LEFTHALF> EQL GTLEX THEN
F_.F OR GTMARK(.GT[.GTE,.I]<LINKF>);
GT[.GTE,0]<MARKBIT>_1;
GT[.GTE,0]<FUNNYBIT>_.F;
.F
END;
INCR I FROM 0 TO GTMASK DO
BEGIN
L_.GRAPHHEAD[.I];
WHILE .L NEQ 0 DO
BEGIN
IF .GT[.L,0]<OCCF> NEQ 0 THEN GTMARK(.L) ELSE
CASE .TOG OF
SET
IF .GT[.L,0]<ROSF> NEQ 0 THEN
IF NOT .GT[.L,0]<RESULTF> THEN GTMARK(.L) ELSE
IF TREGNUM(.GT[.L,1]) GEQ 16 THEN GTMARK(.L);
IF .GT[.L,0]<SAVGEF> GTR 0 THEN GTMARK(.L);
IF .GT[.L,0]<SAVGEF> GTR 1 THEN GTMARK(.L);
TES;
L_.GT[.L,0]<LINKF>;
END;
END;
INCR I FROM 0 TO GTMASK DO
BEGIN
L_.GRAPHHEAD[.I]; GRAPHHEAD[.I]_0;
WHILE .L NEQ 0 DO
BEGIN
L1_.GT[.L,0]<LINKF>;
IF .GT[.L,0]<MARKBIT>
THEN
BEGIN
GT[.L,0]<LINKF>_.GRAPHHEAD[.I]; GRAPHHEAD[.I]_.L;
IF .GT[.L,0]<FUNNYBIT> THEN
BEGIN
GT[.L,0]<RESULTF>_0; GT[.L,0]<FUNNYBIT>_0;
IF (L2_TREGNUM(.GT[.L,1])) GEQ 16 THEN
SCAN( CTRCTH(.L2),
.L,GTLEXP,ERASE)
END;
GT[.L,0]<MARKBIT>_0;
END
ELSE
BEGIN
IF (L2_TREGNUM(.GT[.L,1])) GEQ 16 THEN
SCAN ( CTRCTH(.L2),
.L,GTLEXP,ERASE);
RELEASESPACE(.L,2+.GT[.L,0]<SUBNF>/2)
END;
L_.L1
END;
END;
END;
ROUTINE GTID(TOG)=
BEGIN LOCAL L,NS,OC,RN;
!
! THIS ROUTINE INCREMENTS (TOG=1) OR DECREMENTS (TOG=-1)
! ALL 'SAVGE' FIELDS IN THE GRAPH TABLE. THIS IS DONE TO
! PRESERVE THE EXISTING GRAPH TABLE ACROSS
! FORKS (E.G. IF-THEN-ELSE).
!
INCR I FROM 0 TO GTMASK DO
BEGIN
L_.GRAPHHEAD[.I];
WHILE .L NEQ 0 DO
BEGIN
IF (NS_.GT[.L,0]<SAVGEF>+.TOG) GTR 1^7-1 THEN ERROR(.NDEL,#771) ELSE
IF .NS GEQ 0