Explicit Use of Base Registers

In this lecture we consider the explicit use of the general–purpose registers as base
registers.  This leads to more observations on the structure of the machine language.

Consider the following line of code.

MVC    PRINT+60(2),ASTERS

In this and similar examples, the field ASTERS is defined as “**”, two asterisks.

Question 1:     How many characters are moved?

Answer 1:        The explicit length field is set at 2, so two are moved.

Question 2:     To what addresses are they moved?

Answer 2:        The address of the first operand is PRINT + 60.  One asterisk is
moved to each of addresses PRINT + 60 and PRINT + 61.

Question 3:     What is the real address?

Answer:           Suppose that register 4 is used as a base register, having value X‘8002’
PRINT is at offset 1A, so it has value X‘801C’.
Decimal 60 = X‘3C’, so PRINT + 60 is at offset X‘1A’ + X‘3C’ = X‘56’.
The target address is X‘8002’ + X‘0056’ = X‘8058’.

Move Example: Second Form

Now consider the two lines of code that follow.  What happens here?

LA     8,PRINT+60

MVC    0(2,8),ASTERS

Note that it is not the contents of that address that are loaded.

Remember that the LA instruction still uses register 4 as a base address.
We have just seen that    1)     PRINT is at offset 1A, so it has address X‘801C’, and
2)     PRINT+60 is at offset 56, having address X‘8058’.

General purpose register 8 is loaded with the value X‘8058’.  It will serve as the
explicit base register for the first operand in the MVC instruction.

Each of the arguments in MVC is really of the form Displacement (Length, Base) and references the address Contents(Base) + Displacement.

The displacement here is 0 (zero); 0(2,8) denotes the address 0 + Contents(8), or
0 + X‘8058’ = X‘8058’.

The 2 in (2,8) is the number of bytes to be moved.

Move Example: Third Form

Now consider the two lines of code that follow.  What happens here?

LA     8,PRINT

MVC    60(2,8),ASTERS

Note that it is not the contents of that address that are loaded.

Remember that the LA instruction still uses register 4 as a base address.
We have just seen that    1)     PRINT is at offset 1A, so it has address X‘801C’.

General purpose register 8 is loaded with the value X‘801C’.  It will serve as the
explicit base register for the first operand in the MVC instruction.

Each of the arguments in MVC is really of the form Displacement (Length, Base) and references the address Contents(Base) + Displacement.

The displacement here is 60, which in hexadecimal is X‘3C’.
60(2,8) denotes the address X‘3C’ + Contents(8), or X‘3C’ + X‘801C’ = X‘8058’.

The 2 in (2,8) is the number of bytes to be moved.

The general form for packed instructions permits lengths for both operands 1 and 2.

There are a few issues to be remembered when using packed decimals.

1)   The explicit lengths for the instructions must be in bytes, not decimal digits, and

2)   Digits tend to be packed two per byte.

Consider the following two declarations from the data section of a program.

KGS      DC PL3‘12.53’ Stored as 01253C.

POUNDS   DS PL5

The following code sequence moves the value of KGS into POUNDS.

ZAP   0(5,8),0(3,6)

Tables and Arrays

The book discusses tables, which according to the author “contain a set of related data arranged so that each item can be referenced according to its location in the table”.

According to our author, there are two basic types of tables.

“A static table contains defined data, such as income tax steps…. A dynamic table consists of a series of adjacent blank or zero fields defined to store or accumulate related data.”

We would call these structures “arrays”, with the static table corresponding to an array of constant values and the dynamic table corresponding to a plain array.

The main difference in the table structure, other than the older terminology, is that the values stored can be composite values.  One might consider these tables as equivalent to an array of records or an array of structs.

In each of tables and arrays, the elements are addressed using an offset from the base
address of the table or array.

Let’s now learn some of the older IBM terminology for tables.

Sample Table

Consider the following table, adapted from the textbook.

MONTAB    DC C‘01’,‘JANUARY

DC C‘02’,‘FEBRUARY

...

DC C‘09’,‘SEPTEMBER’

DC C‘10’,‘OCTOBER

DC C‘11’,‘NOVEMBER

DC C‘12’,‘DECEMBER

In the terminology of the book, the first string (representing the month number)
is called the table argument.  The month name is called the table function.

The table is to be searched using a value that may match one of the table arguments.
This value is called the search argument.

While one might think of this in terms of a database table, there is no requirement (other than good coding practice) that the table arguments be unique.

