I can think of a potential use of multiple level indirect addressing.
It has to do with accessing a single cell in a multidimensional array. If we have a three dimensional array A, and we want to access cell A(7, 3, 8). We have to figure out what address that's located at, relative to some base address called, say, ABASE.
The classical way you go about doing this is by doing some address arithmetic. You take the first index, 7 subtract 1 from it (assuming indexes begin at 1 as in Fortran), multiply by the size of the second dimension, now add 3 (maybe minus 1) to that, multiply by the size of the third dimension, and add 8 (maybe minus 1) to that. Finally multiply by the cell size if the cell size is larger than 1 word. Now you have the offset of the desired address from the base address ABASE of the array. (Unless I've made a mistake in the above).
Anyway, it's a whole lot of work, and it takes a considerable amount of time. If you start doing millions of references to a large array, we're talking hours of compute time here.
There is a faster way, using multiple level indirection, and referencing an accumulator in the index field. This requires auxiliary data structures to be set up when the array is constructed. These auxiliary data structures have the indirect bit set (except for the lowest level), and reference some accumulator in the index field.
The top level auxiliary has one entry per possible value of the first index, let's say 20, It has the form:
where ABASE2 is the base address for the second level auxiliary structure, B is one of the accumulators used as an index register and X is some offset that I'm too lazy to figure out.
The second layer of auxiliary structure might have the form:
And the third level auxiliary points to one the cells as follows:
Where Z is some multiple of the cell size.
Now, if you do:
MOVEI A, 6
MOVEI B, 2
MOVEI C, 7
MOVEI D, @ABASE1(A)
what happens is that A selects the seventh entry in ABASE1, which selects the third entry in ABASE2, which selects the eighth entry in ABASE3, which points to the desired address somewhere in ABASE, the array itself.
It's awfully complicated sounding, and I would hate to implement it with my tired old brain, but it runs faster than doing all the address arithmetic at run time.
It also requires extra memory to hold the auxiliaries. This is similar to the way a B-TREE index to a table requires extra space in a database.
What I do not know is whether any of the third generation languages, like Fortran or Algol, ever employed this technique on the PDP-10.