*DECK     MCG 
          IDENT  MCG
 MCG      TITLE  MCG - MACHINE CODE GENERATOR 
*CALL     SSTCALL 
          PASS2TM 
 B=MCG    RPVDEF
  
          TABLES TXT,TREE,PIT,OTI 
*IF       DEF,MCG,1 
          TRACER (II,FINAL,HEAD)
  
 INCT     MICRO  .CPU-71,1,/11411/ INCREMENT UNIT TIME
 MCG      SPACE  3
**        MCG - MACHINE CODE GENERATOR - SCHEDULING AND LOCAL REGISTER
*         ASSIGNMENT. 
* 
*         S.I. JASIK - MARCH 73 
* 
*         *MCG* ORDERS THE INSTRUCTIONS IN THE CODE SEQUENCE SUBJECT TO 
*         THE CONSTRAINTS OF THE PARTIAL ORDER IMPOSED ON IT BY *BDT*,
*         WHICH ARE - 
*          1) DATA INTERFERENCE DEPENDENCIES ( LD/ST INTERFERENCE ) 
*          2) OPERAND DEPENDENCIES
*          3) BOUNDARY MARKER DEPENDENCIES  ( AN INSTRUCTION MUST BE
*         LINKED TO THE NODES OF THE BOUNDARIES OF THE BASIC BLOCK THAT 
*         IT BELONGS TO ).
*          4) EXPLICIT USE OF SPECIFIC RESOURCES ( REGISTERS ). 
*            I.E. THE REUSE/REDEFINITION OF A REGISTER MAY NOT OCCUR
*         UNTIL ALL USES OF THE FIRST DEFINITION HAVE BEEN EXHAUSTED. 
* 
*         THE RESULTANT NETWORK/DEPENDENCY GRAPH ( NOT A TREE ) IS
*         EXPRESSED AS A SUCCESSOR INDEX TABLE, SORTED BY PREDECESSOR,
*         LATE START TIME, AND SUCCESSOR ORDINAL, AND A COUNT OF THE
*         NUMBER OF PREDECESSORS OF EACH INSTRUCTION. 
*         THE PRED COUNT, INDEX TO *SIT*, ETC ARE KEPT IN THE LINK WORD 
*         OF AN *IL* INSTRUCTION (R1+3 ) IN "I." FORMAT.
*         THE ISSUE ( REMOVAL ) OF AN INSTRUCTION FROM THE NETWORK
*         REDUCES THE COUNT OF REMAINING PREDECESSORS ( CONSTRAINTS ) 
*         ON THE SUCCESSORS OF THE ISSUED INSTRUCTION.
*         WHEN THE PRED COUNT BECOMES ZERO THE INSTRUCTION IS ADDED TO
*         THE ISSUE CANDIDATE LIST, AND EVENTUALLY ISSUED.
*         ALSO CALCULATED IN *BDT*, IS THE LATE START TIME, WHICH IS
*         THE LATEST TIME AT WHICH THE INSTRUCTION CAN BE ISSUED WITHOUT
*         INCREASING THE TOTAL TIME ( *SEQTIME* ) IT TAKES TO GET TO
*         THE *EOQ*.
* 
*         TO GENERATE CODE FOR A SEQUENTIAL MACHINE ( I.E. CPU @ 6400 ) 
*         IT IS SUFFICIENT TO CONSIDER ONLY THE REGISTER ALLOCATION (JAM
*         PROBLEM, AND ATTEMPT TO MINIMIZE THE CODE LENGTH AND NUMBER 
*         OF STORES TO COMPILER GENERATED TEMPORARIES.
*         FOR A MULTI-FUNCTIONAL UNIT MACHINE ( 6600, 7600 ) IT IS
*         NECESSARY TO ALSO CONSIDER TIMING INFORMATION AND SIMULATE
*         THE CPU ( TEMPORAL FUNCTIONAL UNIT AND REGISTER AVAILABILITY )
* 
*         THE FORMER PROBLEM HAS A THEORETICAL SOLUTION ( AHO, ULLMAN - 
*         1970 ) WHICH IS NOT COMBINATORIAL IN NATURE WHEN THE NETWORK
*         IS A TREE ( NO MULTIPLE USES OF THE RESULT OF AN INSTRUCTION )
*         , AS OPPOSED TO A DIRECTED ACYCLIC GRAPH. 
* 
*         THE PROBLEM OF PRODUCING AN OPTIMAL SCHEDULE FOR A NETWORK
*         WITH N TASKS AND K PROCESSORS ( K = 9,10 IN OUR CASE )
*         HAS NO GENERAL SOLUTION.  MOST OF THE CURRENT METHODS ARE 
*         COMBINATORIAL IN NATURE ( AND IN THE NUMBER OF STEPS ). 
*         IN ORDER TO KEEP COMPILATION TIME FINITE AND REASONABLE 
*         WE CONTENT OURSELVES WITH A 1 PASS ALGORITHM. 
*         THE BASIC ALGORITHM FOR MAINTAINING THE ISSUE CANIDATE LIST IS SIMILAR
*         SIMILAR TO THE "TOPOLOGICAL SORT" DESCRIBED IN VOL I OF KNUTH.
*         THE SELECTION CRITERIA FOR INSTRUCTION IN SCHEDULING MODE 
*         IS "EARLIEST START TIME". 
* 
*         THE FOLLOWING ARE THE TIMING FORMULA OF THE 66/7600 - 
* 
*         T(IS) = MAX( T , TRA(RESULT) , TFU(F) )          ISSUE TIME 
*         T(EX) = MAX( T(IS) , TRA(OPERANDS) )             EXECUTE TIME 
*                T(IS) = T(EX)  FOR A 7600
*         TRA(REGNO) = MAX( T(EX)+FT[DI] , TLU(REGNO) )    RESULT AVAIL 
*         TFU(F) = TRA(REGNO) + 1                          FUNIT AVAIL
*         TLU(OPERANDS) = MAX( TLU(OPERANDS) , T(EX) )     LAST USE 
*         T = T(EX) + N.PARCELS ( + IWTIME )               MIN ISSUE TIM
* 
*         AT PRESENT THE SCHEDULER IGNORES THIRD ORDER CONFLICTS AND THE
*         FORMULAS IT USES ARE -
*         TRA(REGNO) = T(EX) + FT[DI] 
*         TRA(REGNO) = T(EX) + 1   WHEN A REGISTER IS RELEASED. 
  
          LIST   -R 
  
 BOOL     EQU    2           ORDINAL OF BOOLEAN UNIT
 RN.X0    EQU    20B         *SO* REGISTER NUMBER FOR X0
 RN.A0    EQU    10B         *SO* REGISTER NUMBER FOR A0
 AMX      EQU    -10B        RN.A0-RN.X0  , X TO A CONVERSION 
 T(INF)   EQU    377777B     *INFINITY* 
 MAX.GX   EQU    2           MAX NUMBER OF GENERATED XMITS
 DELTAT   EQU    4           MIN DELTA T FOR *LST* CHECK IN *SNI* 
  
 MX.TXT   ENTRY. 100B        MAX *TXT* LENGTH 
          SPACE  2
*         TYIOM - TYPE I OPERAND MASK AND SHIFT TABLE 
  
          ENTRY  TYIOM
 TYIOM    BSS    0
          VFD    12/2020B,16/-1,16/-1,16/0   RJ, RK 
          VFD    12/2020B,16/0,16/-1,16/0    RK 
          VFD    12/2000B,16/-1,16/-1,16/-1  RJ, RK, RI 
 FXR      TITLE  MACRO DEFINITIONS
**        FX. - VALUES OF THE REGISTERS FOR *FXR* 
  
          ECHO   1,N=(1,2,3,4,5,6,7)
 FX.X_N   EQU    1S_N*1S8 
 FX.X0    EQU    FX.X7*2
 FX.XT    EQU    1S8+1S17    SEARCH TERMINATOR AND EXPONENT BIT 
  
          ECHO   1,N=(0,1,2,3,4,5,6,7)  B-REGISTER BIT VALUES 
 FX.B_N   EQU    1S_N 
  
*         REGISTER CLASSES ( BIT VALUE MASKS )
  
 FB       EQU    2*FX.B7-1         ALL B REGISTERS
 FX       EQU    2*FX.X0-FB-1      ALL X REGISTERS
  
 FX.LD    EQU    FX.X1+FX.X2+FX.X3+FX.X4+FX.X5   LOAD REGISTERS 
 FX.ST    EQU    FX.X6+FX.X7       STORE REGISTERS
 FX.SCR   EQU    FX.X0+FX.LD+FX.ST ALL REGISTERS
  
*         FXRA - REGISTER TRANSLATION TABLE ( SEARCH ORDER )
  
 FXRA     BSS    0
          ECHO   1,N=(0,7,6,5,4,3,2,1)
          VFD    42/FX.X_N,18/RN.X0+N 
          CON    -1          TABLE TERMINATOR 
 FXR      SPACE  2
**        FXR - CALL *FXR* TO FIND A RESULT REGISTER IN CLASS *RC*
*         CALL -
*         FXR    RC,SEXIT,FEXIT 
*                RC = REGISTERS IN CLASS ( LD , ST , SCR )
*                SEXIT = SUCCESS EXIT 
*                FEXIT = FAIL EXIT ( FALL THROUGH IF ABSENT ) 
  
 FXR      MACRO  RC,SEXIT,FEXIT 
          SA1    AXR
          IF     -REG,RC,1
          SX5    FX.RC+FX.XT
          BX7    X1*X5       AVAIL = AXR & CLASS
          NX6    B3,X7
          SA3    B3+FXRA+16-47
          IFGE   .CPU,74                                         ?66/76 
          SA2    TRA+X3 
          SB2    X2 
          SB3    X3 
          LE     B2,B5,SEXIT IF TRA(REGNO) @ T(IS)
          ELSE   2                                               '66/76 
          SB3    X3 
          GT     B3,SEXIT 
          RJ     FXR
          SB3    X3 
          IFC    NE,/FEXIT//,2
          MI     X3,FEXIT 
          ELSE   1
          PL     X3,SEXIT 
          ENDM
 DEBUG    TITLE  DEBUGGING FACILITIES 
**        PRNT - PRINT OUT *THING* AT *LAB* IF *THING* OR *LAB* IS
*         MENTIONED ON A *TRACER* DIRECTIVE.
*         TO DEFINE *PRNT* CALL LABELS -
*         TRACER (HEAD,II,FINAL,RUI,TIMES,ICL)
  
 PRNT     MACRO  LAB,THING,SAVPBI 
          LOCAL  APL         *** DESTROY B2,X6,A6 IF SAVPBI " 0 
          IF     -DEF,/DEBUG/LAB,1
 X        IF     DEF,/DEBUG/THING 
          IFC    NE,/SAVPBI//,3 
          SB2    "DI"+B1
          SX6    B2-"TB"
          SA6    PBI+1
+         RJ     CPR
-         VFD    30/APL 
          USE    DEBUG
 APL      CON    0,Z.THING,*+2,0,10H LAB
          USE    0
 X        ENDIF 
          ENDM
  
 .T       IFNE   TEST,0 
          USE    DEBUG
 Z.ICL    CON    1           ISSUE CANIDATE LIST
 Z.II     CON    2           ISSUED INSTRUCTION 
 Z.RUI    CON    3           REGISTER USEAGE INFO 
 Z.TIMES  CON    4           FU AND X-REG AVAIL TIMES 
 Z.FINAL  CON    5           FINAL SUMMARY
 Z.HEAD   CON    6           LISTING HEADER ( II AND FINAL OPTIONS ONLY 
  
**        CPR - CALL PRINT ROUTINE
  
 CPR0     RJ     =XRESET= 
 CPR      ROUTINE 
          RJ     =XSAVE=
          SA1    CPR
          SA4    O.TXT
          LX1    30 
          SA2    X1-1 
          BX6    X4 
          SA6    X2          [APL] = [O.TXT]
          SA1    A6 
+         RJ     =XPRNTMCG
          SA1    EOQA 
          PL     X1,CPR0
          BX6    -X1
          SA6    A1 
          RJ     =XRESET= 
          SNAPT  TXT,CPR-ERR
          EQ     CPR
  
          USE    0
 .T       ENDIF 
 FLAGS    TITLE  VARIABLES
          USE    /MCG/
 N.INST   BSS    1           NUMBER OF INSTRUCTIONS ( L.TXT/4 ) 
 N.SP     BSS    1           -( NUMBER OF STORE PREDECESSOR OPS ) 
 SEQTIME  BSS    1           CRITICAL PATH TIME 
  
 ICL      BSS    1           ISSUE CANDIDATE LIST POINTER 
 RMR      BSSZ   1           24/0,18/CA,18/A-REG NUMBER 
          VFD    12/1776B,12/0,18/T(INF),18/T(INF)
 PBI      BSS    2           PREVIOUS BEST INST INFO ( PB. FORMAT ) 
  
 DT       CON    4           DELTA T FOR *LST* CHECK
 IWT      CON    .IWT        INTERWORD TIME ( =0 IF NOT A SLOW 6600 ) 
  
 AXR      CON    1S58+FX+FB  AVAILABLE X AND B REGISTERS
 ALR      CON    FX.LD+FX.XT AVAILABLE LOAD REGISTERS 
 STL      CON    -FX.X6      STORE LOCKOUT FLAG 
  
 RVT      BSSZ   24          REGISTER VALUE TABLE ( R-NUMBER IN REGISTER
*                            1/LOCK,59/INDEX TO *TXT* OF *RI* IN REG
  
          CON    1S59+T(INF)       TRA-1  ( FOR *FXR* ) 
 F.CLC    BSS    0          ?FWA OF CLEARED CELLS 
 TRA      BSS    24          TIME REGNO(I) AVAILABLE ( BAX ORDER )
 ARA      BSS    8           A-REGISTER ADDRESS INFO ( [IH WORD] )
 TFU      BSS    12          TIME FU(I) AVAILABLE 
 LST      BSS    2           COMPLETION TIME OF LAST STORE ( 6600 ) 
 LLT      EQU    LST+1       COMPLETION TIME OF LAST LOAD 
 LXR      BSS    1           LOCKED X AND B-REGISTERS 
 NGX      BSS    1           N.GENERATED XMITS
 T        BSS    1           CURRENT SIMULATION TIME ( MINOR CYCLES ) 
 PC       ENTRY. 0           PARCEL COUNT ( 0 - 3 ) 
 TRS      BSS    1           BIT I SET IF A RESULT WILL BE READY AT T+I 
 L.CLC    EQU    *-F.CLC    ' 
  
 JLR      CON    0           BIT(47-REGNO) SET FOR REGISTERS LOCKED 
*                            UNTIL NEXT UNCONDITIONAL JUMP. 
 LRM      BSS    2           LOCKED REG MODE, INITIAL PIT LENGTH
 EOQA     CON    0           ADDRESS OF *EOQ* PROCESSOR 
 IIP      BSS    2           ISSUED INST PTR ( *PIT* ADDR ) / O.PIT 
 EIW      BSS    1           -(NUMBER OF EXTRA PIT WORDS LEFT) JAM MODE 
  
*         RBV - REGISTER BIT VALUE TABLE ( *SO* REGNO ORDER ) 
  
 RBV      BSS    0
          ECHO   1,N=(0,1,2,3,4,5,6,7)
          CON    FX.B_N 
          BSSZ   8           A-REGISTERS
          ECHO   1,N=(0,1,2,3,4,5,6,7)
          CON    FX.X_N 
  
          USE    /TABLES/ 
 SVL      BSS    100B        SAVED LINK WORDS 
          USE    0
  
 DTT      BSS    1           DELTA T TABLE
          ECHO   1,D=(DELTAT,8,16,32) 
          VFD    15/D 
 TABLES   TITLE  TABLE DEFINATIONS
**        USES INDEX ( SUCCESSOR ) TABLE
  
          DESCRIBE U.,60
 LAST     DEFINE 1           "0 IF LAST EDGE OF A GROUP 
 RDL      DEFINE 1           REGISTER REDEFINITION LINK 
 EQV      DEFINE 1           DATA INTERFERENCE LINK 
          DEFINE 3
 PRED     DEFINE 18          INDEX TO *TXT* OF PRED 
 LST      DEFINE 18          LATE START TIME OF SUCCESSOR 
 SUCC     DEFINE 18          INDEX TO *TXT* OF SUCCESSOR
 INFO     SPACE  2
*         LINK INFORMATION WORD    ( INFO SETUP BY *BDT* )
  
          DESCRIBE I.,60
 II       DEFINE 1           "0 IF INSTRUCTION IS ISSUED ( POSTED ) 
 IC       DEFINE 1           "0 IS INSTRUCTION ON ISSUE CANDIDATE LIST
          DEFINE 1
 USES     DEFINE 9
 INDX     DEFINE 15          INDEX TO *TREE* OF SUCCESSORS OF INSTRUCTION 
 LST      DEFINE 15          LATE START TIME
 NPRED    DEFINE 18          NUMBER OF UNISSUED PREDECESSORS
  
 LINK     DEQU   NPRED       INDEX TO NEXT ON ISSUE CANIDATE LIST 
 REG      DEQU   NPRED       REGISTER NUMBER THAT *RI* IS IN ( ISSUED ) 
 PBI      SPACE  2
**        FORMAT OF SAVED PREVIOUS BEST INSTRUCTION INFO
  
          DESCRIBE PB.,60    FIRST WORD 
 REG      DEFINE 12          PACKED REGISTER ORDINAL
          DEFINE 12 
 TEX      DEFINE 18          EXECUTION TIME 
 TIS      DEFINE 18          ISSUE TIME 
  
          DESCRIBE PB.,60    SECOND WORD
 FU       DEFINE 12          PACKED FUNIT ORDINAL 
          DEFINE 12 
 PI       DEFINE 18          INDEX TO *TXT* OF PREVIOUS INST
 LI       DEFINE 18          INDEX TO *TXT* OF PREVIOUS BEST INST 
 REGAS    SPACE  3
**        THE FOLLOWING REGISTER ASSIGNMENTS ARE HELD OVER MOST OF *MCG*
* 
*         (B1) = 1  , B2 - SCRATCH
*         B3 - REGNO
*         B4 - T(EX) EXECUTION START TIME OF CURRENT INSTRUCTION
*         B5 - T(IS) ISSUE TIME OF CURRENT INSTRUCTION
*         B6 - TIS(PBI) IN *SNI*, *DRR*, ETC., ELSE SCRATCH 
 TB       MICRO  1,,/B7/     O.TXT + 3
 PI       MICRO  1,,/A0/     *TXT* INDEX OF PREVIOUS INSTRUCTION
 DI       MICRO  1,,/A4/     ADDRESS OF DESCRIPTOR OF CURRENT INST
 RN       MICRO  1,,/-X0*/   R-NUMBER EXTRACTOR MASK
  
*         THE OTHER X-REGISTERS MAY BE USED AS SCRATCH .
 MCG      TITLE  CONTROL / INITIALIZATION 
          LIST   F,R
  
**        MCG - MACHINE CODE GENERATOR ( CONTROL / MAIN LOOP )
* 
*         ENTRY  (X6) = LRM , " 0 IF LOCKED X-REGISTERS 
* 
*         EXIT   (X6) = FAIL , " 0 IF SCHEDULER COULDNT CODE THE
*                SEQUENCE WITH LOCKED REGISTERS.
  
 MCG      ENTRY. ** 
          SA1    L.PIT
          SX7    X1+
          SA6    LRM         LRM = FLAG 
          SA7    A6+1        IPL = L.PIT   */ SAVE INITIAL *PIT* LENGTH 
  
 #MD      IFGE   .CPU,74                                         ?66/76 
          SA5    L.TXT
          SA1    =XOPT2 
          SB2    X5-4*64
          SA2    =XWB 
          PL     B2,MCG9     IF L.TXT \ 4*64
  
          NZ     X1,MCG1     IF OPT2 " 0
          SX3    X2-1 
          NZ     X3,MCG9     IF WB " 1     */ NOT OPT=1 & INNERMOST LOOP
  
 MCG1     SA5    O.TXT
          CALL   CRW         COMPUTE REG WIDTH
          PRINT  MCG,(*  LINENR,REGW =*2I5),(=XLINENR,X6) 
          SB6    X6 
          SB7    9
          LT     B6,B7,MCG2  IF MAXW @ 8
          GT     B6,B7,MCG9  IF MAXW > 9
  
 MCG2     SA1    DTT+1
          SB7    B7-B1
          BX7    X1          DTT = DTT(2)  */ SET INCREMENT VALUES
          LT     B6,B7,MCG3  IF MAXW < 8
          AX7    15          DTT = SHIFT(DTT,-15)  */ SET FOR 3 TRIES 
 MCG3     SA7    A1-B1
          MX6    0
          CALL   BDT         FORM THE DEPENDENCY GRAPH
  
*         SAVE THE LINK WORDS 
  
          SA1    O.TXT
          SA2    N.INST 
          SA5    X1+3 
          SB2    X2-1 
          BX6    X5 
          SA6    SVL
 MCG5     SA5    A5+4        FOR I = 1 TO N.INST;  SVL(I) = TXT(4*I)
          SB2    B2-B1
          BX6    X5 
          SA6    A6+B1
          NZ     B2,MCG5
  
*         TRY SCHEDULING THE SEQUENCE WITH DIFFERENT LOOK AHEAD VALUES
*         UNTIL IT CAN BE CODED SUCCESSFULLY ( *SIS* EXITS TO *MCG14* ) 
  
 MCG6     SA1    DTT
          MX3    -15
          BX6    -X3*X1      DT = DTT & 77777B  */ SET LOOK AHEAD VALUE 
          SA6    DT 
          SX7    MCG14
          RJ     SIS         SCHEDULE THE SEQUENCE
  
*         FAILURE, RESTORE LINK WORDS AND TRY WITH A SMALLER DELTA T. 
  
          SA1    DTT
          AX1    15 
          BX6    X1          DTT = SHIFT(DTT,-15)  */ ADVANCE TO NEXT IN
          SA6    A1 
          ZR     X1,MCG11    IF DTT = 0    */ END OF DELTA T TABLE
  
          SA5    SVL
          SA1    O.TXT
          SA2    N.INST 
          BX6    X5 
          SB2    X2-1 
          SA6    X1+3 
          SB4    4
 MCG7     SA5    A5+B1       FOR I = 1 TO N.INST;  TXT(4*I) = SVL(I)
          SB2    B2-B1
          BX6    X5 
          SA6    A6+B4
          NZ     B2,MCG7
  
          EQ     MCG6 
  
 MCG9     SX6    DELTAT 
          SA6    DT          DT = DELTAT   */ SET DEFAULT DELTA T 
  
 #MD      ENDIF                                                  ?66/76 
  
*         INITIALIZE FOR SCHEDULING MODE
  
 MCG10    MX6    0
          CALL   BDT         FORM THE DEPENDENCY GRAPH
          SX7    MCG14
          RJ     SIS         TRY AND SCHEDULE THE SEQUENCE
  
*         SCHEDULER FAILED, TRY *JAM* IF NOT *LOCKED X MODE*. 
  
 MCG11    SA1    LRM
          SX6    B1          FAIL = 1 
          MX7    0
          SA7    L.TREE      L.TREE = 0 
          NZ     X1,MCG      IF LRM " 0    */ LOCKED X-MODE 
          SA1    ALR
          SX2    FX.LD
          BX3    X2*X1
          IX4    X2-X3
          NZ     X4,MCG      IF ALR&FX.LD " FX.LD  */ LOCKED A-REGISTERS
  
          RJ     /JAM/JAM    JAM CODE THE SEQUENCE
  
 MCG14    BSS    0
          PRNT   JAM,FINAL
          SA1    LXR
          SX6    0           FAIL = 0 
          SA6    L.TREE      L.TREE = 0 
          ZR     X1,MCG      IF LXR = 0    */ RVT IS ZERO 
          RJ     CLR         CLEAR *RVT*
          EQ     MCG
 SIS      SPACE  3,14        SIS
**        SIS - SCHEDULE INSTRUCTION SEQUENCE 
* 
*         ENTRY  (X7) = SUCCESS EXIT ADDRESS
* 
*         EXIT   RETURNS TO CALLER IF CANNOT CODE SEQUENCE, ELSE TO 
*                SUCCESS EXIT.
  
 SIS0     SA1    LRM+1
          SX7    X1+         L.PIT = IPL   */ RESTORE *PIT* LENGTH
          SA7    L.PIT
          RJ     CLR         CLEAR *RVT*
  
 SIS      ROUTINE 
          SX0    0
          RJ     PRS         PRESET STORAGE 
 #MD      IFGE   .CPU,74                                         ?66/76 
          SA1    DT 
          SA2    SNIB 
          LX1    30 
          BX7    X1+X2       PLUG *DT* IN *SNI* 
          SA7    SNI.P
 #MD      ENDIF                                                  ?66/76 
          EQ     SIS2 
  
 SIS1     RJ     AIL         ADJUST THE ISSUE LIST
          RJ     DUC         DECREMENT USES COUNTS
          SA4    "DI" 
          RJ     ASC         ADVANCE THE CLOCKS 
          SA5    "DI"-2      R1 = DI - 2
          RJ     SII         SAVE THE ISSUED INSTRUCTION
  
 SIS2     RJ     SNI         SELECT THE NEXT INSTRUCTION TO ISSUE 
          PL     B3,SIS1     IF REGNO > 0  */ ISSUABLE INSTRUCTION FOUND
 SIS      SPACE  1,10 
*         CHECK FOR A STORE REGISTER JAM, AND GENERATE AN *XMT* 
*         IF POSSIBLE.
  
          SA1    AXR
          SA5    NGX
          SX2    FX.ST
          SX3    FX.SCR 
          BX2    X2*X1
          BX3    X3*X1
          NZ     X2,SIS0     IF AXR & FX.ST " 0  */ NOT ST-REG JAM
          ZR     X3,SIS0     IF AXR & FX.SCR = 0  */ ALL REGS IN USE
          SB3    X5-MAX.GX
          ZR     B3,SIS0     IF NGX = MAX.GX  */ GEN XMT LIMIT REACHED
  
*         FIND A ST-REG WHOSE RESULT CAN BE MOVED TO ANOTHER REGISTER.
  
          SB4    RN.X0+6     REGF = X6     */ TRY X6
          RJ     CSR
          ZR     X7,SIS3     IF CSR(REGF) = 0  */ RESULT CAN BE MOVED 
          SB4    B4+1        REGF = X7
          RJ     CSR
          NZ     X7,SIS0     IF CSR(REGF) " 0 
  
 SIS3     SA1    AXR
          SA2    T
          SX5    FX.SCR+FX.XT 
          BX7    X1*X5       AVAIL = AXR & FX.SCR 
          NX6    B3,X7
          SB5    X2+         T(IS) = T
          SA3    B3+FXRA+16-47
          SA2    TRA+X3 
          SB2    X2 
          SB3    X3          REGR = FXR( SCR )  */ RESULT REG 
          LE     B2,B5,SIS4  IF TRA(REGR) @ T(IS) 
          SB5    B2          T(IS) = TRA(REGR)
 SIS4     SB2    OC.XMT 
          RJ     /JAM/OXI    OUTPUT AN *XMT* INSTRUCTION
          SA2    NGX
          SX6    X2+B1       NGX = NGX + 1
          SA6    A2 
          EQ     SIS2 
 CSR      SPACE  3,14        CSR
**        CSR - CHECK SPECIFIED REGISTER TO SEE IF THE RESULT IN IT 
*         CAN BE MOVED TO ANOTHER REGISTER ( ^PRS , ETC). 
* 
*         ENTRY  (B4) = REGF , REGNO OF REGISTER TO BE CHECKED. 
* 
*         EXIT   (X7) = PSF = 0 IF RESULT IN REGF CAN BE MOVED
  
 CSR4     LX4    D.PSP-D.PRSP 
          MX6    1
          BX7    X6*X4       PSF = PRS[DI] */ MOVABLE IF ^PRS 
  
 CSR      ROUTINE 
          SA1    RVT+B4      R = RVT(REGF)
          SB6    "TB"-B1
          SA4    B6+X1       DI = BASE-1 + R
          LX4    59-D.PIP 
          MI     X4,CSR3     IF PI[DI]     */ PSEUDO INSTRUCTION
          LX4    D.PIP-D.PSP
          PL     X4,CSR4     IF ^PS[DI] 
  
*         RESULT *PS*, CHECK UNISSUED SUCCESSORS OF *R* 
  
 CSR0     SA5    A4+B1       LI = DI + 1
          MX7    -I.INDXL    PSF = 1
          SA2    O.TREE 
          LX5    -I.INDXP 
          BX6    -X7*X5 
          SB2    X2 
          SA3    B2+X6       UI = O.TREE + INDX[LI] 
  
 CSR1     LX3    -U.SUCCP 
          SA5    "TB"+X3     SI = BASE + SUCC[UI] 
          LX5    59-I.IIP 
          MI     X5,CSR2     IF II[SI]     */ ISSUED
          SA2    A5-3        R1S = SI - 3 
          BX5    X2-X1
          BX6    "RN"X5 
          NZ     X6,CSR2     IF RI[R1S] " R  */ NOT USED IN *RI*
          SA2    A5-B1       D = SI - 1 
          LX2    59-D.STP 
          PL     X2,CSR2     IF ^ST[D]
          LX2    D.STP-D.L2P
          PL     X2,CSR      IF ^L2[D]     */ UNISSUED STORE
 CSR2     BX6    X3          UL = UI
          SA3    A3+B1       UI = UI + 1
          LX6    U.SUCCP+59-U.LASTP 
          PL     X6,CSR1     IF ^LAST[UL] 
  
          MX7    0           PSF = 0
          EQ     CSR
  
 CSR3     SA5    A4-2        R1 = DI - 2   */ INSTRUCTION IS A *DEF*
          MX6    1
          LX5    58-R1.SOP-SO.LKP 
          BX7    X6*X5       PSF = SOLK[R1]/2  */ =1 IF A FULL LOCK 
          NZ     X7,CSR      IF PSF " 0 
          EQ     CSR0 
 CLR      SPACE  3,10        CLR
**        CLR - CLEAR *RVT* 
  
 CLR1     SA7    A6+B1       FOR I = 1 TO 23; RVT(I) = 0
          LX5    1
          SA6    A7+1 
          MI     X5,CLR1
 CLR      ROUTINE 
          SX6    B0 
          MX5    22/2 
          SX7    0
          SA6    RVT+1
          EQ     CLR1 
 PRS      SPACE  3,24        PRS
**        PRS - PRESET STORAGE ( INITIALIZATION ) 
* 
*         ENTRY  (X7) = *EOQ* PROCESSOR ADDRESS 
*                (X0) = CODE MODE, 0/1 = NORMAL/JAM 
  
 PRS      ROUTINE 
          SA7    EOQA        EOQA = EOQP
          IFNE   .IWT,0,2 
          SX6    .IWT 
          SA6    IWT         IWT = .IWT    */ SET INTERWORD TIME
          SX7    FX+FB
          MX5    L.CLC/2
          PX7    X7 
          SA7    AXR         AXR = PACK( 0 , FX + FB )
          SX6    FX.LD+FX.XT
          SA6    ALR         ALR = FX.LD
          SX7    B0 
          MX6    0
  
          SA7    F.CLC       FOR I = 0 TO L.CL , CLC(I) = 0 
 PRS1     SA6    A7+B1
          LX5    1
          NO
          SA7    A6+B1
          MI     X5,PRS1
  
          SA5    N.INST      WDS = N.INST 
          ZR     X0,PRS2     IF MODE = 0   */ NOT JAM MODE
          BX7    -X5
          LX5    1           WDS = 2*N.INST 
          SA7    EIW         EIW = -N.INST
          ALLOC  OTI,30B     ALLOC OTI,30B
  
 PRS2     ALLOC  PIT,X5+MAX.GX+1   ALLOC( PIT , WDS+MAX.GX+1 )
          SA5    =XPARCEL 
          SB5    B6+B1
          BX7    X2 
          SA7    IIP+1       IIP(2) = O.PIT 
          SX6    X2+B5
          SA6    A7-B1       IIP(1) = O.PIT + OLD(L.PIT) + 1
          BX7    X5 
          SA7    PC          PC = PARCEL
  
*         SET UP THE ISSUE CANDIDATE LIST BY ISSUING THE *BOS*
  
          PRNT   JAM,HEAD 
          SA3    O.TXT
          SB7    X3+3        BASE = O.TXT + 3 
          SA4    X3 
          SB3    B0 
          BX7    X4          [IIP-1] = [O.TXT]  */ SET *BOS* FOR POST 
          SA7    X6-1 
          SA4    =XCO.ER
          NZ     X5,PRS3     IF PARCEL " 0
          ZR     X4,PRS3     IF ER = 0     */ NO OBJ TIME RPV 
  
          MX5    -R1.INP
          BX7    X5*X7
          SX4    200B 
          SB2    OC.STT 
          UX5    X7 
          ZR     X5,PRS3     IF LINE NUMBER ZERO
          PX7    B2,X7
          BX7    X4+X7
          SA7    A7+B1       [IIP] = SI(OC.STT,LINE,200B) 
          SX6    X6+B1       IIP = IIP + 1
          SA6    A6 
          SX7    B1+B1
          SA7    PC          PC = 2 
  
 PRS3     S"PI"  B0 
          SA5    "TB" 
          RJ     AIL         INITIALIZE THE ISSUE LIST
          RJ     SSP         SET STORE PREDECESSOR COUNT
          EQ     PRS
 SSP      SPACE  3,14 
**        SSP - SET STORE PREDECESSOR ( N.SP ) FOR A SUBSEQUENCE
* 
*         ENTRY  (X4) = [DI] OF INSTRUCTION JUST ISSUED 
  
 SSP      ROUTINE 
          LX4    -D.USESP 
          MX5    -D.USESL 
          BX2    -X4+X5 
          MX7    0
          SX6    X2+B1
          SA6    N.SP        N.SP = -(USES[DI]-1) 
          SA7    STL         STL = 0
          AX3    B1,X2
          ZR     X3,SSP      IF N.SP .LE. 1 
          SX7    -FX.X6 
          SA7    A7          STL = -FX.X6 
          EQ     SSP
          TTL    MCG - MACHINE CODE GENERATOR - INSTRUCTION SELECTION 
 SNI      TITLE  SNI - SELECT NEXT INSTRUCTION TO ISSUE 
**        SNI - SELECT NEXT INSTRUCTION TO BE POSTED ( ISSUED ) FROM
*         THE *ICL* ( ISSUE CANIDATE LIST ).
*         SCAN INSTRUCTIONS ON *ICL* FOR ONE THAT IS EXECUTABLE AT THE
*         CURRENT TIME, OR ONE WITH THE BEST ISSUE ( T(IS) ) AND
*         EXECUTE TIME ( T(EX) ) ( EARLIEST START TIME ). 
*         NOTE - PSEUDO INSTRUCTIONS AND BOUNDARY MARKERS ARE ISSUED
*                FROM *DRR*.
* 
*         EXIT   (B3) = REGNO OF ISSUABLE INST, < 0 IF NONE FOUND 
*                (B4,B5) = T(EX), T(IS) 
*                (A5) = LI ( ADDRESS OF LINK WORD OF ISSUABLE INSTRUCTION 
*                (A0) = *TXT* INDEX OF PREVIOUS INSTRUCTION 
*                PBI WORDS SET. 
  
 SNIA     BSS    1           TEMP TO SAVE FUNIT ORDINAL 
  
 SNI      ROUTINE 
  
 SNI0     SA4    PBI-1
          SA3    ICL         CI = ICL 
          S"PI"  B0          PI = 0 
          BX6    X4 
          SA6    A4+B1       PBI = PB1(FALSE,0,INFINITY,INFINITY) 
          SB6    X4          TIS[PBI] = INFINITY
  
*         GET INST DESCR, CHECK FOR FIT IN CURRENT WORD 
  
 SNI1     SB4    X3+"TB"     LI = CI + BASE 
          SA2    T
          SA4    B4-B1       DI = LI - 1  ( DESCR)
          SB5    X2          T(IS) = T
          LX4    58-D.SZP 
          PL     X4,SNI4     IF SZ[DI] < 2 */ NO POSSIBLE SIZE FAULT
          SA3    PC 
          MX7    -2 
          BX6    X3+X7
          NZ     X6,SNI4     IF PC " 3     */ NOT IN LAST PARCEL OF WORD
          BX2    X4 
          LX2    1+D.SZP-D.SRP
          PL     X2,SNI3     IF ^SR[DI]    */ NOT SIZE REDUCABLE
  
*         INSTRUCTION IS SIZE REDUCEABLE, CHECK A-REGISTERS TO SEE IF 
*         ADDRESS IS IN ONE OF THEM.
  
          SA2    ARA+7       I = ARA(8) 
          SA3    "DI"-B1     R2 = DI - 1
          SB2    ARA-1
          BX6    X3 
          SA6    B2+B1       ARA(1) = [R2]
  
 SNI2     BX7    X3-X2
          SA2    A2-B1       I = I - 1
          NZ     X7,SNI2     IF [I+1] " [R2]
          SB3    A2-B2
          ZR     B3,SNI3     IF I = 0    */ MATCH WITH SEARCH TERMINATOR
  
          SA2    TRA+RN.A0+B3              */ COMPUTE TRUE ISSUE TIME 
          SB2    X2 
          LE     B2,B5,SNI4 
          SB5    X2 
          EQ     SNI4 
  
 SNI3     SA1    IWT               */ SET PENALITY FOR SIZE FAULT 
          SX2    X1+B1
          SB5    X2+B5       T(IS) = T(IS) + IWT + 1
  
*         SELECT AN AVAILABLE FUNCTIONAL UNIT 
  
 SNI4     LX4    2+D.SZP-D.F1P
          MX6    -D.F1L 
          BX7    -X6*X4      F = F1[DI] 
  
 #MD      IFGE   .CPU,74                                         ?66/76 
          SA3    TFU+X7      TFA = TFU(F) 
          SB3    X3 
          LE     B3,B5,SNI5  IF TFA @ T(IS) 
 #MDA     IFEQ   .CPU,74                                         ?6600
          LX4    D.F1P-D.F2P
          SX1    X7                        */ CHECK SECOND FUNIT
          BX7    -X6*X4      F2 = F2[DI]
          SA2    TFU+X7      TF2 = TFU(F2)
          LX4    D.F2P-D.F1P
          SB4    X2 
          LE     B4,B5,SNI5  IF TF2 @ T(IS) 
          SB5    B4 
          LE     B4,B3,SNI5  IF TF2 @ TF1 
          BX7    X1 
 #MDA     ENDIF                                                  '6600
          SB5    X3          T(IS) = TF1   */ MIN(TFA,TF2)
 #MD      ENDIF                                                  '66/76 
  
*         IF T(IS) @ TIS[PBI] THEN TRY TO GET A RESULT REG, CALC T(EX)
  
 SNI5     GT     B5,B6,SNI6  IF T(IS) > TIS[PBI]
          SA7    SNIA 
          LX4    D.F1P+59-D.NRP 
          RJ     DRR         CALL DRR( DI , T(IS) , T(EX) , REGNO ) 
          GT     B3,SNI7     IF REGNO > 0  */ INSTRUCTION IS ISSUABLE 
          ZR     B3,SNI0     IF REGNO = 0  */ A PSEUDO INSTRUCTION
  
 SNI6     SA5    "DI"+B1     LI = DI + 1
          EQ     SNI9                      */ NO RESULT REG AVAIL 
  
*         COMPARE THIS INSTRUCTION TIMING WITH THAT OF *PBI*
  
 SNI7     SA5    "DI"+B1     LI = DI + 1
 #MD      IFEQ   .CPU,74                                         ?6600
          GT     B5,B6,SNI9  IF T(IS) > TIS[PBI]
          SA3    PBI
          LT     B5,B6,SNI8  IF T(IS) < TIS[PBI]
          LX3    -PB.TEXP 
          SB2    X3 
          GE     B4,B2,SNI9  IF T(EX) \ TEX[PBI]
 #MD      ELSE                                                   '66?76 
          SA4    "DI" 
          GE     B4,B6,SNI9  IF T(EX) \ TEX[PBI]
 #MD      IFGT   .CPU,74                                         ?7600
          LX4    -D.LDP 
 .D       BIT    D.^DP-D.LDP
          SX6    .D+1 
          SB5    B4          T(IS) = T(EX)
          BX7    X6*X4
          LX4    D.LDP-D.FTP
          NZ     X7,SNI8     IF ^D[DI] ! LD[DI] 
  
*         ADJUST T(EX) TO ACCOUNT FOR THE FUNIT TO REGISTER INPUT PATH
  
          SA2    T
          SA1    TRS
          MX6    -D.FTL 
          BX7    -X6*X4 
          IX3    X7-X2
          SB2    X3+B5
          SB4    B4-B1       T(EX) = T(EX) - 1
          AX1    B2,X1       XSW = SHIFT(TRS, -(T(IS)+FT[DI]-T) ) 
  
 SNI7A    LX1    -1          XSW = SHIFT( XSW , 59 )
          SB4    B4+B1       T(EX) = T(EX) + 1
          MI     X1,SNI7A    IF XSW < 0    */ RESULT STORED AT THIS TIME
          SB5    B4          T(IS) = T(EX)
          GE     B4,B6,SNI9  IF T(EX) \ TEX[PBI]
 #MD      ENDIF                                                  '7600
  
*         INSTRUCTION BETTER THAN PREVIOUS BEST, SAVE INFO IN *PBI* 
  
 SNI8     SX4    B5 
          SA1    SNIA 
          SX3    B4 
          LX4    PB.TISP
          PX6    B3,X4
          SX7    "PI" 
          LX3    PB.TEXP
          SB2    X1 
          SX2    A5-"TB"
          BX6    X3+X6
          SA1    T
          LX7    PB.PIP 
          LX2    PB.LIP 
          PX2    B2,X2
          SA6    PBI         PBI(0) = PBII(REG,T(EX),T(IS)) 
          IX7    X7+X2
          SB2    X1+
          SA7    A6+B1       PBI(1) = PBII2(FU,PI,LI) 
  
          EQ     B4,B2,SNI   IF T(EX) = T  */ EXIT IF THIS INST IS EXEC 
  
          SB6    B5+         TIS[PBI] = T(IS) 
  
*         ADVANCE TO NEXT INSTRUCTION ON CHAIN
  
 SNI9     S"PI"  A5-"TB"     PI = LI - BASE 
          LX5    -I.LINKP 
          SX3    X5          CI = LINK[LI]
 #MD      IFGE   .CPU,74                                         ?66/76 
          SA1    PBI
          ZR     X3,SNI10    IF CI = 0
  
*         ONLY CONSIDER INSTRUCTIONS THAT ARE "LATE" SO WE DO NOT CLOG
*         UP THE REGISTERS WITH RESULTS THAT CANNOT BE USED.
*         I.E. DO NOT TRY TO CODE THE SEQUENCE IN A TIME LESS THAN THE
*         CRITICAL PATH TIME ( AN IMPOSSABILITY ).
  
          SA5    "TB"+X3     LI = BASE + CI 
          UX7    B3,X1
          MI     B3,SNI1     IF REG[PBI] < 0 */NO ISSUABLE INST FOUND 
          SA2    T
          MX6    -I.LSTL
          LX5    -I.LSTP
          BX7    -X6*X5 
          IX6    X2-X7
 SNI.P    SX6    X4+DELTAT
          PL     X6,SNI1     IF IF LST[LI] @ T+DT  */ INST IS *LATE*
  
 SNI10    BSS    0
 #MD      ELSE                                                   ?66/76 
          NZ     X3,SNI1     IF CI " 0
  
          SA1    PBI
 #MD      ENDIF 
          SA2    A1+B1
          UX3    B3,X1       REGNO = REG[PBI] 
          LX2    -PB.LIP
          MI     B3,SNI      IF REGNO < 0  */ NO ISSUABLE INST FOUND
  
          SA5    X2+"TB"     LI = LI[PBI] + BASE
          LX2    PB.LIP-PB.PIP
          S"PI"  X2          PI = PI[PBI] 
          LX1    -PB.TISP 
          SB5    X1          T(IS) = TIS[PBI] 
          LX1    PB.TISP-PB.TEXP
          SB4    X1          T(EX) = TEX[PBI] 
          EQ     SNI
          SPACE  2
          IFGE   .CPU,74,2
 SNIB     SX6    X4+0        SKELTON TO PLUG *SNI.P*
          PL     X4,SNI1
 DRR      TITLE  DRR - DETERMINE RESULT REGISTER / T(EX)
**        DRR - DETERMINE RESULT REGISTER / T(EX) OF INSTRUCTION
* 
*         ENTRY  (A4) = INSTRUCTION DESCRIPTOR ADDRESS ( DI ) 
*                (X4) = SHIFT([DI],59-D.NRP)
* 
*         EXIT   (B5) = T(IS) UPDATED 
*                (B4) = T(EX) 
*                (B3) = ACT/REGNO, ACT = 0, THEN ISSUED PSEUDO INSTRUCTION
*                                  ACT < 0, IF NO RESULT REG AVAIL
*                                  ACT > 0, REGNO = ACT 
* 
*         CALLS - CRU, FXR , PPI
*         PRESERVES A0, A4, X0, B6, B7
  
 DRR      ROUTINE 
          NX6    B3,X4
          SB4    B5+         T(EX) = T(IS)
          LX4    1+D.NRP-D.TYP             */ [DI] POS FOR TYPE EXTRACT 
          JP     B3+DRR1     JUMP( NORMC( [X4] ) )
  
 DRR1     BSS    0
          QUAL   DRR
  
          SA5    "DI"+2      R1RS = DI + 2
          EQ     RJRS 
  
          EQ     PS 
  
          SA5    "DI"+2      R1RS = DI + 2
          EQ     PRS
  
          EQ     ECJ         EC JUMP
  
          EQ     LVL2 
  
          EQ     LD 
  
          SA5    "DI"-2      R1 = DI - 2
          EQ     ST 
  
          EQ     JP 
  
          SA5    "DI"-2      R1 = DI - 2
          EQ     XMT
  
          SA5    "DI"-B1     R2 = DI - 1
          EQ     KS 
  
          SA5    "DI"-2      R1 = DI - 2
          EQ     PI                        */ PSEUDO INSTRUCTION
  
          EQ     MUC
  
*         EQ     SCR         ANY X REGISTER 
 SCR      EJECT 
*         SCR - FIND AN X-REGISTER
  
 SCR      SA3    STL
          SX5    FX.XT+FX.SCR+X3   CLASS = SCR & ^STL 
  
 SCR1     FXR    X5,DRR2     REGNO = FXR( ^STL )
  
*         NO REGISTER AVAILABLE, CHECK STORE LOCKOUT FLAG 
  
          SA5    AXR         CLASS = AXR
          SA3    STL
          BX7    X3+X5
          ZR     X7,SCR1     IF AXR & STL " 0  */ X6 LOCKOUT AND AVAIL
          ZR     X3,DRR      IF STL = 0    */ NO *ST* LOCKOUT 
          SA3    L.OTI
          ZR     X3,DRR      IF L.OTI = 0  */ NOT JAM MODE
  
          FXR    ST,DRR2     REGNO = FXR( ST )
          EQ     DRR
 MUC      SPACE  2
*         MUC - MULTI USE COMPUTATION 
  
 MUC      FXR    ST,DRR2     REGNO = FXR( ST )
          SX5    FX.XT+FX.SCR      CLASS = SCR
          EQ     SCR1 
 RJRS     SPACE  3,14 
**        INSTRUCTION PRECEDES AN RJ *RS*  ( UP / NR )
  
 RJRS     RJ     FBR         REGNO = FBR( R1RS )
          MI     B3,DRR      IF ACT < 0    */ NO B-REG FOUND
          SA2    TRA+X6                    */ ADJUST ISSUE TIME 
          SB2    X2 
          LE     B2,B5,RJRS1 T(IS) = MAX( T(IS) , TRA(REGNO) )
          SB4    X2 
          SB5    B2 
  
 RJRS1    BX7    X4 
          LX7    D.TYP-1-D.PSP
          PL     X7,SCR      IF ^PS[DI] 
 PS       SPACE  3,8
*         INSTRUCTION PRECEDES A STORE
  
 PS       FXR    ST,DRR2     REGNO = FXR( ST )
          EQ     DRR
 PRS      SPACE  3,14 
*         INSTRUCTION PRECEDES A *RS* ( REG STORE ) 
  
 PRS      MX2    -SO.REGL 
          LX5    -R1.SOP
          BX6    -X2*X5      REGNO = SOREG[R1RS]
          SB3    X6 
          RJ     CRU         ACT = CRU( REGNO ) 
          MI     B3,DRR      IF ACT < 0    */ REGNO NOT AVAIL NOW 
  
          BX7    X4 
          LX7    D.TYP-1-D.XMTP 
          MI     X7,PRS1     IF XMT[DI] 
  
          IFEQ   .CPU,74,2                                       ?6600
          LX7    D.XMTP-D.LDP 
          MI     X7,LD1      IF LD[DI]
          EQ     DRR2 
  
 PRS1     SA5    "DI"-2      R1 = DI - 2
          LX5    -R1.RJP
          BX7    "RN"X5 
          SA2    "TB"+X7     LJ = BASE + RJ[R1] 
          LX2    -I.REGP
          SB2    X2 
          NE     B2,B3,DRR2  IF REG[LJ] " REGNO 
  
          LX5    R1.RJP 
          LX2    I.REGP      (X2) = LINK WORD OF PRED 
          BX7    "RN"X5      RI = RN[R1]
          EQ     XMT1 
 LVL2     SPACE  3,10 
*         LEVEL 2 LD/ST  ( DRL/DWL )
  
 LVL2     LX6    D.L2P-47+59-D.STP
          PL     X6,SCR      IF ^ST[DI] 
          SA5    "DI"-2      R1 = DI - 2
          EQ     ST 
 LD       SPACE  3,10 
*         LD - INSTRUCTION IS A LOAD
  
 LD       SA5    ALR
          FXR    X5,LD1,DRR  REGNO = FXR( ALR ) 
 LD1      BSS    0
 #MD      IFEQ   .CPU,74                                         ?6600
  
*         INSTRUCTION CANNOT ISSUE UNTIL LAST STORE IS COMPLETE 
  
          SA2    LST
          SB2    X2 
          LE     B2,B5,DRR2  T(IS) = MAX( T(IS) , LST ) 
          SB5    X2 
          SB4    X2 
 #MD      ENDIF                                                  '6600
          EQ     DRR2 
 ST       SPACE  3,10 
*         STORE INSTRUCTION 
  
 ST       BX6    "RN"X5      RI = RN[R1]
          SA3    "TB"+X6     LP = BASE + RI 
          LX3    -I.REGP
          SB3    X3          REGNO = REG[LP]
          SA2    TRA+X3 
          SB2    X2 
 #MD      IFEQ   .CPU,74                                         ?6600
          LE     B2,B5,ST1   T(IS) = MAX( T(IS) , TRA(REGNO) )
          SB5    X2 
          SB4    X2 
 ST1      SA1    LST
          SA2    LLT
          IX7    X1-X2
          MI     X7,ST2      TLS = MAX( LST , LLT ) 
          BX2    X1 
 ST2      SB2    X2 
 #MD      ENDIF                                                  '6600
          LE     B2,B5,DRR2  T(IS/EX) = MAX( T(IS/EX) , TLS ) 
          SB5    X2 
          SB4    X2 
          EQ     DRR2 
 JP       SPACE  2
*         JUMP INSTRUCTION
  
 ECJ      SX6    2
          SA6    PC          PC = 2 
  
 JP       RJ     PJI         PROCESS THE JUMP 
          SB3    B0          REGNO = 0
          EQ     DRR
 XMT      SPACE  2
*         XMT/SXT INSTRUCTIONS
  
 XMT      BX7    "RN"X5      RI = RN[R1]
          LX5    -R1.RJP
          BX6    "RN"X5      RJ = RJ[R1]
          SA2    "TB"+X6     LJ = BASE + RJ 
          MX1    -I.USESL+1 
          SB3    X2          REGNO = REG[LJ]
          LX1    I.USESP+1
          BX3    -X1*X2 
          NZ     X3,SCR      IF USES[LJ] " 1
          SA1    RVT+B3 
          MI     X1,SCR      IF LOCK[RVT(REGNO)]
  
*         ISSUE THE INSTRUCTION 
  
 XMT1     SA7    RVT+B3      RVT(REGNO) = RI
          SX3    B1 
          LX3    I.USESP
          IX6    X2-X3       USES[LJ] = USES[LJ] - 1
          SA6    A2 
          SA5    "DI"+B1     LI = DI + 1
          RJ     AIL         CALL AIL( PI , LI , REGNO )
          PRINT  II,(* XMT X*O1*   OMITTED*),B3 
          SB3    B0          ACT = 0
          EQ     DRR
 KS       SPACE  3,10 
*         CONSTANT SHIFT INSTRUCTION
  
 KS       LX5    -IH.RFP
          SA3    "TB"+X5     LJ = BASE + RF[R2] 
          LX3    -I.REGP
          SA2    TRA+X3 
          SB3    X3          REGNO = REG[LJ]
          SB2    X2 
          LE     B2,B5,DRR   T(IS/EX) = MAX( T(IS/EX) , TRA(REGNO) )
          SB4    X2 
          SB5    X2 
          EQ     DRR
 PI       SPACE  3,8
*         PSEUDO INSTRUCTIONS ( EOQ, BOS, EOS, DAR, DEF, RS, LAB, ENT ) 
  
 PI       RJ     PPI
          SB3    B0          ACT = 0
          EQ     DRR
 GOT      SPACE  2
 #MD      IFLT   .CPU,74                                         '6400
 DRR2     EQU    DRR
 #MD      ELSE                                                   '6400
  
*         GET OPERAND AVAILABLE TIMES AND ADJUST T(EX) ( TYPES I & III )
  
 DRR2     MX1    -D.TYL 
          SA5    "DI"-2      R1 = DI - 2
          BX7    -X1*X4 
          NZ     X7,DRR5     IF TYPE[DI] " I
  
          AX5    R1.RIL 
          BX7    "RN"X5      R = RK[R1] 
          SA2    "TB"+X7
          AX5    R1.RIL 
          LX2    -I.REGP     REGNO = REG[BASE+RN] 
          SA1    TRA+X2 
          SB2    X1 
          LE     B2,B4,DRR3  T(EX) = MAX( T(EX) , TRA(REGNO) )
          SB4    X1 
 DRR3     BX7    "RN"X5      R = RJ[R1] 
          SA2    "TB"+X7
          LX2    -I.REGP
          SA1    TRA+X2 
          SB2    X1 
          LE     B2,B4,DRR   T(EX) = MAX( T(EX) , TRA(REGNO) )
          SB4    X1 
          EQ     DRR
  
*         PROCESS TYPE III INSTRUCTION, *RI* IS ALWAYS A DEFINATION 
  
 DRR5     AX7    1
          ZR     X7,DRR      IF TYPE[DI] = II  */ HAS NO OPERANDS 
          SA2    "DI"-B1     R2 = DI - 1
          LX2    -IH.RFP
          BX3    "RN"X2      RF = RF[R2]
          ZR     X3,DRR      IF RF = 0
          SA2    "TB"+X3
          LX2    -I.REGP
          SA3    TRA+X2 
          SB2    X3 
          LE     B2,B4,DRR   T(EX) = MAX( T(EX) , TRA(REGNO) )
          SB4    B2 
          EQ     DRR
  
 #MD      ENDIF 
          QUAL
 CRU      TITLE  CRU - CHECK REMAINING USES 
**        CRU - CHECK REMAINING USES OF SPECIFIED REGISTER
*                TO SEE IF INSTRUCTION CAN BE ISSUED NOW
* 
*         ENTRY  (B3) = REGNO 
*                (A4,X4) = DI, SHIFT([DI], -D.TYP ) 
* 
*         EXIT   (B3) = REGNO, IF AVAIL, ELSE < 0 
*                B4, B5 UPDATED 
  
 CRU0     SA2    TRA+B2 
          SB3    B2          REGNO = SAVE 
          SB2    X2 
          LE     B2,B5,CRU   T(IS/EX) = MAX( T(IS/EX) , TRA(REGNO) )
          SB4    X2 
          SB5    X2 
  
 CRU      ROUTINE 
          SX6    B3-26B 
          MI     X6,CRU1     IF REGNO < 26B  */ ^ A ST-REGISTER 
          SA1    L.OTI
          NZ     X1,CRU1     IF L.OTI " 0  */ IN JAM MODE 
          SA2    N.SP 
          SX6    X2-1 
          ZR     X6,CRU1     IF N.SP = 1   */ ALL STORES ISSUED 
          SX1    B1 
          SX2    B3 
          BX3    X2-X1       OSR = XOR(REGNO,1) 
          SA1    RVT+X3 
          SB2    "TB"-B1
          SA2    B2+X1       DOS = BASE-1 + RI[RVT(OSR)]
          LX2    59-D.PRSP
          PL     X2,CRU1     IF ^PRS[DOS] 
  
          SB3    -B1         REGNO = -1    */ INDICATE REG NOT AVAIL
          EQ     CRU
  
 CRU1     SA1    RVT+B3      R = RVT(REGNO) 
          SB2    B3          SAVE = REGNO 
          SB3    -B1         REGNO = -1 
          SA2    AXR
          SA3    RBV+B2 
          BX6    X2*X3
          NZ     X6,CRU0     IF AXR & RBV(REGNO) " 0 */ REG IS AVAIL
          SA3    "TB"+X1     LP = BASE + R
          MX2    -I.USESL 
          LX3    -I.USESP 
          SX1    X1                        */ REMOVE LOCK BIT 
          BX2    -X2*X3      U = USES[LP] 
          MX6    -D.TYL 
          ZR     X2,CRU4     IF U = 0 
          SX5    X2-2 
          BX7    -X6*X4 
          MI     X5,CRU2     IF U = 1 
          NZ     X5,CRU      IF U > 2 
  
*         CHECK 2 USES CASE 
  
          NZ     X7,CRU      IF TYPE[DI] " I
          SA5    "DI"-2      R1 = DI - 2
          LX5    -R1.RJP
          BX7    "RN"X5 
          LX5    R1.RJP-R1.RKP
          IX2    X7-X1
          NZ     X2,CRU      IF RJ[R1] " R
          BX5    "RN"X5 
          IX2    X7-X5
          ZR     X2,CRU0     IF RJ[R1] = RK[R1] 
          EQ     CRU
  
 CRU2     LX7    -1 
          MI     X7,CRU      IF TYPE[DI] = II ! IV
          ZR     X7,CRU3     IF TYPE[DI] = I
 CRU      SPACE  1,10 
*         CHECK TYPE III INSTRUCTION
  
          SA5    "DI"-B1     R2 = DI - 1
          LX5    -IH.RFP
          BX7    "RN"X5 
          IX2    X7-X1
          ZR     X2,CRU0     IF RF[R2] = R
          EQ     CRU
  
 CRU3     SA5    "DI"-2      R1 = DI - 2
          LX5    -R1.RJP
          BX7    "RN"X5 
          IX2    X1-X7
          ZR     X2,CRU0     IF RJ[R1] = R
          LX5    R1.RJP-R1.RKP
          BX7    "RN"X5 
          IX2    X1-X7
          ZR     X2,CRU0     IF RK[R1] = R
          EQ     CRU
  
*         USES = 0, R-NUM IN REG MUST BE RESULT OF A FULL LOCK, 
*         IF THIS INSTRUCTION *PRS* A TEMP LOCK, THEN TRY TO ASSIGN 
*         ANOTHER B-REGISTER. 
  
 CRU4     SA5    A4+2        R1RS = R1 + 2
          BX6    X5 
          LX6    59-R1.SOP-SO.LKP 
          PL     X6,CRU0     IF SOLK[R1RS] " 1  */ NOT A TEMP LOCK
          RJ     FBR         FIND ANOTHER B-REGISTER
          MI     B3,CRU      IF ACT < 0    */ NONE FOUND
          SB2    B3 
          EQ     CRU0 
 FBR      TITLE  FBR - FIND AN AVAILABLE B-REGISTER ( *RJRS* ONLY ) 
**        FBR - FIND AN AVAILABLE B-REGISTER FOR AN INSTRUCTION THAT
*                            PRECEEDS A *RJRS*. 
* 
*         ENTRY  (A5,X5) = R1RS, [R1RS] , R1 WORD OF THE RJ *RS*
* 
*         EXIT   (B3) = ACT , < 0 IF NO B-REG WAS FOUND 
*                (X6) = REGNO , OF THE B-REGISTER 
  
 FBR      ROUTINE 
          LX5    -R1.SOP
          MX2    -SO.REGL 
          BX6    -X2*X5      REGNO = SOREG[R1RS]
          RJ     CBR         ACT = CBR(REGNO) 
          PL     B3,FBR      IF ACT > 0 
  
          SX6    7           REGNO = 7
 FBR1     RJ     CBR         ACT = CBR(REGNO) 
          PL     B3,FBR2     IF ACT > 0 
          SX6    X6-1        REGNO = REGNO - 1
          NZ     X6,FBR1     IF REGNO " 0 
          EQ     FBR
  
 FBR2     BX5    X2*X5
          BX7    X6+X5       SOREG[R1RS] = REGNO
          LX7    R1.SOP 
          SA7    A5 
          PRINT  II,(* FBR, NEW REGNO =*Z2),X6
          EQ     FBR
 CBR      SPACE  3
**        CBR - CHECK B-REGISTER TO SEE IF IT IS AVAILABLE
* 
*         ENTRY  (X6) = REGNO 
* 
*         EXIT   (B3) = ACT < 0 IF NOT AVAIL
  
 CBR      ROUTINE 
          SB3    X6+         ACT = REGNO
          SA1    RVT+X6 
          ZR     X1,CBR      IF RVT(I) = 0
          SA1    "TB"+X1     LIP = TB + RI[RVT(I)]
          MX3    -I.USESL 
          LX3    I.USESP
          BX3    -X3*X1 
          NZ     X3,CBR1     IF USES[LIP] " 0 
          SA1    A1-B1       DIP = LIP - 1
          LX1    59-D.PRSP
          PL     X1,CBR1     IF ^PRS[DIP] 
          SA1    A1+2        R1P = DIP + 2
          LX1    59-R1.SOP-SO.SFLP
          MI     X1,CBR      IF SFL[R1P]   */ CAN REUSE THE REGISTER
  
 CBR1     SB3    -B1         ACT = -1 
          EQ     CBR
 FXR      TITLE  FXR - FIND AN AVAILABLE X-REGISTER 
**        FXR - FIND A FREE X-REGISTER
* 
*         ENTRY  (X5) = REGISTER CLASS BITS 
*                (X4) = SHIFT( [DI], -D.TYP ) 
*                (X7) = AXR & REGS IN CLASS 
*                (B5) = T(IS) 
* 
*         EXIT   (X3) = 1/FOUND,NOT FOUND,41/REG BIT,18/REGISTER NUMBER 
*                (B4,B5) = T(IS),T(EX) ARE UPDATED
* 
*         USES   B - 2, 3  , A - 2, 3 
*                X - 1, 2, 3, 5, 6, 7 
  
 FXR0     SB5    X1          T(IS) = BT 
          BX3    X6 
          SB4    X1+         T(EX) = BT 
  
 FXR      ROUTINE 
 #MD      IFGE   .CPU,74                                         ?66/76 
          MI     X3,FXR2     IF REGNO < 0  */ NOTHING AVAIL IN THIS CLASS 
  
*         SEARCH FOR REGISTER IN CLASS WITH EARLIEST AVAILABLE TIME.
  
          BX6    X3 
          SX1    B2          BT = TRA(REGNO)
  
 FXR1     AX3    18 
          BX7    X7-X3       AVAIL = AVAIL - REGBIT(REGNO)
          NO
          NX2    B2,X7
          SA3    B2+FXRA+16-47   REGNO = FXRA( NORMC(AVAIL) ) 
          MI     X3,FXR0
          SA2    TRA+X3 
          SB3    X2 
          IX5    X2-X1
          LE     B3,B5,FXR   IF TRA(REGNO) < T(IS)
  
          PL     X5,FXR1     IF BT @ TRA(REGNO) 
          BX6    X3 
          SX1    B3          BT = TRA(REGNO)
          EQ     FXR1 
 #MD      ENDIF                                                  '66/76 
  
*         CHECK REMAINING USES OF OPERANDS, SEE IF THEY ARE IN THE
*         CLASS OF REGISTERS REQUESTED, AND WILL BE RELEASED BY ISSUE 
*         OF THE CURRENT INSTRUCTION ( MAY BE REUSED ). 
  
 FXR2     SA2    LXR
          MX7    -D.TYL 
          BX6    -X2*X5      CLASS = ^LXR & CLASS 
          BX5    -X7*X4 
          ZR     X5,FXR3     IF TYPE[DI] = I
          AX7    B1,X5
          ZR     X7,FXR      IF TYPE[DI] = II  */ NO OPERANDS 
 FXR      SPACE  1,10 
*         CHECK TYPE III INSTRUCTION ( NOTE - RI IS A DEF ) 
  
          SA5    "DI"-B1     R2 = DI - 1
          LX5    -IH.RFP
          BX7    "RN"X5      RF = RF[R2]
          ZR     X7,FXR      IF RF = 0
          SA2    "TB"+X7     LP = BASE + RF 
          SA1    RBV+X2      REGB = RBV( REG[LP] )
          MX3    -I.USESL+1 
          BX6    X1*X6
          ZR     X6,FXR      IF REGB & CLASS = 0
          SB3    X2 
          LX2    -I.USESP-1 
          BX7    -X3*X2 
          NZ     X7,FXR      IF USES[LP] " 1
  
 FXR2A    SA2    TRA+B3 
          SX3    B3          REGNO = REG[LP]
          SB2    X2 
          LE     B2,B5,FXR   T(IS/EX) = MAX( T(IS/EX) , TRA(REGNO) )
          SB4    X2 
          SB5    X2 
          EQ     FXR
  
*         CHECK OPERANDS OF TYPE I INSTRUCTION
  
 FXR3     BX2    X4 
          SA5    "DI"-2      R1 = DI - 2
          LX2    D.TYP-D.TYIOP
          BX7    -X7*X2 
          SA1    TYIOM+X7 
          MX3    I.USESL-1
          UX2    B2,X1
          BX5    X2*X5
          LX3    I.USESL+I.USESP
          AX5    B2,X5       RNUMS = TYIOM[DI] & [R1] 
          SB3    0           RG = 0 
          SB2    -T(INF)     TB = *INFINITY*
  
 FXR4     BX7    "RN"X5      R = RN[RNUMS]
          AX5    R1.RIL      RNUMS = SHIFT(RNUMS,-16) 
          ZR     X7,FXR5     IF R = 0 
          SA2    "TB"+X7     LP = BASE + R
          BX1    X3*X2
          ZR     X1,FXR6     IF USES[LP] = 1
          BX7    X5-X7
          ZR     X7,FXR7     IF RJ = RK 
 FXR5     NZ     X5,FXR4     IF RNUMS " 0 
          NZ     B3,FXR2A    IF RG " 0     */ WINNER FOUND
          SX3    -B1         REGNO = -1 
          EQ     FXR
  
 FXR6     SA1    RBV+X2 
          BX7    X1*X6
          ZR     X7,FXR5     IF CLASS & RBV(REG[LP]) = 0
          SA1    TRA+X2 
          SX7    X1+B2
          PL     X7,FXR5     IF TRA(REG[LP]) \ TB 
          BX1    -X1
          SB3    X2          RG = REG[LP] 
          SB2    X1          TB = TRA(RG) 
          EQ     FXR5 
  
*         TYPE I  &  RJ = RK
  
 FXR7     SB3    X2          REGNO = REG[LP]
          LX2    -I.USESP 
          MX3    -I.USESL 
          BX2    -X3*X2 
          SX7    X2-2 
          NZ     X7,FXR      IF USES[LP] " 2
  
          SA2    RBV+B3 
          BX6    X2*X6
          ZR     X6,FXR      IF RBV(REGNO) & CLASS = 0
          EQ     FXR2A
          TTL    MCG - MACHINE CODE GENERATOR - INSTRUCTION ISSUE 
 PJI      TITLE  PJI - PROCESS JUMP INSTRUCTION 
**        PJI - PROCESS JUMP INSTRUCTION
* 
*         ENTRY  (A4,X4) = DI, SHIFT( [DI] , -D.TYP ) 
* 
*         EXIT   INSTRUCTION ISSUED, *ICL* UPDATED, CLOCK ADVANCED, ETC.
  
 PJI      ROUTINE 
          MX1    -D.TYL 
          MX7    0
          SB3    B0          REGNO = 0
          BX6    X1+X4
          SA7    TRS         TRS = 0
          ZR     X6,PJI2     IF TYPE[DI] = IV 
  
*         DETERMINE EXECUTION TIME OF CONDITIONAL JP
  
          SA1    "DI"-B1     R2 = DI - 1
          LX1    -IH.RFP
          BX6    "RN"X1      R = RF[R2] 
          ZR     X6,PJI1     IF R = 0 
          SA3    "TB"+X6     LJ = BASE + R
          LX3    -I.REGP
          SA2    TRA+X3 
          SB2    X2 
          LE     B2,B4,PJI1  T(EX) = MAX( T(EX) , TRA(REG[LJ]) )
          SB4    X2 
 PJI1     SA1    A1-B1       R1 = R2 - 1
          BX6    "RN"X1      R = RI[R1] 
          SA3    "TB"+X6     LJ = BASE + R
          LX3    -I.REGP
          SB3    X3          REGNO = REG[LJ]
          SA2    TRA+X3 
          SB2    X2 
          LE     B2,B4,PJI2  T(EX) = MAX( T(EX) , TRA(REGNO) )
          SB4    X2 
  
 PJI2     SA5    "DI"+B1     LI = DI + 1
          RJ     AIL         ADJUST THE ISSUE LIST
          RJ     DUC         DECREMENT USES COUNTS
          SA5    "DI"-2      R1 = DI - 2
          RJ     SII         SAVE THE INSTRUCTION 
  
 DBG      IF     DEF,/DEBUG/II
          SX7    B4 
          PX6    B3,X7
          LX7    PB.TEXP
          BX6    X7+X6
          SA6    PBI
          PRNT   PJI,II,SAV 
 DBG      ENDIF 
  
          SA5    "DI"-2      R1 = DI - 2
          UX5    B2,X5
          SX7    B2-OC.JIN
          MI     X7,PJI5     IF OC[R1] < OC.JIN  */ A CONDITIONAL JP
 PJI      SPACE  1,10 
*         PROCESS UNCONDITIONAL JUMPS ( UJP / RJX / JIN ) 
  
          S"DI"  "DI" 
          RJ     SSP         SET N.SP FOR UPCOMING SEQUENCE 
          RJ     AVC         ADVANCE CLOCK
          SA1    JLR
          SA3    AXR
          MX6    0
          SA6    /JAM/ISC    ISC = 0       */ CLEAR ISSUED STORE CHAIN
          MX7    13 
          ZR     X1,PJI      IF JLR = 0    */ NO UJP LOCKED REGISTERS 
  
 PJI4     PX1    X1 
          NX5    B2,X1       REGNO = NORMC( JLR ) 
          SA2    RBV+B2 
          AX5    B2,X7
          BX3    X2+X3       AXR = RBV(REGNO) ! AXR 
          SA6    RVT+B2      RVT(REGNO) = 0 
          BX1    -X5*X1      JLR = ^MASK(13+REGNO) & JLR
          NZ     X1,PJI4     IF JLR " 0 
          BX7    X3 
          SA7    A3 
          SA6    A1 
          EQ     PJI
  
*         CONDITIONAL JUMP, ADVANCE CLOCK, PARCEL COUNT 
  
 PJI5     SA4    "DI" 
          MX1    -D.FTL 
          SA2    PC 
          LX4    -D.FTP 
          BX6    -X1*X4 
          SX7    X6+B4       T = T(EX) + FT[DI] 
          SX6    B1+B1
          SX3    X2-3 
          SA7    T
          PL     X3,PJI6     PC = IF( PC = 3) 2 ; ELSE MOD( PC+2 , 4 )
          MX3    -2 
          IX2    X2+X6
          BX6    -X3*X2 
 PJI6     SA6    A2 
          EQ     PJI
 PPI      TITLE  PPI - PROCESS PSEUDO INSTRUCTION 
**        PPI - PROCESS PSEUDO INSTRUCTION
*         ENTRY  (A5,X5) = R1,[R1]
*                (A4,X4) = DI, SHIFT([DI], -D.TYP ) 
  
          PROCESS (BOS,EOS) 
 PPI0     SA5    "DI"+B1     LI = DI + 1
          RJ     AIL         CALL AIL( PI , LI , REGNO )
          RJ     SSP         SET N.SP FOR UPCOMING SEQUENCE 
  
 PPI      ROUTINE 
          PRNT   PPI,II,SAVPBI
          UX7    B2,X5
          SB3    B0          REGNO = 0
          JP     PPI.JT+B2   JUMP( PPI.JT( OC[R1] ) ) 
 DAR      SPACE  2
*         DAR  RI,RJ - DEFINE A-REGISTER R-NUMBER 
  
          PROCESS DAR 
          SA4    "DI" 
          LX5    -R1.RJP
          BX5    "RN"X5      RJ = RJ[R1]
          SA3    "TB"+X5     LJ = RJ + BASE 
          LX3    -I.REGP
          SB3    X3+AMX      REGNO = REG[LJ] + AMX  */ A-REGISTER NUMBER
          SB4    0           T(EX) = 0     */ MAKE X-REG AVAIL AT T = 0 
          RJ     DUC         DECREMENT USES COUNTS
          SB4    B5          T(EX) = T(IS)
          EQ     PPI0 
 DEF      SPACE  2
*         DEF  RI,SOREG      DEFINE RI TO BE IN *SOREG* 
  
          PROCESS DEF 
          BX7    "RN"X5      RI = RI[R1]
          LX5    -R1.SOP
          MX3    -SO.RTL-SO.RNL 
          BX6    -X3*X5 
          SB3    X6          REGNO = SOREG[R1]
          SA7    RVT+X6      RVT(REGNO) = RI
          LX5    58-SO.LKP
          SA1    AXR
          SA2    RBV+B3 
          BX6    -X2*X1      AXR = ^RBV(REGNO) & AXR
          SA6    A1 
          PL     X5,PPI0     IF SOLK[R1] = 0  */ NOT FULL /A-REG LOCK 
          LX5    1
          MI     X5,PPI4     IF SOLK[R1] = 3  */ A-REG LOCK 
  
          MX3    1
          SA1    LXR
          BX7    X3+X7       LOCK[RVT(REGNO)] = 1 
          SA7    A7 
          BX6    X1+X2       LXR = LXR ! RBV(REGNO) 
          SA6    A1 
          EQ     PPI0 
  
 PPI4     SA1    ALR
          BX6    -X2*X1      ALR = ^RBV(REGNO) & ALR
          SA6    A1 
          EQ     PPI0 
 LAB      SPACE  3,10 
*         LAB/ENT  IH,CA
  
          PROCESS (LAB,ENT) 
          SA5    "DI"+B1     LI = DI + 1
          RJ     AIL         CALL AIL( PI , LI , 0 )
          RJ     SSP         SET N.SP FOR UPCOMING SEQUENCE 
          SA5    "DI"-2      R1 = DI - 2
          RJ     SII         SAVE THE ISSUED INSTRUCTION
          IFNE   .IWT,0 
          SA3    "DI"-B1     R2 = DI - 1
          LX3    59-IH.STKP 
          PL     X3,PPI6     IF ^STK[R2]   */ LOOP NOT INSTACK
          MX6    0
          SA6    IWT         IWT = 0
          ENDIF                                                  '6600
 PPI6    RJ      AVC         ADVANCE THE CLOCK
          EQ     PPI
 RS       SPACE  2
*         RS  RI,LK,SOREG - REGISTER STORE PROCESSING 
  
          PROCESS RS
          BX7    "RN"X5      RI = RI[R1]
          LX5    -R1.SOP
          MX3    -SO.RTL-SO.RNL 
          BX6    -X3*X5      REGNO = SOREG[R1]
          LX5    -SO.LKP
          MX3    -SO.LKL
          BX2    -X3*X5 
          SB2    X2 
          JP     PPI7+B2     JUMP( SOLK[R1] ) 
  
 PPI7     BSS    0
          LOC    0
          SA1    JLR
          EQ     PPI10
          EQ     PPI0        */ TEMP LOCK 
          EQ     PPI11
          LOC    *O 
  
*         RJ REGISTER STORE 
  
          SA3    "DI"-3      */ CHECK USES OF R-NUMBER OF X-REG OF PRED 
          LX3    -I.REGP
          SA1    TRA+X3      XREG = REG[DI-3] 
          MX2    -I.USESL 
          LX3    I.REGP-I.USESP 
          SA7    RVT+X6      RVT(REGNO) = RI
          SA7    /JAM/LRN+X6 LRN(REGNO) = RI
          SB3    X6 
          BX6    X1 
          SA6    TRA+B3      TRA(REGNO) = TRA(XREG) 
          BX6    -X2*X3 
          NZ     X6,PPI8     IF USES[DI-3] " 0  */ X-RESULT USED
          LX3    I.USESP-I.REGP 
          SA1    RBV+X3 
          SA2    AXR
          SA6    RVT+X3      RVT( REG[DI-3] ) = 0 
          BX7    X1+X2
          SA7    A2          AXR = AXR ! RBV(XREG)
 PPI8     SA1    AXR
          SA2    RBV+B3 
          BX6    -X2*X1      AXR = ^RBV(REGNO) & AXR
          SA6    A1 
          EQ     PPI0 
 RS       SPACE  2
*         UJP LOCK - SET TO CLEAR WHEN NEXT UJP/RJX/JIN ENCOUNTERED 
  
 PPI10    SB2    X6-47
          SX3    B1 
          AX2    B2,X3
          BX6    X2+X1       JLR = SHIFT(1,47-REGNO) ! JLR
          SA6    A1 
          EQ     PPI0 
  
*         FULL LOCK - SET LOCK BITS IN *LXR* AND *RVT*
  
 PPI11    SA5    RVT+X6 
          SA1    RBV+X6 
          SA3    LXR
          MX2    1
          BX6    X2+X5       LOCK[RVT(REGNO)] = 1 
          SA6    A5 
          SA5    "TB"+X7     LI = BASE + RI 
          LX2    1+I.USESP
          BX7    X1+X3       LXR = LXR ! RBV(REGNO) 
          SA7    A3 
          IX6    X5-X2       USES[LI] = USES[LI] - 1
          SA6    A5 
          EQ     PPI0 
 EOQ      SPACE  2
*         EOQ - TERMINATE *PIT* BUFFER, EXIT TO EOQ ADDRESS 
  
          PROCESS EOQ 
          SA5    PPIB 
          RJ     SII         SII( NOP ) 
          SA3    IIP
          SA4    A3+B1
          IX6    X3-X4       L.PIT = IIP(1) - IIP(2)
          SA1    EOQA 
          SA6    L.PIT
          SB2    X1 
          JP     B2          JUMP( EOQA ) 
  
 PPIB     VFD    12/2000B+OC.NOP,48/0 
 AIL      TITLE  AIL - ADJUST ISSUE LIST
**        AIL - ADJUST ISSUE CANDIDATE LIST TO REMOVE ISSUED INSTRUCTION
*         FROM IT. NOTE THAT BECAUSE THE SUCCESSORS OF AN INSTRUCTION 
*         ARE SORTED BY "LATE START TIME" IN THE USES INDEX TABLE, THE
*         *ICL* WILL ALSO BE SORTED BY "LST". 
* 
*         ENTRY  (A5,X5) = LI,[LI] - LINK WORD OF ISSUED INSTRUCTION. 
*                (B3) = REGNO ( NEW VALUE OF LINK FIELD ) 
* 
*         EXIT   (A4,X4) = DI, [DI] - DESCRIPTOR OF ISSUED INSTRUCTION. 
*                (X0) = R-NUMBER EXTRACTOR MASK 
*                LINK[LI] = REGNO 
*                ICL = ISSUE CANDIDATE LIST POINTER UPDATED.
* 
*         USES   B - 2, 6   , X - ALL  ( RESETS X0 )
  
  
*         RESET *ICL* POINTER, AND SET EXIT CONDITIONS
  
 AIL0     MX0    -R1.RIL+1
          SA4    A5-B1       DI = LI - 1
          LX0    1           (X0) = R-NUMBER EXTRACTOR MASK 
          SA1    "TB" 
          NZ     B6,AIL      IF PS " 0     */ DIDNT ISSUE FIRST ELEMENT 
          SX6    X1          ICL = LINK[*BOS*]
          IX7    X1-X6
          SA6    ICL
          SA7    "TB"+       LINK[*BOS*] = 0
  
 AIL      ROUTINE 
          SA1    "PI"+"TB"
          SB6    "PI"        PS = PI
          MX7    -I.LINKL 
          S"PI"  "PI"+"TB"   PI = PI + BASE 
          SX3    X5 
          BX2    X7*X1
          MX4    1
          IX6    X2+X3       LINK[PI] = LINK[LI]
          LX4    I.IIP+1     II[LI] = 1    */ INDICATE ISSUED 
          SA3    "TB"+X3     NI = LINK[LI] + BASE 
          BX5    X7*X5
          SA6    A1 
          SX2    B3 
          LX2    I.REGP 
          IX4    X2+X4       REG[LI] = REGNO
          SX0    B1 
          BX6    X4+X5
          SA6    A5 
          MX7    -I.INDXL 
          SA2    O.TREE 
          LX5    -I.INDXP 
          BX1    -X7*X5 
          LX7    I.LSTP 
          IX2    X1+X2
          BX4    -X7*X3      RN = LST[NI] 
          SA2    X2          UI = O.TREE + INDX[LI] 
          EQ     AIL3 
  
*         LINK THIS TO NEXT, LAST TO THIS 
  
 AIL1     SX5    A3-"TB"
          LX0    I.ICP
          IX5    X0+X5       IC[SI] = 1 
          BX6    X5+X6       LINK[SI] = NI - BASE 
          MX5    -I.LINKL 
          SA6    A1 
          LX0    -I.ICP 
          SA1    "PI"        LINK[PI] = SI - BASE 
          S"PI"  A6          PI = SI
          BX6    X5*X1
          SX5    A6-"TB"
          IX6    X6+X5
  
*         IF NOT LAST SUCCESSOR, ADVANCE TO NEXT
  
 AIL2     SA6    A1 
          MI     X2,AIL0     IF LAST[UI]
          SA2    A2+B1       UI = UI + 1
  
*         REDUCE PRED COUNT OF SUCCESSORS OF INSTRUCTION. 
  
 AIL3     SA1    "TB"+X2     SI = SUCC[UI] + BASE 
          IX6    X1-X0       NPRED[SI] = NPRED[SI] - 1
          SB2    X1+
          NE     B2,B1,AIL2  IF NPRED[SI] " 0 
  
*         ADD SUCCESSOR TO LIST BEFORE NEXT WITH GREATER *LST*
  
          BX1    -X7*X1 
          IX5    X1-X4
 AIL4     MI     X5,AIL1     IF LST[SI] < RN
          S"PI"  A3          PI = NI
          SA3    "TB"+X3     NI = LINK[NI] + BASE 
          BX4    -X7*X3      RN = LST[NI] 
          IX5    X1-X4
          EQ     AIL4 
 DUC      TITLE  DUC - DECREMENT USES COUNTS
**        DUC - DECREMENT USES COUNTS 
* 
*         ENTRY  (A4,X4) = DI, [DI] 
*                (B3) = REGNO  ( OF RESULT REGISTER ) 
*                (B4) = T(EX) OF INSTRUCTION
* 
*         EXIT   RVT, AXR UPDATED 
* 
*         USES   B - 2, 6   X - 1 - 7 
  
 DUC0     MI     X4,DUC      IF ^D[DI] ! TYPE[DI] = IV
          SA5    "DI"-2      R1 = DI - 2
          SA1    RBV+B3 
          SA2    AXR
          BX7    "RN"X5 
          SA7    B6+B3       RVT(REGNO) = RI
          BX6    -X1*X2      AXR = ^RBV(REGNO) & AXR
          SA6    A2 
  
 DUC      ROUTINE 
          LX4    58-D.TYP 
          IX7    X4+X4
          SB6    RVT
          MX6    -D.TYIOL 
          MI     X7,DUC0     IF TYPE[DI] = II ! IV
  
          SA5    "DI"-2      R1 = DI - 2
          PL     X4,DUC1     IF TYPE[DI] = I
  
*         TYPE III INSTRUCTION
  
          SA3    "DI"-B1     R2 = DI - 1
          LX4    1+D.TYP-D.^DP
          BX7    "RN"X5      RI = RI[R1]
          LX3    -IH.RFP
          BX5    "RN"X3      RNUMS = RF[R2] 
          PL     X4,DUC2     IF DEF[DI] 
          LX7    R1.RIL 
          BX5    X7+X5       RNUMS = SHIFT(RI,16) ! RNUMS 
          EQ     DUC2 
  
*         TYPE I INSTRUCTION
  
 DUC1     LX4    2+D.TYP-D.TYIOP
          BX7    -X6*X4 
          SA3    TYIOM+X7 
          UX2    B2,X3
          LX4    D.TYIOP+59-D.^DP 
          BX1    X2*X5
          AX5    B2,X1       RNUMS = TYIOM[DI] & [R1] 
  
*         SETUP REGISTERS FOR LOOP
  
 DUC2     MX1    I.USESL-1
          SX7    B1 
          LX1    I.USESL+I.USESP
          BX3    "RN"X5      R = RI[RNUMS]
          LX7    I.USESP
          NZ     X5,DUC4     IF RNUMS " 0 
          EQ     DUC0 
  
*         DECREMENT USES COUNTS OF OPERANDS, ADJUST *AXR*, *RVT*
  
 DUC3     AX5    R1.RIL      RNUMS = SHIFT(RNUMS,-R1.RIL) 
          ZR     X5,DUC0     IF RNUMS = 0 
          BX3    "RN"X5      R = RI[RNUMS]
 DUC4     SA2    "TB"+X3     LP = BASE + R
          ZR     X3,DUC3     IF R = 0 
          IX6    X2-X7       USES[LP] = USES[LP] - 1
          BX3    X1*X2
          SA6    A2 
          NZ     X3,DUC3     IF USES[LP] " 0
          LX2    -I.REGP     REGP = REG[LP] 
          SA3    B6+X2
          MI     X3,DUC3     IF LOCK[RVT(REGP)] 
  
*         RETURN REGISTER TO AVAILABLE LIST 
  
          MX6    0
          SA6    A3          RVT(REGP) = 0
          SX6    B4+B1
          SA6    TRA+X2      TRA(REGNO) = T(EX) + 1 
          SA3    RBV+X2 
          SA2    AXR
          BX6    X3+X2
          SA6    A2          AXR = RBV(REGP) ! AXR
          EQ     DUC3 
 ASC      TITLE  ASC - ADVANCE SIMULATION CLOCKS
**        ASC - ADVANCE SIMULATION CLOCKS FOR ISSUED INSTRUCTION
*         ALSO DO LD/ST TO SLD/SST TRANSFORMATION AND ADJUST *SP* COUNT 
*         ENTRY  (A4,X4) = DI, [DI] 
*                (B4) = T(EX) 
*                (B5) = T(IS) 
*                (B3) = REGNO ( SOREGNO OF *RI* REGISTER )
* 
*         EXIT   (B3) = CHANGED TO A-REG NUMBER FOR LD/ST INSTRUCTIONS
*                T, PC, TRA, TFU, LST, EXT. UPDATED.
  
 ASC0     SA6    A1 
          IX7    X3+X7
          PRNT   ASC,II 
          PRNT   ASC,ICL
          PRNT   ASC,RUI
          SA7    T
  
 ASC      ROUTINE 
          MX7    -D.LDSTL 
          LX4    -D.LDSTP 
          SA2    PBI+1
          BX1    -X7*X4 
          ZR     X1,ASC7     IF LDST[DI] = 0
 #DAL     IFNE   .DAL,0 
          BX3    X4 
          LX3    D.LDSTP+59-D.L2P 
          MI     X3,ASC6     IF L2[DI]
 #DAL     ENDIF 
  
*         COMMON HANDLING OF LD/ST INSTRUCTIONS 
  
          MX7    -SO.RNL
          SX3    B3 
          AX1    D.LDP-D.LDSTP     I = LD[DI] 
          UX5    B2,X2       F = FU[PBI+1]
          BX3    -X7*X3      RN = SORN[REGNO] 
          SX7    B4+"INCT"   TFU(F) = T(EX) + INC TIME
          LX4    D.LDSTP-D.SZP
          SA2    TSL+X1 
          SB3    X3+RN.A0    REGNO = A0 + RN
 #MD      IFGE   .CPU,74                                         ?66/76 
          SA7    TFU+B2 
          SA7    TRA+RN.A0+X3      TRA(A0+RN) = T(EX) + INC TIME
          SX6    X2+B4
          SA6    TRA+RN.X0+X3      TRA(X0+RN) = T(EX) + TSL(I)
          SA6    LST+X1      LST(I) = T(EX) + TSL(I)
 #MD      ENDIF                                                  '66/76 
  
 #MD      IFEQ   .CPU,76                                         ?7600
          SA2    T
          SA3    TRS         BIT = 0
          SX5    B1                        */ ADJUST BIT VECTOR BASE
          IX7    X5-X2
          SB6    B4+X7
          AX6    B6,X3       TRS = SHIFT( TRS , -( T(EX)+1-T ) )
          SA6    A3 
 #MD      ENDIF                                                  '7600
  
*         CHECK FOR TRANSFORMATION TO SHORT LD/ST 
  
          MX5    D.ARL
          LX5    D.ARL+D.ARP-D.SZP
          SA3    "DI"-B1     R2 = DI - 1
          BX1    X5*X4
          MX7    1
          BX6    -X7*X3      LD[R2W] = 0   */ CLEAR APL LD BIT
          ZR     X1,ASC5     IF ^(SR[DI] ! FP[DI])
          SB2    ARA-1
          SA6    B2+B1       ARA(0) = [R2] */ SET SEARCH TERMINATOR 
          PL     X1,ASC3     IF ^SR[DI] 
  
          SA2    ARA+7       I = ARA(7) 
 ASC1     BX5    X6-X2
          SA2    A2-B1       I = I - 1
          NZ     X5,ASC1     IF [I] " [R2]
          SX7    A2-B2
          ZR     X7,ASC2     IF I = 0      */ MATCH WITH SEARCH TERMIN
          SX4    B1          SZ[DI] = 1 
          SA7    RMR         RMR = I - ARA(-1) */ SAVE A REG NUM
          EQ     ASC5 
  
*         CHECK FOR ELIMINATION OF F.P. ADDSUB
  
 ASC2     LX1    D.SRP-D.FPP
          PL     X1,ASC5     IF ^FP[DI] 
 ASC3     SA2    ARA+7
          MX7    -IH.CAL
          LX7    IH.CAP 
 ASC4     BX5    X6-X2
          SA2    A2-1        I = I - 1
          BX3    X7*X5
          NZ     X3,ASC4     IF RFIH[I] " RFIH[R2]
  
          SX1    A2-B2       I = I - ARA(-1)
          SA2    A2+B1
          ZR     X1,ASC5     IF I = 0 
          SA6    ARA+B3-RN.A0 
          LX6    -IH.CAP
          SB6    X6 
          LX2    -IH.CAP
          SB2    X2 
          SX6    B6-B2       CA[R2] = CA[R2] - CA[I]
          LX6    IH.CAP 
          BX7    -X7*X6 
          IX6    X7+X1
          SA6    RMR         RMR = IHINFO(0,CA,AREGNO)
          EQ     ASC9 
  
 ASC5     SA6    ARA+B3-RN.A0 
          EQ     ASC9 
  
*         LEVEL 2 LD/ST ( DRL/DWL ) 
  
 #DAL     IFNE   .DAL,0 
 ASC6     BSS    0
#MD       IFGT   .CPU,74
          SA1    L2T+X1-1 
          BX6    X1 
          SA6    FUT+9       FUT(LCM) = L2T(LDST)  */ SET LD/ST TIME
#MD       ENDIF 
 #DAL     ENDIF 
 ASC      SPACE  3
*         GENERAL INSTRUCTION 
  
 ASC7     LX4    D.LDSTP+59-D.PSP 
          UX2    B2,X2       F = FU[PBI+1]
          PL     X4,ASC8     IF ^PS[DI] 
          SA3    N.SP 
          SX6    X3+B1       N.SP = N.SP + 1
          SA6    A3 
          NZ     X6,ASC8     IF N.SP " 0
          SA6    STL         STL = 0       */ CLEAR STORE LOCKOUT FLAG
  
 ASC8     LX4    1+D.PSP-D.FTP
          MX5    -D.FTL 
          BX3    -X5*X4 
          SX6    B4+X3       TRA(REGNO) = T(EX) + FT[DI]
          LX4    D.FTP-D.SZP
 #MD      IFLE   .CPU,74                                         ?6600
          SX7    X6+B1       TFU(F) = T(EX) + FT[DI] + 1   */ 6600
 #MD      ELSE                                                   '66?76 
          SA2    T
          SA1    TRS
          SX5    B1 
          IX3    X6-X2
          IX7    X5-X2
          SB6    X3 
          LX5    B6,X5
          SB6    B4+X7
          BX1    X5+X1       TRS = TRS ! SHIFT( 1 , TRA(REGNO) - T )
          AX7    B6,X1       TRS = SHIFT( TRS , -( T(EX)+1 - T ) )
          SA2    FUT+B2-1 
          SA7    A1 
          SX7    B4+X2       TFU(F) = T(EX) + FUT(F)       */ 7600
 #MD      ENDIF                                                  '7600
 #MD      IFGE   .CPU,74                                         ?66/76 
          SA6    TRA+B3 
          SA7    TFU+B2 
 #MD      ENDIF 
  
*         ADVANCE SIMULATION CLOCK, AND PARCEL COUNT
  
 ASC9     SA1    PC 
          MX5    -2 
          BX2    -X5*X4      NP = SZ[DI]
          IX6    X1+X2       PC = PC + NP 
 #MD      IFEQ   .CPU,76                                         ?7600
          SX7    B5+1        T = T(EX) + 1
 #MD      ELSE                                                   ?6600
          SX7    B5+X2       T = T(IS) + NP 
 #MD      ENDIF                                                  '6600
          BX3    X5*X6
          ZR     X3,ASC0     IF PC < 4
          SA3    IWT
          BX6    -X5*X6      PC = MOD( PC , 4 ) 
          ZR     X6,ASC0     IF PC = 0
          BX6    X2          PC = NP
          MX3    0           */ INTERWORD DELAY TAKEN CARE OF IN *SNI*
          EQ     ASC0 
  
 #MD      IFGT   .CPU,74                                         ?7600
 TSL      CON    2,8         STORE/LOAD TIMES  *7600* 
  
 FUT      BSS    0           FUNCTION UNIT TIME TABLE 
          LOC    1
          DATA   1,1,1,1,1
          CON    2           MULTIPLY 
          CON    1           NORM 
          CON    18          DIVIDE 
          DATA   1,3,1
          LOC    *O 
  
 L2T      DATA   3,15        LEVEL 2 STORE/LOAD TIMES 
  
 #MD      ELSE                                                   '7600
 TSL      CON    9,8         STORE/LOAD TIMES  *6600* 
 #MD      ENDIF                                                  '6600
 AVC      TITLE  AVC - ADVANCE CLOCK FOR UJP/RJX/LAB INSTRUCTIONS 
**        AVC - ADVANCE CLOCK AFTER ISSUE OF LAB/UJP/RJX
*         ENTRY  (B4) = T(EX) 
*         EXIT   T , PC UPDATED.  N.SP , STL SET IF STORES IN NEXT BLOCK. 
  
*         SET STORE LOCKOUT FLAG IF MORE THAN 1 STORE PRED IN NEXT BLOCK
  
 AVC0     SA4    "DI" 
          LX4    -D.USESP 
          MX5    -D.USESL 
          SA3    L.OTI
          NZ     X3,AVC1     IF L.OTI " 0  */ JAM MODE
          BX6    -X4+X5 
          AX3    B1,X6
          ZR     X3,AVC1     IF N.SP @ 1
          SX6    X6+B1
          SA6    N.SP        N.SP = -(USES[DI]-1) 
          SX7    -FX.X6 
          SA7    STL         STL = -FX.X6 
  
 AVC1     SA3    "DI"-4      DL = DI - 4
          SA1    AVCA 
          BX2    -X1+X3 
          ZR     X2,AVC      IF BM[DL] & TYPE[DL] = IV
          SETZERO ARA+1,7    FOR I = 1 TO 7; ARA(I) = 0 
  
 AVC      ROUTINE 
          SA1    ICL
          MX2    -I.LSTL
          SA3    "TB"+X1     L = BASE + ICL 
          MX7    0
          SA7    PC          PC = 0 
          LX3    -I.LSTP
          BX6    -X2*X3 
          SA6    T           T = LST[L] 
          SA7    TRS         TRS = 0
          SA2    A3-3        R1 = L - 3 
          UX3    B2,X2
          ZR     B2,AVC      IF OC[R1] = OC.EOQ 
          SB2    X6-10
          GT     B2,B4,AVC0  IF T \ T(EX) + 10
          MX2    8-1
          SA7    TRA+23 
          MX6    0
+         LX2    1           FOR I = 16 TO 24, TRA(I) = 0 
          SA7    A7-B1
          SA6    A7-22+7     TRA(I-8) = 0  */ CLEAR B-REG ASSOCIATES
          MI     X2,*-1 
          MX2    14-1 
          SA7    TFU
+         LX2    1           FOR I = 1 TO 14, TFU(I) = 0
          SA7    A7+B1
          MI     X2,* 
          EQ     AVC0 
  
 AVCA     BFMW   D,(TY,BM)
 SII      TITLE  SII - SAVE ISSUED INSTRUCTION
**        SII - SAVE ISSUED INSTRUCTION FOR LATER PROCESSING
*                I.E. FINAL CONVERSION OF INSTRUCTION TO MACHINE CODE.
* 
*         ENTRY  (B3) = REG[RI] 
*                (A5,X5) = R1, [R1] 
* 
*         EXIT   INSTRUCTION SAVED IN *PIT*, IIP UPDATED. 
* 
*         USES   B - 2, 6  ,  X - 1, 2, 3, 4, 5, 6, 7 
  
          QUAL   SII
 SI.      SPACE  3
**        SI. - SAVED INSTRUCTION FORMAT ( *PIT* )
* 
*         TYPE I     OC,0,RK,RJ,RI
* 
*         TYPE II    OC,IN,0,0,RI 
* 
*         TYPE III   OC,CA,IH,RF,RI + *H2* IN SECOND WORD IF *H2* BIT SET 
* 
*         TYPE IV    OC,CA,0,IH    ( SAME AS RLIST FORMAT ) 
  
          LIST   -R 
  
          DESCRIBE SI.,60    SI(OC,CA,IH/RK,RJ,RI)
 H2       DEFINE 1           *H2* FIELD IN NEXT WORD
 OC       DEFINE 11          PACKED OPCODE
 CA       DEFINE 18          CONSTANT ADDEND
 IH       DEFINE 18          SYMBOL ORDINAL 
 RJ       DEFINE 6
 RI       DEFINE 6
  
 RK       DEQU   IH,6 
  
          LIST   R
 SII      EJECT 
*         TYPE 1 INSTRUCTION WITH 2 OPERANDS
  
 TYI      LX5    -R1.RJP
          BX6    "RN"X5 
          SA1    "TB"+X6
          LX1    -I.REGP
          LX5    R1.RJP-R1.RKP
          BX4    "RN"X5 
          SA2    "TB"+X4
          LX2    -I.REGP
          SX6    X1 
          SX4    X2 
          LX6    SI.RJP 
          BX1    X6+X7       [IIP-1] = SI(OC,0,REG[RK],REG[RJ],REG[RI]) 
          LX4    SI.RKP 
          IX7    X1+X4
  
 SII0     SA7    X3+
  
 SII      ROUTINE            ** ENTRY/EXIT ** 
          SA3    IIP
          UX4    B2,X5
          SX2    B3 
          SA1    SIIA+B2
          SX6    X3+B1       IIP = IIP + 1
          PX7    B2,X2       SIW = PACK(OC[R1],0,0,REG[R])
          SB6    X1 
          SA6    A3 
          JP     B6          JUMP( SIIA( OC[R1] ) ) 
 TYPEI    SPACE  3
*         TYPE 1 - RK = 0 
  
          PROCESS (XMT,XMTC,CX,DRL,DWL) 
          LX5    -R1.RJP
          BX6    "RN"X5 
          SA1    "TB"+X6
          LX1    -I.REGP
          SX2    X1 
          LX2    SI.RJP 
          BX7    X2+X7       [IIP-1] = SI(OC,0,REG[RJ],REG[RI]) 
          EQ     SII0 
  
*         TYPE I - RJ IS A DEF
  
          PROCESS (UP,NR,RNZ) 
          LX5    -R1.RKP
          BX6    "RN"X5 
          SA1    "TB"+X6
          LX5    R1.RKP-R1.RJP
          LX1    -I.REGP
          SX2    X1 
          BX6    "RN"X5 
          LX2    SI.RKP 
          IX7    X2+X7       [IIP-1] = SI(OC,REG[RK],0,REG[RI]) 
          ZR     X6,SII0     IF RJ[R1] = 0
          SA1    A5+4        R1S = R1 + 4 
          MX5    -SO.RTL-SO.RNL 
          LX1    -R1.SOP
          BX2    -X5*X1      REG[RJ] = SOREG[R1S] 
          LX2    SI.RJP 
          IX7    X2+X7
          EQ     SII0 
  
*         TYPE II INSTRUCTION 
  
 TYII     AX4    R1.INP 
          LX4    SI.CAP 
          BX7    X4+X7       [IIP-1] = SI(OC,IN[R1],0,0,REG[RI])
          EQ     SII0 
  
          PROCESS (KLS,KRS) 
          SA1    A5+B1       R2 = R1 + 1
          LX1    -IH.CAP
          SX2    X1 
          LX2    SI.CAP 
          BX7    X2+X7       [IIP-1] = SI(OC,CA[R2],0,0,REG[RI])
          EQ     SII0 
  
*         TYPE III JUMP INSTRUCTIONS
  
 TYIII    SA5    A5+B1       R2 = R1 + 1
          MX6    -IH.CAIHL
          LX5    -IH.CAIHP
          BX4    -X6*X5 
          LX5    IH.CAIHP-IH.RFP
          SA1    "TB"+X5
          LX1    -I.REGP
          LX4    SI.IHP 
          SX2    X1 
          LX2    SI.RJP 
          BX6    X2+X4
          IX7    X6+X7       [IIP-1] = SI(OC,0,IH[R2],REG[RF],REG[RI])
          EQ     SII0 
  
*         TYPE IV INSTRUCTIONS AND *NOP* ( BUFFER TERMINATOR )
  
          PROCESS NOP 
 TYIV     BX7    X5          [IIP-1] = [R1] 
          EQ     SII0 
 SII      EJECT 
*         MEMORY REFERENCES 
  
          PROCESS (LD,ST,STT,TLD,TST,ILD) 
          SA1    RMR
          MX6    -IH.CAIHL
          SA2    A5+B1       R2 = R1 + 1
          NZ     X1,LSS2     IF RMR " 0    */ REDUCABLE MEMREF
          LX2    -IH.CAIHP
          BX6    -X6*X2 
          LX2    IH.CAIHP-IH.RFP
          SA1    "TB"+X2
          SB6    X2 
          MX4    -R1.H2L
          LX1    -I.REGP
          SX2    X1 
          NE     B6,B1,LSS1  IF RF[R2] " 1
          SX2    RN.A0       REG[RF] = A0 
 LSS1     LX6    SI.IHP 
          BX1    X6+X7
          LX2    SI.RJP 
          IX7    X1+X2       [IIP-1] = SI(OC,CA,IH,REG[RF],REG[RI]) 
          LX5    -R1.H2P
          BX6    -X4*X5 
          ZR     X6,SII0     IF H2[R1] = 0
  
          MX5    12 
          SA6    X3+B1       [IIP] = H2[R1] 
          BX7    X5-X7       H2[IIP-1] = 1
          SA7    X3 
          SX6    A6+B1       IIP = IIP + 1
          SA6    A3 
          EQ     SII
  
*         REDUCABLE MEM REF 
  
 LSS2     SX2    X1 
          MX6    0
          IX1    X1-X2
          SA6    A1          RMR = 0
          SX4    X2+RN.A0 
          LX1    SI.CAP-IH.CAP
          BX5    X1+X7
          LX4    SI.RJP 
          IX7    X4+X5       [IIP-1] = SI(OC,CA[RMR],0,REG[RF],REG[RI]) 
          EQ     SII0 
 PLD      SPACE  2,8
          PROCESS (PLD,PST) 
          SA2    A5+B1       R2 = R1 + 1
          LX4    -R1.RJP
          SB6    X4 
          BX4    "RN"X4 
          SA1    "TB"+X4     LJ = TB + RJ[R1] 
          LX2    -IH.CAP     C = CA[R2] 
          SX6    RN.A0       REGJ = A0
          EQ     B6,B1,PLD1  IF RJ[R1] = 1
          LX1    -I.REGP
          SX6    X1+         REGJ = REG[LJ] 
  
 PLD1     SA1    A1-B1       DJ = LJ - 1
          LX6    SI.RJP 
          SB6    A1-B1       R2P = DJ - 1 
          BX7    X6+X7
          LX1    59-D.PIP 
          MI     X1,PLD2     IF PI[DJ]     */ PRED IS A *DEF* 
          LX1    D.PIP-D.PRSP 
          PL     X1,PLD3     IF ^PRS[DI]   */ NOT REDEF OF REG
          SB6    B6+4        R2P = R2P + 4 */ ADVANCE TO *RS* 
  
*         OPT=2 PLD/PST, BASE CA IS IN R2 WORD OF *DEF/RS*
  
 PLD2     SA1    B6 
          LX1    -IH.CAP
          SB2    X1 
          SX2    X2+B2       C = CA[R2] + ( -CA[R2P] )
  
 PLD3     MX5    -IH.CAL
          BX2    -X5*X2 
          LX2    SI.CAP 
          BX7    X2+X7       [IIP-1] = SI(OC,C,0,REGJ,REG[RI])
          EQ     SII0 
  
*         CLR - GENERATE A MXI 0  OR A  BXI XI-XI 
  
          PROCESS CLR 
          SA1    PBI+1
          SB2    OC.FMA 
          UX4    B6,X1
          SX6    B6-BOOL
          PX7    B2,X7       [IIP-1] = SI(FMA,0,0,0,0,REG[RI])
          NZ     X6,SII0     IF FU[PBI+1] " BOOL
          SB2    OC.XOR 
          SX4    B3          R = REG[RI]
          LX4    SI.RJP 
          BX7    X4+X7
          LX4    SI.RKP-SI.RJP
          BX5    X4+X7
          PX7    B2,X5       [IIP-1] = SI(XOR,0,R,R,R)
          EQ     SII0 
  
*         SXT -  - GENERATE AN *XMT* OR A NOMINAL LEFT SHIFT
  
          PROCESS SXT 
          SA1    PBI+1
          SB2    OC.XMT      OC = OC.XMT
          UX6    B6,X1
          SX4    B6-BOOL
          PX7    B2,X7
          ZR     X4,.XMT     IF FU[PBI+1] = BOOL
          LX5    -R1.RJP
          BX6    "RN"X5 
          SA1    "TB"+X6
          LX1    -I.REGP
          SB2    OC.ILS      OC = OC.ILS
          PX7    B2,X7
          SX2    X1 
          LX2    SI.RKP 
          BX7    X2+X7       [IIP-1] = SI(OC,REG[RJ],0,REG[RI]) 
          EQ     SII0 
 JUMPT    SPACE  3,14 
*         OPR - DEFINE MACRO TO FROM JUMP TABLES FOR *PPI* AND *SII*
  
          MACRO  OPR,NAM,SS 
          NOREF  .NAM 
 TYP      MICRO  3,3,$SS$ 
 X        IFLT   OC.NAM,OC.XMT
          EQ     //.NAM            NAM
-         JP     TY"TYP"
 X        ELSE
          IF     DEF,.NAM,2 
          CON    .NAM              NAM
          SKIP   1
          CON    TY"TYP"     NAM
 X        ENDIF 
          ENDM
 SII      SPACE  2
 SIIA     BSS    0
          LOC    0
          LIST   G
*CALL     OPRDEFS 
          LIST   -G 
          LOC    *O 
  
          QUAL
  
 PPI.JT   EQU    /SII/SIIA
 SII      EQU    /SII/SII 
 JAM      TTL    MCG - MACHINE CODE GENERATOR - JAM MODE
 JAM      TITLE  JAM MODE / DOCUMENTION 
**        JAM MODE - OVERVIEW/STRATEGY
* 
*         THE GOAL OF THE JAM ALGORITHM IS TO CODE INSTRUCTION SEQUENCE 
*         IN THE FINITE NUMBER OF REGISTERS ( 8 X-REGISTERS ) THAT WE 
*         HAVE ON THE 6X/7X THOUSAND SERIES MACHINES.  THE INITIAL
*         SEQUENCE OF INSTRUCTIONS MAY REQUIRE MORE THAN 8 REGISTERS
*         TO CODE BECAUSE REDUNDANT OPERATION ELIMINATION HAS EXTENDED
*         THE RANGE OF THE USES OF INSTRUCTIONS, OR MAY REQUIRE LESS, 
*         BUT THE SCHEDULER MAY HAVE PICKED AN ORDER FOR THE INSTRUCTION
*         THAT BROUGHT ABOUT A DEADLOCK.
*         IN JAM MODE, SCHEDULING TAKES SECOND PRIORITY TO RESOURCE 
*         ALLOCATION.  THE INPUT TO JAM IS THE SEQUENCE OF INSTRUCTIONS 
*         LST[I] = (*TXT* INDEX[I])/2  ( INITIALLY ). 
*            THE *SIT* IS ASSUMED TO HAVE NO DUPLICATE ENTRIES
*         ( FOR *RIL* ) , AND OPERATIONS  WHICH PRECEED AN *RJX* REG
*         STORES ARE LINKED TO THE RJX.  MOREOVER THE REGW FIELD OF 
*         THE DESCRIPTOR CONTAINS A COUNT OF THE NUMBER OF X-REGISTERS
*         IN USE AT ANY GIVEN POINT.
*         THE BASIC STRATEGY OF JAM MODE ASSUMES THAT THE ORDER OF THE
*         INSTRUCTIONS IS A REASONABLE ONE AND ATTEMPTS TO ISSUE THE
*         INSTRUCTIONS IN THAT ORDER. 
*         SINCE MOST PROBLEMS FROM REGISTER JAMMING ARISE FROM
*         ATTEMPTING TO KEEP TOO MANY PARTIAL RESULTS IN THE REGISTERS
*         FOR TOO LONG, WE ADOPT THE FOLLOWING STRATEGY.
*         ON ENTRY TO JAM THE INSTRUCTIONS HAVE BEEN TOTALLY ORDERED, 
*         A SIT BUILT, AND THE NUMBER OF REGISTERS IN USE AT EACH POINT 
*         COMPUTED. 
*         THE ALGORITHM THEN PROCEEDS TO ISSUE THE INSTRUCTIONS IN
*         THE GIVEN ORDER AND ADJUSTS IT AS FOLLOWS:  
*         WHEN A RESULT, R IN A REGISTER IS THE OPERAND OF AN 
*         INSTRUCTION WHICH DOES NOT EXHAUST ITS USES, LOOK AT THE
*         DISTANCE AND REGISTER REQUIREMENTS BETWEEN THE ISSUED 
*         INSTRUCTION AND THE NEXT USE OF R.  IF THE USE IS 
*         "FAR AWAY" AND TOO MANY OTHER RESULTS ARE BEING EXTENDED
*         OVER THAT INTERVAL, THEN SAVE THE RESULT AND REISSUE THE
*         INSTRUCTION.  IN THIS MANNER MOST CRISIS SITUATIONS ARE 
*         AVIODED AND THE SEQUENCE IS UNSQUEEZED IN A GRACEFUL FASHION. 
 RV.      SPACE  3
          QUAL   JAM
  
          IF     DEF,/DEBUG/JAM,1 
          TRACER (SSR,UJR)
 N.UR0    EQU    9           NUMBER OF UNLOADED REGISTERS ( INIT VALUE )
  
**        RV. - FORMAT OF *RVT* ENTRIES DURING JAM MODE 
  
          DESCRIBE RV.,60 
 LOCK     DEFINE 1           LOCK BIT 
 COST     DEFINE 11          COST OF RESTORING RESULT IN REG
          DEFINE 11 
 SRO      DEFINE 1           STORE REGISTER OUT ( UNSAVED RESULT )
 NU       DEFINE 18          *TXT* INDEX OF NEXT USE
 RN       DEFINE 18          R-NUMBER IN THE REG
 JAM      TITLE  JAM MODE / CONTROL 
**        JAM - REGISTER JAM CODE GENERATION MODE 
  
 JAM0     SA1    M.OT 
          SA2    =XN.OT 
          MX7    0
          IX3    X2-X1
          SA7    L.OTI       L.OTI = 0
          BX6    X1 
          PL     X3,JAM            N.OT = MAX( N.OT , M.OT )
          SA6    A2 
  
 JAM      ROUTINE 
          SETZERO M.OT,10    SETZERO( M.OT , 10 ) 
  
          SA4    L.TXT
          SA2    O.TXT
          SB2    X4-4 
          SA6    X2+3        FOR I = 3 TO L.TXT BY 4; TXT(I) = 0
+         SB2    B2-4 
          SA6    A6+4 
          GT     B2,*-1 
  
          CALL   RIO         RESET INSTRUCTION ORDER
          SX6    B1 
          CALL   BDT         FORM THE DEPENDENCY INFO 
          SX7    JAM0 
          SX0    B1 
          RJ     PRS         PRESET STORAGE 
          SX7    N.UR0
          SA7    UR          UR = N.UR0 
          MX6    0
          SA6    N.SP        N.SP = 0 
          SX7    -FX.X6 
          SA7    STL         STL = -FX.X6 
          RJ     SMB
  
*         MAIN LOOP 
  
 JAM1     SA1    SF 
          SA2    AXR
          BX6    X1*X2
          ZR     X6,JAM2     IF SF & AXR = 0 */ NO UNSAVED STORES/ST REGS 
          RJ     SUR         STORE UNSAVED RESULTS
  
 JAM2     RJ     SNI         SELECT NEXT INSTRUCTION TO ISSUE 
          MI     B3,JAM6     IF REGNO < 0  */ NO ISSUABLE INST FOUND
          ZR     B3,JAM4     IF REGNO = 0  */ A ISSUED PSEUDO INST
          LX5    59-I.IIP 
          PL     X5,JAM3     IF ^II[L]
          SA1    UR 
          SX7    N.UR0
          SX6    X1-1 
+         IX3    X6-X7
          PL     X3,*+1      UR = MAX( UR-1 , N.UR0 ) 
          BX6    X7 
          SA6    A1 
  
 JAM3     LX5    1+I.IIP
          RJ     AIL         ADJUST THE ISSUE LIST
          RJ     DUC         DECREMENT USES COUNTS
          S"DI"  "DI" 
          RJ     ASC         ADVANCE CLOCKS 
          SA5    "DI"-2 
          RJ     SII         SAVE THE INSTRUCTION 
  
 JAM4     S"DI"  "DI" 
          RJ     SNU         SET NEXT USE ADDRESS 
  
 JAM5     ZR     X7,JAM1     IF UOR = 0    */ NO UNCLEARED OPERAND REGS 
          RJ     CNU         CHECK NEXT USES OF OPERANDS
          EQ     JAM1 
  
 JAM6     SA3    ICL
          SX7    0
          SA7    UOR         UOR = 0
          RJ     UJR         UNJAM THE REGISTERS
          SA1    UOR
          SA2    T0 
          SB6    "TB"-B1
          BX7    X1 
          S"DI"  B6+X2       DI = BASE-1 + T0 
          EQ     JAM5 
 JCG      SPACE  3
          USE    /MCG/
 M.OT     BSS    1           MAX NUMBER OF OT.S IN CURRENT SEQUENCE 
 SF       BSS    1           = FX.ST IF UNSAVED RESULTS NOT IN ST REGS
 LRN      BSS    8           LAST R-NUMBER IN B-REGISTER I
 ISC      EQU    LRN         ISSUED STORE CHAIN 
  
 CLASS    BSS    1           REGISTER CLASS 
 R0       BSS    1           *TXT* INDEX OF INSTRUCTION  REMOVED FROM REGS
 T0       BSS    1           *TXT* INDEX OF INSTRUCTION TO BE ISSUED
 T0C      BSS    1           COPY OF T0 
 SIW      BSS    1           INDEX OF AVAIL WORD IN *SIT* 
 DRI      BSS    4           DUMMY RLIST INSTRUCTION BUFFER 
 UOR      BSS    1           LIST OF UNCLEARED OP REGISTERS ( *UJR* ) 
 UR       CON    9           COUNT OF UNLOADED REGISTERS
 PIS      BSS    1           POINT IN SEQUENCE
 TM       BSS    1           MAX *LST* OF ISSUABLE INST TO CONSIDER 
          USE    0
 SNI      TITLE  SNI - SELECT NEXT INSTRUCTION TO ISSUE 
**        SNI - SELECT NEXT INSTRUCTION TO BE POSTED ( ISSUED ) FROM
*         THE *ICL* ( ISSUE CANIDATE LIST ).
*         SCAN INSTRUCTIONS ON *ICL* FOR WHICH LST[INST] < LST[ICL] + 7 
*         OTHERWISE THIS ROUTINE IS IDENTICAL TO THE SCHEDULER
*         VERSION OF *SNI*. 
* 
*         EXIT   (B3) = REGNO OF ISSUABLE INST, < 0 IF NONE FOUND 
*                (B4,B5) = T(EX), T(IS) 
*                (A5) = LI ( ADDRESS OF LINK WORD OF ISSUABLE INSTRUCTION 
*                (A0) = *TXT* INDEX OF PREVIOUS INSTRUCTION 
*                PBI WORDS SET. 
  
 SNI0     SA5    "DI"+1      LI = DI + 1
  
 SNI      ROUTINE 
          SA4    PBI-1
          SA3    ICL         CI = ICL 
          S"PI"  B0          PI = 0 
          BX6    X4 
          SA6    A4+B1       PBI = PB1(FALSE,0,INFINITY,INFINITY) 
          SB6    X4          TIS[PBI] = INFINITY
          SA5    "TB"+X3     L = BASE + CI
          MX7    -I.LSTL
          LX5    -I.LSTP
          BX2    -X7*X5 
          SX6    X2+7        TM = LST[L] + 7  */ MAX LATE START TIME
          SA6    TM 
  
*         GET INST DESCR, CHECK FOR FIT IN CURRENT WORD 
  
 SNI1     SB4    X3+"TB"     LI = CI + BASE 
          SA2    T
          SA4    B4-B1       DI = LI - 1  ( DESCR)
          SB5    X2          T(IS) = T
          LX4    58-D.SZP 
          PL     X4,SNI4     IF SZ[DI] < 2 */ NO POSSIBLE SIZE FAULT
          SA3    PC 
          MX7    -2 
          BX6    X3+X7
          NZ     X6,SNI4     IF PC " 3     */ NOT IN LAST PARCEL OF WORD
          BX2    X4 
          LX2    1+D.SZP-D.SRP
          PL     X2,SNI3     IF ^SR[DI]    */ NOT SIZE REDUCABLE
  
*         INSTRUCTION IS SIZE REDUCEABLE, CHECK A-REGISTERS TO SEE IF 
*         ADDRESS IS IN ONE OF THEM.
  
          SA2    ARA+7       I = ARA(8) 
          SA3    "DI"-B1     R2 = DI - 1
          SB2    ARA-1
          BX6    X3 
          SA6    B2+B1       ARA(1) = [R2]
  
 SNI2     BX7    X3-X2
          SA2    A2-B1       I = I - 1
          NZ     X7,SNI2     IF [I+1] " [R2]
          SB3    A2-B2
          ZR     B3,SNI3     IF I = 0    */ MATCH WITH SEARCH TERMINATOR
  
          SA2    TRA+RN.A0+B3              */ COMPUTE TRUE ISSUE TIME 
          SB2    X2 
          LE     B2,B5,SNI4 
          SB5    X2 
          EQ     SNI4 
  
 SNI3     SA1    IWT               */ SET PENALITY FOR SIZE FAULT 
          SX2    X1+B1
          SB5    X2+B5       T(IS) = T(IS) + IWT + 1
  
*         SELECT AN AVAILABLE FUNCTIONAL UNIT 
  
 SNI4     LX4    2+D.SZP-D.F1P
          MX6    -D.F1L 
          BX7    -X6*X4      F = F1[DI] 
          SA3    TFU+X7      TFA = TFU(F) 
          SB3    X3 
          LE     B3,B5,SNI5  IF TFA @ T(IS) 
 #MD      IFEQ   .CPU,74                                         ?6600
          LX4    D.F1P-D.F2P
          SX1    X7                        */ CHECK SECOND FUNIT
          BX7    -X6*X4      F2 = F2[DI]
          SA2    TFU+X7      TF2 = TFU(F2)
          LX4    D.F2P-D.F1P
          SB4    X2 
          LE     B4,B5,SNI5  IF TF2 @ T(IS) 
          SB5    B4 
          LE     B4,B3,SNI5  IF TF2 @ TF1 
          BX7    X1 
 #MD      ENDIF                                                  '6600
          SB5    X3          T(IS) = TF1   */ MIN(TFA,TF2)
  
*         IF T(IS) @ TIS[PBI] THEN TRY TO GET A RESULT REG, CALC T(EX)
  
 SNI5     GT     B5,B6,SNI6  IF T(IS) > TIS[PBI]
          SA7    SNIA 
          LX4    D.F1P+59-D.NRP 
          RJ     DRR         CALL DRR( DI , T(IS) , T(EX) , REGNO ) 
          GT     B3,SNI7     IF REGNO > 0  */ INSTRUCTION IS ISSUABLE 
          ZR     B3,SNI0     IF REGNO = 0  */ A PSEUDO INSTRUCTION
  
 SNI6     SA5    "DI"+B1     LI = DI + 1
          EQ     SNI9                      */ NO RESULT REG AVAIL 
  
*         COMPARE THIS INSTRUCTION TIMING WITH THAT OF *PBI*
  
 SNI7     SA5    "DI"+B1     LI = DI + 1
 #MD      IFEQ   .CPU,74                                         ?6600
          GT     B5,B6,SNI9  IF T(IS) > TIS[PBI]
          SA3    PBI
          LT     B5,B6,SNI8  IF T(IS) < TIS[PBI]
          LX3    -PB.TEXP 
          SB2    X3 
          GE     B4,B2,SNI9  IF T(EX) \ TEX[PBI]
 #MD      ELSE                                                   '66?76 
          SA4    "DI" 
          GE     B4,B6,SNI9  IF T(EX) \ TEX[PBI]
 #MD      IFGT   .CPU,74                                         ?7600
          LX4    -D.LDP 
 .D       BIT    D.^DP-D.LDP
          SX6    .D+1 
          SB5    B4          T(IS) = T(EX)
          BX7    X6*X4
          LX4    D.LDP-D.FTP
          NZ     X7,SNI8     IF ^D[DI] ! LD[DI] 
  
*         ADJUST T(EX) TO ACCOUNT FOR THE FUNIT TO REGISTER INPUT PATH
  
          SA2    T
          SA1    TRS
          MX6    -D.FTL 
          BX7    -X6*X4 
          IX3    X7-X2
          SB2    X3+B5
          SB4    B4-B1       T(EX) = T(EX) - 1
          AX1    B2,X1       XSW = SHIFT(TRS, -(T(IS)+FT[DI]-T) ) 
  
 SNI7A    LX1    -1          XSW = SHIFT( XSW , 59 )
          SB4    B4+B1       T(EX) = T(EX) + 1
          MI     X1,SNI7A    IF XSW < 0    */ RESULT STORED AT THIS TIME
          SB5    B4          T(IS) = T(EX)
          GE     B4,B6,SNI9  IF T(EX) \ TEX[PBI]
 #MD      ENDIF                                                  '7600
  
*         INSTRUCTION BETTER THAN PREVIOUS BEST, SAVE INFO IN *PBI* 
  
 SNI8     SX4    B5 
          SA1    SNIA 
          SX3    B4 
          LX4    PB.TISP
          PX6    B3,X4
          SX7    "PI" 
          LX3    PB.TEXP
          SB2    X1 
          SX2    A5-"TB"
          BX6    X3+X6
          SA1    T
          LX7    PB.PIP 
          LX2    PB.LIP 
          PX2    B2,X2
          SA6    PBI         PBI(0) = PBII(REG,T(EX),T(IS)) 
          IX7    X7+X2
          SB2    X1+
          SA7    A6+B1       PBI(1) = PBII2(FU,PI,LI) 
  
          EQ     B4,B2,SNI   IF T(EX) = T  */ EXIT IF THIS INST IS EXEC 
  
          SB6    B5          TIS[PBI] = T(IS) 
  
*         ADVANCE TO NEXT INSTRUCTION ON CHAIN
  
 SNI9     S"PI"  A5-"TB"     PI = LI - BASE 
          LX5    -I.LINKP 
          SX3    X5          CI = LINK[LI]
          ZR     X3,SNI10    IF CI = 0
  
*         ONLY CONSIDER INSTRUCTIONS THAT ARE NEAR THE FIRST ON THE ISSUE 
*         LIST, SO WE DO NOT GO TOO FAR ASTRAY FROM THE PREDETERMINED 
*         ORDER.
  
          MX6    -I.LSTL
          SA5    "TB"+X3     LI = BASE + CI 
          SA2    TM 
          LX5    -I.LSTP
          BX7    -X6*X5 
          IX4    X7-X2
          MI     X4,SNI1     IF LST[LI] < TM  */ INSTRUCTION IS NEAR T0 
  
 SNI10    SA1    PBI
          SA2    A1+B1
          UX3    B3,X1       REGNO = REG[PBI] 
          LX2    -PB.LIP
          MI     B3,SNI      IF REGNO < 0  */ NO ISSUABLE INST FOUND
  
          SA5    X2+"TB"     LI = LI[PBI] + BASE
          LX2    PB.LIP-PB.PIP
          S"PI"  X2          PI = PI[PBI] 
          LX1    -PB.TISP 
          SB5    X1          T(IS) = TIS[PBI] 
          LX1    PB.TISP-PB.TEXP
          SB4    X1          T(EX) = TEX[PBI] 
          EQ     SNI
 ISI      TITLE  ISI - ISSUE SELECTED INSTRUCTION 
**        ISI - ISSUE SELECTED INSTRUCTION
* 
*         ENTRY  (X2) = R , *TXT* INDEX OF INSTRUCTION
* 
*         EXIT   (B3) < IF INSTRUCTION WAS NOT ISSUED 
*                UOR SET
  
 ISI0     SA4    "DI" 
          RJ     SNU         SET ADDR OF NEXT USES
          SA7    UOR
  
 ISI      ROUTINE 
          SA3    ICL         NI = ICL 
          SA5    "TB"+X2     LI = BASE + R
          S"PI"  B0          PI = 0 
          S"DI"  A5-B1       DI = LI - 1
          LX5    59-I.ICP 
          IX6    X2-X3
          PL     X5,*+1S17   IF ^IC[LI] BLOWUP
          ZR     X6,ISI2     IF R = ICL 
  
 ISI1     SA5    "TB"+X3     L = BASE + NI
          S"PI"  X3          PI = NI
          SX3    X5          NI = LINK[L] 
          IX6    X3-X2
          NZ     X6,ISI1     IF R " NI
  
 ISI2     SA1    T
          LX4    -D.F1P 
          MX5    -D.F1L 
          SB5    X1          T(IS) = T
          BX6    -X5*X4 
          SB2    X6          FU[PBI+1] = F1[DI] 
          PX6    B2,X2       LI[PBI+1] = R
          LX4    D.F1P+59-D.NRP 
          SA6    PBI+1
          RJ     DRR         REGNO = DRR( DI )
          ZR     B3,ISI0     IF REGNO = 0  */ A PSEUDO INSTRUCTION
          MI     B3,ISI      IF REGNO < 0  */ NO RESULT REG FOUND 
          SX3    B5 
          LX3    PB.TISP     TIS[PBI] = T(IS) 
          SX2    B4 
          SA5    "DI"+B1     L = DI + 1 
          LX2    PB.TEXP
          PX3    B3,X3       REG[PBI] = REGNO 
          BX6    X2+X3       TEX[PBI] = T(EX) 
          SA6    PBI
          LX5    59-I.IIP 
          PL     X5,ISI3     IF ^II[L]     */ NOT PREVIOUSLY ISSUED 
          SA1    UR 
          SX7    N.UR0
          SX6    X1-1 
+         IX3    X6-X7
          PL     X3,*+1      UR = MAX( UR-1 , N.UR0 ) 
          BX6    X7 
          SA6    A1 
  
 ISI3     LX5    1+I.IIP
          RJ     AIL         ADVANCE THE ISSUE LIST 
          RJ     DUC         DECREMENT USES COUNTS
          SA4    "DI" 
          RJ     ASC         ADVANCE CLOCKS 
          SA5    "DI"-2 
          RJ     SII         SAVE INSTRUCTION 
          EQ     ISI0 
 CNU      TITLE  CNU - CHECK NEXT USE OF RESULTS IN REGISTERS 
**        CNU - CHECK NEXT USE OF RESULTS IN REGISTERS OF OPERANDS
*                OF THE ISSUED INSTRUCTION AND RELEASE THE REGISTER 
*                IF THEIR NEXT USE IS "FAR AWAY". 
* 
*         ENTRY  (X7) = UOR = LIST OF UNCLEARED OPERAND REGISTERS 
*                    UOR = 24/0,18/REG2,18/REG1,  REG1 " REG2 & REG1 " 0
*                (A4) = DI OF INSTRUCTION 
*                (UR) = COUNT OF UNLOADED REGISTERS 
* 
*         USES   B - 2, 3, 4, 5, 6  X - 1, 2, 3, 4, 5, 6, 7 
  
 MIN.D    EQU    14*4        MIN DISTANCE FOR UNLOAD CHECK ( 14 INST )
  
 CNU0     SX6    0
          SA6    UOR         UOR = 0
 CNU      ROUTINE 
          SA4    "DI" 
          LX4    59-D.PIP 
          MI     X4,CNU0     IF PI[DI]     */ *DEF* OR *RS* 
          SA5    "DI"+B1     L = DI + 1 
          MX4    -I.LSTL
          LX5    -I.LSTP
          BX3    -X4*X5 
          AX6    B1,X3       PIS = (LST[L]/2)*4  */ POINT IN SEQ
          LX6    2
          SA6    PIS
  
*         ORDER REG1,REG2 IN DECREASING DISTANCE OF NEXT USE
  
          BX3    X7 
          AX3    18 
          ZR     X3,CNU1     IF REG2 = 0
          SA1    RVT+X7 
          SA2    RVT+X3 
          LX1    -RV.NUP
          LX2    -RV.NUP
          SB2    X1 
          SB3    X2 
          GE     B2,B3,CNU1  IF NU[RVT(REG1)] \ NU[RVT(REG2)] 
          SX7    X7 
          LX7    18 
          BX7    X3+X7       SWAP( REG1 , REG2 )
  
 CNU1     MX1    -D.REGWL 
          SA2    UR 
          LX1    D.REGWP
          SA5    PIS
          LX2    D.REGWP
          SB6    "TB"-B1
          SB5    X5+MIN.D    TMIN = PIS + MIN.D 
  
 CNU2     SA5    RVT+X7 
          SX6    X7-RN.X0 
          SB3    X7          REGNO = REG[UOR] 
          AX7    18          UOR = SHIFT( UOR , -18 ) 
          BX3    X5+X6
          LX5    -RV.NUP
          MI     X3,CNU4     IF LOCK[RVT(REGNO)] ! REGNO < RN.X0
          SB4    X5          NS = NU[RVT(REGNO)]  */ POINT OF NEXT USE
          SA4    B6+X5       DI = BASE-1 + NS 
          LE     B4,B5,CNU4  IF NS @ TMIN  */ USE IS NEARBY 
  
*         SEARCH BACKWARDS FROM THE POINT OF NEXT USE FOR A "PEAK" IN 
*         THE REG WIDTH"S, AND IF FOUND TRY TO DUMP THE REGISTER. 
  
 CNU3     BX5    -X1*X4 
          IX6    X2-X5       N = UR - REGW[DI]
          MI     X6,CNU5     IF N < 0      */ USE IS PAST A REG PEAK
          AX6    D.REGWP-2
          SB2    X6+4        N = 4*(N+1)   */ MIN DIST TO MAKE REGW > UR
          SB4    B4-B2       NS = NS - N
          SA4    A4-B2       DI = DI - N
          GE     B4,B5,CNU3  IF NS \ TMIN 
  
 CNU4     NZ     X7,CNU2     IF UOR " 0 
          EQ     CNU
  
*         POINT OF NEXT USE OVER A REG WIDTH PEAK, DUMP THE REG 
  
 CNU5     SA3    T
          SA7    UOR
          BX6    X3 
          SA6    TRA+B3      TRA(REGNO) = T 
          RJ     CRC         COMPUTE RESTORE COSTS FOR THIS REG 
          RJ     SSR         SAVE THE RESULT
          SA1    UOR
          BX7    X1          UOR = CNUA 
          ZR     X1,CNU      IF UOR = 0 
          EQ     CNU1 
 SSR      TITLE  SSR - SAVE SPECIFIED REGISTER
**        SSR - SAVE SPECIFIED REGISTER 
* 
*         ENTRY  (B3) = REGNO , REGISTER TO BE FREED
*                (B4) = COST ( OF SAVING RESULT IN REGNO )
  
 SSR0     SA1    UR 
          SX6    X1+B1       UR = UR + 1   */ INCREMENT COUNT OF UNL REGS 
          SA6    A1 
          RJ     AIS         ALLOCATE INSTRUCTION SPACE 
  
 SSR      ROUTINE 
          SX6    B4-3 
          MI     X6,SSR3     IF COST < 3
  
*         COST = 3, COMPUTATION NOT IN A STORE REG
  
          SA1    AXR
          SX7    FX.ST
          BX6    X7*X1
          NZ     X6,SSR1     IF AXR & FX.ST " 0  */ IF A STORE REG IS AVAIL 
          SX3    B1 
          SA2    RVT+B3 
          LX3    RV.SROP
          BX6    X3+X2       SRO[RVT(REGNO)] = 1
          SA7    SF          SF = FX.ST    */ INDICATE UNSAVED RESULTS
          SA6    A2 
          EQ     SSR
  
 SSR1     SB4    B3+         REGF = REGNO 
          SB3    RN.X0+6
          SB2    OC.XMT 
          SA3    RVT+B3 
          ZR     X3,SSR2     REGR = IF( RVT(X6) = 0 ) THEN X6; ELSE X7
          SB3    B3+1 
 SSR2     RJ     OXI         MOVE RESULT TO A STORE REG 
          SB4    2           COST = 2 
  
 SSR3     SA1    RVT+B3 
          BX6    "RN"X1      R0 = RI[RVT(REGNO)]
          BX1    X6 
          SA6    R0 
          PRINT  SSR,(* R0,UR = *,O6,I5),(R0,UR)
          SA2    AXR
          SA3    RBV+B3 
          MX6    0
          BX7    X2+X3       AXR = AXR ! RBV(REGNO)  */ MAKE THE REG AVAIL
          SA6    A1          RVT(REGNO) = 0 
          SA7    A2 
  
          GT     B4,B1,SSR4  IF COST > 1
          RJ     RII         REISSUE THE INSTRUCTION
          EQ     SSR0 
  
 SSR4     SX6    0
          SA6    T0          T0 = 0 
          RJ     SRM         SAVE RESULT IN MEMORY
          EQ     SSR0 
 SUR      SPACE  3,14        SUR
**        SUR - STORE UNSAVED RESULTS 
* 
*         ENTRY  AXR & FX. ST " 0 ( STORE REGISTER FREE ) 
*                SF " 0 , UNSAVED RESULTS IN THE REGISTERS THAT 
*                      HAVE NO IMMEDIATE USES.
  
 SUR      ROUTINE 
          SB3    RN.X0+6
          SB4    RN.X0       I = RN.X0
          SA1    RVT+B3 
          SX6    0           T0 = 0 
          SA6    T0 
          ZR     X1,SUR1     REGR = IF( RVT(X6) = 0 ) THEN X6; ELSE X7
          SB3    B3+1 
  
 SUR1     SA1    RVT+B4 
          BX7    "RN"X1 
          LX1    59-RV.SROP 
          PL     X1,SUR2     IF ^SRO[RVT(I)]
  
          SB2    OC.XMT 
          SA7    R0          R0 = RI[RVT(I)]
          SX2    B4 
          PX6    B3,X2
          SA6    SURA 
          RJ     OXI         OUTPUT AND XMIT
          SA1    UR 
          SX6    X1+B1       UR = UR + 1
          SA6    A1 
          RJ     SRM         AND SAVE RESULT IN MEMORY
          SA2    SURA 
          SB4    X2 
          UX6    B3,X2
  
 SUR2     SB4    B4+B1       I = I + 1
          SX6    B4-RN.X0-6 
          MI     X6,SUR1     IF I < RN.X6 
  
          SA1    AXR
          SA2    RBV+B3 
          SA6    RVT+B3      RVT(REGR) = 0 */ MAKE REG AVAIL
          SA6    SF          SF = 0 
          BX7    X1+X2       AXR = AXR ! RBV(REGR)
          SA7    A1 
          EQ     SUR
  
 SURA     BSS    1
 UJR      TITLE  UJR - UNJAM REGISTERS
**        UJR - UNJAM REGISTERS, FORCE ISSUE OF CURRENT INSTRUCTION 
*                BY FREEING UP A REGISTER, CREATING AN *XMT*, ETC.
* 
*         ENTRY  (X3) = T0 , *TXT* INDEX OF INSTRUCTION TO BE ISSUED
* 
*         EXIT   (UOR) = EXIT VALUE FROM *SNU* IF *ISI* WAS CALLED
  
 UJR      ROUTINE 
          SB6    "TB"-1 
          S"DI"  X3+B6       DI = BASE-1 + T0 
          BX6    X3 
          SA6    T0C         T0C = T0 
          SA6    T0 
          RJ     DRT         CLASS = DRT( DI ) */ DETERMINE REG CLASS 
          PRINT  UJR,(* TO = *,O6),T0 
          PRNT   UJR,RUI
          SA6    CLASS
          SX7    0
          SA7    ISI         ISI = 0       */ INDICATE *ISI* NOT ENTERED
          RJ     CSI         CHECK STORE REGISTERS
          SA1    ISI
          ZR     X1,UJR0A    IF ISI = 0 */NO INSTRUCTIONS ISSUED
  
 UJR0     SA2    T0 
          RJ     ISI         TRY AND ISSUE T0 
          PRINT  JAM,(* CSI ISSUED A ST, REGNO =*Z2),B3 
          PL     B3,UJR      IF REGNO \ 0  */ ISI ISSUED THE INSTRUCTION
  
 UJR0A    RJ     AIS         ALLOCATE INSTRUCTION SPACE 
          SA1    AXR
          SX4    FX.SCR 
          BX6    X4*X1       AVAIL = AXR & FX.SCR 
          ZR     X6,UJR2     IF AVAIL = 0 
          SA1    CLASS
          BX7    X1*X6
          NZ     X7,UJR      IF AVAIL & CLASS " 0 
  
 UJR1     SA1    CLASS
          RJ     CRA         CHANGE REGISTER ASSIGNMENTS AND ISSUE *T0* 
          EQ     UJR
  
 UJR2     SA1    CLASS
          RJ     FRR         REGF = FRR(RVT,MCOST)  */ FIND A RESULT REG
          SX7    B4-3 
          MX5    0
          MI     X7,UJR3     IF MCOST < 3 
  
*         DUMP THE STORE REG WHOSE FIRST USE IS FURTHEST AWAY 
  
          RJ     FSR         FIND A STORE REGISTER
  
 UJR3     SA1    RVT+B3 
          BX6    "RN"X1      R0 = RI[RVT(REGF)] 
          SA6    R0 
          PRINT  UJR,(* R0 = *,O6),R0 
          SA1    AXR
          SA2    RBV+B3 
          SA3    CLASS
          BX6    X1+X2       AXR = AXR ! RBV(REGF) */ MAKE REG AVAIL
          SA6    A1 
          MX7    0
          SA7    RVT+B3 
          MI     X5,UJR10    IF BOTH X6 AND X7 LOCKED 
          BX5    X2*X3
          NZ     X5,UJR5     IF CLASS & RBV(REGF) " 0 
  
*         REGF NOT IN *CLASS*, FREE IT UP AND OUTPUT AN *XMT* 
  
          LE     B4,B1,UJR4  IF MCOST @ 1 
          RJ     TGL         SHOULD R0 BE TOGGLED 
          NZ     B4,UJR0     IF B4 " 0 R0 WAS TOGGLED 
          SX6    0
          SA6    T0          T0 = 0 
          RJ     SRM         SAVE RESULT IN MEMORY
          SA5    T0C
          SX6    X5+         T0 = T0C      */ RESTORE T0
          SA6    T0 
          EQ     UJR1 
  
 UJR4     SA1    R0 
          RJ     RII         RESET FOR REISSUE
          EQ     UJR1 
  
*         REGF IN *CLASS*, FREE IT UP 
  
 UJR5     LE     B4,B1,UJR6  IF MCOST @ 1 
  
          RJ     TGL         SHOULD R0 BE TOGGLED 
          NZ     B4,UJR0     IF B4 " 0 R0 WAS TOGGLED 
          RJ     SRM         SAVE RESULT IN MEMORY
          EQ     UJR
  
 UJR6     SA2    T0 
          RJ     ISI         ISSUE T0 
          SA1    R0 
          RJ     RII         RESET FOR REISSUE
          EQ     UJR
  
*         BOTH X6 AND X7 LOCKED UP - FREE ONE OF THEM.
  
 UJR10    SA1    R0 
          SA3    LXR
          SB2    "TB"-1 
          BX7    -X2*X3 
          S"DI"  B2+X1       DI OF R0 
          SA7    A3          CLEAR LXR AT R0
          LX4    59-D.PRSP
          PL     X4,UJR.E1   IF ^PRS ABORT
  
          RJ     OTS         OUTPUT TEMP STORE
  
          SA1    R0 
          RJ     GLI         GENERATE LOAD OF TEMP
  
*         UPDATE DESCRIPTOR AND LINK WORDS OF R0. 
  
          SA1    R0 
          SA3    "TB"+X1
          SX2    B1 
          LX3    -I.USESP 
          IX7    X2+X3       USES = USES + 1
          SA4    A3-B1       DI = LI - 1
          LX7    I.USESP
          SA7    A3 
          LX2    D.PRSP 
          BX7    -X2*X4      [DI] = [DI] AND ^PRS 
          SA7    A4 
  
*         GENERATE XMT OF LOADED TEMP AT END OF TEXT
  
          ALLOC  TXT,8
          ALLOC  TREE,3      (B6) =  LTR = OLD(L.TREE)
          RJ     AIP
          SA1    R0 
          SA2    L.TXT
          SX2    X2-8        LT = L.TXT - 8 
          SX7    B1 
          SX6    B6 
          LX6    I.INDXP
          BX6    X6+X7
          SA6    "TB"+X2     [LIT] = LW(O,O,LTR,0,1)
          SB2    OC.XMT 
          SA4    F.RDT+B2 
          LX7    D.PRSP 
          BX6    X4+X7
          SA6    A6-B1       DIT=LIT-1;[DIT]=RDT(OC.XMT)!PRS
          MX7    0
          SA7    A6-B1       R2T=DIT-1;[R2T]=0
          SX1    X1 
          LX1    R1.RJP 
          BX7    X1+X2
          PX6    B2,X7
          SA6    A7-B1       R1T=R2T-1;[R1T]=TYI(OC.XMT,R0,0,LT)
          LX1    -R1.RJP
  
*         GENERATE RS AFTER XMT.
  
          SB2    X2+4        RSLT = LT + 4
          SX6    B6+2 
          SX7    B1 
          LX6    I.INDXP
          BX7    X6+X7
          SA7    "TB"+B2     [LIT] = LW(0,0,LTR+2,0,1)
          SA3    F.RDT+OC.RS
          SB2    "TB"+B1
          BX7    X3 
          SA7    A7-B1       DIT=LIT-1;[LIT]=F.RDT(OC.RS) 
          MX6    0
          SA6    A7-B1       R2T=DIT-1;[R2T]=0
          SA3    B2+X1       R1W OF RS OF R0
          BX6    X0*X3       MASK OUT RI
          BX7    X6+X2       REPLACE IT WITH LT 
          SA7    A6-B1       R1T=R2T-1;[R1T]=TYII(OC.RS,IN,SO,LT) 
  
*         ADJUST *SIT* SO THAT XMT IS THE LAST SUCCESSOR OF R0. 
  
          SA3    "TB"+X1
          SA4    O.TREE 
          LX3    -I.INDXP 
          MX7    -I.INDXL 
          SB2    X4          =UO
          BX3    -X7*X3 
          SA3    B2+X3       = UI 
  
*         SEARCH FOR LAST SUCCESSOR OF R0 
  
 UJR20    LX3    59-U.LASTP 
          MI     X3,UJR30    IF LAST
          SA3    A3+B1
          EQ     UJR20       LOOP UNTIL LAST IS FOUND 
  
*         MAKE LT THE LAST SUCCESSOR OF RO. 
  
 UJR30    LX3    U.LASTP-U.SUCCP+1
          BX7    X0*X3       MASK OUT SUCC. 
          BX6    X2+X7
          LX6    U.SUCCP
          SA6    A3          LAST SUCC OF R0 = LT 
  
*         MAKE RS OF LT THE FIRST SUCCESSOR OF LT.
  
          SX4    X2+4        RSLT = LT + 4
          LX2    U.PREDP
          LX4    U.SUCCP
          BX7    X2+X4
          SA7    B2+B6       [LTR] = USES(0,LT,0,RSLT)
  
*         MAKE THE PREVIOUS LAST SUCCESSOR OF RO THE LAST SUCCESSOR OF LT.
  
          BX6    "RN"X3      LSR0 = PREV. LAST SUCCESSOR OF R0
          SX7    B1 
          LX7    U.LASTP
          BX6    X6+X7
          BX7    X2+X6
          SA7    A7+B1       [LTR+1] = USES(1,LT,0,LSR0)
  
*         MAKE THE PREV. LAST SUCCESSOR OF RO THE LAST SUCCESSOR OF RSLT
  
          LX4    U.PREDP-U.SUCCP
          BX7    X4+X6
          SA7    A7+B1       [LTR+2] = USES(1,RSLT,0,LSR0)
          EQ     UJR0        TRY AGAIN
  
*         COMPILER ERROR, UNFORSEEN SITUATION 
  
 DRT0     BSS    0
 UJR.E1   BSS    0
          PRNT   JAM,RUI
          EQ     *+1S17 
 FSR      SPACE  3,14 
**        FSR - FIND STORE REGISTER, NO REGS AVAIL
* 
*         EXIT   (B3) = REGNO, = 0 IF NOTHING FOUND 
*                (B4) = MCOST 
*         (X5) = NEG IF BOTH X6 AND X7 LOCKED.
  
 FSR      ROUTINE 
          SA1    RVT+RN.X0+6
          SA2    A1+B1
          MX5    1
          BX6    X5*X1
          BX7    X5*X2
          SA6    FSRA        FSRA(1) = LOCK[RVT(X6)]
          SA7    A6+B1       FSRA(2) = LOCK[RVT(X7)]
          SA3    CLASS
          SX4    X3-FX.SCR
          ZR     X4,FSR2     IF CLASS = FX.SCR
          SA2    T0 
          RJ     GOR         GET REGNO"S OF OPERANDS OF T0
  
 FSR1     ZR     X7,FSR2     IF END OF LIST 
          SX4    X7-RN.X0-6 
          AX7    18 
          MI     X4,FSR1     IF NOT A STORE REG 
          MX6    1
          SA6    FSRA+X4     INDICATE REGISTER IS NOT AVAIL 
          EQ     FSR1 
  
 FSR2     SA1    FSRA 
          SA2    A1+B1
          BX5    X1*X2
          SB3    RN.X0+6     REGNO = X6 
          SB4    B1+B1       MCOST = 2
          MI     X5,FSR3     IF BOTH X6 AND X7 LOCKED 
          BX7    X1+X2
          ZR     X7,FSR3     IF BOTH AVAILABLE
          ZR     X1,FSR      IF X6 IS AVAILABLE 
          SB3    B3+B1       REGNO = RN.X7
          EQ     FSR
  
*         BOTH ST REGS AVAIL, SEARCH FOR NEXT USE OF EACH.
  
 FSR3     SA3    O.TREE 
          SA1    RVT+RN.X0+6
          SA2    A1+B1
          MX7    -I.INDXL 
          SB2    X3-1 
          SA1    "TB"+X1     LX6 = TB + RVT(X6) 
          SA2    "TB"+X2     LX7 = TB + RVT(X7) 
          LX1    -I.INDXP 
          LX2    -I.INDXP 
          BX1    -X7*X1 
          BX2    -X7*X2 
          SB6    59-U.EQVP
          SA1    B2+X1       UX6 = TREE-1 + INDX[LX6] 
          SA2    B2+X2       UX7 = TREE-1 + INDX[LX7] 
  
 FSR4     SA1    A1+B1       UX6 = UX6 + 1
          LX6    B6,X1
          MI     X6,FSR4     IF EQV[UX6]
          LX1    -U.SUCCP 
          SA4    "TB"+X1     LIS = TB + SUCC[UX6] 
          LX4    59-I.IIP 
          MI     X4,FSR4     IF II[LIS] 
  
 FSR5     SA2    A2+B1       UX7 = UX7 + 1
          LX6    B6,X2
          MI     X6,FSR5     IF EQV[UX7]
          LX1    -U.SUCCP 
          SA4    "TB"+X2     LIST = TB + SUCC[UX7]
          LX4    59-I.IIP 
          MI     X4,FSR5     IF II[LIS] 
  
          SB5    X1 
          SB6    X2 
          GT     B5,B6,FSR   IF ( SUCC[UI6] > SUCC[UI7] ) 
          SB3    B3+B1             THEN RN.X6   ELSE RN.X7
          NE     B5,B6,FSR   IF SUCC[UX6] " SUCC[UX7] 
          SA2    RVT+B3      RX7 = RVT + RN.X7
          SA1    A2-B1       RX6 = RX7 - 1
          MX7    -I.USESL 
          SA1    "TB"+X1     LIX6 = BASE + RX6
          SA2    "TB"+X2     LIX7 = BASE + RX7
          LX1    -I.USESP 
          LX2    -I.USESP 
          BX1    -X7*X1 
          BX2    -X7*X2 
          SB5    X1 
          SB6    X2 
          GT     B6,B5,FSR    IF USES[LIX7] > USES[LIX6]
          SB3    B3-B1       REGNO = RN.X6
          EQ     FSR
  
 FSRA     BSS    2
 GOR      SPACE  3,14 
**        GOR - GET OPERAND REGISTERS OF INSTRUCTIONS THAT ARE
*                A) NOT LOCKED
*                B) NOT IN *CLASS*
* 
*         ENTRY  (X2) = R-NUMBER OF INSTRUCTION TO CHECK OPERANDS OF
* 
*         EXIT   (X7) = LOR, LIST OF REGISTERS
  
 GOR      ROUTINE 
          SB6    "TB"-B1
          S"DI"  B6+X2       DI = BASE-1 + T0 
          LX4    58-D.TYP 
          MX7    0           LOR = 0
          IX6    X4+X4
          MI     X6,GOR      IF TYPE[DI] = II ! IV
          PL     X4,GOR1     IF TYPE[DI] = I
  
*         ASSEMBLE OPERAND R-NUMBERS
  
          SA3    "DI"-B1     R2 = DI - 1
          LX3    -IH.RFP
          BX5    "RN"X3      RNUMS = RF[R2] 
          EQ     GOR2 
  
 GOR1     LX4    2+D.TYP-D.TYIOP
          MX6    -D.TYIOL 
          SA5    "DI"-2      R1 = DI - 2
          BX7    -X6*X4 
          SA3    TYIOM+X7 
          UX6    B2,X3
          BX2    X6*X5
          AX5    B2,X2       RNUMS = TYIO[R1,DI]
  
 GOR2     MX4    1
          LX4    1+RV.LOCKP 
          SA1    CLASS
  
 GOR3     BX6    "RN"X5      R = RI[RNUMS]
          AX5    R1.RIL      RNUMS = SHIFT( RNUMS , -16 ) 
          ZR     X6,GOR4     IF R = 0 
          SA3    "TB"+X6     L = BASE + R 
          LX3    -I.REGP     REGNO = REG[L] 
          SA2    RBV+X3 
          BX6    X2*X1
          NZ     X6,GOR4     IF RBV(REGNO) & CLASS " 0  */ REG IN CLASS 
          SA2    RVT+X3 
          MI     X2,GOR4     IF LOCK[RVT(REGNO)]
          LX7    18 
          SX3    X3 
          BX7    X3+X7       LOR = SHIFT(LOR,18) ! REGNO
 GOR4     NZ     X5,GOR3     IF RNUMS " 0 
  
          EQ     GOR
 RII      TITLE  RII - RESET ISSUED INSTRUCTION 
**        RII - RESET ISSUED INSTRUCTION FOR REISSUE
* 
*         ENTRY  (X1) = R , *TXT* INDEX OF INSTRUCTION
  
 RII      ROUTINE 
          RJ     RIL         RESET ISSUE LIST FOR R 
          SB6    "TB"-B1
          S"DI"  B6+B3       DI = BASE-1 + R0 
          LX4    59-D.ZPP 
          MI     X4,RII      IF ZP[DI]     */ NOT A *LD* WITH OPERANDS
  
*         ADJUST USES COUNTS OF OPERAND REGS, SET FOR REISSUE 
  
          LX4    1+D.ZPP+58-D.TYP 
          PL     X4,RII1     IF TYPE[DI] = I
          SA3    "DI"-B1     R2 = DI - 1
          LX3    -IH.RFP
          BX5    "RN"X3      RNUMS = RF[R2] 
          EQ     RII2 
  
 RII1     SA3    "DI"-2      R1 = DI - 2
          SA2    TYIOM
          UX6    B2,X2
          BX7    X6*X3
          AX5    B2,X7       RNUMS = TYIO[R1,0] 
  
 RII2     SX4    B1 
          LX4    I.USESP
  
 RII3     BX6    "RN"X5      R = RI[RNUMS]
          AX5    R1.RIL      RNUMS = SHIFT( RNUMS , -16 ) 
          ZR     X6,RII4     IF R = 0 
          SA3    "TB"+X6     L = BASE + R 
          IX7    X3+X4       USES[L] = USES[L] + 1
          SA7    A3 
          LX3    -I.REGP     REGNO = REG[L] 
          SB3    X3 
          SA2    RVT+X3 
          BX1    X2-X6
          BX3    "RN"X1 
          ZR     X3,RII4     IF RI[RVT(REGNO)] = R
          SA1    AXR
          SA3    RBV+B3 
          SA6    A2          RVT(REGNO) = R 
          BX7    -X3*X1      AXR = AXR & ^RBV(REGNO)
          SA7    A1 
 RII4     NZ     X5,RII3     IF RNUMS " 0 
  
          EQ     RII
 CSI      TITLE  CSI - CHECK STORE ISSUE
**        CSI - CHECK STORE REGS FOR ISSUE OF A STORE INSTRUCTION 
*                RECOMPUTE PS BIT FOR RESULTS IN STORE REGS 
  
 CSI      ROUTINE 
          SB3    RN.X0+6     I = RN.X6
  
 CSI1     SA1    RVT+B3      R = RVT(I) 
          SB6    "TB"-B1
          SA4    B6+X1       DI = BASE-1 + R
          LX4    59-D.PSP 
          PL     X4,CSI4     IF ^PS[DI]    */ NOT A STORE PREDECESSOR 
  
*         CHECK FOR ISSUABLE STORES, ADJUST PS BIT
  
          SA5    "DI"+B1     L = DI + 1 
          MX7    -I.INDXL    ^P = 1 
          SA2    O.TREE 
          LX5    -I.INDXP 
          BX6    -X7*X5 
          SB2    X2 
          MX2    1
          SA3    B2+X6       UI = O.TREE + INDX[L]
  
 CSI2     LX3    -U.SUCCP 
          SA5    "TB"+X3     SI = BASE + SUCC[UI] 
          LX5    59-I.IIP 
          MI     X5,CSI3     IF II[SI]
          SA1    A5-B1       D = SI - 1 
          LX5    I.IIP-I.ICP
          LX1    59-D.STP 
          BX6    X1*X5
          MI     X6,CSI5     IF ST[D] & IC[SI]
 #DAL     IFNE   .DAL,0 
          BX5    X2*X1
          LX1    D.STP-D.L2P
          BX1    -X1*X5 
 #DAL     ENDIF 
          BX7    -X1*X7      ^P = ^P & ^(ST[D] &^L2[D]) 
 CSI3     LX3    U.SUCCP+59-U.LASTP 
          BX6    X3          UL = UI
          SA3    A3+B1       UI = UI + 1
          PL     X6,CSI2     IF ^LAST[UL] 
  
          PL     X7,CSI4     IF ^P = 0     */ RESULT STILL IS *PS*
          BX7    -X2*X4      PS[DI] = 0 
          LX7    1+D.PSP
          SA7    A4 
  
 CSI4     SB3    B3+B1       I = I + 1
          SX6    B3-RN.X0-7 
          ZR     X6,CSI1     IF I = RN.X7 
          EQ     CSI
  
 CSI5     SX2    A5-"TB"     R = SI - BASE
          RJ     ISI         ISSUE THE STORE
          SB3    RN.X0+6     I = RN.X6     */ RESET 
          EQ     CSI1 
 DRT      TITLE  DRT - DETERMINE RESULT REGISTER TYPE ( CLASS ) 
**        DRT - DETERMINE RESULT REGISTER TYPE ( CLASS ) NEEDED 
* 
*         ENTRY  (A4,X4) = DI , [DI]
* 
*         EXIT   (X6) = REGISTER CLASS BITS 
  
 DRT      ROUTINE 
          LX4    59-D.NRP 
          SX6    FX.SCR      CLASS = FX.SCR 
          NX7    B2,X4
          JP     DRT1+B2     JUMP( NORMC[DI] )
  
 DRT1     BSS    0
          SA5    "DI"+2      R1RS = DI + 2
          EQ     DRT2 
  
          SX6    FX.ST       CLASS = FX.ST
          EQ     DRT
  
          SA5    "DI"+2      R1RS = DI + 2
          EQ     DRT3 
  
          EQ     DRT0        ECJ
  
          EQ     DRT         LVL2 
  
          SX6    FX.LD       CLASS = LD 
          EQ     DRT
  
          EQ     DRT0        ST 
          EQ     DRT0        JP 
          EQ     DRT         SXT
          EQ     DRT0        KS 
          EQ     DRT0        PI 
          EQ     DRT         MUC
          EQ     DRT         SCR
  
*         INSTRUCTION PRECEEDS AN *RJRS*, ENSURE B-REG IS AVAILABLE 
  
 DRT2     RJ     FBR         REGNO = FBR( R1RS )
          MI     B3,DRT0     IF ACT < 0    */ NO AVAILABLE B-REG
          LX4    D.NRP-D.PSP
          SX6    FX.SCR      CLASS = FX.SCR 
          PL     X4,DRT      IF ^PS[DI] 
          SX6    FX.ST       CLASS = FX.ST
          EQ     DRT
 DRT      SPACE  1,10 
*         INSTRUCTION PRECEEDS A *RS* 
  
 DRT3     LX5    -R1.SOP
          MX7    -SO.REGL 
          BX3    -X7*X5 
          SA2    RBV+X3 
          SX6    X2          CLASS = RBV( SOREG[R1RS] ) 
          EQ     DRT
 FRR      TITLE  FRR - FIND RESULT REGISTER 
**        FRR - FIND RESULT REGISTER
* 
*         ENTRY  (X1) = CLASS OF REGISTERS WHICH RESULT SHOULD BE IN
*                (T0) = *TXT* INDEX OF INSTRUCTION TO BE ISSUED 
* 
*         EXIT   (B3) = REGF , REGNO OF REGISTER THAT IS CHEIPEST TO FREE 
*                (B4) = MCOST , COST OF RESTORING *REGF*
* 
*         CALLS  CRC
  
 FRR0     SB3    B0 
          SB6    B0          ABR = 0
          RJ     CRC         REGF = CRC(RVT,MCOST)
  
 FRR      ROUTINE 
          SX6    X1-FX.SCR
          ZR     X6,FRR0     IF CLASS = FX.SCR
          SA2    T0 
          SB6    "TB"-B1
          S"DI"  B6+X2       DI = BASE-1 + T0 
          LX4    58-D.TYP 
          IX7    X4+X4
          MI     X7,FRR0     IF TYPE[DI] = II ! IV
          PL     X4,FRR1     IF TYPE[DI] = I
  
*         ASSEMBLE OPERAND R-NUMBERS
  
          SA3    "DI"-B1     R2 = DI - 1
          LX3    -IH.RFP
          BX5    "RN"X3      RNUMS = RF[R2] 
          EQ     FRR2 
  
 FRR1     LX4    2+D.TYP-D.TYIOP
          MX6    -D.TYIOL 
          SA5    "DI"-2      R1 = DI - 2
          BX7    -X6*X4 
          SA3    TYIOM+X7 
          UX6    B2,X3
          BX2    X6*X5
          AX5    B2,X2       RNUMS = TYIO[R1,DI]
  
*         LOCKOUT OPERANDS OF *T0* THAT ARE NOT IN *CLASS* SO *CRC* 
*         WON"T CONSIDER THEM.
  
 FRR2     MX4    1
          LX4    1+RV.LOCKP 
          MX7    0           I = 0         */ LIST OF LOCKED OPERAND REG
  
 FRR3     BX6    "RN"X5      R = RI[RNUMS]
          AX5    R1.RIL      RNUMS = SHIFT( RNUMS , -16 ) 
          ZR     X6,FRR4     IF R = 0 
          SA3    "TB"+X6     L = BASE + R 
          LX3    -I.REGP     REGNO = REG[L] 
          SA2    RBV+X3 
          BX6    X2*X1
          NZ     X6,FRR4     IF RBV(REGNO) & CLASS " 0 */ REG IN CLASS
          SA2    RVT+X3 
          MI     X2,FRR4     IF LOCK[ RVT(REGNO) ]
          LX7    18 
          SX3    X3 
          BX6    X4+X2
          IX7    X3+X7       I = SHIFT( I , 18) ! REGNO 
          SA6    A2          LOCK[ RVT(REGNO) ] = 1 
 FRR4     NZ     X5,FRR3     IF RNUMS " 0 
  
          SA7    FRRA        FRRA = I 
          SB3    B0 
          SB6    B0          ABR = 0
          RJ     CRC         REGF = CRC(RVT,MCOST)
  
*         UNLOCK THE LOCKED OPERAND REGISTERS 
  
          SA1    FRRA        I = FRRA 
          MX4    1
          LX4    1+RV.LOCKP 
  
 FRR5     SA2    RVT+X1 
          BX6    -X4*X2      LOCK[RVT(I)] = 0 
          AX1    18          I = SHIFT( I , -18 ) 
          SA6    A2 
          NZ     X1,FRR5
          EQ     FRR
  
 FRRA     BSS    1
 CRC      TITLE  CRC - COMPUTE RESTORE COSTS
**        CRC - COMPUTE RESTORE COSTS OF RESTABLISHING A RESULT IN A REG
* 
*         ENTRY  (B3) = REGNO, IF 0 THEN CHECK ALL X-REGS, ELSE CHECK 
*                            ONLY "REGNO".
*                (B6) = ABR " 0 IF B-REGISTERS AVAIL FOR A MOVE TO THEM 
* 
*         EXIT   (B3) = REGNO OF REGISTER WHICH IS CHEIPEST TO FREE 
*                (B4) = RESTORATION COST
* 
*         PRESERVES - X0, B1, B7
* 
*         THE COST OF RESTORING A REGISTER ARE -
*         COST   INSTRUCTION PROPERITIES / RESTORE ACTION 
* 
*         -1     RF[DI] " 0 / MOVE RESULT TO AN AVAILABLE B-REGISTER
* 
*         0      ZP[DI] & ^LD[DI] / REISSUE INSTRUCTION 
* 
*         1      LD[DI] & ^(L2[DI] ! FP[DI]) & NO INTERFERING STORE ISSU
*                   IF ZP[DI] ! OPERANDS"S ARE IN B-REGS , THEN REISSUE 
* 
*         2      RESULT IN X6/X7 WITH NO SPECIAL PROPERTIES 
*                   STORE THE RESULT IN A TEMP CELL AND SETUP A *LD*
*                   OF IT ( OT.+CA ). 
  
 RF.SAV   EQU    0           TURN OFF *RF* LOGIC
  
 CRC0     SB6    RVT
          SB3    A0-B6       REGNO = IREG 
  
 CRC      ROUTINE 
          SA3    =22333333B 
          SA1    CRCA 
          SA2    RVT+RN.X0   I = RN.X0
          BX7    X3          RCOST = 22333333B
          SB4    4           MCOST = 4
          SB5    B0          MAXD = 0 
          ZR     B3,CRC4     IF REGNO = 0 
  
          SA2    RVT+B3      I = REGNO
          SB6    B0          ABR = 0
          SX6    B3-RN.X0-6 
          SX7    B1+B1
          PL     X6,CRC4     RCOST = IF( REGNO \ X6 ) THEN 2 ELSE 3 
          SX7    X7+B1
          EQ     CRC4 
  
*         SEARCH *RVT* TO FIND RESULT WHICH IS CHEIPEST TO RESTORE, 
*         AND IS THE FURTHEST DISTANCE TO ITS NEXT USE. 
  
 CRC1     MX4    -3 
          BX6    -X4*X7      COST = RCOST & 7 
          SB2    X6+
  
 CRC2     PX6    B2,X2       COST[RVT(I)] = COST
          SA6    A2 
          GT     B2,B4,CRC3  IF COST > MCOST
          LX2    -RV.NUP
          SB3    X2 
          ZR     B3,CRC3     IF NU[RVT(I)] = 0  */ RESULT NOT USED YET
          LT     B2,B4,CRC2A IF COST < MCOST
          LT     B3,B5,CRC3  IF NU[RVT(I)] < MAXD 
 CRC2A    SB4    B2          MCOST = COST 
          SA0    A2          IREG = I 
          SB5    B3          MAXD = NU[RVT(I)]
  
 CRC3     AX7    3           RCOST = SHIFT( RCOST , -3 )
          SA2    A2+B1       I = I + 1
          ZR     X7,CRC0     IF RCOST = 0 
  
 CRC4     MI     X2,CRC3     IF LOCK[RVT(I)]
          SB3    "TB"-B1
          S"DI"  X2+B3       DI = BASE-1 + RI[RVT(I)] 
          ZR     X2,CRC3     IF RVT(I) = 0
          BX6    X1*X4
          LX4    59-D.RFP 
          ZR     X6,CRC1     IF (LD[DI]&ZP[DI]&RF[DI]) = 0
          PL     X4,CRC5     IF ^RF[DI] 
          IFNE   RF.SAV,0 
  
          ZR     B6,CRC5     IF ABR = 0    */ NO B-REGS AVAIL 
          SB4    -B1         MCOST = -1 
          SA0    A2          IREG = I 
          EQ     CRC0 
          ENDIF 
  
 CRC5     LX4    D.RFP-D.LDP
          SB2    B0          COST = 0 
          PL     X4,CRC2     IF ^LD[DI]    */ MUST BE ZEROP 
  
*         INSTRUCTION IS A *LD*, SEE IF IT CAN BE REISSUED
*         IF IT HAS OPERANDS, SEE IF THEY ARE IN B-REGISTERS. 
  
          SA3    CRCB 
          BX6    X3*X4
          LX4    D.LDP-D.ZPP
          NZ     X6,CRC1     IF FP[DI] ! L2[DI] 
          MI     X4,CRC9     IF ZP[DI]     */ NO REG PRED 
          BX6    X4 
          LX6    1+D.ZPP+58-D.TYP 
          PL     X6,CRC6     IF TYPE[DI] = I
          SA3    "DI"-B1     R2 = DI - 1
          LX3    -IH.RFP
          EQ     CRC7 
  
 CRC6     SA3    "DI"-2      R1 = DI - 2
          LX3    -R1.RJP
  
 CRC7     BX6    "RN"X3      RN = RI[RWORD] 
          SA5    "TB"+X6     L = BASE + R 
          LX5    -I.REGP
          SX3    X5-8 
          PL     X3,CRC1     IF REG[L] > 7 */ PRED NOT IN A B-REG 
          SA5    LRN+X5 
          BX6    X6-X5
          NZ     X6,CRC1     IF LRN( REG[L] ) " RN
 CRC      SPACE  3,14 
*         CHECK ISSUED STORE CHAIN FOR AN INTERFERING STORE 
  
 CRC9     LX4    D.ZPP-D.EQVP 
          SB2    B1          COST = 1 
          PL     X4,CRC2     IF ^EQV[DI]
          SA3    ISC         J = ISC
          SA5    "DI"-1      R2 = DI - 1
  
*         IF NEXT USE IS AN EQUIV LINK TO A STORE, THEN CANNOT RELOAD 
  
          LX2    -RV.NUP
          SA4    B3+X2       DS = BASE-1 + NU[RVT(I)] 
          LX2    RV.NUP 
          LX4    59-D.STP 
          PL     X4,CRC10    IF ^ST[DS]    */ NEXT USE NOT IN A STORE 
          SA4    A4-B1       R2S = DS - 1 
          LX4    -IH.RFP
          BX6    X2-X4
          BX4    "RN"X6 
          NZ     X4,CRC1     IF RF[R2S] " RI[RVT(I)]  */ AN EQUIV LINK
  
 CRC10    SX6    X3 
          ZR     X6,CRC2     IF J = 0      */ END OF CHAIN
          SA3    "TB"+X3     L  = BASE + J;  J = [L]
          SA4    A3-2        R2J = L - 2
          BX6    X4-X5
          LX6    -IH.IHP
          SB3    X6 
          NZ     B3,CRC10    IF IH[R2] " IH[R2J]
          LX6    IH.IHP-IH.RFP
          SB3    X6 
          NZ     B3,CRC11    IF RF[R2] " RF[R2J]
          LX6    IH.RFP-IH.CAP
          SB3    X6 
          NZ     B3,CRC10    IF CA[R2] " CA[R2J]
  
 CRC11    SX4    A3-"TB"
          SX6    X2+
          IX6    X4-X6
          MI     X6,CRC10    IF J < RI[RVT(I)]  */ ST BEFORE LD 
  
*         ISSUE OF AN INTERFERING STORE COUNTS AS A USE, UPDATE *NU*
  
          LX2    -RV.NUP
          SX6    X2 
          IX5    X4-X6
          LX2    RV.NUP 
          MI     X5,CRC1     IF NU[RVT(I)] > J
  
          SA5    "TB"+X2     LI = BASE + RI[RVT(I)] 
          SA4    O.TREE 
          MX3    -I.INDXL 
          LX5    -I.INDXP 
          SB3    X4-1 
          BX3    -X3*X5 
          SA4    B3+X3       UI = TREE-1 + INDX[LI] 
  
 CRC12    SA4    A4+B1       UI = UI + 1
          LX4    -U.SUCCP 
          SA5    "TB"+X4     SI = BASE + SUCC[UI] 
          LX5    59-I.IIP 
          MI     X5,CRC12    IF II[SI]
  
          LX2    -RV.NUP
          SX4    X4 
          BX2    X2-X6
          BX6    X2+X4       NU[RVT(I)] = SUCC[UI]
          LX6    RV.NUP 
          BX2    X6 
          SA6    A2 
          EQ     CRC1 
  
          IFEQ   RF.SAV,0,2 
 CRCA     BFMW   D,(LD,ZP)
          ELSE   1
 CRCA     BFMW   D,(LD,ZP,RF) 
 CRCB     BFMW   D,(L2,FP),59-D.LDP 
 CRA      TITLE  CRA - CHANGE REGISTER ASSIGNMENT 
**        CRA - CHANGE REGISTER ASSIGNMENT
* 
*         THOSE WISHING TO EXPRESS THEIR APPREATION FOR THE EXISTANCE OF
*         THIS ROUTINE AND OTHERS WHICH GENERATE *XMT"S* , ETC MAY
*         THANK SEYMOUR CRAY. 
* 
*         ENTRY  AVAIL " 0 , AVAIL & CLASS = 0
*                (X1) = CLASS 
*                (T0) = TXT INDEX OF INSTRUCTION THAT CANNOT BE ISSUED
  
 CRA      ROUTINE 
          SX7    X1-FX.ST 
          NZ     X7,CRA4     IF CLASS " FX.ST 
  
*         STORE REGISTERS JAMMED, FREE ONE OF THEM UP 
  
          SA1    AXR
          SX5    FX.SCR+FX.XT 
          BX7    X1*X5       AVAIL = AXR & FX.SCR 
          NX6    B3,X7
          SA3    B3+FXRA+16-47
          SB6    "TB"-B1
          SB3    X3          REGR = FXRA( NORMC(AVAIL) )
          SB4    RN.X0+6     REGF = X6
          SA1    RVT+B4      RX6 = RI[RVT(RN.X6)] 
          SA2    A1+B1       RX7 = RI[RVT(RN.X7)] 
          SA3    B6+X1       DX6 = BASE-1 + RX6 
          SA4    B6+X2       DX7 = BASE-1 + RX7 
          MX7    -D.STRSL 
          LX7    D.STRSP
          BX5    -X7*X3 
          BX6    -X7*X4 
          ZR     X5,CRA1     IF STRS[DX6] = 0 
          NZ     X6,CRA2     IF STRS[DX7] " 0 
          SB4    B4+1        REGF = X7
  
 CRA1     SB2    OC.XMT 
          RJ     OXI         OUTPUT XMT REGF TO REGR
          SA2    T0 
          RJ     ISI         ISSUE T0 
          EQ     CRA
  
*         BOTH RESULTS IN X6 & X7 PS!PRS, THIS IS A PATHALOGICAL CASE.
*         U = A; V = B; IF(W) GO TO LAB; X(I) = C; X(J) = A; X(K) = B;
  
 CRA2     LX1    -RV.NUP
          LX2    -RV.NUP
          SB2    X1          DX6 = NU[RVT(RN.X6)] 
          SB5    X2          DX7 = NU[RVT(RN.X7)] 
          GE     B2,B5,CRA3  REGF = IF( DX6 \ DX7 ) THEN RN.X6 ELSE X7
          SB4    B4+B1
          BX1    X2 
  
 CRA3     LX1    RV.NUP 
          SB2    OC.XMT 
          BX6    "RN"X1      R0 = RI[RVT(REGF)] 
          PX7    B3,X6
          SA7    R0 
          RJ     OXI         OUTPUT XMT REGF TO REGR
          SA2    T0 
          RJ     ISI         ISSUE *T0* 
          SX6    B0 
          RJ     SXB         SETUP *XMT* BACK 
          EQ     CRA
  
*         *LD* REGISTER NEEDED. 
  
 CRA4     SX7    X1-FX.LD 
          NZ     X7,CRA10    IF CLASS " FX.LD 
          SB3    B0 
          SB6    B0          ABR = 0
          RJ     CRC         COMPUTE RESTORE COSTS
          SA1    AXR
          SX2    FX.ST
          BX3    X2*X1
          ZR     X3,CRA9     IF AXR & FX.ST = 0  */ NO STORE REG AVAIL
  
*         STORE REG AVAIL, MOVE RESULT THAT HAS HIGHEST RESTORE COST
*         AND IS FURTHEST DISTANCE TO A NEXT USE TO IT, ON THE ASSUMPTION 
*         THAT IT MAY BE SAVED LATER. 
  
          SB4    -B1         MAXC = -1
          SB5    -B1         MAXD = -1
          SB2    RN.X0+1     I = X1 
          SA0    B2          REGF = X1     */ INCASE ALL LD-REGS LOCKED 
  
 CRA5     SA1    RVT+B2 
          MI     X1,CRA7     IF LOCK[RVT(I)]
          SB6    "TB"-B1
          SA4    B6+X1       DI = TB-1 + RI[RVT(I)] 
          LX4    59-D.PRSP
          MI     X4,CRA7     IF PRS[DI] 
          UX6    B3,X1
          LX1    -RV.NUP
          GT     B3,B4,CRA6  IF COST[RVT(I)] > MAXC 
          LT     B3,B4,CRA7  IF COST[RVT(I)] < MAXC 
          SB6    X1+
          LT     B6,B5,CRA7  IF NU[RVT(I)] < MAXD 
 CRA6     SA0    B2          REGF = I 
          SB4    B3          MAXC = COST[RVT(I)]
          SB5    B6          MAXD = NU[RVT(I)]
 CRA7     SB2    B2+1        I = I + 1
          SX6    B2-RN.X0-6 
          MI     X6,CRA5     IF I < RN.X6 
          SB3    RN.X0+6
          SA1    RVT+B3 
          SB4    A0 
          SB6    "TB"-B1
          ZR     X1,CRA8     REGR = IF( RVT(X6) = 0 ) THEN X6 ELSE X7 
          SB3    B3+B1
  
 CRA8     SA1    RVT+B4 
          S"DI"  B6+X1       DI = BASE-1 + RI[RVT(REGF)]
          LX4    59-D.PRSP
          PL     X4,CRA1     IF ^PRS[DI]
          LX1    -RV.NUP
          SA2    RBV+B4 
          SA3    LXR
          BX6    -X2*X3      LXR = LXR & ^RBV(REGF)  */ CLEAR LOCK BIT
          SA6    A3 
          EQ     CRA3 
 CRA      SPACE  2,10 
*         LD REG NEEDED AND NO ST REG AVAILABLE, SEARCH FOR ^PRS LD-REG.
  
 CRA9     SB3    RN.X0       REGR = RN.X0  */ RESULT REG
          SB6    "TB"-B1
          SB4    B3+B1       REGF = RN.X1  */ OPERAND 
  
 CRA9A    SA1    RVT+B4 
          S"DI"  B6+X1       DI = TB-1 + RN[RVT(REGF)]
          LX4    59-D.PRSP
          PL     X4,CRA1     IF ^PRS[DI]
          SB4    B4+B1       REGF = REGF + 1
          SX6    B4-RN.X0-5 
          MI     X6,CRA9A    IF REGF < RN.X5
  
          EQ     CRA8 
  
*         INSTRUCTION PRS AND CANNOT BE ISSUED
  
 CRA10    SA1    T0 
          SB6    "TB"+B1
          SA2    X1+B6       R1RS = BASE + T0+4 
          MX5    -SO.REGL 
          LX2    -R1.SOP
          BX6    -X5*X2 
          SB4    X6          REGF = SOREG[R1RS] 
          SX7    X6-8 
          MI     X7,CRA11    IF REGF @ 7   */ A B-REGISTER
          SA1    AXR
          SX5    FX.SCR+FX.XT 
          BX7    X1*X5       AVAIL = AXR & FX.SCR 
          NX6    B3,X7
          SA3    B3+FXRA+16-47
          SB3    X3          REGR = FXRA( NORMC(AVAIL) )
          EQ     CRA1 
  
*         INSTRUCTION PRS TO A B-REGISTER AND IT CANNOT BE ISSUED, SEE
*         IF THE USES OF THE R-NUMBER IN THE B-REGISTER ARE SUCH THAT 
*         WE CAN MOVE IT TO AN X-REGISTER.
  
 CRA11    SA1    RVT+B4 
          SA2    JLR
          SB3    B4+12
          LX2    B3 
          MI     X2,CRA15    IF SHIFT(JLR,REG+12) < 0 */ JUP LOCK 
          SA2    "TB"+X1     LI = TB + RN[RVT(REGF)]
          MX7    -I.INDXL 
          SA3    O.TREE 
          LX2    -I.INDXP 
          BX6    -X7*X2 
          SB3    X3 
          SA3    B3+X6       UI = TREE + INDX[LI] 
          EQ     CRA13
  
 CRA12    LX3    59-U.LASTP+U.SUCCP 
          MI     X3,CRA21    IF LAST[UI]
          SA3    A3+1        UI = UI + 1
  
 CRA13    LX3    -U.SUCCP 
          SA5    "TB"+X3     LIS = TB + SUCC[UI]
          LX5    59-I.IIP 
          MI     X5,CRA12    IF II[LIS]    */ ISSUED
          SA5    A5-B1       DIS = LIS - 1
          SA2    A5-2 
          LX6    B1,X5
          ERRNZ  59-D.TYP-1 
          MI     X6,CRA12    IF TYPE[DIS] = II ! IV 
          LX5    58-D.TYP 
          PL     X5,CRA14    IF TYPE[DIS] = I 
          LX5    1+D.TYP-D.JPP
          PL     X5,CRA12    IF ^JP[DIS]   */ ^ B USE 
          EQ     CRA15
  
*         TYPE I INST, B-RESULT IS USED IN RJ OF ILS, IRS AND PK, AND 
*         RJ, RK OF SA, SS, SLD, SST, SDL, SDS. SUFFICIENT TO CHECK 
*         FOR RK[R1] = 0 TO IMPLY X-USE POSSIBLE
  
 CRA14    SA5    A5-2        R1S = DIS - 2
          UX7    B3,X5
          LX5    -R1.RKP
          BX6    "RN"X5 
          ZR     X6,CRA12    IF RK[R1S] = 0  */ CAN MOVE TO AN X-REGISTE
          SB5    OC.SLD 
          LT     B3,B5,CRA15 IF OC[R1] < OC.SLD 
          SB5    OC.SA
          GT     B3,B5,CRA15 IF OC[R1] > OC.SA  */ NOT SLD, SST OR SA 
  
*         IF BOTH OPERANDS IN A B-REGISTER, THEN ONE CAN BE MOVED 
  
          SX1    X1          R = RN[RVT(REGF)]  */ RI IN B-REG
          BX7    X1-X6       ORN = RK[R1] 
          NZ     X7,CRA14A   IF R " ORN 
          LX5    R1.RKP-R1.RJP
          BX6    "RN"X5      ORN = RJ[R1] 
 CRA14A   SB5    "TB"-3 
          SA5    B5+X6       R1P = TXT(ORN) 
          UX7    B3,X5
          SB5    OC.DEF 
          NE     B3,B5,CRA15 IF OC[R1P] " OC.DEF
          LX5    -R1.SOP-SO.RTP 
          MX7    -SO.RTL
          BX6    -X7*X5 
          ZR     X6,CRA21    IF RT[R1P] = 0  */ A B-REGISTER
  
*         INSTRUCTION HAS B USES THAT CANNOT BE CHANGED TO X USES.
  
 CRA15    EQ     UJR.E1 
  
*         ALL FUTURE USES OF INSTRUCTION CAN BE X-USES, MOVE INSTRUCTION
*         TO AN X-REGISTER. 
  
 CRA21    SA1    AXR
          SA2    T
          SX5    FX.SCR+FX.XT 
          BX7    X1*X5       AVAIL = AXR & FX.SCR 
          NX6    B3,X7
          SB5    X2 
          SA3    B3+FXRA+16-47
          SA2    TRA+X3 
          SB2    X2 
          SB3    X3          REGR = FXR( SCR )
          LE     B2,B5,CRA22 T(IS) = MAX( T , T(IS) ) 
          SB5    B2 
 CRA22    SB2    OC.SA
          RJ     OXI         OUTPUT A *SA*
          SA2    T0 
          RJ     ISI         ISSUE T0 
          EQ     CRA
 SXB      EJECT 
**        SXB - SETUP XMT BACK ( INSTRUCTION PS/PRS ) 
* 
*         ENTRY  (R0) = *TXT* INDEX OF INSTRUCTION
*                (X6) = CALLF = 0 IF CALL FROM *CRA*
  
 SXB      ROUTINE 
          SA2    R0 
          SB6    "TB"-B1
          SA4    B6+X2       DI = BASE-1 + R0 
          LX4    59-D.PSP 
          MI     X4,SXBS     IF PS[DI]
  
          SA5    L.TXT       LT = L.TXT 
          ALLOC  TXT,4
          SA4    R0 
          UX6    B3,X4
          BX7    X5 
          SA7    RVT+B3      RVT(REGR) = LT 
          BX4    "RN"X4 
          IX3    X2+X5
          IX2    X2+X4
          MOVE   X1,X2,X3    MOVE( 4 , O.TXT+R0 , O.TXT+LT )
          RJ     AIP         ADJUST POINTERS
  
*         SETUP AN *XMT* WHERE THE ORIGINAL INSTRUCTION WAS 
  
          SA1    R0 
          SB2    OC.XMT 
          SB6    "TB"-B1
          SA2    F.RDT+B2 
          MX6    -D.STRSL 
          S"DI"  B6+X1       D0 = BASE-1 + R0 
          LX6    D.STRSP
          MX7    0
          SA7    "DI"-B1     [DI-1] = 0 
          BX4    -X6*X4 
          LX5    R1.RJP 
          BX5    X5+X1
          PX6    B2,X5
          SA6    A7-B1       [DI-2] = TYI(OC.XMT,LT,0,R0) 
          BX7    X4+X2
          SA7    A4          [DI] = RDT(OC.XMT) ! STRS[DI]
          SA5    A4+B1
          MX3    1
          LX3    1+I.IIP
          BX6    -X3*X5      II[DI+1] = 0  */ CLEAR IN CASE STORED OUT
          SA6    A5 
          RJ     RIL         RESET THE ISSUE LIST 
          SA3    SIW
          NZ     X3,SXB0     IF SIW " 0 
          ALLOC  TREE,1 
          SX3    X3-1        SIW = L.TREE - 1 
          RJ     AIP         ADJUST *PIT* POINTERS
  
 SXB0     SA1    L.TXT
          SA2    SXBA 
          SA4    O.TREE 
          SB4    X1-4 
          SA5    "TB"+B4     L = BASE + L.TXT-4 
          SB2    X3 
          BX6    -X2*X5 
          LX3    I.INDXP
          SX7    B1 
          BX6    X6+X3       INDX[L] = SIW
          LX7    I.USESP
          IX6    X6+X7       USES[L] = 1
          SA2    R0 
          MX5    -I.LSTL
          SA3    "TB"+X2     LI = BASE + R0 
          LX5    I.LSTP 
          BX3    -X5*X3      LST = LST[LI] */ LST OF *XMT* BACK 
          BX6    X3+X6       LST[L] = LST 
          SA6    A5 
          MX1    -D.STRSL 
          SA5    A5-B1       DI = L - 1 
          LX1    D.STRSP
          BX6    X1*X5       STRS[DI] = 0  */ CLEAR *STRS* OF MOVED INST
          SA6    A5 
  
          LX7    U.LASTP-I.USESP
          LX3    U.LSTP-I.LSTP
          SX2    X2 
          BX3    X3+X2
          BX7    X7+X3
          SA7    X4+B2       TREE(SIW) = SIT(1,0,LST,R0)
          EQ     SXB
  
*         INSTRUCTION *PS*, NOT ALL USES MAY BE STORES, SETUP *XMT LT,R0
*         AT END OF *TXT*, CHANGE *RI"S* IN THE ST"S, ^ST USES WILL WORK
*         OFF ORIGINAL *RI* ( R0 ). 
  
 SXBS     SA6    SXBB 
          SA2    R0 
          SA1    L.TXT
          SA4    O.TREE 
          SA5    "TB"+X2     LI = BASE + R0 
          MX7    -I.INDXL 
          SB3    B0          UST = 0       */ N.ST USES 
          SB4    X4 
          SB5    B0          FSU = 0       */ FIRST ST USE
          LX5    -I.INDXP 
          BX6    -X7*X5 
          SA3    B4+X6       UI = TREE + INDX[LI] 
          BX5    "RN"X2                    (X5) = R0
          EQ     SXB2 
  
*         SCAN *SIT*, COUNT USES OF *R0* AS A ST-PRED, CHANGE THEM TO 
*         USE AN *XMT* AT THE END OF *TXT* AS THEIR *RI*. 
  
 SXB1     LX3    59-U.LASTP 
          MI     X3,SXB3     IF LAST[UI]
          SA3    A3+1        UI = UI + 1
  
 SXB2     LX3    -U.SUCCP 
          SA2    "TB"+X3     LIS = BASE + SUCC[UI]
          LX3    U.SUCCP
          LX2    59-I.IIP 
          MI     X2,SXB1     IF II[LIS] 
          SA4    A2-B1       DIS = LIS - 1
          LX4    59-D.STP 
          PL     X4,SXB1     IF ^ST[DIS]
          LX4    D.STP-D.L2P
          MI     X4,SXB1     IF L2[DIS] 
          SA4    A4-2        R1S = DIS - 2
          BX6    "RN"X4 
          BX7    X5-X6
          NZ     X7,SXB1     IF RI[R1S] " R0  */ NOT RI USE 
  
          BX6    X0*X4
          BX7    X6+X1       RI[R1S] = L.TXT  */ CHANGE *RI*
          SA7    A4 
          LX3    -U.PREDP 
          BX2    X0*X3
          LX3    U.PREDP
          BX6    X2+X1       PRED[UI] = L.TXT 
          LX6    U.PREDP
          SB3    B3+B1       UST = UST + 1
          SA6    A3 
          NZ     B5,SXB1     IF FSU " 0 
          SB5    A2-"TB"     FSU = SUCC[UI] 
          EQ     SXB1 
  
*         UPDATE LINK WORD OF *R0*, FORM *XMT LT,R0* AT END OF *TXT*. 
  
 SXB3     SX5    B5 
          PX5    B3,X5
          ALLOC  TXT,4       ALLOC( TXT , 4 ) 
          UX6    B3,X5
          ALLOC  TREE,B3     ALLOC( TREE , UST );  LTR = OLD(L.TREE)
          RJ     AIP         ADJUST POINTERS
          SA1    R0 
          SA3    "TB"+X1     LI = BASE + R0 
          UX5    B2,X5
          SB5    X2                        (B5) = O.TREE
          SX6    B2-B1
          LX6    I.USESP
          SA4    A3-B1
          IX6    X3-X6       USES[LI] = USES[LI] + 1 - UST
          SA6    A3 
          SX7    B1 
          LX7    D.PSP
          BX7    -X7*X4      PS[LI-1] = 0 
          SA7    A4 
  
          SA2    L.TXT
          SX2    X2-4        LT = L.TXT - 4 
          SX7    B2 
          LX7    I.USESP
          SX6    B6 
          LX6    I.INDXP
          BX7    X6+X7
          LX5    I.LSTP-1 
          BX7    X5+X7
          SX6    B1 
          BX7    X6+X7       LIT = BASE + LT
          SA7    "TB"+X2     [LIT] = LW(0,UST,LTR,FSU/2,1)
          SA4    F.RDT+OC.XMT 
          LX6    D.PSP
          BX7    X4+X6
          SA7    A7-B1       DIT = LIT - 1;  [DIT] = RDT(OC.XMT) ! PS 
          MX6    0
          SA6    A7-B1       R2T = DIT - 1;  [R2T] = 0
          SB3    OC.XMT 
          SX1    X1 
          LX1    R1.RJP 
          BX7    X1+X2
          PX6    B3,X7
          SA6    A6-B1       R1T = R2T - 1;  [R1T] = TYI(OC.XMT,R0,0,LT)
  
*         RESCAN *SIT* FOR *R0* AND SUBDIVIDE IT INTO 2 LISTS.
  
          LX3    -I.INDXP 
          MX7    -I.INDXL 
          BX6    -X7*X3 
          SA3    B5+X6       UI = TREE + INDX[LI] 
          SB3    A3          UO = UI
          SB2    B5+B6       UX = TREE + LTR
          SB4    B0          XI = 0        */ XMT LINK INSERTED 
          LX5    U.LSTP-I.LSTP
          LX1    -R1.RJP
          SB5    60-U.PREDP 
          EQ     SXB6 
                                                                         A
 SXB4     BX6    X3 
          SA6    B3          [UO] = [UI]
          SB3    B3+1        UO = UO + 1
  
 SXB5     LX3    59-U.LASTP 
          MI     X3,SXB7     IF LAST[UI]
          SA3    A3+1        UI = UI + 1
  
 SXB6     LX3    -U.SUCCP 
          SA4    "TB"+X3     LIS = TB + SUCC[UI]
          LX3    U.SUCCP
          LX4    59-I.IIP 
          MI     X4,SXB5     IF II[LI]
          LX7    B5,X3
          BX6    X7-X1
          BX7    "RN"X6 
          ZR     X7,SXB4     IF PRED[UI] = R0 
  
*         ADD EDGE TO *XMT* LIST
  
          BX6    X3 
          SA6    B2          [UX] = [UI]
          SB2    B2+B1       UX = UX + 1
          NZ     B4,SXB5     IF XI " 0     */ ^ FIRST *ST*
          SB4    B1          XI = 1 
          BX6    X5+X2
          LX1    U.PREDP
          BX6    X1+X6
          LX1    -U.PREDP 
          SA6    B3          [UO] = SIT(0,R0,FST,LT)
          SB3    B3+B1       UO = UO + 1
          EQ     SXB5 
  
 SXB7     SA1    B2-B1
          SA3    B3-B1
          SA4    SXBB 
          MX5    1
          LX5    1+U.LASTP
          BX6    X1+X5       LAST[UX-1] = 1  */ TERMINATE LISTS 
          SA6    A1 
          BX7    X3+X5       LAST[UO-1] = 1 
          SA7    A3 
          NZ     X4,SXB      IF CALLF " 0  */ NOT CALL FROM *CRA* 
          SX1    X2 
          SA2    "TB"+X1
          SX3    B1 
          LX3    I.ICP
          BX6    X3+X2       IC[BASE+LT] = 1
          SA6    A2 
          RJ     RIL         PUT GENERATED XMT ON *ICL* 
          EQ     SXB
  
 SXBA     BFMW   I,(USES,INDX,LST)
 SXBB     BSS    1
 OXI      TITLE  OXI - OUTPUT TRANSMIT INSTRUCTION
**        OXI - OUTPUT XMIT INSTRUCTION ( *XMT* OR *SA* ) 
* 
*         ENTRY  (B3) = REGR ( RESULT REGISTER )
*                (B4) = REGF ( FROM ) 
*                (B2) = OC , INSTRUCTION OPCODE 
* 
*         EXIT   INSTRUCTION ISSUED, AXR AND RVT UPDATED
  
 OXI      ROUTINE 
          SA1    RVT+B4 
          MX7    0
          BX6    X1          RVT(REGR) = RVT(REGF)
          SA6    RVT+B3 
          SA2    AXR
          SA3    RBV+B4 
          SA4    RBV+B3 
          SA7    A1          RVT(REGF) = 0
          BX5    -X4*X2 
          BX7    X5+X3       AXR = AXR & ^RBV(REGR) ! RBV(REGF) 
          SA7    A2 
          SA1    T
          SA2    TRA+B3 
+         IX3    X1-X2
          PL     X3,*+1 
          BX1    X2 
          SX7    X1          T = MAX( T , TRA(REGR) ) 
          SA7    A1 
  
          SA2    F.RDT+B2 
          BX5    "RN"X6      R = RI[RVT(REGR)]
          LX5    R1.RJP 
          PX7    B2,X5
          MX6    0
          SA7    DRI         [DRI] = TYI(OC,R,0,0)
          SA6    A7+B1       [DRI+1] = 0
          BX7    X2 
          SA7    A6+B1       [DRI+2] = RDT(OC)
          SA4    A7 
          RJ     OEI         OUTPUT THE INSTRUCTION 
  
*         ADJUST THE *REG* FIELD OF THE OPERAND 
  
          SA1    RVT+B3 
          MX7    -I.REGL
          SA2    "TB"+X1     L = BASE + RI[RVT(REGR)] 
          SX4    B3 
          BX3    X7*X2       REG[L] = REGR
          IX6    X3+X4
          SA6    A2 
          EQ     OXI
 RIL      TITLE  RIL - RESET ISSUE LIST 
**        RIL - RESET ISSUE LIST TO REMOVE ISSUED INSTRUCTION FROM
*                REGISTERS AND PLACE IT BACK ON THE ISSUE LIST. 
* 
*         ENTRY  (X1) = R , *TXT* INDEX OF THE INSTRUCTION
* 
*         EXIT   (B4) = LST[R] , NEW *LST* OF THE INSTRUCTION 
*                (B3) = R , *TXT* INDEX OF THE INSTRUCTION
*                (A0) = PI , *TXT* INDEX OF PREVIOUS INSTRUCTION ON *ICL* 
*                (SIW) = *SIT* INDEX OF AN AVAIL WORD, 0 IF NONE. 
* 
*         PRESERVES - X0, B7
  
 RIL      ROUTINE 
          SA5    "TB"+X1     LI = BASE + R
          SA2    O.TREE 
          MX7    -I.INDXL 
          SB3    X1 
          SB2    X2 
          LX5    -I.INDXP 
          BX4    -X7*X5 
          SA3    B2+X4       UI = O.TREE + INDX[LI] 
          LX5    I.INDXP-I.LSTP 
          SB4    A3          US = UI
          MX4    -1 
          SB5    A3          UF = UI
          BX5    X7*X5
          SX1    B1 
          SB6    B0          N = 0
          LX1    I.ICP
          EQ     RIL3 
  
*         REMOVE ISSUED SUCCESSORS OF R FROM *SIT*, ADJUST PRED COUNTS
*         OF UNISSUED SUCC. 
  
 RIL1     IX7    X2-X4       NPRED[SI] = NPRED[SI] + 1
          SA7    A2 
  
 RIL2     LX3    59-U.LASTP 
          MI     X3,RIL4     IF LAST[UI]
          SA3    A3+1        UI = UI + 1
  
 RIL3     LX3    -U.SUCCP 
          SA2    "TB"+X3     SI = BASE + SUCC[UI] 
          BX7    X1*X2
          LX3    U.SUCCP
          LX2    59-I.IIP 
          MI     X2,RIL2     IF II[SI]     */ IF ISSUED 
          LX6    B1,X3
          ERRNZ  58-U.RDLP
          MI     X6,RIL2     IF RDL[UI]    */ REMOVE REDEFINITION LINKS 
          BX6    X3 
          SA6    B4          [US] = [UI]
          SB4    B4+1        US = US + 1
          ZR     X7,RIL1     IF ^IC[SI] 
          BX6    -X1*X2      IC[SI] = 0 
          SB6    B6+B1       N = N + 1     */ COUNT NUM OF CHANGED IC"S 
          SA6    A2 
          EQ     RIL2 
 RIL      SPACE  1,10 
*         FINISH RESET OF *SIT* 
  
 RIL4     SA2    B5 
          SB5    A3+B1       UL = UI + 1
          SA3    B4-B1
          MX4    1
          LX4    1+U.LASTP
          BX6    X4+X3       LAST[US-1] = 1 
          SA6    A3 
          LX2    -U.LSTP
          SX1    X2          RN = LST[UF] 
          BX7    X5+X1       LST[LI] = RN  */ NEW LATE START TIME 
          LX7    I.LSTP 
          SA7    A5 
  
+         SX6    B4-B2
          LT     B4,B5,*+1   SIW = IF( US < UL ) THEN US-O.TREE; ELSE 0 
          MX6    0
          SA6    SIW
          SB4    X1+
          ZR     B6,RIL8     IF N = 0 
  
*         REMOVE INSTRUCTIONS THAT ARE NO LONGER *IC"S* FROM *ICL*
  
          SA3    ICL         CI = ICL 
          MX1    -I.LINKL 
          S"PI"  B0          PI = 0 
          LX4    I.ICP-U.LASTP
          EQ     RIL6 
  
 RIL5     S"PI"  X3          PI = CI
          SX3    X5          CI = LINK[L] 
          ZR     X3,RIL7     IF CI = 0
  
 RIL6     SA5    "TB"+X3     L = BASE + CI
          BX2    X4*X5
          NZ     X2,RIL5     IF IC[L] 
  
          SA2    "TB"+"PI"
          BX3    -X1*X5      CI = LINK[L] 
          SB6    B6-B1       N = N - 1
          BX6    X1*X2
          IX7    X6+X3       LINK[BASE+PI] = CI 
          MX6    -1 
          SA7    A2 
          BX5    X1*X5       LINK[L] = 0
          IX6    X5-X6       NPRED[L] = 1 
          SA6    A5 
          NZ     B6,RIL6     IF N " 0      */ NOT END OF DELETES
  
          NZ     X3,RIL7     IF CI " 0
          SX3    "PI" 
          NZ     X3,RIL7     IF PI " 0     */ ICL NOT EMPTY 
          SA5    "TB"+B3     L = BASE + R 
          MX1    -I.LINKL 
          BX6    X1*X5       LINK[L] = 0
          SX7    B3 
          SA6    A5 
          SA7    ICL         ICL = R
          EQ     RIL
  
 RIL7     SA2    "TB" 
          SX6    X2 
          ZR     X6,RIL8     IF LINK[BASE] = 0
          SA6    ICL         ICL = LINK[BASE] 
          BX7    X1*X2       LINK[BASE] = 0 
          SA7    A2 
  
*         ADD THE REMOVED INSTRUCTION BACK ONTO *ICL* 
  
 RIL8     SA3    ICL         CI = ICL 
          SX2    B4 
          S"PI"  B0          PI = 0 
          LX2    I.LSTP 
          MX1    -I.LSTL
          SA5    "TB"+X3     L = BASE + CI
          LX1    I.LSTP 
  
 RIL9     BX4    -X1*X5 
          IX6    X2-X4
          MI     X6,RIL10    IF LST[LI] > RN
          S"PI"  X3          PI = CI
          SX3    X5          CI = LINK[L] 
          SA5    "TB"+X5     L = BASE + CI
          NZ     X3,RIL9     IF CI " 0
  
 RIL10    SA5    "TB"+B3     L = BASE + R 
          MX1    -I.LINKL 
          SB6    "PI" 
          BX4    X1*X5
          ZR     B6,RIL11    IF PI = 0
          SA2    "TB"+"PI"
          IX6    X4+X3       LINK[L] = CI 
          SX3    B3 
          SA6    A5 
          BX1    X1*X2
          IX7    X1+X3       LINK[BASE+PI] = R
          SA7    A2 
          EQ     RIL
  
 RIL11    SA3    ICL
          IX6    X4+X3       LINK[L] = ICL
          SA6    A5 
          SX7    B3          ICL = R
          SA7    A3 
          EQ     RIL
 SMB      TITLE  SMB - SET MULTIPLE USE COMPUTATION BIT 
**        SMB - SET *MUC* BIT FOR MULTIPLE USE COMPUTATIONS WHOSE 
*         USES ARE SPREAD APART SO THAT *DRR* WILL TRY TO PUT THEM IN 
*         STORE REGISTERS AND AVOID HAVING TO OUTPUT *XMT"S* WHEN THEY
*         ARE SAVED IN MEMORY LATER.
  
 SMB0     MX0    -R1.RIL+1
          LX0    1
  
 SMB      ROUTINE 
          SA2    L.TXT
          SA5    O.TREE 
          MX0    -D.USESL 
          LX0    D.USESP
          SB4    4
          MX1    -I.INDXL 
          SB2    X2-4        I = L.TXT - 4
          SB3    X5 
          SX7    B1 
          SA3    SMBA 
          LX7    D.MUCP 
          S"DI"  "TB"-B1     DI = BASE - 1
          EQ     SMB2 
  
 SMB1     BX6    X7+X4       MUC[DI] = 1
          SA6    A4+
  
 SMB2     SB2    B2-B4       I = I - 4
          S"DI"  "DI"+B4     DI = DI + 4
          ZR     B2,SMB0     IF I = 0 
          BX2    -X0*X4 
          AX2    D.USESP+1
          ZR     X2,SMB2     IF USES[DI] < 2
  
          BX6    X3*X4
 #DAL     IFEQ   .DAL,0 
          NZ     X6,SMB2     IF BITS[DI] " 0
 #DAL     ELSE
          ZR     X6,SMB3     IF BITS[DI] = 0
          LX6    D.L2P-D.LDP
          BX2    X4*X6
          LX2    59-D.L2P 
          PL     X2,SMB2     IF ^( L2[DI]&LD[DI] )
 SMB3     BSS    0
 #DAL     ENDIF 
  
*         CHECK DISTANCE BETWEEN USES 
  
          SA2    "DI"+B1     LI = DI + 1
          LX2    -I.INDXP 
          BX6    -X1*X2 
          SA5    B3+X6       UI = O.TREE + INDX[LI] 
          LX5    -U.SUCCP 
          SB5    X5+MIN.D    SL = SUCC[UI] + MIN.D
          LX5    U.SUCCP+59-U.LASTP 
          MI     X5,SMB2     IF LAST[UI]   */ 2 USES IN 1 INSTRUCTION 
  
 SMB4     SA5    A5+B1       UI = UI + 1
          LX5    -U.SUCCP 
          SB6    X5          SI = SUCC[UI]
          GT     B6,B5,SMB1  IF SI > SL    */ DIST BETWEEN USES IS BIG
          LX5    U.SUCCP+59-U.LASTP 
          SB5    B6+MIN.D    SL = SI + MIN.D
          PL     X5,SMB4     IF ^LAST[UI] 
          EQ     SMB2 
  
 SMBA     BFMW   D,(RJRS,PS,PRS,ECJ,LD,ST,JP,XMT,KS,PI,ZP)
 SNU      TITLE  SNU - SET NEXT USE DISTANCE
**        SNU - SET NEXT USE OF OPERANDS OF INSTRUCTION IN *RVT*
*         NOTE - *SNU* MAY ONLY BE CALLED AFTER A CALL TO *DUC*.
* 
*         ENTRY  (A4,X4) = DI , [DI]
* 
*         EXIT   *NU* FIELD UPDATED IN *RVT* OF OPERANDS OF INSTRUCTION 
*                STORES ADDED TO ISSUED STORE CHAIN ( *ISC* ) 
*                (X7) = UOR = LIST OF UNCLEARED OPERAND REGISTERS 
* 
*         USES   B - 2, 6 , X - 1, 2, 3, 4, 5, 6, 7 
  
 SNU0     MX7    0           UOR = 0
          MI     X4,SNU      IF TYPE[DI] = IV 
          LX4    1+D.TYP-D.PIP
          PL     X4,SNU6     IF ^PI[DI]    */ NOT A PSEUDO INSTRUCTION
          SA3    "DI"-2      R1 = DI - 2
          BX5    "RN"X3      R = RNUMS = RI[R1] 
          UX6    B2,X3
          SX7    B2-OC.DEF
          NZ     X7,SNU2     IF OC[R1] " OC.DEF 
  
*         SEARCH *UIT* AND REMOVE LOGICAL LINKS FROM THE SUCCESSOR LIST 
  
          SA2    "DI"+B1     LI = DI + 1
          LX4    1+D.PIP
          SA3    O.TREE 
          MX7    -I.INDXL 
          LX2    -I.INDXP 
          SB6    X3 
          BX6    -X7*X2 
          SA2    B6+X6       UI = O.TREE + INDX[LI] 
          SA3    A2-B1
          SB2    A2          FLAG = UI     */ 0 IF SOMETHING STORED 
          SB6    "TB"-B1     DB = BASE - 1
          BX6    X3 
          SA6    A3          US = UI - 1;  [US] = [UI-1]
  
 RLL1     LX2    -U.SUCCP 
          SA3    B6+X2       DJ = DB + SUCC[UI] 
          LX2    U.SUCCP
          LX3    58-D.TYP 
          LX6    B1,X3
          MI     X6,RLL4     IF TYPE[DJ] = II ! IV
          SA1    A3-2        R1J = DJ - 2 
          BX6    X5-X1
          BX7    "RN"X6 
          NZ     X7,RLL1A    IF RI[R1J] " R 
  
*         DEF USED IN *RI* OF ANOTHER INSTRUCTION, RESET *PS* IF A STORE
  
          LX3    1+D.TYP-D.STP
          PL     X3,RLL3     IF ^ST[DJ] 
 #DAL     IFNE   .DAL,0 
          LX3    D.STP-D.L2P
          MI     X3,RLL3     IF L2[DJ]
 #DAL     ENDIF 
          SX3    B1 
          LX3    D.PSP
          BX7    X3+X4       PS[DI] = 1    */ INDICATE THAT *DEF* IS *PS
          SA7    A4 
          EQ     RLL3 
  
 RLL1A    MI     X3,RLL2     IF TYPE[DJ] = III
          LX1    -R1.RJP
          BX6    X5-X1
          LX1    R1.RJP-R1.RKP
          BX7    "RN"X6 
          ZR     X7,RLL3     IF RJ[R1J] = R 
          BX6    X5-X1
          BX7    "RN"X6 
          ZR     X7,RLL3     IF RK[R1J] = R 
          EQ     RLL4 
  
 RLL2     SA1    A1+B1       R2J = R1J + 1
          LX1    -IH.RFP
          BX6    X5-X1
          BX7    "RN"X6 
          NZ     X7,RLL4     IF RF[R2J] " R 
 RLL3     BX6    X2 
          SA6    A6+B1       US = US + 1;  [US] = [UI]
          SB2    0           FLAG = 0 
  
 RLL4     BX6    X2          UL = [UI]
          SA2    A2+B1       UI = UI + 1
          LX6    59-U.LASTP 
          PL     X6,RLL1     IF ^LAST[UL] 
  
          MX7    1
          LX7    1+U.LASTP
          NZ     B2,RLL5     IF FLAG " 0   */ NOTHING STORED
          SA2    A6 
          BX6    X7+X2       LAST[US] = 1 
          SA6    A2 
          EQ     SNU2 
  
 RLL5     SA3    L.TXT
          SX4    X3-4 
          BX6    X7+X4
          SA6    B2          [FLAG] = UIT(1,0,0,L.TXT-4)
          EQ     SNU2 
  
 SNU      ROUTINE 
          LX4    58-D.TYP 
          IX7    X4+X4
          MI     X7,SNU0     IF TYPE[DI] = II ! IV
          PL     X4,SNU1     IF TYPE[DI] = I
  
          SA3    "DI"-B1     R2 = DI - 1
          LX4    1+D.TYP-D.^DP
          LX3    -IH.RFP
          BX5    "RN"X3      RNUMS = RF[R2] 
          PL     X4,SNU2     IF DEF[DI] 
          SA3    A3-B1       R1 = R2 - 1
          LX5    R1.RIL 
          BX2    "RN"X3 
          IX5    X2+X5       RNUMS = SHIFT( RNUMS , 16) ! RI[R1]
          EQ     SNU2 
  
 SNU1     LX4    2+D.TYP-D.TYIOP
          MX6    -D.TYIOL 
          SA5    "DI"-2      R1 = DI - 2
          BX7    -X6*X4 
          SA3    TYIOM+X7 
          UX2    B2,X3
          BX1    X2*X5
          AX5    B2,X1       RNUMS = TYIO[R1,DI]
          NZ     X7,SNU2     IF TYIO[DI] " 0  */ NOT RJ,RK CASE 
          AX6    B2,X5
          BX7    X6-X5
          BX3    "RN"X7 
          NZ     X3,SNU2     IF RJ[R1] " RK[R1] 
          AX5    B2,X5       RNUMS = RJ[R1] 
  
 SNU2     SA3    O.TREE 
          MX1    -I.USESL 
          SB6    X3 
          IX7    X7-X7       UOR = 0
          LX1    I.USESP
          MX4    -I.INDXL 
  
*         SET *TXT* INDEX OF NEXT USE OF OPERANDS IN *RVT*
  
 SNU3     BX6    "RN"X5      R = RI[RNUMS]
          ZR     X6,SNU5     IF R = 0 
          SA3    "TB"+X6     L = BASE + R 
          BX2    -X1*X3 
          ZR     X2,SNU5     IF USES[L] = 0 
  
*         SEARCH *SIT* TO FIND FIRST UNISSUED SUCCESSOR OF OPERAND
  
          LX3    -I.INDXP 
          BX6    -X4*X3 
          LX3    I.INDXP-I.REGP 
          SA2    B6+X6       UI = O.TREE + INDX[L]
          SX6    X3          REGNO = REG[L] 
 SNU4     LX2    -U.SUCCP 
          SA3    "TB"+X2     SI = BASE + SUCC[UI] 
          LX3    59-I.IIP 
          LX2    59-U.RDLP+U.SUCCP
          BX3    X2+X3
          SA2    A2+B1       UI = UI + 1
          MI     X3,SNU4     IF II[SI] ! RDL[UI-1]
  
          SA2    RVT+X6 
          LX7    18 
          IX7    X6+X7       UOR = SHIFT( UOR , 18 ) ! REGNO
          LX2    -RV.NUP
          SX6    A3-"TB"
          BX3    X0*X2
          IX6    X6+X3       NU[ RVT(REGNO) ] = SUCC[UI-1]
          LX6    RV.NUP 
          SA6    A2 
  
 SNU5     AX5    R1.RIL      RNUMS = SHIFT( RNUMS , - 16 )
          NZ     X5,SNU3     IF RNUMS " 0 
  
*         CHECK FOR STORES AND OPS THAT *PRS*, ADJUST APPROPIATE FLAGS
  
 SNU6     S"DI"  "DI" 
          SA1    SNUA 
          BX6    X1*X4
          ZR     X6,SNU      IF ST[DI] & PRS[DI] = 0
          LX4    59-D.STP 
          MI     X4,SNU7     IF ST[DI]
  
          SA5    "DI"+2      R1RS = DI + 2
          BX6    "RN"X5 
          LX5    -R1.SOP
          MX1    -SO.RTL-SO.RNL 
          BX3    -X1*X5      RN = SOREG[R1RS] 
          SX2    X3-8 
          PL     X2,SNU      IF RN > 7     */ IF NOT A B-REGISTER 
          SA6    LRN+X3      LRN(RN) = R   */ SAVE LAST R-NUMBER IN B-REG 
          EQ     SNU
  
 SNU7     SA1    ISC
          MX3    -I.LINKL 
          SA5    "DI"+B1     L = DI + 1 
          BX2    X3*X5
          BX6    X2+X1       LINK[L] = ISC */ POINT THIS TO LAST
          SA6    A5 
          SX6    A5-"TB"
          SA6    A1          ISC = L - BASE  */ CHAIN POINTS TO THIS
  
*         ADJUST *PS* BIT FOR THE *RI* IN THE STORE 
  
          SA1    "DI"-2      R1 = DI - 2
          BX4    "RN"X1      R = RI[R1] 
          SA5    "TB"+X4     L = BASE + R 
          MX6    -I.INDXL 
          SA3    O.TREE 
          LX5    -I.INDXP 
          SB2    X3 
          BX2    -X6*X5 
          SA3    B2+X2       UI = O.TREE + INDX[L]
  
 SNU9     LX3    -U.SUCCP 
          SA2    "TB"+X3     SI = BASE + SUCC[UI] 
          LX2    59-I.IIP 
          MI     X2,SNU10    IF II[SI]
          SA1    A2-3        R1S = SI - 3 
          BX2    X1-X4
          BX6    "RN"X2 
          NZ     X6,SNU10    IF RI[R1S] " R 
          SA1    A2-B1       D = SI - 1 
          LX1    59-D.STP 
 #DAL     IFEQ   .DAL,0 
          MI     X1,SNU      IF ST[DI]     */ AN UNISSUED STORE 
 #DAL     ELSE
          PL     X1,SNU10    IF ^ST[DI] 
          LX1    D.STP-D.L2P
          PL     X1,SNU      IF ^L2[DI] 
 #DAL     ENDIF 
 SNU10    LX3    U.SUCCP+59-U.LASTP 
          BX6    X3          UL = UI
          SA3    A3+B1       UI = UI + 1
          PL     X6,SNU9     IF ^LAST[UL] 
  
          SA5    A5-B1       D = L - 1
          SX4    B1 
          LX4    D.PSP
          BX6    -X4*X5      PS[D] = 0     */ CLEAR *PS* BIT
          SA6    A5 
          EQ     SNU
  
 SNUA     BFMW   D,(PRS,ST) 
 TGL      EJECT 
          TITLE  TGL - TOGGLE TWO REGISTERS.
**        TGL - THIS ROUTINE WILL BE INOLKED BEFORE UJR 
*         TRIES TO STORE OUT A REGISTER.  BASICALLY IT WILL 
*         CHECK TO SEE IF R0 IS AN OPERAND OF T0.  IF THIS
*         HAPPENS R0 WILL NOT BE STORED TO MEMORY BUT WILL
*         BE SIMPLY TOGGLED WITH AN AVAILABLE REGISTER OF THE 
*         CLASS SOUGHT BY T0.  THIS MODULE IS AN ANSWER TO
*         FCC2207 WHERE SRM OF R0 REMOVED T0 FROM THE ISSUE 
*         CANDIDATE LIST. 
* 
*         ENTRY  (B3) = REGNO CURRENTLY ASSIGNED TO R0
*                (T0) = INSTRUCTION TO BE ISSUED
*                (R0) = RESULT TO BE STORED 
*                (CLASS) = CLASS BITS FOR T0
  
*         EXIT   (B4) = REGNO. TOGGLED WITH R0 (= 0 NO TOGGLE)
  
*         MAINTAINS B3,T0,CLASS,R0
  
 RTGL     BSS    1
  
 TGL      ROUTINE 
  
*         FIND OPERANDS OF T0.
  
          SB4    B0 
          SA2    T0 
          RJ     GOR         GET OPERAND ROUTINE
  
*         LOOK IN OPERAND LIST FOR R0.
  
          SX1    B3 
 TGL20    ZR     X7,TGL      IF ROP = 0  */EXIT 
          BX5    X1-X7
          SX6    X5 
          ZR     X6,TGL40    IF ROP = REGR0 
          AX7    18 
          EQ     TGL20
  
*         R0 IS AN OPERAND OF T0 - TOGGLE IT. 
*         CHECK IF R0 HAS MORE THAN ONE USE - IF SO FORGET IT.
  
 TGL40    SA1    R0 
          BX1    "RN"X1 
          SA5    "TB"+X1     LT = BASE + R0 
          MX7    -I.USESL 
          LX5    59-I.USESP 
          BX6    -X7*X5 
          NZ     X6,*+1S17   IF USES[LT] > 1 BLOWUP 
  
*         FIND A REGISTER TO TOGGLE WITH R0.
  
          SA3    CLASS
          SA2    LXR
          BX7    -X2*X3      TRV = ^LXR & CLASS 
          ZR     X7,*+1S17   IF TRV = 0 BLOWUP
          NX6    B4,X7
          SA3    B4+FXRA+16-47
          SB4    X3          REGTGL = FIRST TRV 
  
*         MAKE R0 UNAVAILABLE AND RESTORE RVT(REGR0)
  
          SA2    RBV+B3 
          SA3    AXR
          SX7    X1 
          BX6    X3-X2
          SA7    RVT+B3      RVT(REGRO) = R0
          SA6    A3          MAKE REGRO UNAVAIL.
  
*         TOGGLE REGTGL AND R0. 
*         OUTPUT THE FOLLOWING SEQUENCE.
*         XOR    R0,R0,RTGL 
*         XOR    RTGL,R0,RTGL 
*         XOR    R0,R0,RTGL 
  
          SA2    RVT+B4 
          PX7    B3,X1
          BX2    "RN"X2 
          PX6    B4,X2
          SA7    A1 
          SA6    RTGL 
          SB2    OC.XOR 
          SA3    =XF.RDT+B2 
          BX1    "RN"X1      R0 
          BX2    "RN"X2      RTGL 
          LX1    R1.RJP 
          LX2    R1.RKP 
          BX7    X1+X2
          PX6    B2,X7
          MX7    0
          SA6    DRI         DRI(0) = TYI(OC.XOR,R0,RTGL,0) 
          SA7    A6+B1       DRI(1) = 0 
          BX6    X3 
          SA6    A7+B1       DRI(2) = FX.RDT(OC.XOR)
          SA4    A6 
          SX7    B3 
          SA7    A4+B1       DRI(3) = REGR0 
          RJ     OEI         ISSUE XOR REGR0,R0,RTGL
          SA1    R0 
          SA2    RTGL 
          UX6    B4,X1
          UX7    B3,X2
          SA4    DRI+2
          SX7    B3 
          SA7    A4+B1       DRI(3) = REGR0 
          RJ     OEI         ISSUE XOR REGTGL,R0,RTGL 
          SA1    R0 
          SA2    RTGL 
          UX6    B3,X1
          UX7    B4,X2
          SA4    DRI+2
          SX7    B3 
          SA7    A4+B1       DRI(3) = REGTGL
          RJ     OEI         ISSUE XOR REGR0,R0,RTGL
  
*         TOGGLE RVT ENTRIES AND LINK WORDS.
  
          SA1    R0 
          SA2    RTGL 
          UX3    B3,X1       (B3) = REGR0 
          UX4    B4,X2       (B4) = REGTGL
          SA1    RVT+B3 
          SA2    RVT+B4 
          BX6    X1 
          BX7    X2 
          SA6    A2          RVT(REGR0) = RVT(REGTGL) 
          SA7    A1          RVT(REGTGL) = RVT(REGR0) 
          SA1    "TB"+X3     LIR0 = BASE + R0 
          SA2    "TB"+X4     LIRTGL = BASE + RTGL 
          BX6    X2 
          BX7    X1 
          SA6    A1          LIR0 = LIRTGL
          SA7    A2          LIRTGL = LIR0
  
*         RETURN
          EQ     TGL
 SRM      TITLE  SRM - SAVE RESULT IN MEMORY
**        SRM - SAVE RESULT IN MEMORY AND SET FOR RELOAD OF INSTRUCTION 
* 
*         ENTRY  (B3) = REGNO , OF REGISTER TO BE STORED OUT
*                (R0) = *TXT* INDEX OF INSTRUCTION
*                (T0) = *TXT* INDEX OF INSTRUCTION TO ISSUE 
  
 SRM      ROUTINE 
          SA1    R0 
          SA2    O.TREE 
          SA5    "TB"+X1     LI = BASE + R0 
          MX7    -I.INDXL 
          SB2    X2 
          LX5    -I.INDXP 
          BX6    -X7*X5 
          SA4    A5-B1       DI = LI - 1
          SB6    B2+X6       U0 = O.TREE + INDX[LI] 
          LX4    59-D.EQVP
          PL     X4,SRM3     IF ^EQV[DI]   */ NO EQUIV LINKS
  
*         INSTRUCTION IS A PREDECESSOR OF INTERFERING STORES, REMOVE
*         THE LOGICAL LINKS FROM *SIT*
  
          SA3    B6          UI = U0
          SB5    B6          US = U0
  
 SRM1     BX6    X3          UL = [UI]
          LX3    59-U.EQVP
          MI     X3,SRM2     IF EQV[UI] 
          SA6    B5+         [US] = UL
          SB5    B5+1        US = US + 1
 SRM2     SA3    A3+B1       UI = UI + 1
          LX6    59-U.LASTP 
          PL     X6,SRM1     IF ^LAST[UL] 
  
          SA3    B5-B1
          MX7    1
          LX7    1+U.LASTP
          BX6    X7+X3       LAST[US-1] = 1 
          SA6    A3+
  
*         SEARCH SUCCESSORS OF *R0* FOR AN ISSUED STORE TO A
*         *CHEIP* ADDRESS.
  
 SRM3     SA3    B6          UI = U0
          SA1    SRMA 
          R=     B6,59-U.LASTP+U.SUCCP
          SB2    59-D.STP 
          SB5    IH.RFP 
  
 SRM4     LX3    -U.SUCCP 
          SA5    "TB"+X3     SI = BASE + SUCC[UI] 
          LX5    59-I.IIP 
          PL     X5,SRM6     IF ^II[SI]    */ NOT ISSUED
          SA4    A5-B1       DI = LI - 1
          LX6    B2,X4
          PL     X6,SRM6     IF ^ST[DI] 
          BX7    X1*X4
          NZ     X7,SRM6     IF FP[DI] ! L2[DI] ! EQV[DI] 
          SA2    A4-B1       R2 = DI - 1
          AX7    B5,X2
          SB4    X7 
          GE     B4,B1,SRM6  IF RF[R2] > 1
          LX4    58-D.TYP 
          MI     X4,SRM8     IF TYPE[DI] = III
  
 SRM6     LX6    B6,X3       UL = [UI]
          SA3    A3+B1       UI = UI + 1
          PL     X6,SRM4     IF ^LAST[UL] 
  
          RJ     OTS         OUTPUT A TEMP STORE
  
 SRM7     SA2    T0 
          ZR     X2,SRM7A    IF T0 = 0     */ NO INSTRUCTION TO ISSUE 
          RJ     ISI         ISSUE SELECTED INSTRUCTION 
  
 SRM7A    SA1    R0 
          RJ     GLI         GENERATE A *LD* OF SAVED RESULT
          EQ     SRM
  
 SRM8     BX6    X2 
          SA6    DRI+1       DRI(2) = [R2]
          EQ     SRM7 
  
 SRMA     BFMW   D,(FP,L2,EQV)
 GOT      TITLE  GOT - GET OT. ORDINAL
**        GOT - GET OT. CELL ( TEMPORARY LOCATION ) FOR STORE TO TEMP 
* 
*         ENTRY  (X5) = RN , R-NUMBER TO BE SAVED IN THE OT.
* 
*         EXIT   (X6) = IHWORD ( R2 ) OF AN AVAILABLE LOCATION
  
 GOT      ROUTINE 
          SA1    M.OT 
          SA2    L.OTI
          IX6    X1-X2
          MI     X6,GOT1     IF M.OT < L.OTI
          ALLOC  OTI,30B     ALLOC( OTI , 30B ) 
          RJ     AIP         ADJUST *PIT* POINTERS
          SA1    M.OT 
  
 GOT1     SA2    O.OTI
          SB2    X1 
          MX7    -I.USESL 
          SA3    X2-1        OI = O.OTI - 1 
          SA7    X2+B2       [O.OTI+M.OT] = -0  */ SEARCH TERMINATOR
          LX7    I.USESP
  
*         SEARCH FOR AN OT. CELL THAT IS NO LONGER BEING USED 
  
 GOT2     SA3    A3+B1       OI = OI + 1
          MI     X3,GOT3     IF [OI] < 0   */ END OF TABLE
          SA2    "TB"+X3     LI = BASE + RI[OI] 
          BX1    -X7*X2 
          NZ     X1,GOT2     IF USES[LI] " 0
  
          UX3    B2,X3       CA = UEXP(OI)
          EQ     GOT4 
  
 GOT3     SX6    B2+B1       CA = M.OT
          SA6    M.OT        M.OT = CA + 1
  
 GOT4     PX7    B2,X5
          SA4    =XOT.
          SX6    B2 
          SA7    A3          [OI] = PACK( CA , R-NUM )
          LX6    IH.CAP 
          LX4    IH.IHP 
          BX6    X4+X6       IHWORD = IHW(0,CA,IH)
          EQ     GOT
 SRM      SPACE  3
 OTS      TITLE  OTS - OUTPUT TEMP STORE
**        OTS - OUTPUT TEMP STORE 
* 
*         ENTRY  (B3) = REGNO OF REGISTER TO BE STORED OUT
*                (R0) = TXT INDEX OF INSTRUCTION
* 
*         EXIT   (DRI+1) = IH WORD OF SAVED RESULT
  
 OTS      ROUTINE 
          SB2    OC.ST
          SA5    R0          R = [R0] 
          SA2    =XF.RDT+B2 
          PX6    B2,X5
          SX4    B1 
          SA6    DRI         DRI(0) = TYII(OC.ST,0,0,R) 
          LX4    D.SRP
          BX7    X4+X2
          SA7    A6+2        DRI(2) = F.RDT(OC.ST) ! SR 
          SX6    B3 
          SA6    A7+B1       DRI(3) = REGNO 
          RJ     GOT         DRI(1) = GOT(R)
          S"DI"  DRI+2       DI = DRI(2)
          SA5    A4+B1
          SB3    X5 
          SA6    A4-B1
          SB4    X5 
          RJ     OEI         OUTPUT THE INSTRUCTION 
          EQ     OTS
 GLI      SPACE  3
**        GLI - GENERATE A *LD* OF A SAVED RESULT 
* 
*         ENTRY  (X1) = R , *TXT* INDEX OF INSTRUCTION
*                (DRI+1) = IH WORD OF SAVED RESULT
  
 GLI      ROUTINE 
          RJ     RIL         RESET R FOR REISSUE
          SB6    "TB"-B1
          SA3    DRI+1
          S"DI"  B6+B3       DI = BASE-1 + R
          SA2    =XIT.
          SB2    OC.LD
          BX7    X2-X3
          SX2    X7 
          NZ     X2,GLI1     OC = IF( IH[DRI+1] " IT. ) THEN OC.LD
          SB2    OC.TLD                    ELSE OC.TLD
 GLI1     SX5    B3 
          BX7    X3 
          SA1    F.RDT+B2 
          SA2    GLIA 
          PX6    B2,X5
          SA7    "DI"-B1     [DI-1] = [DRI+1]  */ IH WORD 
          MX5    -D.STRSL 
          SA6    A7-B1       [DI-1] = TYII(OC,0,0,R)
          BX1    X1+X2
          LX5    D.STRSP
          BX3    -X5*X4 
          BX7    X1+X3       [DI] = RDT(OC) ! ZP ! SR ! STRS[DI]
          SA7    "DI" 
          LX4    59-D.PSP 
          PL     X4,GLI      IF ^PS[DI] 
 GLI      SPACE  1,10 
*         GENERATE AN *XMT* TO MOVE THE RESULT TO A STORE REGISTER
  
          SA6    R0          R0 = R 
          RJ     SXB         SETUP A *XMT* BACK TO THE *ST-REG* 
          EQ     GLI
  
 GLIA     BFMW   D,(ZP,SR)
 OEI      TITLE  OEI - OUTPUT EXTRA INSTRUCTION 
**        OEI - OUTPUT EXTRA INSTRUCTION
* 
*         ENTRY  (A4,X4) = DI, [DI] OF DUMMY INSTRUCTION
*                (B3) = REGNO OF RESULT REG OF INSTRUCTION
*                (B4) = REGO , REGNO OF OPERAND REGISTER
* 
*         CALLS  ASC, SII 
  
 OEI      ROUTINE 
          SA2    T
          SA3    TRA+B4 
+         IX6    X2-X3
          PL     X6,*+1      T(IS) = MAX( T , TRA(REGO) ) 
          BX2    X3 
          LX4    -D.F1P 
          SB6    "DI"+B1
          MX7    -D.F1L 
          BX6    -X7*X4 
          SB2    X6 
          SX1    B6-"TB"
          MX5    -18
          SB4    X2          T(EX) = T(IS)
          BX6    -X5*X1 
          SB5    X2 
          PX7    B2,X6
          SA7    PBI+1       FU[PBI(2)] = F1[DI]
          LX4    D.F1P
          PX6    B3,X2       REG[PBI] = REGNO 
          SA6    A7-B1
          RJ     ASC         ADVANCE THE CLOCK
          SA5    "DI"-2      R1 = DI - 2
          RJ     SII         SAVE THE INSTRUCTION IN *PIT*
          EQ     OEI
 AIS      SPACE  3           AIS
**        AIS - ALLOCATE INSTRUCTION SPACE FOR EXTRA INSTRUCTIONS 
  
 AIS      ROUTINE 
          SA1    EIW
          SX6    X1+B1       EIW = EIW + 1
          SA6    A1 
          MI     X6,AIS      IF EIW < 0 
          SA1    N.INST 
          AX1    2
          BX6    -X1
          SA6    A6          EIW = -N.INST/4
          ALLOC  PIT,X1      ALLOC( PIT , N.INST/4 )
          RJ     AIP         ADJUST POINTERS
          EQ     AIS
 AIP      SPACE  3,14        AIP
**        AIP - ADJUST INSTRUCTION POINTERS ( AFTER A TABLE MANAGER CALL
* 
*         EXIT   (B7) = O.TXT + 3 
* 
*         USES   X - 1, 4, 6, 7 , A - 1, 4, 6, 7
  
 AIP0     SA1    O.TXT
          SB7    X1+3        BASE = O.TXT + 3 
  
 AIP      ROUTINE 
          SA1    O.PIT
          SA4    IIP+1
          IX6    X1-X4
          ZR     X6,AIP0     IF IIP(2) = O.PIT  */ *PIT* NOT MOVED
          BX7    X1 
          SA1    A4-B1
          IX6    X1+X6       IIP = IIP - IIP(2) + O.PIT  */ RESET POINTER 
          SA7    A4          IIP(2) = O.PIT    */ SAVE NEW BASE 
          SA6    A1 
          EQ     AIP0 
  
          QUAL
  
          END 