There are no keys to this table.

Sample Table Again

Here again is the sample table, showing only six of its twelve entries.

MONTAB    DC C‘01’,‘JANUARY

DC C‘02’,‘FEBRUARY

...

DC C‘09’,‘SEPTEMBER’

DC C‘10’,‘OCTOBER

DC C‘11’,‘NOVEMBER

DC C‘12’,‘DECEMBER

Note that the following table is exactly equivalent.

MONTAB    DC C‘01JANUARY

DC C‘02FEBRUARY ’

...

DC C‘09SEPTEMBER’

DC C‘10OCTOBER

DC C‘11NOVEMBER ’

DC C‘12DECEMBER ’

Note also that every table entry has exactly the same length (11 characters).
This is required by the table search algorithm.

Searching the Table by “Key Value”

Here is a fragment of code, written in a better style, that searches the above table.
The search argument, MONIN, is defined as two digits.

USING *,4,5

LA    8,MONTAB    Address of table in reg 8

L     9,=H’12’    Number of entries in table

C10LOOP  CLC   MONIN,0(8)  Compare to table argument

BE    C30EQUAL    Have a match

BL    C20NOTEQ    Table is ordered; no hit.

AH    8,=H‘11’    Move to next row

BCT   9,C10LOOP   Decrement counter, branch if > 0

C20NOTEQ Do something

C30EQUAL Do something else.

Note that the search argument is being compared to the two characters at the addresses
MONTAB, MONTAB + 11, MONTAB + 22, …, etc.

Note that this is a counted loop.  It will search no more than twelve table entries.

Terminating the Loop

The textbook suggests the “high values” method of terminating the loop.

This is extremely bad coding practice and should be avoided.

Consider the table of packed data in Figure 11–8 on page 284 of the textbook.

The high value here is the five digit string ‘99999’.

Thus, one has hard coded an upper limit of 99,998 for the discounts.  Orders of
a million units cannot be discounted more than orders of 500 units.

Suppose that this table listed applicable discounts by account number.

The largest valid account number would be ‘99998’.

Suppose that an unsuspecting account manager assigned account number ‘99999’?
This has happened.
[Ridiculous true story goes here.]

Ordered and Unordered Tables

The textbook’s discussion of table searching implicitly assumes that the table
arguments are sorted in increasing order by table entry.

Here are the book’s rules for comparing the search argument to each table argument.

1.   The search argument is equal.  The table function has been found and
can be used.

2.   The search argument is high.  Continue the search unless this is the
last entry in the table.

3.   The search argument is low.  Stop the search and take action appropriate
to the type of table.  If it is a table with steps, return with the step number.

For unordered tables, the basic comparisons are restricted to Equal or Not Equal.

As we know, ordered tables can be searched using binary search.  This very efficient search technique is discussed in the textbook.

It is possible to use the table structure to implement a linked list.

Every entry in the table contains an additional field specifying
the offset in the table of the next item in the list.

The textbook’s example (on page 292) is as good as any.

Offset   Part No.    Price  Next Offset

0000      0103      12.50      0036

0012      1720      08.95      0024

0024      1827      03.75      0000

0036      0120      13.80      0048

0048      0205      25.00      0012

Note that the order on the linked list is by part number.

The textbook illustrates the creation of a linked list.  We may consider this example later; by developing an insert and delete method, as well as a more modern create method.

Consider a table in which the table arguments are sequential and consecutive.
One good example would be the table of months, already discussed.

MONTAB    DC C‘01’,‘JANUARY

DC C‘02’,‘FEBRUARY

...

DC C‘09’,‘SEPTEMBER’

DC C‘10’,‘OCTOBER

DC C‘11’,‘NOVEMBER

DC C‘12’,‘DECEMBER

The table argument is implied by the position in the table.  This could be written as:

MONTAB    DC C‘JANUARY

DC C‘FEBRUARY ’

...

DC C‘SEPTEMBER’

DC C‘OCTOBER

DC C‘NOVEMBER ’

DC C‘DECEMBER ’

Entry K in the table is at offset (K – 1)·9

Let us define the following terms.

A(F)            is the address of the required function (table entry).

A(T)            is the address of the table.

SA               is the numeric value of the search argument
with range 1 through table_length.

L                  is the length (in bytes) of each function (table entry).
All table entries have the same length.

The equation of interest is

A(F) = A(T) + (SA – 1)·L

This is just the access formula for describing a singly dimensioned array in memory.