*DECK CODGK3S 
USETEXT   TSOURCE 
USETEXT   TTARGET 
USETEXT   TSYMCNS 
USETEXT   TCEXECQ 
USETEXT   TREGNOS 
USETEXT   TCOM39Q 
USETEXT   TCOM78Q 
USETEXT   TCEXEC
USETEXT   TCOM88
USETEXT   TCOM88K 
      PROC CODGK3S; 
      BEGIN 
#**********************************************************************#
#     CODGK3S - A COLLECTION OF SUPPORT ROUTINES USED (PRIMARILY) BY   #
#               CODGK3                                                 #
#**********************************************************************#
  
  
  
  
*CALL COMEX 
  
  
  
  
#     DEFS                                                             #
  
      DEF J861 #861#;        # SYMABT DIAGNOSTIC 861                   # CODGK3S
      DEF J862 #862#;        # SYMABT DIAGNOSTIC 862                   # CODGK3S
  
  
  
  
#     XREFS                                                            #
  
      XREF
          BEGIN 
          PROC BINDEC;
          PROC BINOCT;
          PROC CHRCHR;
          PROC CG2ABT;       #ISSUE ABORT FROM CG2                     #
          PROC DB;           #DEBUG TRACE ROUTINE#
          ARRAY SCHDBGH [-1:SCRAR] P(2);    #CONTAINS SCHEDULER HISTORY#
            ITEM
                DCLK   I  (0,0,12) ,    # CLOCK                        #
                DISU   I  (0,12,9) ,    # ISUT                         #
                DEXT   I  (0,21,9) ,    # EXUT                         #
                DPR    I  (0,30,14),    # PFF1[INX]                    #
                DUSS   I  (0,44,9) ,    # REFCT[INX]                   #
                DNR    I  (1,0,9)  ,    # NREDY                        #
                DNP    I  (1,9,9)  ,    # NSCN                         #
                DFC    B  (1,18,1) ,    # FORCE                        #
         DRP      B (1,21,1) ,      #   REGISTER PROBLEM               #
            # FIELDS USED TO SAVE REGISTER CONTENTS AT LABELS          #
                DX0    I  (0,0,12) ,    # RGMEM[XREG0]                 #
                DX1A   I  (0,12,12),    # RGMEM[XREG0+1]               #
                DX2A   I  (0,24,12),    # RGMEM[XREG0+2]               #
                DX3    I  (0,36,12),    # RGMEM[XREG0+3]               #
                DX4    I  (0,48,12),    # RGMEM[XREG0+4]               #
                DX5    I  (1,0,12),     # RGMEM[XREG0+5]               #
                DX6    I  (1,12,12),    # RGMEM[XREG0+6]               #
                DX7    I  (1,24,12);    # RGMEM[XREG0+7]               #
          END 
  
  
  
  
#     XDEFS                                                            #
  
      XDEF
          BEGIN 
          PROC BGA00;        #REGISTER AVAILABILITY SIMULATION# 
          PROC BGB00;        #LINK INSTR INTO GENERATED CODE CHAIN# 
          PROC CIE00;        #COMPUTE ISSUE AND EXECUTION TIMES#
          PROC CNO00;        #PROCESS NOP GENERATION# 
          PROC FGR00;        #FORGET REGISTERS# 
          PROC RMH00;        #MAINTAIN REGISTER MEMORY HISTORY# 
          PROC RMI00;        #RECORD MINIMUM ISSUE INSTRUCTIONS#
          PROC RPC00;        #REDUCE PREDECESSOR COUNTS#
          PROC RRC00;        #REDUCE REFERENCE COUNT OF OPERANDS# 
          PROC SP00;         #TRY TO PREVENT NOP GENERATION#
          PROC SST00;        #COMPUTE STATUS OF INSTRUCTION#
          END 
  
  
      $BEGIN
      XDEF
          BEGIN 
          PROC ESDH00;
          PROC SRP00; 
          PROC SSDH00;
          END 
      $END
  
  
  
  
#     LOCAL DATA                                                       #
  
      ITEM PREDA; 
      ITEM PREDB; 
      ITEM SUSP;
      ITEM NEWR;
      ITEM
         MIX      I ,               #  MIN IMUM ISSUE INDEX            #
         TNREDY   I =  0  , 
          TNSCAN; 
CONTROL EJECT;
#**********************************************************************#
#     BGA00 - BASIC GENERATION A.  PERFORM THE REGISTER AVAILABILITY   #
#             SIMULATION.                                              #
#                                                                      #
#     PURPOSE-                                                         #
#         UPDATES THE REGFT ARRAY FOR THE CURRENT INSTRUCTION. THIS    #
#         HAS ENTRIES CONTAINING THE TIME AT WHICH EACH REG CAN BE USED#
#         AS A RESULT REG (RRFT) AND THE TIME AT WHICH EACH REG CAN BE #
#         USED AS AN OPERAND                                           #
#                                                                      #
#     INPUT-                                                           #
#         IETIM = TIME BEFORE CURRENT INSTR WILL COMPLETE EXECUTION.   #
#               = ISUT + EXUT                                          #
#         CLOCK = CURRENT TIME.                                        #
#         REGI = REG NUM OF I-DESIGNATOR FIELD OF CURRENT INSTRUCTION. #
#         REGJ = REG NUM OF J-DESIGNATOR FIELD OF CURRENT INSTRUCTION. #
#         REGK = REG NUM OF K-DESIGNATOR FIELD OF CURRENT INSTRUCTION. #
#         IEFTIM = FTIM + IETIM (FTIM = TIME REQUIRED BY FUNCTIONAL    #
#                  UNIT).                                              #
#         LSTYP = LOAD/STORE TYPE                                      #
#                                                                      #
#     OUTPUT-                                                          #
#         RRFT[REGJ] = TIME AT WHICH REGISTER REGJ CAN BE USED AS A    #
#                      RESULT REGISTER.                                #
#         RRFT[REGK] = TIME AT WHICH REGISTER REGK CAN BE USED AS A    #
#                      RESULT REGISTER.                                #
#         ROFT[REGI] = TIME AT WHICH REGISTER REGI CAN BE USED AS AN   #
#                      OPERAND REGISTER.                               #
#**********************************************************************#
    PROC BGA00    ; 
         BEGIN    #      BGA00                                         #
         ITEM     T1  I   ; 
