Mnemonic

Description

The divide instruction causes a 32-bit value to be divided by a 16-bit word from core storage. Result of the operation is placed in the accumulator; the remainder is placed in the accumulator extension.

Before the divide operation is started, the 32-bit value must be loaded into the accumulator and accumulator extension. (The units position is in bit 15 of the accumulator extension.) The divide instruction then addresses a 16-bit word (in core storage) that is used as the divisor. Examples of the arithmetic are:

Example 1

Example 2

The names of the values in the operation are:

The sign of the remainder is always the same as the sign of the original dividend. Before the operation, bit 0 of the accumulator specifies the sign of the dividend: bit 0 = 0 specifies a positive dividend; bit 0 = 1 specifies a negative dividend. Therefore, the value of bit 0 of the accumulator extension (after the operation when the extension contains the remainder) is the same as the original value of bit 0 of the accumulator (when it contained the original dividend).

The sign of the quotient is determined as follows:

Dividend		Divisor	=	Quotient
+		+	=	+
-		+	=	-
+		-	=	-
-		-	=	+

If a 16-bit dividend (in the accumulator) is the result of some prior operation, it must be shifted to the right 16 places into the accumulator extension before the divide operation is performed. (A shift-right-accumulator-and-extension instruction can be used for this purpose.)

There are no addressing exceptions for the divide instruction; all forms of addressing that are described under "Effective-Address Generation" apply to the D instruction.

The largest dividend that can be correctly operated on is 2³⁰ + 2¹⁵ - 1 (1,073,774,591 decimal) if divided by the largest negative divisor, -2¹⁵ (-32,768 decimal).

Indicators: The carry indicator is not affected during a divide operation. The overflow indicator must be reset to 0 before the divide operation if it is to be used. When the overflow indicator is initially at a value of 0, it is set to 1 during a divide operation for either of two conditions:

1. An attempt is made to divide by zero. (The divisor, in core storage, has a value of 0000 0000 0000 0000.)
2. A quotient overflow occurs. A quotient overflow occurs when the quotient exceeds the range to -2¹⁵ to +2¹⁵-1. A quotient overflow causes the accumulator and accumulator extension to be left in an undefined state.

Examples

Divide

But wait, there's MORE...