Contributed by Claus Buchholz
The TMC0501 architecture underlying the TI SR-5x and TI-58/9 calculators of the 70s is well known. One of its features is the Constant ROM, which holds several 16-digit BCD constants required for CORDIC and other algorithms. In later calculators of the series, TI even took advantage of extra CROM space to store subroutines written not in the native CPU instructions but rather in the user programming language. This was discovered in the day and was a big topic in the user group newsletters.
Less well known is the architecture of the low end TI programmables, the TI-57, -55, and MBA. The TMC1500 single-chip design did not include any Constant ROM. One might expect then that the instruction set allowed for loading of data from instruction ROM tables, but it did not. Also lacking were immediate load instructions found in most any microprocessor. So how did those calculators store their constants? The answer is interesting and surprising.
A few years ago HrastProgrammer found TI-57 object listings and instruction descriptions in various patent disclosures. He used them to write an emulator. This has proven the only way yet to see how the -57 really works inside. Maybe decappers will map an actual -57 chip someday.
In the disassembly I found these routines based on a sequence of 9 increment instructions:
LD8 A=ASL MAEX
BRNC SUM8
LD77 CALL LD7
LD7 A=ASL MAEX
BRNC SUM7
LD66 CALL LD6
LD6 A=ASL MAEX
BRNC SUM6
LD95 CALL LD9
LD5 A=ASL MAEX
BRNC SUM5
LD4 A=ASL MAEX
BRNC SUM4
LD63 CALL LD6
LD3 A=ASL MAEX
BRNC SUM3
LD2 A=ASL MAEX
BRNC SUM2
L59S CALL LD9
L49S CALL LD9
L39S CALL LD9
LD99 CALL LD9
LD9 A=ASL MAEX
A=A+1 MAEX
SUM8 A=A+1 MAEX
SUM7 A=A+1 MAEX
SUM6 A=A+1 MAEX
SUM5 A=A+1 MAEX
SUM4 A=A+1 MAEX
SUM3 A=A+1 MAEX
SUM2 A=A+1 MAEX
SUM1 A=A+1 EXP
RTN
Each routine puts a digit from 1 to 9 into the low end of the 16-digit Accumulator, A. When an algorithm needs a 5, for example, it calls the LD5 subroutine, which shifts A left one digit and jumps to SUM5, which increments A 5 times. So every digit is generated by such a subroutine call, and up to 12 calls are made to generate one constant.
Take the constant $\pi$:
A=A-A MAEX
CALL LD7 0.785398163400 pi/4
CALL LD8
CALL LD5
CALL LD3
CALL LD9
CALL LD8
CALL LD1
CALL LD63
CALL LD4
CALL LD00
D=A MAEX
A=A+A MAEX pi/2
B=A MAEX
A=A+A MAEX pi
RTN
The code starts by generating $\pi/4$. First A is cleared by subtracting it from itself. Then routines are called in the order LD7, LD8, LD5, LD3, LD9, and so on. Notice that some digits are doubled up to save a little ROM space. Finally, $\pi/4$ moves to the D register, A is doubled, $\pi/2$ moves to B, A doubles again, and $\pi$ remains in A.
Here are other trig constants:
CALL LD5 57.295779513 deg/rad
CALL LD7
CALL LD2
CALL LD95
CALL LD77
CALL LD95
CALL LD1
CALL LD3
CALL LD63 63.661977237 grd/rad
CALL LD66
CALL LD1
CALL LD9
CALL LD77
CALL LD2
CALL LD3
CALL LD7
And here are constants for the logarithmic and trigonometric CORDIC routines:
A=A-A FMAEX
CALL LD2 2.302585093000 ln 10
CALL LD3
A=ASL MAEX
CALL LD2
CALL LD5
CALL LD8
CALL LD5
A=ASL MAEX
CALL LD9
CALL LD3
L30S A=ASL MAEX
LD00 A=ASL MAEX
A=ASL MAEX
CALL LD95 0.095310179800 ln 1.1
CALL LD3
CALL LD1
A=ASL MAEX
CALL LD1
CALL LD7
CALL LD9
L800 CALL LD8
L00 CALL LD00
CALL LD99 0.009950330800 ln 1.01
CALL LD5
A=ASL MAEX
CALL LD3
CALL LD3
A=ASL MAEX
BRNC L800
CALL L39S 0.000999500200 ln 1.001
CALL LD5
CALL LD00
CALL LD2
BRNC L00
CALL L49S 0.000099995000 ln 1.0001
CALL LD5
CALL L30S
CALL LD99 0.099668652491 atan .1
CALL LD66
CALL LD8
CALL LD6
CALL LD5
CALL LD2
CALL LD4
LD91 CALL LD9
LD1 A=ASL MAEX
BRNC SUM1
CALL L49S 0.009999666691 atan .01
CALL LD66
CALL LD66
BRNC LD91
CALL L59S 0.000999999667 atan .001
CALL LD9
CALL LD66
BRNC LD7
Notice there are many 9s in these constants. To save some more ROM space (the whole calculator has to fit into only 2K instructions), there are routines to generate from one to five consecutive 9s.
You can see that it takes very many instruction cycles to generate one constant. Emulator execution traces show that these constants are generated as needed and not saved for later reuse, as register and RAM spaces are tight. All this explains why the TI-57 executes trig and log functions much more slowly than the SR-56 or TI-58.
Especially inefficient is the generation of a 9. Instead of shifting left and incrementing nine times, you could increment once, shift left, and decrement once, using three cycles instead of ten. Even better is to generate 99 in four cycles rather than twenty. I have rewritten LD9 and LD99 and fit them into five spare words at the end of the ROM:
LD99 BRNC 7FB
LD9 A=A+1 MAEX
BRNC 7FD
7FB A=A+1 MAEX
7FC A=ASL MAEX
7FD A=ASL MAEX
7FE A=A-1 MAEX
7FF RTN
I patched them into the emulator and tested them. They speed up trig functions by about 10%. A better optimization would be to store the smaller constants [$ 10^{-N} - {\rm atan}(10^{-N}) $] rather than ${\rm atan}(10^{-N})$. I estimate that would reduce constant generation time by half.
No one cares much about the TI-57 these days, but it is still impressive to see how much TI could squeeze into a small chip back in 1976.
Claus Buchholz
Michigan, USA
Credit: TI-57 ROM Listing Disassembled by HrastProgrammer
ROM dump retyped/analyzed/fixed by HrastProgrammer from the following US patents: 4078251 4079459 4100600 4107781 4125901 4164037
P.S. There are also three two-digit constants in the ROM whose function I do not know:
CALL SUM5
CALL LD1
CALL SUM4
CALL LD8
CALL SUM7
CALL LD6 