7. EXTRACODE INSTRUCTIONS

7.1 Introduction

The basic instructions consist in just those simple operations which the computer has been designed to execute directly. In the Atlas order-code, however, there are many complicated operations which the computer deals with in a special way; these are known as extracodes and are distinguished from the basic instructions by having a 1 in f₀, the most-significant bit of the 10-bit function number. Upon encountering an instruction with f = 1, there occurs an automatic entry to one of many built-in subroutines, the choice being determined by the remaining three octal digits of the function number. The exit from the subroutine is again automatic, and the program proceeds in the usual way with the instruction next after the extracode, unless the extracode subroutine has initiated a jump.

7.1.1 Uses of the Extracode Instructions.

As their name implies, the extracodes provide an extension of the basic order-code, including both those complicated operations which are excluded from the basic instructions, and many of the facilities which on previous machines have been obtained by the use of library subroutines.

Amongst the arithmetic instructions provided by extracodes we may instance those in which the address, interpreted as a floating-point number, is used as an operand; double-length operations; and a full range of elementary functions such as logarithm, square-root, sine etc.

An important group of extracodes deals with the special requirements of input and output and also of magnetic tape transfers; the uses of these will be discussed at some length in Chapters 8 and 9.

The organisational extracodes comprise extensive facilities designed to assist the programmer in making efficient use of the operating system of Atlas. The various aspects of this are described in later Chapters (particularly Chapters 11 and 12).

7.1.2 To the programmer, extracode instructions appear as basic instructions. The two types of instruction can be freely intermixed, and after each instruction control passes sequentially to the next (except for jump instructions). It is therefore not strictly necessary to know how the computer deals with extracode instructions, although this is given for completeness in the next section.

There are 512 function numbers available for extracodes, 1000-1777. Of these, 1000-1477 are singly-modified instructions (B-type) and 1500-1777 are doubly-modified instructions (A-type). In some of the B-type instructions, bm is used as an operand so no modification takes place.

7.2 The Logical Interpretation of Extracode Instructions

When an extracode instruction is encountered the following action place:-

1. The content of Main control, b127, is increased by one to the address of the next program instruction.
2. The address is modified according to the type (i.e. N + bm for B-type, N + ba + bm for A-type) and the result stored in B119.
3. The seven Ba digits are placed in bits 15-21 of B121, unless Ba is B122 in which case B121 is left unchanged; this enables B122 to be used to specify a B-register in extracode functions exactly as in basic functions.
4. The function digits f1 - f9 are placed in extracode control, B126, as shown below.
   

   Bit   0    1-9    10 11 12 13 14 15 16 17 18 19 20 21-23 
   Value 1 000000000 f1 f2 f3 0  0  f4 f5 f6 f7 f8 f9  000
   

5. Control is switched from Main (B127) to extracode (B126).

The next instruction to be obeyed is now in the fixed store, under extracode control, at a location determined by the function digits. It is in one of 64 registers (given by f4-f9) in one of 8 tables at intervals of 256 words (given by f1-f3). The tables of 64 registers are called jump tables. In general this instruction will be an unconditional jump into a routine which performs the required function. These routines are permanently stored in the fixed-store and written in normal basic instructions. Each routine terminates with an instruction in which f1 = f3 = 1 in the function number. This is obeyed as if f1 = 0 and then control is switched back to main control (e.g. 521 is equivalent to 121 followed by extracode exit). The next instruction to be obeyed is then the one whose address is in B127; if no jump has been initiated by the extracode this instruction will be the one immediately following the extracode instruction.

The routines that perform extracodes can use B-registers 91 to 99 inclusive and always use B119, B126, and B121 (unless Ba = 122).

Examples:

1. Extracode 1714 is defined as am' = 1/s

Replace the numbers in locations 100 to 105 by their reciprocals.

    121    1     0     5        set modifier count
  2)1714   0     1     100      am' = 1/s
    356    0     1     100      store
    203    127   1     A2       count

Each time the extracode instruction is encountered b127' = b127 + 1, b121' = 0, b119' = 100 +b1 + b0, b126' = J40034140 = +1804J4 and control is switched to B126. The instruction in the jump table is

    121    126   0     A14    

The instructions at A14 are

    334    0     0     A96      set am = +1
    774    0     119   0        374 division 1/s, then reswitch to
                                main control.
 96)+1   

2. Extracode 1341 is defined as bat = ba.2ⁿ (arithmetic shift up) Shift b16 up by 2 more than the integer in B17

    1341   16    17    2    

This instruction sets b121' = 16D1, b119' = 2 + b17, etc. (Note that b16 is not added to b119 because 1341 is a singly-modified (B-type) extracode).

3. Shift the contents of B20 to B47 inclusive up by 5 places.

    121    121   0     20D1     set modifier count
  1)1341   122   0     5        shift. As Ba = B122, b121 is left
                                unchanged when the extracode is 
                                entered.
    172    121   0     47D1     bt' = b121 - 47D1
    220    127   121   A1       If bt ≠ 0, b121' = b121 + 0.4
                                and b127' = A1