#        RESULT FREE TIME                                              #
#        CLOCK + ISSUE TIME  + (TIME TO BEGIN EXECUTION) + 1           #
         T1  =   IETIM + CLOCK + 2   ;
         RRFT [ REGJ ]  = T1  ; 
         RRFT [ REGK ]  = T1  ; 
#        OPERAND FREE TIME                                             #
         ROFT [REGI] = IEFTM + CLOCK + 1   ;
         IF LSTYP EQ QLT"LOAD" THEN #   LOAD FROM MEMORY               #
                  ROFT [REGI] = ROFT [REGI] + 5  ;  #  MEMORY ACCESS   #
         IF LSTYP EQ QLT"STOR" THEN RRFT [REGI] = ROFT [REGI] + 5  ;
$BEGIN
      DB("(9X,17H BGA00      IJK  ,3(O2,2X),9HROFT[I]= ,O6, 
          12H RRFT[J,K]= ,O6)",REGI,REGJ,REGK,ROFT[REGI],T1,"."); 
$END
         END      #      BGA00                                         #
CONTROL EJECT;
    PROC BGB00    ; 
                                        #LINKS AN INSTRUCTION INTO THE #
                                        # GENERATED CODE CHAIN AND     #
                                        # PERFORMS SOME STANDARD       #
                                        # GENERATING FUNCTIONS FOR THE #
                                        # OBJECT MACHINE EMULATION.    #
         BEGIN    #      BGB00                                         #
          $BEGIN
#                                                                      #
         IF  SKRMK  THEN            #   SCHEDULE REMARKS               #
         CALL  SSDH00 ;             #   SCHEDULER DEBUG  HISTORY       #
         SDLY  =  SDLY + ISUT ;     #   DELAY IN  SEQUENCE             #
         $END 
#        FUNCTIONAL UNIT FREE TIME                                     #
         T2  =    IEFTM  +  CLOCK + 1 ; 
         FACL [FUNU]  =  T2  ;
         IF  LSTYP EQ  QLT"LOAD" THEN   # LOAD TIES UP PSEUDO STORE    #
              IF   MOP[INX] EQ  QCFOP"RXJ"  THEN                         LARRY-R
                  FACL[LCMU]  =  T2 + 14 ;                               LARRY-R
              ELSE                                                       LARRY-R
                  FACL [PSST] =  T2 + 5 ; 
         IF  LSTYP EQ  QLT"STOR" THEN   # STORE TIES UP PSEUDO LOAD    #
              IF  MOP[INX] EQ  QCFOP"WXJ"  THEN                          LARRY-R
                  FACL[LCMU]  =  T2 + 1 ;                                LARRY-R
              ELSE                                                       LARRY-R
                  FACL [PSLD] =  T2 + 5 ; 
#        INCREMENT CLOCK                                               #
         CLOCK  = CLOCK + ISUT + INSIZ  ; 
#        I,J,K                                                         #
         IDES [INX] = REGI  ; 
         JDES [INX] = REGJ   ;
         IF  INSIZ  GT  1  THEN  KDES [INX] = KACON  ;
                  ELSE  KDES  [INX] =  REGK  LAN O"7"  ;
         IF  MOP [INX]  EQ 0  THEN
                  MOP [INX]  =  KFOP [ OPCOD ] ;
#        LINK INTO FOL GEN  ORDER                                      #
         FOL  [LGEN]  =  INX  ; 
         LGEN  =  INX  ;
         FOL  [INX]  =  PSOS  ; 
#        CURRENT LOCATION  COUNTER                                     #
         CLC  [0]  =  CLC  [0] +  INSIZ  ;
         IF  PARCL  EQ  0 THEN CLOCK =  CLOCK  +  WDTIM  ;
#                                                                      #
         END      #      BGB00                                         #
CONTROL EJECT;
#        COMPUTE ISSUE TIME AND EXECUTION TIME         #
#        EXUT IS TIME FROM ISSUE TO BEGIN EXECUTION    #
          ITEM CLOCKBEATER B; 
    PROC CIE00 ;
         BEGIN #CIE00#
