Removed compiler "intrinsics" which can now be found in the Builtins module

git-svn-id: https://svn.inf.ethz.ch/svn/lecturers/a2/trunk@8047 8c9fc860-2736-0410-a75d-ab315db34111

source/FoxIntermediateBackend.Mod

@@ -14010,10 +14010,7 @@ TYPE
 			noRuntimeChecks := options.GetFlag("noRuntimeChecks");
 			noAsserts := options.GetFlag("noAsserts");
 			cooperative := options.GetFlag("cooperative");
-			IF options.GetFlag("newObjectFile") THEN newObjectFile := TRUE; 
-				IF cooperative THEN 
-					SetBuiltinsModuleName("CPU") END
-				END;
+			newObjectFile := options.GetFlag("newObjectFile");
 			IF options.GetString("objectFile",string) & (string = "Minos") THEN 
 				simpleMetaData := TRUE
 			END;

source/I386.CPU.Mod

@@ -236,391 +236,4 @@ BEGIN {UNCOOPERATIVE, UNCHECKED}
 	END;
 END Initialize;
 
-(* compiler intrinsic *)
-PROCEDURE DivHA(l,r: HUGEINT): HUGEINT;
-CODE{SYSTEM.i386}
-	PUSH	ECX
-	; taken from "Software Optimization Guide for AMD64 Processors"
-	; divides two signed 64-bit numbers and delivers the quotient
-	;
-	; In: [EBP+l+4]:[EBP+l+0] = dividend (l)
-	; [EBP+r+4]:[EBP+r+0] = divisor (r)
-	; Out: EDX:EAX = quotient of division
-	MOV EDX, [EBP+l+4] 	    ; dividend_hi
-	MOV EAX, [EBP+l+0] 		; dividend_lo
-	MOV ECX, [EBP+r+4] 	    ; divisor_hi
-	MOV EBX, [EBP+r+0] 	    ; divisor_lo
-	MOV ESI, ECX 			; divisor_hi
-	XOR ESI, EDX 			; divisor_hi ^ dividend_hi
-	SAR ESI, 31 				; (quotient < 0) ? -1 : 0
-	MOV EDI, EDX 			; dividend_hi
-	SAR EDI, 31 				; (dividend < 0) ? -1 : 0
-	XOR EAX, EDI 			; If (dividend < 0),
-	XOR EDX, EDI 			; compute 1's complement of dividend.
-	SUB EAX, EDI 			; If (dividend < 0),
-	SBB EDX, EDI 			; compute 2's complement of dividend.
-	MOV EDI, ECX 			; divisor_hi
-	SAR EDI, 31 				; (divisor < 0) ? -1 : 0
-	XOR EBX, EDI 			; If (divisor < 0),
-	XOR ECX, EDI 			; compute 1's complement of divisor.
-	SUB EBX, EDI 			; If (divisor < 0),
-	SBB ECX, EDI 			; compute 2's complement of divisor.
-	JNZ BIGDIVISOR 			; divisor > 2^32 - 1
-	CMP EDX, EBX 			; Only one division needed (ECX = 0)?
-	JAE TWODIVS 			; Need two divisions.
-	DIV EBX 				; EAX = quotient_lo
-	MOV EDX, ECX 			; EDX = quotient_hi = 0 (quotient in EDX:EAX)
-	XOR EAX, ESI 			; If (quotient < 0),
-	XOR EDX, ESI 			; compute 1's complement of result.
-	SUB EAX, ESI 			; If (quotient < 0),
-	SBB EDX, ESI 			; compute 2's complement of result.
-	JMP DONE
-	TWODIVS:
-	MOV ECX, EAX 			; Save dividend_lo in ECX.
-	MOV EAX, EDX 			; Get dividend_hi.
-	XOR EDX, EDX 			; Zero-extend it into EDX:EAX.
-	DIV EBX 				; QUOtient_hi in EAX
-	XCHG EAX, ECX 			; ECX = quotient_hi, EAX = dividend_lo
-	DIV EBX 				; EAX = quotient_lo
-	MOV EDX, ECX 			; EDX = quotient_hi (quotient in EDX:EAX)
-	JMP MAKESIGN 		; Make quotient signed.
-	BIGDIVISOR:
-	SUB ESP, 12 			; Create three local variables.
-	MOV [ESP], EAX 		; dividend_lo
-	MOV [ESP+4], EBX 		; divisor_lo
-	MOV [ESP+8], EDX 		; dividend_hi
-	MOV EDI, ECX 			; Save divisor_hi.
-	SHR EDX, 1 				; Shift both
-	RCR EAX, 1 				; divisor and
-	ROR EDI, 1 				; and dividend
-	RCR EBX, 1 				; right by 1 bit.
-	BSR ECX, ECX 			; ECX = number of remaining shifts
-	SHRD EBX, EDI, CL 		; Scale down divisor and
-	SHRD EAX, EDX, CL 		; dividend such that divisor is
-	SHR EDX, CL 				; less than 2^32 (that is, fits in EBX).
-	ROL EDI, 1 				; Restore original divisor_hi.
-	DIV EBX 				; COMpute quotient.
-	MOV EBX, [ESP] 		; dividend_lo
-	MOV ECX, EAX 			; Save quotient.
-	IMUL EDI, EAX 			; quotient * divisor high word (low only)
-	MUL DWORD [ESP+4] ; quotient * divisor low word
-	ADD EDX, EDI 			; EDX:EAX = quotient * divisor
-	SUB EBX, EAX 			; dividend_lo - (quot.*divisor)_lo
-	MOV EAX, ECX 			; Get quotient.
-	MOV ECX, [ESP+8] 		; dividend_hi
-	SBB ECX, EDX 			; Subtract (divisor * quot.) from dividend
-	SBB EAX, 0 				; Adjust quotient if remainder is negative.
-	XOR EDX, EDX 			; Clear high word of quotient.
-	ADD ESP, 12 			; Remove local variables.
-	MAKESIGN:
-	XOR EAX, ESI 			; If (quotient < 0),
-	XOR EDX, ESI 			; compute 1's complement of result.
-	SUB EAX, ESI 			; If (quotient < 0),
-	SBB EDX, ESI 			; compute 2's complement of result.
-	DONE:
-	POP	ECX
-END DivHA;
-
-PROCEDURE DivH*(l,r: HUGEINT): HUGEINT;
-VAR result: HUGEINT;
-BEGIN {UNCOOPERATIVE, UNCHECKED}
-	IF l > 0 THEN RETURN DivHA(l,r)
-	ELSIF l< 0 THEN
-		result :=  -DivHA(-l,r);
-		IF result * r # l THEN DEC(result) END; (* mathematical definition of DIV and MOD, to be optimized in DivHA *)
-		RETURN result
-	ELSE RETURN 0
-	END;
-END DivH;
-
-PROCEDURE MulH*(l,r: HUGEINT): HUGEINT;
-CODE{SYSTEM.i386}
-	PUSH	ECX
-	; taken from "Software Optimization Guide for AMD64 Processors"
-	; computes the low-order half of the product of its
-	; arguments, two 64-bit integers.
-	;
-	; In: [EBP+l+4]:[EBP+l+0] = multiplicand (l)
-	; [EBP+r+4]:[EBP+r+0] = multiplier (r)
-	; Out: EDX:EAX = (multiplicand * multiplier) % 2^64
-	; Destroys: EAX, ECX, EDX, EFlags
-	MOV EDX, [EBP+l+4] 		; multiplicand_hi
-	MOV ECX, [EBP+r+4] 		; multiplier_hi
-	OR EDX,ECX 				; One operand >= 2^32?
-	MOV EDX, [EBP+l+0] 		; multiplier_lo
-	MOV EAX, [EBP+r+0] 		; multiplicand_lo
-	JNZ twomul 				; Yes, need two multiplies.
-	MUL EDX 					; multiplicand_lo * multiplier_lo
-	JMP done 					; Done, return to caller.
-	twomul:
-	IMUL EDX, [EBP+l+4]		; p3_lo = multiplicand_hi * multiplier_lo
-	IMUL ECX,EAX 			; p2_lo = multiplier_hi * multiplicand_lo
-	ADD ECX, EDX 			; p2_lo + p3_lo
-	MUL DWORD [EBP+r+0] 	; p1 = multiplicand_lo * multiplier_lo
-	ADD EDX,ECX 			; p1 + p2_lo + p3_lo = result in EDX:EAX
-	done:
-	POP	ECX
-END MulH;
-
-PROCEDURE ModHA(l,r: HUGEINT): HUGEINT;
-CODE{SYSTEM.i386}
-	PUSH	ECX
-	; taken from "Software Optimization Guide for AMD64 Processors"
-	; DIVIDES TWO SIGNED 64-BIT NUMBERS AND RETURNS THE REMAINDER.
-	;
-	; IN: [EBP+l+4]:[EBP+l+0] = DIVIDEND (l)
-	; [EBP+r+4]:[EBP+r+0] = DIVISOR (r)
-	;
-	; OUT: EDX:EAX = REMAINDER OF DIVISION
-	;
-	; DESTROYS: EAX, ECX, EDX, EFLAGS
-	MOV EDX, [EBP+l+4]           	; DIVIDEND-HI
-	MOV EAX, [EBP+l+0]            	; DIVIDEND-LO
-	MOV ECX, [EBP+r+4]           	; DIVISOR-HI
-	MOV EBX, [EBP+r+0]           	; DIVISOR-LO
-	MOV ESI, EDX	                	; SIGN(REMAINDER) == SIGN(DIVIDEND)
-	SAR ESI, 31 		               	; (REMAINDER < 0) ? -1 : 0
-	MOV EDI, EDX	                	; DIVIDEND-HI
-	SAR EDI, 31 	                	; (DIVIDEND < 0) ? -1 : 0
-	XOR EAX, EDI	                	; IF (DIVIDEND < 0),
-	XOR EDX, EDI	                	; COMPUTE 1'S COMPLEMENT OF DIVIDEND.
-	SUB EAX, EDI	                	; IF (DIVIDEND < 0),
-	SBB EDX, EDI	                	; COMPUTE 2'S COMPLEMENT OF DIVIDEND.
-	MOV EDI, ECX	                	; DIVISOR-HI
-	SAR EDI, 31 	                	; (DIVISOR < 0) ? -1 : 0
-	XOR EBX, EDI	                	; IF (DIVISOR < 0),
-	XOR ECX, EDI	                	; COMPUTE 1'S COMPLEMENT OF DIVISOR.
-	SUB EBX, EDI	                	; IF (DIVISOR < 0),
-	SBB ECX, EDI	                	; COMPUTE 2'S COMPLEMENT OF DIVISOR.
-	JNZ SRBIGDIVISOR          	; DIVISOR > 2^32 - 1
-	CMP EDX, EBX				; ONLY ONE DIVISION NEEDED (ECX = 0)?
-	JAE SRTWODIVS             		; NO, NEED TWO DIVISIONS.
-	DIV EBX      		               	; EAX = QUOTIENT_LO
-	MOV EAX, EDX                	; EAX = REMAINDER_LO
-	MOV EDX, ECX                	; EDX = REMAINDER_LO = 0
-	XOR EAX, ESI                		; IF (REMAINDER < 0),
-	XOR EDX, ESI                		; COMPUTE 1'S COMPLEMENT OF RESULT.
-	SUB EAX, ESI                		; IF (REMAINDER < 0),
-	SBB EDX, ESI                		; COMPUTE 2'S COMPLEMENT OF RESULT.
-	JMP done                 			; DONE, RETURN TO CALLER.
-	SRTWODIVS:
-	MOV ECX, EAX                	; SAVE DIVIDEND_LO IN ECX.
-	MOV EAX, EDX                	; GET DIVIDEND_HI.
-	XOR EDX, EDX                	; ZERO-EXTEND IT INTO EDX:EAX.
-	DIV EBX                     		; EAX = QUOTIENT_HI, EDX = INTERMEDIATE REMAINDER
-	MOV EAX, ECX                	; EAX = DIVIDEND_LO
-	DIV EBX                     		; EAX = QUOTIENT_LO
-	MOV EAX, EDX                	; REMAINDER_LO
-	XOR EDX, EDX                	; REMAINDER_HI = 0
-	JMP SRMAKESIGN 			;MAKE REMAINDER SIGNED.
-	SRBIGDIVISOR:
-	SUB ESP, 16 			 	;CREATE THREE LOCAL VARIABLES.
-	MOV [ESP], EAX 			; DIVIDEND_LO
-	MOV [ESP+4], EBX 			; DIVISOR_LO
-	MOV [ESP+8], EDX 			; DIVIDEND_HI
-	MOV [ESP+12], ECX 			; DIVISOR_HI
-	MOV EDI, ECX 				; SAVE DIVISOR_HI.
-	SHR EDX, 1 					; SHIFT BOTH
-	RCR EAX, 1 					; DIVISOR AND
-	ROR EDI, 1 					; AND DIVIDEND
-	RCR EBX, 1 					; RIGHT BY 1 BIT.
-	BSR ECX, ECX 				; ECX = NUMBER OF REMAINING SHIFTS
-	SHRD EBX, EDI, CL 			; SCALE DOWN DIVISOR AND
-	SHRD EAX, EDX, CL 			; DIVIDEND SUCH THAT DIVISOR IS
-	SHR EDX, CL 				; LESS THAN 2^32 (THAT IS, FITS IN EBX).
-	ROL EDI, 1 					; RESTORE ORIGINAL DIVISOR_HI.
-	DIV EBX 					; COMPUTE QUOTIENT.
-	MOV EBX, [ESP] 			; DIVIDEND_LO
-	MOV ECX, EAX 				; SAVE QUOTIENT.
-	IMUL EDI, EAX 				; QUOTIENT * DIVISOR HIGH WORD (LOW ONLY)
-	MUL DWORD [ESP+4] 		; QUOTIENT * DIVISOR LOW WORD
-	ADD EDX, EDI 				; EDX:EAX = QUOTIENT * DIVISOR
-	SUB EBX, EAX 				; DIVIDEND_LO - (QUOT.*DIVISOR)_LO
-	MOV ECX, [ESP+8] 			; DIVIDEND_HI
-	SBB ECX, EDX 				; SUBTRACT DIVISOR * QUOT. FROM DIVIDEND.
-	SBB EAX, EAX 				; REMAINDER < 0 ? 0XFFFFFFFF : 0
-	MOV EDX, [ESP+12] 		; DIVISOR_HI
-	AND EDX, EAX 				; REMAINDER < 0 ? DIVISOR_HI : 0
-	AND EAX, [ESP+4] 			; REMAINDER < 0 ? DIVISOR_LO : 0
-	ADD EAX, EBX 				; REMAINDER_LO
-	ADD EDX, ECX 				; REMAINDER_HI
-	ADD ESP, 16 				; REMOVE LOCAL VARIABLES.
-	SRMAKESIGN:
-	XOR EAX, ESI 				; IF (REMAINDER < 0),
-	XOR EDX, ESI 				; COMPUTE 1'S COMPLEMENT OF RESULT.
-	SUB EAX, ESI 				; IF (REMAINDER < 0),
-	SBB EDX, ESI 				; COMPUTE 2'S COMPLEMENT OF RESULT.
-	done:
-	POP	ECX
-END ModHA;
-
-PROCEDURE ModH*(l,r: HUGEINT): HUGEINT;
-VAR res: HUGEINT;
-BEGIN {UNCOOPERATIVE, UNCHECKED}
-	res := ModHA(l,r);
-	IF res < 0 THEN INC(res,r) END;
-	RETURN res
-END ModH;
-
-PROCEDURE AbsH*(l: HUGEINT): HUGEINT;
-BEGIN {UNCOOPERATIVE, UNCHECKED}
-	IF l< 0 THEN RETURN -l ELSE RETURN l END;
-END AbsH;
-
-PROCEDURE AslH*(l: HUGEINT; r: LONGINT): HUGEINT; (*! coincides with Logic Shift, remove ? *)
-BEGIN {UNCOOPERATIVE, UNCHECKED}
-	RETURN LslH(l,r)
-END AslH;
-
-PROCEDURE LslH*(l: HUGEINT; r: LONGINT): HUGEINT;
-CODE{SYSTEM.i386}
-	PUSH	ECX
-	; taken from "Software Optimization Guide for AMD64 Processors"
-	MOV ECX,[EBP+r+0]
-	MOV EAX,[EBP+l+0]
-	MOV EDX,[EBP+l+4]
-	; Shift EDX:EAX left, shift count in ECX (count
-	; applied modulo 64).
-	SHLD EDX,EAX,CL		; First apply shift count.
-	SHL EAX,CL 			; mod 32 to EDX:EAX
-	TEST ECX,32 			; Need to shift by another 32?
-	JZ lshiftdone 			; No, done.
-	MOV EDX,EAX			; Left shift EDX:EAX
-	XOR EAX,EAX 			; by 32 bits
-	lshiftdone:
-	POP	ECX
-END LslH;
-
-PROCEDURE AsrH*(l: HUGEINT; r: LONGINT): HUGEINT;
-CODE{SYSTEM.i386}
-	PUSH	ECX
-	; taken from "Software Optimization Guide for AMD64 Processors"
-	MOV ECX,[EBP+r+0]
-	MOV EAX,[EBP+l+0]
-	MOV EDX,[EBP+l+4]
-	; Shift EDX:EAX right, shift count in ECX (count
-	; applied modulo 64).
-	SHRD EAX,EDX,CL		; First apply shift count.
-	SAR EDX,CL 			; mod 32 to EDX:EAX
-	TEST ECX,32 			; Need to shift by another 32?
-	JZ rshiftdone 			; No, done.
-	MOV EAX,EDX			; Left shift EDX:EAX
-	SAR EDX,31 			; by 32 bits (fill EDX with sign bits)
-	rshiftdone:
-	POP	ECX
-END AsrH;
-
-PROCEDURE LsrH*(l: HUGEINT; r: LONGINT): HUGEINT;
-CODE{SYSTEM.i386}
-	PUSH	ECX
-	; taken from "Software Optimization Guide for AMD64 Processors"
-	MOV ECX,[EBP+r+0]
-	MOV EAX,[EBP+l+0]
-	MOV EDX,[EBP+l+4]
-	; Shift EDX:EAX right, shift count in ECX (count
-	; applied modulo 64).
-	SHRD EAX,EDX,CL		; First apply shift count.
-	SHR EDX,CL 			; mod 32 to EDX:EAX
-	TEST ECX,32 			; Need to shift by another 32?
-	JZ rshiftdone 			; No, done.
-	MOV EAX,EDX			; Left shift EDX:EAX
-	XOR EDX,EDX 			; by 32 bits (clear EDX)
-	rshiftdone:
-	POP	ECX
-END LsrH;
-
-PROCEDURE RorH*(l: HUGEINT; r: LONGINT): HUGEINT;
-CODE{SYSTEM.i386}
-	PUSH	ECX
-	; taken from "Software Optimization Guide for AMD64 Processors"
-	MOV ECX,[EBP+r+0]
-	MOV EAX,[EBP+l+0]
-	MOV EDX,[EBP+l+4]
-	; EBX (initially=EAX) -> EDX -> EAX
-	; Shift EDX:EAX right, shift count in ECX (count
-	; applied modulo 64).
-	MOV EBX,EAX
-	SHRD EAX,EDX,CL		; First apply shift count.
-	SHRD EDX,EBX,CL 		; mod 32 to EDX:EAX
-	TEST ECX,32 			; Need to shift by another 32?
-	JZ rshiftdone 			; No, done.
-	MOV EBX,EAX
-	SHRD EAX,EDX,CL
-	SHRD EDX,EBX,CL
-	rshiftdone:
-	POP	ECX
-END RorH;
-
-PROCEDURE RolH*(l: HUGEINT; r: LONGINT): HUGEINT;
-CODE{SYSTEM.i386}
-	PUSH	ECX
-	; taken from "Software Optimization Guide for AMD64 Processors"
-	MOV ECX,[EBP+r+0]
-	MOV EAX,[EBP+l+0]
-	MOV EDX,[EBP+l+4]
-	; EDX <- EAX <- EBX (intially=EDX)
-	; Shift EDX:EAX left, shift count in ECX (count
-	; applied modulo 64).
-	MOV EBX,EDX
-	SHLD EDX,EAX,CL		; First apply shift count.
-	SHLD EAX, EBX, CL
-	TEST ECX,32 			; Need to shift by another 32?
-	JZ lshiftdone 			; No, done.
-	MOV EBX,EDX
-	SHLD EDX,EAX,CL
-	SHLD EAX, EBX, CL
-	lshiftdone:
-	POP	ECX
-END RolH;
-
-PROCEDURE CasH*(VAR value: HUGEINT; old, new: HUGEINT): HUGEINT;
-CODE{SYSTEM.Pentium}
-	PUSH	ECX
-	MOV	EAX, [EBP + old + 0]
-	MOV	EDX, [EBP + old + 4]
-	MOV	EBX, [EBP + new + 0]
-	MOV	ECX, [EBP + new + 4]
-	MOV	EDI, [EBP + value]
-	LOCK CMPXCHG8B [EDI]
-	POP	ECX
-END CasH;
-
-PROCEDURE EntierXH*(x: LONGREAL): HUGEINT;
-CODE
-	FLD	QWORD [EBP+x]
-	SUB	ESP, 12
-	FNSTCW	[ESP]
-	FWAIT
-	MOV	ESI, [ESP]
-	AND	ESI, 0000F3FFH
-	OR	ESI, 00000400H
-	MOV	[ESP+4], ESI
-	FLDCW	[ESP+4]
-	FISTP	QWORD [ESP+4]
-	FWAIT
-	FLDCW	[ESP]
-	POP	EDI
-	POP	EAX
-	POP	EDX
-END EntierXH;
-
-PROCEDURE EntierRH*(x: REAL): HUGEINT;
-CODE
-	FLD DWORD [EBP+x]
-	SUB	ESP, 12
-	FNSTCW	[ESP]
-	FWAIT
-	MOV	ESI, [ESP]
-	AND	ESI, 0000F3FFH
-	OR	ESI, 00000400H
-	MOV	[ESP+4], ESI
-	FLDCW	[ESP+4]
-	FISTP	QWORD [ESP+4]
-	FWAIT
-	FLDCW	[ESP]
-	POP	EDI
-	POP	EAX
-	POP	EDX
-END EntierRH;
-
-END CPU.
+END CPU.

