MIT PDP-10 'Info' file converted to Hypertext 'html' format by Henry Baker

# Fixed point arithmetic ADD, SUB, IMUL, IDIV, MUL, DIV

In positive numbers bit 0 is zero. Bits 1 is most significant; bit 35 is least significant. Negative numbers are the twos complement of postive numbers. Results (of ADD, SUB or IMUL) outside the range -2^|35 to 2^|35-1 will set overflow (PC bit 0).

Each arithmetic instruction has four forms, with modifier characters (nothing), M, B and I.

• The ordinary form operates on an accumulator and memory, putting the result in the accumulator.
• The Memory form puts the result in the memory location instead. The accumulator is not changed.
• The Both form stores the result in both the accumulator and the memory location.
• The Immediate form uses an accumulator and the effective address, putting the result in the accumulator.
```ADD     C(AC) <- C(AC) + C(E);
ADDI    C(AC) <- C(AC) + E;
ADDM    C(E)  <- C(AC) + C(E);
ADDB    C(AC) <- C(AC) + C(E);  C(E) <- C(AC);

SUB     C(AC) <- C(AC) - C(E);
SUBI    C(AC) <- C(AC) - E;
SUBM    C(E)  <- C(AC) - C(E);
SUBB    C(AC) <- C(AC) - C(E);  C(E) <- C(AC);
```
The IMUL instructions are for multiplying numbers where the product is expected to be representable as one word.
```IMUL    C(AC) <- C(AC) * C(E);
IMULI   C(AC) <- C(AC) * E;
IMULM   C(E)  <- C(AC) * C(E);
IMULB   C(AC) <- C(AC) * C(E);  C(E) <- C(AC);
```
The IDIV instructions are for divisions in which the dividend is a one word quantity. Two consecutive accumulators are used for the results; these are AC for the quotient, and AC+1 for the remainder (Actually, AC+1 is calculated mod 20, so if AC=17, the remainder is stored in accumulator 0.) If the divisor is zero set overflow and no divide; don't change AC or memory operands. The remainder will have the same sign as the dividend.
```IDIV    C(AC) <- C(AC) / C(E);  C(AC+1) <- remainder
IDIVI   C(AC) <- C(AC) / E;  C(AC+1) <- remainder;
IDIVM   C(E)  <- C(AC) / E;
IDIVB   C(AC) <- C(AC) / C(E);  C(AC+1) <- remainder; C(E) <- C(AC);
```
The MUL instructions produce a double word product. A double word integer has 70 bits of significance. Bit 0 of the high order word is the sign bit. In data, Bit 0 of the low order word is ignored by the hardware. In results, bit 0 of the low word is the same as bit 0 in the high word. MUL will set overflow if both operands are -2^|35.
```MUL     C(AC AC+1) <- C(AC) * C(E);
MULI    C(AC AC+1) <- C(AC) * E;
MULM    C(E)  <- high word of product of C(AC) * C(E);
MULB    C(AC AC+1) <- C(AC) * C(E);  C(E) <- C(AC);
```
The DIV instructions are for divisions in which the dividend is a two word quantity (such as produced by MUL). If C(AC) is greater than the memory operand then set overflow and no divide.
```DIV     C(AC) <- C(AC AC+1) / C(E); C(AC+1) <- remainder;
DIVI    C(AC) <- C(AC AC+1) / E;    C(AC+1) <- remainder;
DIVM    C(E)  <- C(AC AC+1) / E;
DIVB    C(AC) <- C(AC AC+1) / C(E); C(AC+1) <- remainder;
C(E) <- C(AC);
```