*DECK     FBV 
          IDENT  FBV
 FBV      TITLE  FBV - FORM BIT VECTORS ( USE/DEF AND LIVE EXIT ) 
*CALL     SSTCALL 
 B=FBV    RPVDEF
          PASS2TM 
  
 FBV      SPACE  2
*IF       DEF,FBV,1 
          TRACER CLI
**        FBV - FORM BIT VECTORS ( PHASE 2 OF OPT=2 PASS 2 ). 
*         READ PROGRAM BLOCKS TO FORM *USE, DBU AND USE* VECTORS. 
*         USE ULLMAN ALGORITHM TO FORM BLOCK *LIVE EXIT* BIT VECTORS. 
* 
*         NOTE - THE SPACE OCCUPIED BY *FBV* IS USED AS A BUFFER FOR
*         LCM TO LCM TRANSFERS BY *MIO*.
  
**        DEBUGING SNAP LABELS
* 
*         TRACER (FBV,SNO,CLI)
 FBV      SPACE  2
          TABLES BIT,BVT,CFT,RND,SEQ,TXT
  
          EXT    BN,BVL,M.BBL,NPB,O.IST 
 FBV      SPACE  3
**        FBV.ERR - REQUESTED BLOCK IS NOT SAME AS BLOCK RECEIVED FROM
*         I/O ROUTINES.  THIS IS INDICATIVE OF A BUG IN *MIO* OR THE
*         OPERATING SYSTEM ( *READNS* FUNCTION ). 
  
 FBV.ERR  SX1    =C$ FTN/FBV - BLOCK READ ERROR$
          EQ     =XFTNABT 
 FBV      SPACE  2
*CALL     CFTBLD
 FBV      EJECT 
**        FBV - FORM BIT VECTORS
  
 FBV      ENTRY. ** 
          SA1    M.BBL
          ALLOC  TXT,X1+2    ALLOC( TXT , M.BBL + 2 ) 
          SX7    X2+B1       O.SEQ = O.TXT + 1
          SA7    O.SEQ
          SX6    B1+B1       BN = 2 
  
*         READ PROGRAM BLOCKS SEQUENTIALLY AND FORM BIT VECTORS 
  
 FBV1     SA1    O.BIT
          SX6    X6+2        BN = BN + 2
          SB2    X6 
          SA2    X1+B2       BIW = BIT(BN)
          BX7    X2 
          SA5    A2+B1       RIW = BIT(BN+1)
          SA3    O.SEQ
          ZR     X5,FBV3     IF RIW = 0    */ END OF PROGRAM BLOCKS 
          SA6    BN 
          SA7    BIW
          CALL   RNB         READ NEXT BLOCK
          SA2    BIW
          SA5    O.SEQ
          LX2    59-BI.RBP
          PL     X2,FBV2     IF ^RB[BIW]   */ DEAD CODE 
          SA4    BN 
          SA1    X5 
          BX6    X4-X1
          SB2    X6 
          NZ     B2,FBV.ERR  IF BN[SEQ] " BN  */ READNS ERROR 
  
          CALL   FUD         FORM USE/DEF BIT VECTORS 
  
 FBV2     SA1    BN 
          SX6    X1+
          EQ     FBV1 
  
 FBV3     SX7    0
          SA7    L.TXT       L.TXT = 0
  
          RJ     SNO         SET NODE ORDER 
  
          RJ     CLI         COMPUTE LIVE EXIT BIT VECTORS
  
          IFEQ   CP#RM,0,1
          RECALL =XF.OPT     WAIT UNTIL READ NS FINISHED
          SX6    0
          SA6    L.RND       L.RND = 0
          SA6    L.CFT       L.CFT = 0
  
          IF     DEF,/DEBUG/CLI,1 
          DCALL  PRNTLX,([O.BVT],[O.BIT],NPB) 
  
          EQ     FBV
  
 BIW      BSS    1           SAVED COPY OF BLOCK INDEX WORD 
 SNO      TITLE  SNO - SET NODE ORDER BY A DEPTH FIRST SEARCH 
**        SNO - SET NODE ORDER USING A DEPTH FIRST SEARCH OF THE FLOW 
*         GRAPH TO ASSIGN THE *NUM* ORDER TO THE BLOCKS IN THE ORDER
*         IN WHICH THEY ARE LAST VISITED. 
  
*         TEMPORARY TABLE FOR DEPTH FIRST SEARCH / *NUM* COMPUTATION
  
          DESCRIBE I.,60     TTW
 TREE     DEFINE 1           IN TREE
          DEFINE 11 
 SUI      DEFINE 18          SUCCESSOR INDEX
 NS       DEFINE 12          N.SUCC NOT VISITED 
 BN       DEFINE 18          BLOCK NUMBER OF NUM(I) 
  