#        XWRT IS TIME TO USE WORK REGISTER AS RESULT   #
#        FUNU IS FUNCTIONAL UNIT (INDEX ALSO)          #
#        XREGJ AND XREGK ARE THE OPERAND REGISTERS     #
#        OUTPUT:  ISUT , EXUT      #
         ITEM     TXT1 ;
         ITEM     TXT2 ;
         IF  FACL [ FUNU ] LE  CLOCK THEN 
                  ISUT  =  XWRTO  ; ELSE
                  ISUT = FACL [FUNU] - CLOCK ;
                  IF XWRTO GT ISUT THEN ISUT = XWRTO ;
         IF LSTYP EQ QLT"LOAD" THEN     #  CHECK PSEUDO LOAD UNIT      #
               BEGIN
               IF  MOP[INX] EQ  QCFOP"RXJ"  THEN                         LARRY-R
                      # LCM READ  #                                      LARRY-R
                  T1 =  FACL[LCMU]  -  CLOCK ;                           LARRY-R
               ELSE                                                      LARRY-R
                      # SCM        #                                     LARRY-R
               T1 = FACL [PSLD] - CLOCK ; 
               IF T1 GT ISUT THEN ISUT = T1 ; 
               END
          ELSE
               BEGIN
         IF LSTYP EQ QLT"STOR" THEN     #  CHECK PSEUDO STORE UNIT     #
               BEGIN
               IF  MOP[INX] EQ  QCFOP"WXJ"  THEN                         LARRY-R
                      # LCM  WRITE   #                                   LARRY-R
                  T1 =  FACL[LCMU]  -  CLOCK ;                           LARRY-R
               ELSE                                                      LARRY-R
                      #  SCM       #                                     LARRY-R
               T1 = FACL [PSST] - CLOCK ; 
               IF T1 GT ISUT THEN ISUT = T1 ; 
               END
               END
          IF REGJ EQ SUDOR
              OR REGJ EQ BREG0
          THEN
              TXT1 = 0;      #REGJ NOT USED - NO WAITING# 
          ELSE
         TXT1  =  ROFT [REGJ] - CLOCK ; 
          IF REGK EQ SUDOR
              OR REGK EQ BREG0
          THEN
              TXT2 = 0;      #REGK NOT USED - NO WAITING# 
          ELSE
         TXT2  =  ROFT [REGK] - CLOCK ; 
         IF  TXT2  GT  TXT1 THEN TXT1 = TXT2 ;
         EXUT = TXT1 - ISUT ; 
          CLOCKBEATER = FALSE;
      IF OPCODE NQ QICFOP"REPL"    #NEVER HINDER STORES#
          AND PFFVH[INX] EQ 0      #NEVER HINDER HIGH PRIORITY INSTRS#
          AND PFFMH[INX] EQ 0 
          AND ((PFF1[INX] LS CURSEQF) OR (EXUT LS -FUDGE))
      THEN
          CLOCKBEATER = TRUE;      #WAIT A WHILE FOR THIS INSTR#
         IF EXUT LT 0 THEN EXUT = 0 ; 
#                                                                      #
#        IF THE RESULT REGISTER  HAS NOT BEEN READ OUT ( BY LAST USE ) #
#        BY THE TIME THE INSTRUCTION HAS ISSUED AND EXECUTED           #
#        THEN TIE UP THE FUNCTIONAL UNIT  LONGER                       #
#        (UNTIL THE RESULT REGISTER IS STORED INTO                     #
#                                                                      #
  
      $BEGIN
      DB("(9X,17H CIE00      IJK  3(O2,2X),6HISUT= ,O6,7H EXUT= ,O6,
          14H CLOCKBEATER= ,O1)",REGI,REGJ,REGK,ISUT,EXUT,CLOCKBEATER,
          "."); 
      $END
  
         END   #CIE00#
      CONTROL EJECT;
    PROC CNO00    ; 
                                        #PERFORMS THE APPROPRIATE      #
                                        # HARDWARE SIMULATION CAUSED   #
                                        # BY THE GENERATION OF A NOP   #
                                        # WHEN A TWO-PARCEL INSTRUCTION#
                                        # IS GENERATED AND THE LOCATION#
                                        # COUNTER IS ON PARCEL 3 OF A  #
                                        # WORD.                        #
         BEGIN    #  CN000    # 
$BEGIN
DB("( 9X17H CNO00      IJK  O2,2X,O2,2X,O2)",REGI,REGJ,REGK,"."); 
$END
         IF INSIZ  EQ  2 AND  PARCL  EQ  3  THEN
                  BEGIN 
         CLOCK =  CLOCK + WDP ; 
         CLC [0]  =  CLC [0] + 1 ;
         ISUT =  ISUT - WDP  ;
                  END 
         IF  ISUT LT 0 THEN 
                  BEGIN 
                  EXUT =  EXUT + ISUT  ;
                  ISUT = 0 ;
                  IF EXUT LT 0 THEN EXUT = 0 ;
                  END 
         FTIM  =  EXTIM  [FUNU] ; 
         T1  =  RRFT [REGI] - CLOCK - ISUT - EXUT - FTIM  ; 
         IF T1 GT 0 THEN FTIM  = FTIM  + T1 ; 
         IETIM  =  ISUT + EXUT   ;
#                                                                      #
         IEFTM =  IETIM + FTIM ;
         END      #  CN000    # 
      CONTROL EJECT;
      $BEGIN
      PROC ESDH00;