Example 3 illustrates the use that can be made of B121 and B122 in extracodes; this is the same as their use in basic instructions except that extracodes with Ba ≠122 will overwrite B121.

Allocation of Functions

The extracodes are divided into sections as shown below, though there are a few functions which do not fit into this pattern. References are given for those subjects described in this chapter.

Not all of the 512 extracode functions have been allocated and, where convenient, constants and extracode programs have been packed into the vacant jump-table locations.

This means that the use of an unallocated extracode function may result in an unassigned function interrupt or may cause some extracode to be entered incorrectly. The latter case would give the programmer wrong results.

In particular, the first location in the fixed store, J4, contains the floating-point number ½. This causes an unassigned function interrupt if extracode 1000 is encountered, since J4 is the first register of the first jump-table. Note that floating-point zero is equivalent to the instruction

    1000   0     0     0    

There follows a description of many of the extracodes. Where possible, the actual number of basic instructions obeyed in each extracode routine is given in the right hand column.

Appendix 3 gives an ordered summary of all the extracodes, for easy references.

7.4 The Accumulator Extracodes

7.4.1 The Most Used Arithmetic Functions

The following routines each have two extracode numbers. The first operates on s, which is standardised on entry. The second operates on a, which is standardised, rounded and truncated to a single-length number on entry. For this number we use the notation aq. The results are always standardised rounded numbers in Am.

7.4.2 Other Floating-Point Arithmetic Functions

1774 and 1775, besides providing a division instruction which operates on unstandardised numbers, store information which enables extracodes 1776 and 1407 to calculate a quotient and remainder.

                        
Ba   Sign of remainder
O    Same as the denominator
1    Opposite to the denominator
2    Same as the numerator
3    Opposite to the numerator
4    Same as the quotient
5    Opposite to the quotient
6    Positive
7    Negative

Extracode 1415