*         REGISTER ASSIGNMENTS
  
 C0       MICRO  1,,/B7/     O.CFT
 EI       MICRO  1,,/B6/     EIB
 NO       MICRO  1,,/B5/     NUM COUNTER
 ST       MICRO  1,,/B4/     STK - PUSHDOWN STACK 
 NS       MICRO  1,,/B3/     N.SUCC 
 N        MICRO  1,,/X7/     NODE NUMBER
  
 SNO      ROUTINE 
          SA5    NPB
          SX2    X5+B1
          LX1    B1,X2
          ALLOC  CFT,X1      ALLOC( CFT , 2*(NPB+1) ) 
          S"C0"  X2          C0 = O.CFT 
          SA1    O.IST
          SB2    X5          N = NPB
          S"EI"  X1+3        EIB = O.IST + 3
          SX6    2000B
          SA5    "EI"+B1     EI = EIB + 1 
          LX6    I.NSP
          MX0    1
          LX0    1+I.TREEP
          BX6    X0+X6
          SA6    "C0"        CI = C0;  [CI] = 0  */ EXIT NODE HAS NO SUC
  
*         SETUP AUX TABLE WITH SUCCESSOR INFORMATION
  
 SNO1     LX5    -EI.SUIP 
          UX4    "NS",X5
          SX3    X4          SI = SUI[EI] 
          SA5    A5+B1       EI = EI + 1
          PX6    "NS",X3
          LX6    I.SUIP 
          SB2    B2-B1       N = N - 1
          SA6    A6+B1       CI = CI + 1;  [CI] = TTW(0,SI,NS,0)
          NZ     B2,SNO1     IF N " 0 
  
          S"ST"  A6+B1       ST = CI + 1   */ STACK ADDRESS 
          MX7    0
          SA7    "ST"        [ST] = 0 
          S"NO"  B1          NO = 1 
          S"N"   1           N = 1         */ START WITH PROG ENTRY BLOCK 
  
*         VISIT NODE *N*
  
 SNO2     SA5    "C0"+"N"    TW = C(N)
          BX6    X0+X5       TREE[TW] = 1  */ INDICATE IN TREE
          SA6    A5 
          LX6    -I.SUIP
          UX5    "NS",X6
          SB2    "EI"+X6
  
*         VISIT SUCCESSORS
  
 SNO3     ZR     "NS",SNO4   IF NS[TW] = 0 */ IF ALL SUCC VISITED 
          S"NS"  "NS"-B1     NS[TW] = NS[TW] - 1
          SA3    B2+"NS"     ET = EIB + SUI[TW] + NS[TW]
          LX3    -ET.SUCCP   I = SUCC[ET] 
          SA2    "C0"+X3
          LX2    59-I.TREEP 
          MI     X2,SNO3     IF TREE[C(I)] */ IF SUCC IN TREE 
  
          PX6    "NS",X6
          LX6    I.SUIP 
          SA6    A6 
  
          S"ST"  "ST"+B1     ST = ST + 1   */ STACK NODE N
          R=     X7,"N" 
          SA7    "ST"        [ST]  = N
          S"N"   X3          N = I         */ SET TO VISIT SUCCESSOR
          EQ     SNO2 
  
*         LAST VISIT TO NODE, ASSIGN NUM(NO) = BLOCK NUMBER 
  
 SNO4     PX6    "NS",X6
          LX6    I.SUIP 
          SA6    A6 
  
          SA1    "C0"+"NO"
          R=     X7,"N" 
          LX7    I.BNP
          BX6    X1+X7       BN[C(NO)] = N */ SET ORDER OF LAST VISIT 
          SA6    A1 
          S"NO"  "NO"+B1     NO = NO + 1
          SA4    "ST" 
          S"N"   X4          N = [ST]      */ FETCH LAST FROM STACK 
          S"ST"  "ST"-B1     ST = ST - 1
          NZ     "N",SNO2    IF N " 0 
  
          MX6    0
          SA6    A6+B1       C(NO) = 0     */ TABLE TERMINATOR
          SX7    "NO"+B1
          TRACE  SNO,CFT
          SA7    L.CFT       L.CFT = NO + 1 
          EQ     SNO
 CLI      TITLE  CLI - COMPUTE LIVE EXIT INFORMATION