#**********************************************************************#
#                                                                      #
#     ESDH00 - FORMAT INFO FOR DEBUG COMPILER OBJECT CODE LISTING.     #
#                                                                      #
#     PURPOSE-                                                         #
#         FORMATS SDLINE WHICH WILL BE WRITTEN TO THE CODE FILE.  THIS #
#         IS THE INFORMATION WHICH IS PRINTED TO THE RIGHT OF THE      #
#         OBJECT CODE BY THE DEBUG COMPILER IF O SELECTED.             #
#                                                                      #
#     INPUT-                                                           #
#         INX = ICFT POINTER OF CURRENT INSTRUCTION.                   #
#                                                                      #
#     OUTPUT-                                                          #
#         ARRAY SDLINE FORMATTED FOR WRITING TO CFL.                   #
#                                                                      #
#**********************************************************************#
  
  
      BEGIN 
  
      ITEM I; 
  
        SDC[0] = " ";    # BLANK COMMENT BUFFER                        #
        SDC[1] = " "; 
        SDC[2] = " "; 
        SDC[3] = " "; 
        I = 1;           # INITIAL CHARACTER POSITION                  #
         IF MOP  [INX]  EQ   QCFOP"CODE"  THEN    # SAVE/TSSV          #
                  BEGIN 
                  CHRCHR ( SDLINE , I , "SAVE - STORE", 12 ) ;
      RETURN; 
                  END 
        IF OPCD[INX] NE QICFOP"LABL" THEN 
        BEGIN 
            BINDEC(SDLINE,I,DPR[INX],4);     # PRIORITY                #
            I = I+5;
            CHRCHR(SDLINE,I,BCDOP[OPCD[INX]],4);  # BCD OPCD           #
            I = I+5;
            BINOCT(SDLINE,I,CNO[INX],4);     # COMPUTATION NUMBER      #
            I = I+5;
            BINDEC(SDLINE,I,DUSS[INX],2);    # NUMBER OF USES          #
            I = I+3;
            BINDEC(SDLINE,I,DNR[INX],2);     # NUMBER READY            #
         I = I+3; 
                  BINDEC ( SDLINE, I, DNP[INX],2 );  # NUMBER SCANNED  #
                  I = I + 3  ;
            IF DFC[INX] THEN CHRCHR(SDLINE,I,"F",1);   # FORCE         #
         I = I + 1 ;
         IF  DRP [INX]  THEN CHRCHR (SDLINE,I,"*",1) ; # REGISTER OUT  #
         I = I + 1 ;
            BINDEC(SDLINE,I,DCLK[INX],4);    # CLOCK                   #
            I = I+5;
            BINDEC(SDLINE,I,DISU[INX],2);    # ISSUE TIME              #
            I = I+3;
            BINDEC(SDLINE,I,DEXT[INX],2);    # EXECUTE TIME            #
            I = I+3;
        END 
        ELSE
        BEGIN  # REGISTER VALUE OUTPUT AT LABEL                        #
            BINOCT(SDLINE,1,DX0[INX],4);
            IF DX0[INX] LT 0 THEN CHRCHR(SDLINE,1,"  * ",4);
            BINOCT(SDLINE,6,DX1A[INX],4); 
            IF DX1A[INX] LT 0 THEN CHRCHR(SDLINE,6,"  * ",4); 
            BINOCT(SDLINE,11,DX2A[INX],4);
            IF DX2A[INX] LT 0 THEN CHRCHR(SDLINE,11,"  * ",4);
            BINOCT(SDLINE,16,DX3[INX],4); 
            IF DX3[INX] LT 0 THEN CHRCHR(SDLINE,16,"  * ",4); 
            BINOCT(SDLINE,21,DX4[INX],4); 
            IF DX4[INX] LT 0 THEN CHRCHR(SDLINE,21,"  * ",4); 
            BINOCT(SDLINE,26,DX5[INX],4) ;
            IF DX5[INX] LT 0 THEN CHRCHR(SDLINE,26,"  * ",4); 
            BINOCT(SDLINE,31,DX6[INX],4); 
            IF DX6[INX] LT 0 THEN CHRCHR(SDLINE,31,"  * ",4); 
            BINOCT(SDLINE,36,DX7[INX],4); 
            IF DX7[INX] LT 0 THEN CHRCHR(SDLINE,36,"  * ",4); 
        END 
      END 
      $END
CONTROL EJECT;
      PROC FGR00((K1),(K2));
      BEGIN 
#**********************************************************************#
#                                                                      #
#     FGR00 - FORGET REGISTERS                                         #
#                                                                      #
#     PURPOSE-                                                         #
#         FGR00 IS CALLED DURING LABEL PROCESSING TO FORGET THE        #
#         CONTENTS OF A SPECIFIED RANGE OF REGISTERS.  PROCESSING      #
#         SIMPLY CONSISTS OF SETTING THE REGISTER MEMORY ENTRY FOR EACH#
#         REGISTER IN THE RANGE TO -1 (DEAD REGISTER).  ALSO IF ANY B  #
#         OR X REGISTER IN THE RANGE CONTAINS AN ICFT POINTER (TO A    #
#         COMPUTATION RESULT), THE ICFT FIELD WHICH REMEMBERS THE REG  #
#         NUMBER CONTAINING THE RESULT IS "FORGOTTEN" (SET TO 0).      #
#                                                                      #
#     INPUT-                                                           #
#         K1 - FIRST REGISTER OF RANGE TO BE FORGOTTEN                 #
#         K2 - LAST REGISTER TO BE FORGOTTEN.                          #
#         RGMEM ARRAY - THE REGISTER MEMORY ARRAY.                     #
#         ICFT ARRAY - THE INSTRUCTION TABLE                           #
#                                                                      #
#     OUTPUT-                                                          #
#         RGMEM[K1] - RGMEM[K2] = -1                                   #
#                                                                      #
#**********************************************************************#
  
  
      ITEM K1;               #FIRST REG TO BE FORGOTTEN#
      ITEM K2;               #LAST REG TO BE FORGOTTEN# 
      ITEM I;                #TEMP - INDUCTION VARIABLE#
      ITEM T1;               #TEMP - RGMEM[I] (FOR MORE EFFICIENT CODE)#
  
  
      CONTROL FASTLOOP; 
  
  
      $BEGIN
      DB("(12H FGR00 FROM= ,O6,4H TO= ,O6)",K1,K2,"."); 
      $END
  
      FOR I = K1 STEP 1 UNTIL K2 DO 
          BEGIN 
          IF I LQ XREG7 
          THEN
              BEGIN          #B-REG OR X-REG# 
              T1 = RGMEM[I];
              IF T1 GQ 0               #REG IS NOT DEAD#
                  AND T1 LS ICFTW1     #ICFT POINTER AND NOT ENCOD. AD.#
              THEN
                  BEGIN 
                  IF I LQ BREG7 
                  THEN
                      BREGL[T1]=0;     #FORGET B-REG CONTAINING COMP   #
                  ELSE
                      BEGIN 
                      XREGL[T1]=0;     #FORGET X-REG CONTAINING COMP   #
                      RGMEM[I+XADOFS] = -1; 
                      END 
                  END 
              END 
          RGMEM[I] = -1;     #FORGET CONTENTS OF REG I# 
          END 
  
      CONTROL SLOWLOOP; 
  
      END 