Generate pseudo-random numbers (PRN's) in A and S (or S*) from numbers in S and S*. This extracode may be used in several ways.

1. With digit 21 of S equal to 0, the PRN is placed in S and A.
   1. If s*y = 0, sx > 0 and s*x > 0, then s' will be a PRN in the range 0 to 8^sy , rectangularly distributed and fixed-point (i.e. sx' is a fixed-point PRN and sy' = sy). a' will be a PRN in the range 0 to s*x.8^sy (with al' = s').
   2. If s*y = 0, sx < 0 and s*x < 0, then as (a) except that ranges become -8^sy to 0 and -s*x.8^sy-1 to 0 respectively.
   3. If s*y = 0 and s*x > 0, then as (a) except that the PRN's alternate in sign.
2. With digit 21 of S = 1, the PRN's are generated in S* and A instead of S and A. The cases are as for 1, interchanging S and S* throughout.
3. 3. Two successive uses of the extracode, with digit 21 of S first = 0 and then = 1, and with sy = s*y = 0, will set PRN's in S end S*, both rectangularly distributed in the range 0 to 1. A will contain the product of two PRN's and so will be distributed in the range 0 to 1 with the probability -log xdx of being in the neighbourhood dx of x.

In all cases the generation process must be started with Sx Iand S*x containing numbers with a random mixture of binary digits, but with their least-significant bits set to 1.

7.4.3 Accumulator functions suitable for Fixed-Point Working

Fixed-Point Divisions with remainder

The three extracodes 1474, 1475 and 1476 each divide some part of the accumulator by the contents of store location S, placing an unstandardised quotient q in the location whose address is ba and leaving an unstandardised remainder r in Am. In all cases, r retains the original sign of am and has a mantissa in the range 0 ≤ |rx| < |sx|. The quotient is rounded towards zero. Division overflow is set if sx = 0 or -1.0 or if |sx| ≤ |mantissa of dividend|. Both DO and AO are set when the mantissa of the dividend is equal to -1.0.

If only the remainder is required, one can avoid the need to set ba by putting Ba = B126 in the extracode instruction.

7.4.4 Double-Length Arithmetic

The double-length number s: is stored in two consecutive locations s and s + 1 as two standardised floating-point numbers, where sy ≥ s*y. s* and al are assumed to be always positive. All arithmetic is standardised, rounded and checked for exponent overflow.

7.4.5 Arithmetic Using the Address as an Operand

The modified address is taken as a 21-bit integer with an octal fraction. Fixed-point operations imply an exponent of 12.

After 1574 and 1575, the extracodes 1776 and 1407 can be used to give a remainder and adjusted integral quotient. See section 7.4.2.

7.4.6 Complex Arithmetic

The complex accumulator Ca is taken as a pair of consecutive registers, the address of the first one given by the contents of Ba in the instruction. If Ba is B0, Ca will be locations 0 and 1. As with the double-length arithmetic, s: is a number pair consisting of the two numbers at addresses S and S + 1. For Ca and S:, the real part of the number is in the first location, the imaginary part in the second. Ca may coincide with S: if desired, but the two must not partially overlap, i.e. the difference between ba and S must not equal 1. The accumulator is used for the arithmetic so its original contents on entry are spoiled. All arithmetic is standardised, rounded and checked for exponent overflow.

Note: 1400 - the imaginary part of the complex logarithm will lie in the range - π (not inclusive) to π (inclusive).

1410 - of the two possible values of the complex square root, the one computed here has a non-negative real part; the remaining ambiguity about the square roots of negative real numbers is removed by computing the one whose imaginary part is positive.

7.4.7 Vector Arithmetic

The following instructions operate on two vectors s₁ and s₂. Both vectors consist of lists of floating-point numbers stored in successive locations. In each instruction the singly-modified address n gives the number of terms in the vectors (i.e. the order) and Ba gives the starting address of s₁. The next B-register after Ba, Ba*, gives the starting address of s₂. Address n must be a positive integer.

Besides their uses in vector and matrix arithmetic, these instructions can be used to manipulate lists of numbers in the store.

The accumulator is used in the arithmetic so its original contents on entry are lost. All operations are standardised rounded and checked for exponent overflow.

7.4.8 Half-Word Packing

Half-word floating-point numbers consisting of 8-bit exponents and 16-bit mantissae are sometimes useful for low-accuracy calculations where it is necessary to reduce store usage.

7.5 B-Register Arithmetic

7.5.1 General B-Register Operations

The following six instructions provide integer multiplications and division of ba by n.

For 1302 - 1304, ba and n are interpreted in the normal way as 21-bit integers with a least-significant octal fraction. In the multiplication instructions octal fractions are rounded away from zero, and overflow of the answer is not detected. The accumulator is used in the calculation, but am is preserved.

For 1312-1314, ba and n are interpreted as 24-bit integers, and the result is again a 24-bit integer.

The following six instructions provide general n-place shifts of numbers in B-registers.

In arithmetic shifts, the sign digit is propagated at the most-significant end of the register for shifts to the right (i.e. down).

In logical shifts the sign digit is not propagated.

For both arithmetic and logical shifts the result is unrounded on shifts down. In circular shifts, digits shifted off the most-significant end of the register reappear at the least-significant end and vice-versa. n is an integer in bits 0-20 as usual, with no octal fraction. (If n has an octal fraction the answer may be wrong by a shift of one place). In each case, if n is negative a shift of n places in the opposite direction occurs.

The following are miscellaneous arithmetic instructions on half-words and index registers.

7.5.2 Character Data Processing

bits    0-9    10-20   21-23   0-23
         k       l     spare    m
      interval count           mask

In the following two instructions S is taken as a character address, the octal fraction giving the address of the 6-bit character within the word.

In the following two instructions ba is interpreted as a character address, and the content of the next B-register, ba*, is interpreted as a half-word address. n is used as a count and its octal fraction must be zero.

7.5.3 Logical Accumulator Instructions

B98 and B99 are used in these instructions as a double-length B-register. This is called the logical accumulator and denoted by G.

Test Instructions

7.6.1 Accumulator test Instructions

For 1234 and 1235, approximate equality is defined as |(am - s) / am| < C(ba)
am must be standardised on entry. By definition, if am = 0 then am is not approximately equal to s.

In 1234, 1235, 1727, 1736 and 1737 am is preserved but l is not.

7.6.2 B-register Test Instructions

The B-carry digit (Bc) is set to 0 or a 1 in the following basic instructions.

    100   102   104
    110   112   114
    120   122   124
    150   152   164
    170   172   

Bc records the final carry or borrow generated after the addition or subtraction of the most significant digits of the operands.

When the most-significant digit is taken as a sign bit, which is usually the case, Bc is not a true overflow digit. For example, adding -1 or +1 gives 0 and also sets Bc = 1 as there is a final carry. (See Chapter 4).

7.7 Subroutine Entry

The link set in Ba can be picked up as an exit from the subroutine by the instruction

    121    127   B%    0     

where B% is the address of the B-register (Ba) in which the link was set. It is conventional to use B90 for this purpose, and 1362 was provided for that reason.

7.8 Miscellaneous Operations

bits  0-3   4-7   8-11   12-15   16-19   20-23
     tens  units  tens   units   tens    units
       HOURS        MINUTES        SECONDS

bits  0-3   4-7   8-11   12-15   16-19   20-23
     tens  units  tens   units   tens    units
        DAY          MONTH           YEAR

bit    Set to 0     Set to 1  
 18    13 shift     12 shift      on division;
                                  needed to
                                  adjust remainder
                                  for 376, 377
                                  instructions
 19    Qs ≥ 0       Qs < 0        Sign of quotient
                                  in basic division
                                  orders
 20    AO clear     AO set
 21    bt ≥ 0       bt < 0
 22    bt = 0       bt ≠ 0
 23    Bc clear     Bc set