source/RPI.CPU.Mod

@@ -358,220 +358,4 @@ handle:
 	d32	HandleInterrupt
 END IRQHandler;
 
-(* compiler intrinsics *)
-TYPE ULONGINT = LONGINT; (* alias to make distinction between signed and unsigned more clear *)
-TYPE UHUGEINT = HUGEINT;
-
-PROCEDURE DivS8*(left, right: SHORTINT): SHORTINT;
-VAR result, dummy: LONGINT;
-BEGIN {UNCOOPERATIVE, UNCHECKED} DivModS32(left, right, result, dummy); RETURN SHORTINT(result)
-END DivS8;
-
-PROCEDURE DivS16*(left, right: INTEGER): INTEGER;
-VAR result, dummy: LONGINT;
-BEGIN {UNCOOPERATIVE, UNCHECKED} DivModS32(left, right, result, dummy); RETURN INTEGER(result)
-END DivS16;
-
-PROCEDURE DivS32*(left, right: LONGINT): LONGINT;
-VAR result, dummy: LONGINT;
-BEGIN {UNCOOPERATIVE, UNCHECKED} DivModS32(left, right, result, dummy); RETURN result
-END DivS32;
-
-PROCEDURE DivU32*(left, right: ULONGINT): ULONGINT;
-VAR result, dummy: LONGINT;
-BEGIN {UNCOOPERATIVE, UNCHECKED} DivModU32(left, right, result, dummy); RETURN result
-END DivU32;
-
-PROCEDURE DivS64*(left, right: HUGEINT): HUGEINT;
-VAR result, dummy: HUGEINT;
-BEGIN {UNCOOPERATIVE, UNCHECKED} DivModS64(left, right, result, dummy); RETURN result
-END DivS64;
-
-PROCEDURE ModS8*(left, right: SHORTINT): SHORTINT;
-VAR result, dummy: LONGINT;
-BEGIN {UNCOOPERATIVE, UNCHECKED} DivModS32(left, right, dummy, result); RETURN SHORTINT(result)
-END ModS8;
-
-PROCEDURE ModS16*(left, right: INTEGER): INTEGER;
-VAR result, dummy: LONGINT;
-BEGIN {UNCOOPERATIVE, UNCHECKED} DivModS32(left, right, dummy, result); RETURN INTEGER(result)
-END ModS16;
-
-PROCEDURE ModS32*(left, right: LONGINT): LONGINT;
-VAR result, dummy: LONGINT;
-BEGIN {UNCOOPERATIVE, UNCHECKED} DivModS32(left, right, dummy, result); RETURN result
-END ModS32;
-
-PROCEDURE ModU32*(left, right: ULONGINT): ULONGINT;
-VAR result, dummy: LONGINT;
-BEGIN {UNCOOPERATIVE, UNCHECKED} DivModU32(left, right, dummy, result); RETURN result
-END ModU32;
-
-PROCEDURE ModS64*(left, right: HUGEINT): HUGEINT;
-VAR result, dummy: HUGEINT;
-BEGIN {UNCOOPERATIVE, UNCHECKED}
-	DivModS64(left, right, dummy, result); RETURN result
-END ModS64;
-
-(* signed division and modulus
-- note: this implements the mathematical definition of DIV and MOD in contrast to the symmetric one
-*)
-PROCEDURE DivModS32(dividend, divisor: LONGINT; VAR quotient, remainder: LONGINT);
-BEGIN {UNCOOPERATIVE, UNCHECKED}
-	ASSERT(divisor > 0);
-	IF dividend >= 0 THEN
-		DivModU32(dividend, divisor, quotient, remainder)
-	ELSE
-		dividend := -dividend;
-		DivModU32(dividend, divisor, quotient, remainder);
-		quotient := -quotient;
-		IF remainder # 0 THEN
-			DEC(quotient);
-			remainder := divisor - remainder
-		END
-	END
-END DivModS32;
-
-(*
-	Fast 32-bit unsigned integer division/modulo (author Alexey Morozov)
-*)
-PROCEDURE DivModU32(dividend, divisor: ULONGINT; VAR quotient, remainder: ULONGINT);
-CODE
-	MOV R2, #0 ; quotient will be stored in R2
-
-	LDR R0, [FP,#dividend] ; R0 := dividend
-	LDR R1, [FP,#divisor] ; R1 := divisor
-
-	; check for the case dividend < divisor
-	CMP R0, R1
-	BLT Exit ; nothing to do than setting quotient to 0 and remainder to dividend (R0)
-
-	CLZ R3, R0 ; R3 := clz(dividend)
-	CLZ R4, R1 ; R4 := clz(divisor)
-
-	SUB R3, R4, R3 ; R2 := clz(divisor) - clz(dividend) , R2 >= 0
-	LSL R1, R1, R3 ; scale divisor: divisor := LSH(divisor,clz(divisor)-clz(dividend))
-
-Loop:
-	CMP R0, R1
-	ADC R2, R2, R2
-	SUBCS R0, R0, R1
-	LSR R1, R1, #1
-	SUBS R3, R3, #1
-	BPL Loop
-
-	; R0 holds the remainder
-
-Exit:
-	LDR R1, [FP,#quotient] ; R1 := address of quotient
-	LDR R3, [FP,#remainder] ; R3 := address of remainder
-
-	STR R2, [R1,#0] ; quotient := R1
-	STR R0, [R3,#0] ; remainder := R0
-END DivModU32;
-
-(* signed division and modulus
-- note: this implements the mathematical definition of DIV and MOD in contrast to the symmetric one
-*)
-PROCEDURE DivModS64*(dividend, divisor: HUGEINT; VAR quotient, remainder: HUGEINT);
-BEGIN {UNCOOPERATIVE, UNCHECKED}
-	ASSERT(divisor > 0);
-	IF dividend >= 0 THEN
-		DivModU64(dividend, divisor, quotient, remainder)
-	ELSE
-		dividend := -dividend;
-		DivModU64(dividend, divisor, quotient, remainder);
-		quotient := -quotient;
-		IF remainder # 0 THEN
-			DEC(quotient);
-			remainder := divisor - remainder
-		END
-	END
-END DivModS64;
-
-(* Count leading zeros in a binary representation of a given 64-bit integer number *)
-PROCEDURE Clz64*(x: UHUGEINT): LONGINT;
-CODE
-	; high-half
-	LDR R1, [FP,#x+4]
-	CMP R1, #0 ; if high-half is zero count leading zeros of the low-half
-	BEQ LowHalf
-
-	CLZ R0, R1
-	B Exit
-
-	; low-half
-LowHalf:
-	LDR R1, [FP,#x]
-	CLZ R0, R1
-	ADD R0, R0, #32 ; add 32 zeros from the high-half
-
-Exit:
-END Clz64;
-
-(*
-	Fast 64-bit unsigned integer division/modulo (Alexey Morozov)
-*)
-PROCEDURE DivModU64*(dividend, divisor: UHUGEINT; VAR quotient, remainder: UHUGEINT);
-VAR m: LONGINT;
-BEGIN {UNCOOPERATIVE, UNCHECKED}
-	quotient := 0;
-
-	IF dividend = 0 THEN remainder := 0; RETURN; END;
-	IF dividend < divisor THEN remainder := dividend; RETURN; END;
-
-	m := Clz64(divisor) - Clz64(dividend);
-	ASSERT(m >= 0);
-
-	divisor := LSH(divisor,m);
-	WHILE m >= 0 DO
-		quotient := LSH(quotient,1);
-		IF dividend >= divisor THEN
-			INC(quotient);
-			DEC(dividend,divisor);
-		END;
-		divisor := LSH(divisor,-1);
-		DEC(m);
-	END;
-
-	remainder := dividend;
-END DivModU64;
-
-	PROCEDURE MulS64*(x, y: HUGEINT): HUGEINT;
-	CODE
-		ldr r0, [FP,#x]
-		ldr r1, [FP,#x+4]
-
-		ldr r2, [FP,#y]
-		ldr r3, [FP,#y+4]
-
-		muls	r1, r1, r2
-		muls	r3, r3, r0
-		adds	r1, r1, r3
-
-		lsrs	r3, r0, #16
-		lsrs	r4, r2, #16
-		muls	r3, r3, r4
-		adds	r1, r1, r3
-
-		lsrs	r3, r0, #16
-		uxth	r0, r0
-		uxth	r2, r2
-		muls	r3, r3, r2
-		muls	r4, r4, r0
-		muls	r0, r0, r2
-
-		movs	r2, #0
-		adds	r3, r3, r4
-		adcs	r2, r2, r2
-		lsls	r2, r2, #16
-		adds	r1, r1, r2
-
-		lsls	r2, r3, #16
-		lsrs	r3, r3, #16
-		adds	r0, r0, r2
-		adcs	r1, r1, r3
-
-	END MulS64;
-
 END CPU.

source/Zynq.CPU.Mod

@@ -289,183 +289,4 @@ handle:
 	d32	HandleInterrupt
 END IRQHandler;
 
-(* compiler intrinsics *)
-TYPE ULONGINT = LONGINT; (* alias to make distinction between signed and unsigned more clear *)
-TYPE UHUGEINT = HUGEINT;
-
-PROCEDURE DivS8*(left, right: SHORTINT): SHORTINT;
-VAR result, dummy: LONGINT;
-BEGIN {UNCOOPERATIVE, UNCHECKED} DivModS32(left, right, result, dummy); RETURN SHORTINT(result)
-END DivS8;
-
-PROCEDURE DivS16*(left, right: INTEGER): INTEGER;
-VAR result, dummy: LONGINT;
-BEGIN {UNCOOPERATIVE, UNCHECKED} DivModS32(left, right, result, dummy); RETURN INTEGER(result)
-END DivS16;
-
-PROCEDURE DivS32*(left, right: LONGINT): LONGINT;
-VAR result, dummy: LONGINT;
-BEGIN {UNCOOPERATIVE, UNCHECKED} DivModS32(left, right, result, dummy); RETURN result
-END DivS32;
-
-PROCEDURE DivU32*(left, right: ULONGINT): ULONGINT;
-VAR result, dummy: LONGINT;
-BEGIN {UNCOOPERATIVE, UNCHECKED} DivModU32(left, right, result, dummy); RETURN result
-END DivU32;
-
-PROCEDURE DivS64*(left, right: HUGEINT): HUGEINT;
-VAR result, dummy: HUGEINT;
-BEGIN {UNCOOPERATIVE, UNCHECKED} DivModS64(left, right, result, dummy); RETURN result
-END DivS64;
-
-PROCEDURE ModS8*(left, right: SHORTINT): SHORTINT;
-VAR result, dummy: LONGINT;
-BEGIN {UNCOOPERATIVE, UNCHECKED} DivModS32(left, right, dummy, result); RETURN SHORTINT(result)
-END ModS8;
-
-PROCEDURE ModS16*(left, right: INTEGER): INTEGER;
-VAR result, dummy: LONGINT;
-BEGIN {UNCOOPERATIVE, UNCHECKED} DivModS32(left, right, dummy, result); RETURN INTEGER(result)
-END ModS16;
-
-PROCEDURE ModS32*(left, right: LONGINT): LONGINT;
-VAR result, dummy: LONGINT;
-BEGIN {UNCOOPERATIVE, UNCHECKED} DivModS32(left, right, dummy, result); RETURN result
-END ModS32;
-
-PROCEDURE ModU32*(left, right: ULONGINT): ULONGINT;
-VAR result, dummy: LONGINT;
-BEGIN {UNCOOPERATIVE, UNCHECKED} DivModU32(left, right, dummy, result); RETURN result
-END ModU32;
-
-PROCEDURE ModS64*(left, right: HUGEINT): HUGEINT;
-VAR result, dummy: HUGEINT;
-BEGIN {UNCOOPERATIVE, UNCHECKED}
-	DivModS64(left, right, dummy, result); RETURN result
-END ModS64;
-
-(* signed division and modulus
-- note: this implements the mathematical definition of DIV and MOD in contrast to the symmetric one
-*)
-PROCEDURE DivModS32(dividend, divisor: LONGINT; VAR quotient, remainder: LONGINT);
-BEGIN {UNCOOPERATIVE, UNCHECKED}
-	ASSERT(divisor > 0);
-	IF dividend >= 0 THEN
-		DivModU32(dividend, divisor, quotient, remainder)
-	ELSE
-		dividend := -dividend;
-		DivModU32(dividend, divisor, quotient, remainder);
-		quotient := -quotient;
-		IF remainder # 0 THEN
-			DEC(quotient);
-			remainder := divisor - remainder
-		END
-	END
-END DivModS32;
-
-(*
-	Fast 32-bit unsigned integer division/modulo (author Alexey Morozov)
-*)
-PROCEDURE DivModU32(dividend, divisor: ULONGINT; VAR quotient, remainder: ULONGINT);
-CODE
-	MOV R2, #0 ; quotient will be stored in R2
-
-	LDR R0, [FP,#dividend] ; R0 := dividend
-	LDR R1, [FP,#divisor] ; R1 := divisor
-
-	; check for the case dividend < divisor
-	CMP R0, R1
-	BLT Exit ; nothing to do than setting quotient to 0 and remainder to dividend (R0)
-
-	CLZ R3, R0 ; R3 := clz(dividend)
-	CLZ R4, R1 ; R4 := clz(divisor)
-
-	SUB R3, R4, R3 ; R2 := clz(divisor) - clz(dividend) , R2 >= 0
-	LSL R1, R1, R3 ; scale divisor: divisor := LSH(divisor,clz(divisor)-clz(dividend))
-
-Loop:
-	CMP R0, R1
-	ADC R2, R2, R2
-	SUBCS R0, R0, R1
-	LSR R1, R1, #1
-	SUBS R3, R3, #1
-	BPL Loop
-
-	; R0 holds the remainder
-
-Exit:
-	LDR R1, [FP,#quotient] ; R1 := address of quotient
-	LDR R3, [FP,#remainder] ; R3 := address of remainder
-
-	STR R2, [R1,#0] ; quotient := R1
-	STR R0, [R3,#0] ; remainder := R0
-END DivModU32;
-
-(* signed division and modulus
-- note: this implements the mathematical definition of DIV and MOD in contrast to the symmetric one
-*)
-PROCEDURE DivModS64*(dividend, divisor: HUGEINT; VAR quotient, remainder: HUGEINT);
-BEGIN {UNCOOPERATIVE, UNCHECKED}
-	ASSERT(divisor > 0);
-	IF dividend >= 0 THEN
-		DivModU64(dividend, divisor, quotient, remainder)
-	ELSE
-		dividend := -dividend;
-		DivModU64(dividend, divisor, quotient, remainder);
-		quotient := -quotient;
-		IF remainder # 0 THEN
-			DEC(quotient);
-			remainder := divisor - remainder
-		END
-	END
-END DivModS64;
-
-(* Count leading zeros in a binary representation of a given 64-bit integer number *)
-PROCEDURE Clz64*(x: UHUGEINT): LONGINT;
-CODE
-	; high-half
-	LDR R1, [FP,#x+4]
-	CMP R1, #0 ; if high-half is zero count leading zeros of the low-half
-	BEQ LowHalf
-
-	CLZ R0, R1
-	B Exit
-
-	; low-half
-LowHalf:
-	LDR R1, [FP,#x]
-	CLZ R0, R1
-	ADD R0, R0, #32 ; add 32 zeros from the high-half
-
-Exit:
-END Clz64;
-
-(*
-	Fast 64-bit unsigned integer division/modulo (Alexey Morozov)
-*)
-PROCEDURE DivModU64*(dividend, divisor: UHUGEINT; VAR quotient, remainder: UHUGEINT);
-VAR m: LONGINT;
-BEGIN {UNCOOPERATIVE, UNCHECKED}
-	quotient := 0;
-
-	IF dividend = 0 THEN remainder := 0; RETURN; END;
-	IF dividend < divisor THEN remainder := dividend; RETURN; END;
-
-	m := Clz64(divisor) - Clz64(dividend);
-	ASSERT(m >= 0);
-
-	divisor := LSH(divisor,m);
-	WHILE m >= 0 DO
-		quotient := LSH(quotient,1);
-		IF dividend >= divisor THEN
-			INC(quotient);
-			DEC(dividend,divisor);
-		END;
-		divisor := LSH(divisor,-1);
-		DEC(m);
-	END;
-
-	remainder := dividend;
-END DivModU64;
-
 END CPU.