CONTROL EJECT;
#        MAINTAIN REGISTER MEMORY HISTORY                              #
    PROC RMH00    ; 
         BEGIN    #      RMH00                                         #
         ITEM     I,
                  J,
                   KK,
                  PLABL ; 
         KK = -1 ;
         PLABL =  OPN1 [INX] ;      # S.T.P. TO LABEL                  #
         IF PLABL LE 0 THEN GOTO RMH35 ;
         IF CLAS [PLABL] NQ QCLAS"LABL" THEN GOTO RMH35 ; 
         IF FRGT [PLABL] THEN GOTO RMH35 ;
         I  =  0  ; 
         J  =  BRJ + 1  ; 
RMH20:  
         IF RHIST [I] LT 0 THEN 
                  BEGIN 
RMH22:  
                  RHIST [I]  = PLABL ;
         I  =  I + BRJ + 2  ; 
RMH23:  
                  RHIST [I]  =  RGMEM [J]  ;
                  I = I + 1 ; 
                  J = J + 1 ; 
                  IF J LT SUDOR THEN GOTO RMH23;
                  GOTO RMH35  ; 
                  END 
         IF  RHIST [I]  EQ PLABL  THEN
                  BEGIN 
         I  =  I + BRJ + 2 ;
RMH27:  
                  IF  RGMEM [J]  NE RHIST [I]  THEN 
           RHIST [I] =  -1  ; 
                  I = I + 1 ; 
                  J = J + 1 ; 
                  IF J LT SUDOR THEN GOTO RMH27;
                  GOTO  RMH35 ; 
                  END 
         IF RHIST [I] EQ 0  AND KK LT 0 THEN KK = I ; 
         I  =  I + RMESZ  ; 
         IF  I  LE  EORGM  THEN  GOTO  RMH20 ;
         IF KK GE 0 THEN   BEGIN
                   I = KK ;            #  EMPTY SLOT                   #
                   GOTO RMH22 ; 
                           END
         FRGT [PLABL] = TRUE ;
#        HISTORY TABLE IS FULL SO WE JUST QUIT REMEMBERING REG CONTENTS#
#        THIS WILL AT WORST FORCE SOME EXTRA LOADS                     #
RMH35:  
         END      #      RMH00                                         #
CONTROL EJECT;
#        RECORD INSTRUCTION WITH MINIMUM ISSUE TIME                    #
#        ONE FOR  15 BIT, ONE FOR 30 BIT INSTRUCTION                   #
PROC     RMI00    ; 
         BEGIN    #      RMI00                                         #
         ITEM     I  ;
$BEGIN
DB("( 9X17H RMI00      IJK  O2,2X,O2,2X,O2)",REGI,REGJ,REGK,"."); 
$END
         IF  CDROP  THEN
                  BEGIN 
                  I  =  2 ; 
            #SCHEDUABLE BY DESTORYING ONE OF ITS OPERANDS#               NEWFEAT
                       # BUT BE CAREFUL ABOUT X1 AND X2#                 NEWFEAT
          IF FREZA1 AND (REGJ EQ XREG1 OR REGK EQ XREG1) THEN            NEWFEAT
                          GOTO RMI30;                                    NEWFEAT
          IF FREZA2 AND (REGJ EQ XREG2 OR REGK EQ XREG2) THEN            NEWFEAT
                          GOTO RMI30;                                    NEWFEAT
                  IF MINSZ [2]  EQ 0  THEN  GOTO RMI20  ; 
                  GOTO  RMI30 ; 
                  END 
         IF  INSIZ  EQ  2  THEN  I =  1 ; 
                  ELSE  I = 0  ;
         IF  MINSZ [I]  LE  0  THEN  GOTO  RMI20 ;
          ITEM OOBCL ,  #OLD BEATS THE CLOCK# 
               NOBCL ;  # NEW BEATS THE CLOCK#
          OOBCL = MPFF[I] - CURSEQF;
          NOBCL = PRIOP - CURSEQF;
              #IF OLD BEATS THE CLOCK AND NEW DOESNT - KEEP NEW#
          IF OOBCL LS 0 AND NOBCL GQ 0 THEN GOTO RMI20; 
  
              #IF NEW BEATS THE CLOCK AND OLD DOESNT - KEEP OLD#
          IF OOBCL GQ 0 AND NOBCL LS 0 THEN GOTO RMI30; 
         IF MISUT [I] LT ISUT THEN GOTO RMI30 ; # KEEP OLD OP          #
         IF MISUT [I] GT ISUT THEN GOTO RMI20 ; #  TAPE NEW OP         #
