*PROCESS USING(NOMAP),NODXREF,NOMXREF ********************************************************************* * * UADN444: 128-BIT SUM OF TWO SIGNED/UNSIGNED 128-BIT INTEGERS * ********************************************************************* * * CALL: CALL UADN444(I,J,K) * * PARAMETER TYPE DESCRIPTION * * I 4-WORD INTEGER THE FIRST WORD OF A 4-WORD SIGNED * OR UNSIGNED INTEGER * * J 4-WORD INTEGER THE FIRST WORD OF A 4-WORD SIGNED * OR UNSIGNED INTEGER * * K 4-WORD INTEGER THE SUM OF THE 4-WORD INTEGERS AT I * AND J IS STORED IN 4 SUCCESSIVE * WORDS AT K. * * * SUMMARY: THIS ROUTINE COMPUTES THE SUM OF THE TWO 4-WORD * ARGUMENTS I AND J, AND STORES THE RESULT AT K. * NONE OF I, J, OR K NEED BE DISTINCT FROM ONE ANOTHER. ********************************************************************* UADN444 RSECT , UADN444 RMODE ANY UADN444 AMODE ANY USING UADN444,R15 SAVE (14,6),,* SAVE REGISTERS LM R1,R3,0(R1) GET ARGUMENT ADDRESSES LA R4,12 FORM WORD INDEX LA R5,4 FORM INCREMENT IN R5 LCR R5,R5 INDEX DOWNWARD BY -4 SR R6,R6 CLEAR CARRY BOX TO ZERO IADDA L R0,0(R4,R1) GET WORD FROM I AL R0,0(R4,R2) ADD WORD FROM J BC NC,IADDB BRANCH IF NO CARRY ALR R0,R6 ADD IN OLD CARRY (NO NEW ONE POSSIBLE) B IADDC AND MARK NEW CARRY IADDB ALR R0,R6 ADD IN OLD CARRY LA R6,0 ASSUME NO NEW ONE BC NC,IADDX BRANCH IF NO NEW CARRY IADDC LA R6,1 SET NEW CARRY BIT IADDX ST R0,0(R4,R3) STORE RESULT WORD AT K BXH R4,R5,IADDA COUNT DOWN AND LOOP RETURN (0,6) RESTORE REGISTERS AND EXIT NC EQU 12 R0 EQU 0 R1 EQU 1 R2 EQU 2 R3 EQU 3 R4 EQU 4 R5 EQU 5 R6 EQU 6 R15 EQU 15 END *PROCESS USING(NOMAP),NODXREF,NOMXREF ********************************************************************* * * USBN444: 128-BIT DIFFERENCE OF SIGNED/UNSIGNED 128-BIT INTS * ********************************************************************* * * CALL: CALL USBN444(I,J,K) * * PARAMETER TYPE DESCRIPTION * * I 4-WORD INTEGER THE FIRST WORD OF A 4-WORD SIGNED * OR UNSIGNED INTEGER * * J 4-WORD INTEGER THE FIRST WORD OF A 4-WORD SIGNED * OR UNSIGNED INTEGER * * K 4-WORD INTEGER THE DIFFERENCE OF THE 4-WORD * INTEGERS AT I AND J IS STORED AT K. * * * SUMMARY: THIS ROUTINE COMPUTES THE DIFFERENCE OF THE TWO 4-WORD * ARGUMENTS I AND J, AND STORES THE RESULT AT K. * NONE OF I, J, OR K NEED BE DISTINCT FROM ONE ANOTHER. * NO OVERFLOWS ARE DETECTED. ********************************************************************* USBN444 RSECT , USBN444 RMODE ANY USBN444 AMODE ANY USING USBN444,R15 SAVE (14,6),,* SAVE REGISTERS LM R1,R3,0(R1) GET ARGUMENT ADDRESSES LA R4,12 SET INITIAL WORD OFFSET LA R5,4 FORM INCREMENT IN R5 LCR R5,R5 INDEX DOWNWARD BY -4 SR R6,R6 CLEAR BORROW BOX TO ZERO ISUBA L R0,0(R4,R1) GET WORD FROM I SL R0,0(R4,R2) SUBTRACT WORD FROM J BC CY,ISUBB BRANCH IF A CARRY, NO BORROW SLR R0,R6 SUBTRACT OLD BORROW (NO NEW ONE POSSIBLE) B ISUBC AND MARK NEW BORROW ISUBB SLR R0,R6 PROPAGATE OLD BORROW LA R6,0 ASSUME NO NEW ONE BC CY,ISUBX BRANCH IF NO NEW BORROW ISUBC LA R6,1 SET NEW BORROW BIT ISUBX ST R0,0(R4,R3) STORE RESULT WORD AT K BXH R4,R5,ISUBA COUNT DOWN AND LOOP RETURN (0,6) RESTORE REGISTERS AND EXIT CY EQU 3 CARRY OR NO BORROW R0 EQU 0 R1 EQU 1 R2 EQU 2 R3 EQU 3 R4 EQU 4 R5 EQU 5 R6 EQU 6 R15 EQU 15 END *PROCESS USING(NOMAP),NODXREF,NOMXREF ********************************************************************* * * SMPY224: 128-BIT PRODUCT OF SIGNED 64-BIT INTEGERS * ********************************************************************* * * CALL: CALL SMPY224(I,J,K) * * PARAMETER TYPE DESCRIPTION * * I TWO-WORD THE FIRST WORD OF A 64-BIT SIGNED * INTEGER TWO'S COMPLEMENT INTEGER. * * J TWO-WORD THE FIRST WORD OF A 64-BIT SIGNED * INTEGER TWO'S COMPLEMENT INTEGER. * * K FOUR-WORD THE FOUR-WORD TWO'S COMPLEMENT * INTEGER INTEGER PRODUCT OF THE TWO TWO- * WORD ARGUMENTS IS STORED AT K. * * * SUMMARY: THIS ROUTINE COMPUTES THE FOUR-WORD SIGNED PRODUCT OF * TWO SIGNED TWO-WORD INTEGERS. ********************************************************************* SMPY224 RSECT , SMPY224 RMODE ANY SMPY224 AMODE ANY USING SMPY224,R15 SAVE (14,12),,* SAVE REGISTERS LA R12,1 CONSTANT 1 LM R9,R11,0(R1) GET ARGUMENT ADDRESSES LM R7,R8,0(R9) GET ARGUMENT I LM R9,R10,0(R10) GET ARGUMENT J SR R0,R0 CLEAR CORRECTOR LTR R3,R10 SET UP LOWEST-ORDER PRODUCT TERMS BNM SMPY224E BRANCH IF JLOW IS NON-NEGATIVE LR R0,R8 CORRECTOR IS ILOW SMPY224E LTR R8,R8 CHECK SIGN OF ILOW BNM SMPY224F BRANCH IF NON-NEGATIVE ALR R0,R10 OTHERWISE ADD JLOW TO CORRECTOR SMPY224F MR R2,R8 FORM PRODUCT ALR R2,R0 ADD CORRECTOR FOR SIGNS LTR R5,R10 SET UP JLOW*IHIGH MR R4,R7 FORM SIGNED PRODUCT BNM SMPY224G BRANCH IF JLOW IS NON-NEGATIVE LR R4,R7 CORRECT FOR APPARENT SIGN SMPY224G LR R0,R4 MOVE HIGH-ORDER PART TO RESULT AREA SRDA R0,32 PROPAGATE SIGN ALR R2,R5 ACCUMULATE THIRD-ORDER TERM BC NC,SMPY224A BRANCH IF NO CARRY ALR R1,R12 PROPAGATE CARRY INTO SECOND-ORDER TERM BC NC,SMPY224A BRANCH IF NO CARRY ALR R0,R12 ADD IN CARRY BIT SMPY224A LTR R5,R8 SET UP JHIGH*ILOW MR R4,R9 FORM SIGNED PRODUCT BNM SMPY224H BRANCH IF ILOW IS NON-NEGATIVE ALR R4,R9 CORRECT FOR APPARENT - SIGN OF ILOW SMPY224H LR R6,R5 MOVE THIRD-ORDER TERM SRDA R4,32 EXTEND HIGH-ORDER PART ALR R2,R6 ACCUMULATE THIRD-ORDER SUM BC NC,SMPY224B BRANCH IF NO CARRY ALR R5,R12 PROPAGATE CARRY TO SECOND-ORDER TERM BC NC,SMPY224B BRANCH IF NO FURTHER CARRY ALR R4,R12 PROPAGATE TO HIGH-ORDER TERM SMPY224B ALR R1,R5 ACCUMULATE SECOND-ORDER SUM BC NC,SMPY224C BRANCH IF NO CARRY ALR R0,R12 PROPAGATE CARRY BIT SMPY224C ALR R0,R4 ACCUMULATE HIGH-ORDER SUM MR R6,R9 FORM IHIGH*JHIGH ALR R1,R7 ACCUMULATE SECOND-ORDER SUM BC NC,SMPY224D BRANCH IF NO CARRY ALR R0,R12 PROPAGATE CARRY BIT SMPY224D ALR R0,R6 ADD LAST HIGH-ORDER TERM STM R0,R3,0(R11) STORE RESULT RETURN (0,12) RESTORE REGISTERS AND EXIT NC EQU 12 R0 EQU 0 R1 EQU 1 R2 EQU 2 R3 EQU 3 R4 EQU 4 R5 EQU 5 R6 EQU 6 R7 EQU 7 R8 EQU 8 R9 EQU 9 R10 EQU 10 R11 EQU 11 R12 EQU 12 R15 EQU 15 END *PROCESS USING(NOMAP),NODXREF,NOMXREF ********************************************************************* * * SNEG44: NEGATE 128-BIT INTEGERS * ********************************************************************* * * CALL: CALL SNEG44(I,J,M) * * PARAMETER TYPE DESCRIPTION * * I 4-WORD THE FIRST WORD OF A 4-WORD SIGNED * INTEGER INTEGER TO BE NEGATED * * J 4-WORD THE FIRST WORD OF A 4-WORD SIGNED * INTEGER INTEGER, THE NEGATED RESULT * * M FULLWORD STATUS INDICATOR: * INTEGER 0 NO OVERFLOW * +1 OVERFLOW (ARGUMENT = -2**127) * * * SUMMARY: THIS ROUTINE NEGATES I AND STORES THE RESULT IN J. THE * STATUS INDICATOR IS SET TO 1 IF THE RESULT OVERFLOWS. * I AND J NEED NOT BE DISTINCT FROM ONE ANOTHER. ********************************************************************* SNEG44 RSECT , SNEG44 RMODE ANY SNEG44 AMODE ANY SAVE (14,6),,* Save registers USING SNEG44,R15 LM R4,R6,0(R1) Get parameter addresses LM R0,R3,0(R4) Complement low-order words 3 and 4 LCR R0,R0 Complement each word LCR R1,R1 LCR R2,R2 LCR R3,R3 End with least significant BNZ FIX3 If nonzero, remove previous carries LTR R2,R2 BNZ FIX2 LTR R1,R1 BNZ FIX1 B DONE All words were zero FIX3 BCTR R2,0 FIX2 BCTR R1,0 FIX1 BCTR R0,0 DONE DC 0H'0' STM R0,R3,0(R5) Store result LA R0,1 Set possible return code CLC MAXNEG4,0(R5) Check operand BE *+6 Skip if it's the max neg number BCTR R0,0 ST R0,0(0,R6) Store overflow indicator RETURN (0,6) Return to caller DROP R15 MAXNEG4 DC A(X'80000000',0,0,0) * * General Purpose Registers * R0 EQU 0 R1 EQU 1 R2 EQU 2 R3 EQU 3 R4 EQU 4 R5 EQU 5 R6 EQU 6 R15 EQU 15 END *PROCESS USING(NOMAP),NODXREF,NOMXREF ********************************************************************* * * SABS44: ABSOLUTE VALUE OF 128-BIT INTEGERS * ********************************************************************* * * CALL: CALL SABS44(I,J,M) * * PARAMETER TYPE DESCRIPTION * * I 4-WORD THE FIRST WORD OF A 4-WORD SIGNED * INTEGER INTEGER * * J 4-WORD THE FIRST WORD OF A 4-WORD SIGNED * INTEGER INTEGER, THE RESULT * * M FULLWORD STATUS INDICATOR: * INTEGER 0 NO OVERFLOW * +1 OVERFLOW (ARGUMENT = -2**127) * * * SUMMARY: THIS ROUTINE STORES THE ABSOLUTE VALUE IF I AT J. THE * STATUS INDICATOR IS SET TO 1 IF THE RESULT OVERFLOWS. * I AND J NEED NOT BE DISTINCT FROM ONE ANOTHER. ********************************************************************* SABS44 RSECT , SABS44 RMODE ANY SABS44 AMODE ANY SAVE (14,6),,* Save registers USING SABS44,R15 LM R4,R6,0(R1) Get parameter addresses LM R0,R3,0(R4) Complement low-order words 3 and 4 SLDA R0,0 Check sign BNM DONE Store result if non-negative LCR R0,R0 Complement each word LCR R1,R1 LCR R2,R2 LCR R3,R3 End with least significant BNZ FIX3 If nonzero, remove previous carries LTR R2,R2 BNZ FIX2 LTR R1,R1 BNZ FIX1 B DONE All words were zero FIX3 BCTR R2,0 FIX2 BCTR R1,0 FIX1 BCTR R0,0 DONE DC 0H'0' STM R0,R3,0(R5) Store result LA R0,1 Set possible return code CLC MAXNEG4,0(R5) Check operand BE *+6 Skip if it's the max neg number BCTR R0,0 ST R0,0(0,R6) Store overflow indicator RETURN (0,6) Return to caller DROP R15 MAXNEG4 DC A(X'80000000',0,0,0) * * General Purpose Registers * R0 EQU 0 R1 EQU 1 R2 EQU 2 R3 EQU 3 R4 EQU 4 R5 EQU 5 R6 EQU 6 R15 EQU 15 END *PROCESS USING(NOMAP),NODXREF,NOMXREF ********************************************************************* * * SCMP44: COMPARE TWO SIGNED 128-BIT INTEGERS * ********************************************************************* * * CALL: CALL SCMP44(I,J,M) * * PARAMETER TYPE DESCRIPTION * * I 4-WORD INTEGER THE FIRST WORD OF A 4-WORD SIGNED * INTEGER * * J 4-WORD INTEGER THE FIRST WORD OF A 4-WORD SIGNED * INTEGER * * M 1-WORD INTEGER STATUS INDICATOR: M = SIGN(I-J) * 0 I = J * +1 I > J * -1 I < J * * * SUMMARY: THIS ROUTINE COMPARES I AND J, AND SETS THE STATUS * INDICATOR DEPENDING IN WHETHER I IS GREATER THAN, * EQUAL TO, OR LESS THAN J. * I AND J NEED NOT BE DISTINCT FROM ONE ANOTHER. * (BUT WHY WOULDN'T THEY BE?) ********************************************************************* SCMP44 RSECT , SCMP44 RMODE ANY SCMP44 AMODE ANY SAVE (14,3),,* Save registers USING SCMP44,R15 USING (Save,Save+72),R13 Save area used for work temps LM R1,R3,0(R1) Get parameter addresses LA R0,1 Set initial value of m * Move operands to temps; they may be read-only constants. MVC LTEMP,0(R1) Move n1 to temp storage MVC LTEMP2,0(R2) Move n2 to temp storage XI LTEMP,X'80' Invert sign bit for logical order XI LTEMP2,X'80' Invert sign bit for logical order CLC LTEMP,LTEMP2 Compare operands logically BH I8CMPA Branch if n1 > n2 BCTR R0,0 Prepare for equality case BE I8CMPA Branch if n1 = n2 BCTR R0,0 Set m = -1, n1 < n2 I8CMPA DS 0H ST R0,0(,R3) Store result indicator RETURN (2,3) Return to caller DROP R15 * Save DSect , Save Area Mapping DC 10F'0' Reserved: head; links; R14-R4 LTEMP DC 0D'0',XL16'0' Work area LTEMP2 DC XL16'0' Work area * * General Purpose Registers * R0 EQU 0 R1 EQU 1 R2 EQU 2 R3 EQU 3 R13 EQU 13 R15 EQU 15 END *PROCESS USING(NOMAP),NODXREF,NOMXREF ********************************************************************* * * UCMP44: COMPARE TWO UNSIGNED 128-BIT INTEGERS * ********************************************************************* * * CALL: CALL UCMP44(I,J,M) * * PARAMETER TYPE DESCRIPTION * * I 4-WORD INTEGER THE FIRST WORD OF A 4-WORD UNSIGNED * INTEGER * * J 4-WORD INTEGER THE FIRST WORD OF A 4-WORD UNSIGNED * INTEGER * * M 1-WORD INTEGER STATUS INDICATOR: M = SIGN(I-J) * 0 I = J * +1 I > J * -1 I < J * * * SUMMARY: THIS ROUTINE COMPARES I AND J, AND SETS THE STATUS * INDICATOR DEPENDING IN WHETHER I IS GREATER THAN, * EQUAL TO, OR LESS THAN J. * I AND J NEED NOT BE DISTINCT FROM ONE ANOTHER. * (BUT WHY WOULDN'T THEY BE?) ********************************************************************* UCMP44 RSECT , UCMP44 RMODE ANY UCMP44 AMODE ANY SAVE (14,3),,* Save registers USING UCMP44,R15 LM R1,R3,0(R1) Get parameter addresses LA R0,1 Set initial value of m CLC 0(16,R1),0(R2) Compare operands logically BH I8CMPA Branch if n1 > n2 BCTR R0,0 Prepare for equality case BE I8CMPA Branch if n1 = n2 BCTR R0,0 Set m = -1, n1 < n2 I8CMPA DS 0H ST R0,0(,R3) Store result indicator RETURN (2,3) Return to caller DROP R15 * * General Purpose Registers * R0 EQU 0 R1 EQU 1 R2 EQU 2 R3 EQU 3 R15 EQU 15 END *PROCESS USING(NOMAP),NODXREF,NOMXREF ********************************************************************* * * UMPY144: 128-BIT PRODUCT OF UNSIGNED 32- AND 128-BIT INTEGERS * ********************************************************************* * * CALL: CALL UMPY144(I,J,K,M) * * PARAMETER TYPE DESCRIPTION * * I FULLWORD UNSIGNED 32-BIT INTEGER * INTEGER * * J FOUR-WORD THE FIRST WORD OF AN UNSIGNED * INTEGER 128-BIT INTEGER * * K FOUR-WORD THE 128-BIT UNSIGNED PRODUCT OF * INTEGER I AND J IS STORED AT K. * * M FULLWORD 32-BIT UNSIGNED INTEGER, * INTEGER NONZERO M INDICATES OVERFLOW * (M IS IN FACT THE HIGH-ORDER 32 * BITS OF THE 160-BIT PRODUCT) * * * SUMMARY: THIS ROUTINE COMPUTES THE UNSIGNED 128-BIT PRODUCT * OF THE UNSIGNED 32-BIT ARGUMENT I AND THE UNSIGNED * 128-BIT ARGUMENT J. M INDICATES OVERFLOW CONDITIONS. ********************************************************************* UMPY144 RSECT , UMPY144 RMODE ANY UMPY144 AMODE ANY USING UMPY144,R15 SAVE (14,10),,* SAVE REGISTERS LM R4,R7,0(R1) GET ARG POINTERS LA R10,1 CONSTANT 1 IN R10 L R3,12(0,R5) GET J4 IN R3 LM R8,R9,=A(12,-4) INDEXING CONSTANTS IN R8,R9 SR R2,R2 CLEAR CARRY BOX ICM R4,15,0(R4) GET I BM NEG_I BRANCH IF I IS APPARENTLY NEGATIVE * (R0,R1): working products * R2: HO term of previous product, adds to LO term of next * R3: element of J POS_I DC 0H'0' L R3,0(R8,R5) GET ELEMENT OF J LTR R1,R3 SIGN(JN), COPY TO R1 MR R0,R4 I*JN BNM *+6 ALR R0,R4 CORRECT FOR NEGATIVE JN BY ADDING I ALR R1,R2 ADD CARRIES FROM PREVIOUS TERM ST R1,0(R8,R6) STORE KN BC NCY,*+6 ALR R0,R10 ADD THE CARRY BIT LR R2,R0 HOLD PARTIAL PRODUCT TERM IN R2 BXH R8,R9,POS_I AND LOOP B FINISH AND EXIT * NEG_I DC 0H'0' APPARENTLY NEGATIVE I L R3,0(R8,R5) JN LTR R1,R3 SIGN(JN), COPY TO R1 MR R0,R4 I*JN BNM *+6 ALR R0,R4 CORRECT FOR SIGN OF JN BY ADDING I ALR R0,R3 CORRECT FOR SIGN OF I BY ADDING JN ALR R1,R2 ACCUMULATE PARTIAL PRODUCT ST R1,0(R8,R6) STORE KN BC NCY,*+6 BRANCH IF NO CARRY ALR R0,R10 ADD CARRY, PARTIAL TERM IN R0 LR R2,R0 HOLD PARTIAL TERM IN R2 BXH R8,R9,NEG_I AND LOOP * FINISH ST R0,0(0,R7) STORE HI-ORDER OVERFLOW AS M * RETURN (0,10) RETURN * NCY EQU 12 R0 EQU 0 R1 EQU 1 R2 EQU 2 R3 EQU 3 R4 EQU 4 R5 EQU 5 R6 EQU 6 R7 EQU 7 R8 EQU 8 R9 EQU 9 R10 EQU 10 R15 EQU 15 END