Suppose we want to add 23 to something. The instruction:

   23 => adder

is syntacticly "nice", but we have provided no method yet to implement it. Assuming the adder here is behind register 87, then if the instruction were encoded as the 16-bit quantity (23,87), it will end up copying the content of register 23 to register 87, which is not what we want. So far, I have presented no way to do what we want, namely load constants.

Other TTA processors (see the "Move" project by Henk Corporal) have added a bit to indicate that we have a constant. And many other bits. And added much complexity. I won't do that, and have created another way.

We're going to create a unique register, "const8", and alter its backend circuit to do what we want. It will get its data, not from the bus's data bits, but from the upper 8 bits of the bus's instruction word. This is a surprisingly simple modification, shown above. Thus:

   23 => const8

puts the constant 23 into the const8 register.

Note that this is not "23 => adder" it is "23 => const8". Only this one "special" register works this way. Thus, to get the constant to the adder, we'd need two instructions. That is:

   23 => const8 ; const8 => adder

Any compiler could do this translation automatically, ie "23 -> adder" would generate the above two instructions.

Shown above is the const8's RCL's modification: we cut the lines to the D input buffers, and drive them from the instruction word itself (upper 8 bits only). As it is a write-only register, EN-OUT and the Q outputs and their buffers may be deleted (or just cut). Only EN-IN remains, with input buffers driven by the instruction word. Note that no hardware is added here, only deleted!

In other words, if const8 were register 66, then the instruction (23,66) would have 23 in the upper 8 bits of the instruction word, and when register 66's RCL activates, that 23 is what is read, rather than whatever is on the main data bus (from register 23).

Now there are quite a few problems with this implementation: we'll fix them on the next page. For one thing, registers are 32 bits wide, but only 8 bits can be moved in this way. Worse, if the constant were 23, then register 23 will still be selected as the source for this instruction, and will put its data onto the data bus anyway, which will then be ignored by the const8 register! lol. And even worse still, if register 23 happened to be a register like the "counter" presented earlier, reading it would cause an increment, which would really mess us up!