#        ISSUE TIMES EQUAL ( TYPICALLY ZERO )                          #
         IF MPFF [I] GT PRIOP + 5  THEN GOTO RMI30 ; #  KEEP OLD OP    #
         IF MEXUT [I] LE EXUT THEN GOTO RMI30 ;  #  KEEP OLD OP        #
#                                                                      #
RMI20:  
         MINSZ [I]  = INSIZ  ;
         MRI   [I]  =  REGI   ; 
         MRJ   [I]  =  REGJ   ; 
         MRK   [I]  =  REGK   ; 
         MABSO [I]  =  ABSO   ; 
         MINXA [I]  =  INXA   ; 
         MINX  [I]  =  INX    ; 
         MISUT [I]  =  ISUT   ; 
         MEXUT [I]  =  EXUT   ; 
         MIETM [I]  = IETIM  ;
         MFUNU [I] = FUNU  ;        #   FUNCTIONAL UNIT                #
         MITYP  [I]  =  ITYPE  ;
         MKCON [I]  =  KACON  ; 
         MTOP1 [I]  =  TOP1  ;
         MTOP2 [I]  =  TOP2  ;
         MOPC  [I]  =  OPCOD   ;
         MFTIM [I]  =  FTIM   ; 
         MLSTYP [I] = LSTYP  ;
         MPFF  [I] = PRIOP  ; 
#                                                                      #
RMI30:  
         END      #      RMI00                                         #
CONTROL EJECT;
      PROC RPC00; 
      BEGIN 
#**********************************************************************#
#     RPC00 - REDUCE PREDECESSOR COUNT.                                #
#                                                                      #
#     PURPOSE-                                                         #
#        REDUCE THE PREDECESSOR COUNTS OF THE SUCCESSORS OF INX        #
#        INXA PRECEDES INX IN READY SET                                #
#        REMOVE INX FROM READY SET                                     #
#        INTRODUCE INTO THE READY SET ANY ICF OP WHICH BECOMES READY   #
#**********************************************************************#
  
  
$BEGIN
DB("( 9X17H RPC00      IJK  O2,2X,O2,2X,O2)",REGI,REGJ,REGK,"."); 
$END
  
      SUSP = STI[INX];       #POINTER TO START OF SUCCESSOR LIST# 
      FOL[INXA] = FOL[INX];  #REMOVE INX FROM READY SET#
  
#     SCAN ALL SUCCESSORS OF INX.  REDUCE PREDECESSOR COUNT BY ONE.  IF#
#     ANY BECOMES READY CALL RPC40 TO INSERT IT IN PRIORITY ORDER INTO #
#     THE READY SET.                                                   #
  
  
      FOR SUSP=SUSP WHILE SUSP GT 0 DO
          BEGIN 
      NEWR = ISUC[SUSP];     #ICFT INDEX OF NEXT SUCCESSOR# 
          NPRED[NEWR] = NPRED[NEWR] - 1;  #REDUCE PREDECESSOR COUNT#
          IF NPRED[NEWR] LQ 0 
          THEN
              RPC40;         #IF READY - PUT INTO READY SET#
      SUSP = LSUC[SUSP];     #LINK TO NEXT SUCCESSOR IN SUCCESSOR LIST #
          END 
         END      # RPC00  #
      CONTROL EJECT;
  
 #  BIAS PRIORIY CODE BY PREFERENCE TO
                                   OPPRI
          REPL                      2 
          RFO (REGISTER FREEING OP) 1 
          OTHERS (LOADS ETC)        0 
  
                                        # 
DEF CALCPFF(I) # (PFF[I] * (OPPRI[OPCD[I] ] +1 ) )#;
#        INSERT NEW READY ICFT OP   # 
#        NEWR IS READY  # 
    PROC RPC40    ; 
         BEGIN    #  RPC40  # 
$BEGIN
DB("( 9X17H RPC40 REDY IJK  O2,2X,O2,2X,O2)",REGI,REGJ,REGK,"."); 
DB("( 9X15H  NEW READY OP O4)",NEWR,"."); 
$END
         PREDA =  INXA  ; 
RPC41:  
         PREDB =  FOL [INXA] ;
         NPRED [NEWR] = 0 ; 
         XBREG [NEWR] = 0 ; 
         LIP  [NEWR] = FALSE ;
         LUSE  [NEWR]  =  FALSE  ;  #   NOT USED YET                   #
         TSYM  [NEWR] = 0  ;
         $BEGIN 
         NREDY =  NREDY + 1 ;       #   NUMBER READY                   #
         $END 
                                                                         LARRY-Y
         IF OPCD[NEWR] EQ QICFOP"EOS" THEN                               LARRY-Y
              BEGIN  #INSERT EOS#                                        LARRY-Y
              ASLONGAS PREDB GQ 0 DO
                   BEGIN  #SCAN READY SET#                               LARRY-Y
                   PREDA = PREDB;              #SCAN TO END OF REDY SET# LARRY-Y
                   PREDB = FOL[PREDB];                                   LARRY-Y
                   END  #SCAN READY SET#                                 LARRY-Y
              FOL[PREDA] = NEWR;               #AND INSERT EOS THERE   # LARRY-Y
      RETURN; 
              END  #INSERT EOS#                                          LARRY-Y
                                                                         LARRY-Y
  