**        CLI - COMPUTE LIVE EXIT INFORMATION ( BIT VECTORS ).
*                COMPUTE THE LIVE EXIT ( LX ) BIT VECTORS FOR EACH
*         PROGRAM BLOCK.   THE METHOD IS TAKEN FROM THE ALGORITHMS
*         DESCRIBED IN THE PAPER "ANALYSIS OF A SIMPLE ALGORITHM FOR
*         GLOBAL FLOW PROBLEM" BY HECHT AND ULLMAN, PAGES 207 - 217 IN
*         THE ACM CONFRENCE RECORD, OCT 73 SIGACT/SIGPLAN MEETING.
  
 BI       MICRO  1,,/B5/     O.BIT
 EI       MICRO  1,,/B6/     EDGE INDEX TABLE BASE
 BV       MICRO  1,,/B7/     O.BVT
  
 CLI      ROUTINE 
          SA2    O.IST
          SA2    X2+2        GBM = [O.IST+2]
          LX2    -GB.ILIP 
          ALLOC  RND,X2+3    ALLOC( RND , ILI[GBW]+3 )
          SA4    O.CFT
          SA1    O.BVT
          SA7    X2          CS = [O.RND]  */ LOOP CONTROL STORE INDEX
          SA3    O.IST
          SA0    X2+B1       C0 = CS + 1
          SA5    X4+B1       NI = [O.CFT] + 1;  I = BN[NI]
          SA2    O.BIT
          MX0    1
          S"BI"  X2 
          S"EI"  X3+3        EIB = O.IST + 3  */ EDGE INDEX BASE
          S"BV"  X1 
  
*         SETUP THE LOOP CONTROL VECTOR FOR THE LIVE EXIT COMPUTATION 
  
 CLI1     SA4    "EI"+X5     EI = EIB + I 
          SB4    "BI"+X5
          LX4    -EI.SUIP 
          UX6    B2,X4       NS = NS[EI]
          SA3    B4+X5
          SA2    "EI"+X4     SI = EIB + SUI[EI] 
          LX3    -BI.BVIP    VI = BVI[BIT(2*I)] 
          SX7    "BV"+X3     BVA = O.BVT + VI 
          SA7    A7+B1       CS = CS + 1;  [CS] = BVA 
  
 CLI2     LX2    -ET.SUCCP   J = SUCC[SI] 
          SB3    "BI"+X2
          SA1    B3+X2
          SA2    A2+B1       SI = SI + 1
          SB2    B2-B1       NS = NS - 1
          LX1    -BI.BVIP 
          SX6    "BV"+X1     BVA = O.BVT + BVI[BIT(2*J)]
          BX7    X0+X6
          SA7    A7+1        CS = CS + 1;  [CS] = 1S59 + BVA
          NZ     B2,CLI2     IF NS " 0
  
          SA5    A5+1        NI = NI + 1;  I = BN[NI] 
          NZ     X5,CLI1     IF [NI] " 0
          MX7    0
          SA7    A7+B1       CS = CS + 1;  [CS] = 0  */ TERMINATOR
 CLI      SPACE  1,10 
*         NOW COMPUTE THE LIVE EXIT VECTORS FOR EACH PROGRAM BLOCK
  
          SA4    BVL
          SB2    B0          WI = 0        */ WORD INDEX
          SB3    X4+B1       VL = BVL + 1  */ LIMIT 
          SB4    X4+B1       WIF = VL      */ WI TO *UBD* VECTOR
          SB5    B3+B3
          SB5    B5+B3       WIL = 3*VL    */ WI TO LX VECTOR 
          SB6    B0          N = 0         */ N.ITERATIONS
  
 CLI3     SA5    A0+         CI = C0;  BVA = [CI] 
          SX0    0           CHNG = 0 
  
 CLI4     SA4    X5+B5       LXA = BVA + WIL;  OLX = [LXA]
          SA5    A5+1        CI = CI + 1;  BVA = [CI]  */ BV ADDR OF SUC
          MX7    0           LX = 0 
  
*         LX = ! ( ( LX & ^DEF ) ! UBD ) OVER SUCCESSORS OF THE NODE. 
  
 CLI5     SA1    X5+B5       LXS = [BVA+WIL]
          SA2    X5+B2       DVS = [BVA+WI] 
          SA3    X5+B4       UFS = [BVA+WIF]
          SA5    A5+B1       CI = CI + 1;  BVA = [CI] 
          BX6    -X2*X1 
          NO
          BX1    X6+X3
          BX7    X1+X7       LX = LX ! ((LXS&^DVS)!UFS) 
          MI     X5,CLI5     IF [CI] < 0   */ NEXT IS A SUCC ADDR 
  
          BX6    X4-X7
          SA7    A4          [LXA] = LX 
          BX0    X0+X6       CHNG = CHNG ! XOR(OLX,LX)
          NZ     X5,CLI4     IF [CI] " 0   */ NOT END OF CONTROL VECTOR 
  
*         TEST FOR CONVERGENCE OF LX VECTORS
  
          CX6    X0 
          SB6    B6+B1       N = N + 1
          NZ     X6,CLI3     IF COUNT( CHNG ) " 0 
  
*         ADVANCE TO NEXT BIT VECTOR WORD 
  
          SB2    B2+B1       WI = WI + 1
          SB4    B4+B1       WIF = WIF + 1
          SB5    B5+B1       WIL = WIL + 1
          SB6    B0          N = 0
          LT     B2,B3,CLI3  IF WI < VL 
          EQ     CLI
  
          IFLT   *-FBV,100B,1 
          BSS    FBV+100B-* 
  
          END 