#     SCAN READY SET (STARTING AT PREDB) LOOKING FOR ENTRY OF LOWER    #
#     PRIORITY THAN NEWR.  WHEN FOUND LINK NEWR INTO READY SET.        #
  
RPC42:  
        IF CALCPFF(NEWR) GE CALCPFF(PREDB)
        OR PREDB LT 0 THEN
RPC44:      #LABL TO ALLOW THE FORCING OF THE INSERTION OF A NEW READY #
                  BEGIN 
  
#     LINK PREVIOUS TOP OF READY SET CHAIN (AT PREDA) TO NEW ENTRY,    #
#     THUS MAKING IT THE TOP OF THE CHAIN.                             #
#     LINK NEW ENTRY TO ONE HAVING LOWER PRIORITY (AT PREDB).          #
  
         FOL [PREDA] = NEWR ; 
         FOL [NEWR]  = PREDB ;
      RETURN; 
                  END 
RPC45:  
         IF PREDB EQ FOL[PREDB] THEN           #WE HAVE REAL PROBLEMS  #
             BEGIN  #ERROR# 
             CG2ABT(J861,"CIRCULAR ENTRY IN READY SET(RPC40 IN CODGK3S) 
LINE XXXXX", 56); 
             PREDA = INXA;                     #RESET THE POINTERS     #
             PREDB = FOL[INXA];                #AND INSERT OP AT TOP   #
             GOTO RPC44;
             END  #ERROR# 
         PREDA  = PREDB  ;
         PREDB  = FOL [PREDA] ; 
         GOTO  RPC42 ;
         END      # RPC40 # 
CONTROL EJECT;
      PROC RRC00((OPTR)); 
      BEGIN 
#**********************************************************************#
#     RRC00 - REDUCE REFERENCE COUNT OF OPERAND.                       #
#                                                                      #
#     PURPOSE-                                                         #
#         REDUCE THE REFERENCE COUNT, REFCT, OF AN OPERAND AND FREE    #
#         THE REGISTER CONTAINING THE OPERAND IF REFCT BECOMES ZERO.   #
#                                                                      #
#     INPUT-                                                           #
#         OPTR - ICFT INDEX OF OPERAND.                                #
#         REGMEM ARRAY - THE REGISTER MEMORY ARRAY                     #
#         ICFT ARRAY - THE INSTRUCTION TABLE                           #
#                                                                      #
#     OUTPUT-                                                          #
#         NONE                                                         #
#**********************************************************************#
  
         ITEM     OPTR ;
  
  
      FOR J=J WHILE OPCD[OPTR] EQ QICFOP"NULL" DO 
          OPTR = BI - OPN1[OPTR];      #SKIP PAST NULLS#
  
      IF OPTR LT -1 
          OR OPTR GT ICFTW1 
      THEN
          BEGIN 
          CG2ABT(J862,"INVALID ICFT INDEX(RPC00 IN CODGK3S) LINE XXXXX",
                 47); 
          END 
  
         LIP  [OPTR]  =  FALSE  ;   #   LOAD NOT IN PROCESS HERE       #
         LUSE  [OPTR]  =  TRUE  ;   #   TRUE ON REFERENCE              #
         REFCT [OPTR ]  =  REFCT [OPTR] -1  ; 
         IF  REFCT [OPTR]  LE  0  THEN
                  BEGIN 
                  REFCT [OPTR] = 0 ;
  
#     IF WE JUST FREED UP A BPSB THAT WAS IN A B-REG WE MUST REDUCE THE#
#     COUNT OF THESE BEASTIES.                                         #
  
                  IF OPCD[OPTR] EQ QICFOP"BPSB" 
                      AND NOT SXREG[OPTR] 
                  THEN
                      BRK = BRK - 1;
                  TX  =  XREGL [OPTR]  ;
                  IF  TX  GT  0  THEN 
                      BEGIN 
                      RGMEM[TX] = -1; 
                      RGMEM[TX+XADOFS] = -1;
                      END 
                  TY  =  BREGL [OPTR] ; 
                  IF TY GT 0 AND TY GE BRJ
                  THEN
                      BEGIN 
                      RGMEM[TY] = -1; 
                      RGMEM[TY+BADOFS] = -1;
                      BREGL[OPTR] = 0;
                      END 
                  XREGL [OPTR] = 0  ; 
                  END 
  
      $BEGIN
      DB("(10X16HRRC00      IJK  3(O2,2X),6HOPTR= ,O6,8H REFCT= ,O6)",
          REGI,REGJ,REGK,OPTR,REFCT[OPTR],"."); 
      $END
  
         END      #  RRC00   #
CONTROL EJECT;
PROC SP00;
BEGIN 
#        THIS IS THE POST-PROCESSOR  - LOOK AT CODE GOING OUT          #
#                                                                      # LARRY-R
#           WE  NEED TO OUTPUT A  2-PARCEL  INSTRUCTION AND  ARE       # LARRY-R
#           SITUATED IN  THE  LAST PARCEL  OF  A  WORD   --            # LARRY-R
#                                                                      # LARRY-R
#           LOOK  AT  ISSUED  INSTRUCTIONS (BACKWARDS)  TO  SEE  IF    # LARRY-R
#           ANY  15-BIT  SET  INSTRUCTION  CAN  BE  EXPANDED  TO  A    # LARRY-R
#           30-BIT  SET  TO  SAVE  THE NOP.                            # LARRY-R
#                                                                      # LARRY-R
           ITEM  PARC ,     # PARCEL COUNT   #                           LARRY-R
                 LGN  ,     # INSTRUCTION POINTER #                      LARRY-R
                 PC   ;                                                  LARRY-R
           PARC = CLC - 1;                  #KEEP ACCURATE PARCEL COUNT# LCMISC 
           LGN  =  LGEN;    # LAST GENERATED INSTRUCTION #               LARRY-R
NEXT15:                                                                  LARRY-R
           IF CFOPEQ[MOP[LGN]]  NQ  0         # 15-BIT SET     #         LARRY-R
           AND NOT B<58,2>PARC EQ 3            #15 BIT INST IN BOTTOM  # LCMISC 
           AND  KDES[LGN]       EQ  0    THEN #  USES  B-ZERO  #         LARRY-R
             BEGIN                                                       LARRY-R
             MOP  [LGN] = CFOPEQ[MOP[LGN]] ;                             LARRY-R
             XFRMD[LGN] = TRUE;                                          LARRY-R
             CLC = CLC + 1 ;                                             LARRY-R
      $BEGIN
      DB("(10X,14HSP00,EXPANDED ,O4)",LGN,"."); 
      $END
             END                                                         LARRY-R
           ELSE                                                          LARRY-R
             BEGIN        # LOOK  FOR  PREVIOUS  INSTRUCTION       #     LARRY-R
             PC = PSOS ;       # START OF CODE CHAIN  #                  LARRY-R
      ASLONGAS LGN NQ FOL[PC] DO
          PC = FOL[PC]; 
             PARC  =  PARC - CFOPSIZ[MOP[LGN]]  ;                        LARRY-R
             IF LGN NQ  FOL[PSOS]  THEN # NOT FIRST INSTRUC    #         LARRY-R
               BEGIN                                                     LARRY-R
               LGN = PC ;                                                LARRY-R
               IF  NOT  CFOPEND[MOP[LGN]]                                LARRY-R
               AND NOT (B<58,2>PARC EQ 3       #30 BIT INST IN BOTTOM  # LCMISC 
                      AND CFOPSIZ[MOP[LGN]] EQ 2 )    THEN               LARRY-R
                 BEGIN                                                   LARRY-R
                 GOTO  NEXT15;                                           LARRY-R
                 END                                                     LARRY-R
               END                                                       LARRY-R
             END                                                         LARRY-R
END  #SP00# 
      CONTROL EJECT;
      $BEGIN
      PROC SRP00; 
      BEGIN 
      DRP[LGEN] = TRUE; 
      END 
      $END
      CONTROL EJECT;
      $BEGIN
  PROC SSDH00;  # SAVES SCHEDULER DEBUG HISTORY # 
   BEGIN
        IF OPCD[INX] NE QICFOP"LABL" THEN 
        BEGIN 
            DCLK[INX] = CLOCK;
            DISU[INX] = ISUT; 
            DEXT[INX] = EXUT; 
            DPR[INX] = PFF1[INX]; 
            DUSS[INX] = REFCT[INX]; 
            DNR[INX] = NREDY; 
            DNP[INX] = NSCN;
            DFC[INX] = FORCE; 
         DRP [INX] = FALSE  ; 
         TNREDY = TNREDY + NREDY  ; 
         TNSCAN = TNSCAN + NSCN  ;
        END 
        ELSE
        BEGIN # SAVE X-REGISTER CONTENTS AT LABEL                      #
            DX0[INX] = RGMEM[XREG0];
            DX1A[INX]=RGMEM[XREG0+1]; 
            DX2A[INX]=RGMEM[XREG0+2]; 
            DX3[INX] = RGMEM[XREG0+3];
            DX4[INX] = RGMEM[XREG0+4];
            DX5[INX] = RGMEM[XREG0+5];
            DX6[INX] = RGMEM[XREG0+6];
            DX7[INX] = RGMEM[XREG0+7];
        END 
      END 
      $END
      CONTROL EJECT;
      PROC SST00; 
      BEGIN 
#**********************************************************************#
#     SST00 - COMPUTE STATUS                                           #
#                                                                      #
#     PURPOSE-                                                         #
#         COMPUTE STATUS OF A SCHEDULABLE ICFT INSTRUCTION             #
#                                                                      #
#     INPUT-                                                           #
#         CLOCKBEATER-                                                 #
#         ISUT - ISSUE TIME OF CURRENT INSTRUCTION (TIME BEFORE INSTR  #
#                CAN BE ISSUED).                                       #
#         EXUT - EXECUTION TIME OF CURRENT INSTRUCTION (TIME BETWEEN   #
#                ISSUE AND EXECUTION.)                                 #
#                                                                      #
#     OUTPUT-                                                          #
#         INSTAT - 1 IF SCHEDULABLE ONLY (NOT ISSUABLE)                #
#                - 2 IF ISSUABLE ONLY (NOT EXECUTABLE)                 #
#                - 3 IF ISSUABLE AND EXECUTABLE                        #
#**********************************************************************#
  
  
      INSTAT = 1;            #ASSUME SCHEDULABLE ONLY#
      IF NOT CLOCKBEATER
          AND ISUT EQ 0      #AT LEAST ISSUABLE#
      THEN
          BEGIN 
          IF EXUT EQ 0
          THEN
              INSTAT = 3; 
          ELSE
              INSTAT = 2; 
          END 
  
      $BEGIN
      DB("(10X16HSST00      IJK  3(O2,2X),8HINSTAT= ,O1)",REGI,REGJ,
          REGK,INSTAT,"."); 
      $END
  
      END 
      END 
      TERM
