Professional Documents
Culture Documents
-
-
-----
--
-
-- - - ---
--_~--
- .
-
.. -
---
A Programmer's Introduction
---_.- to IBM System/360
Assembler Language
Student Text
-- ------
-
-~-
" -----
- A Programmer's Introduction
-- --- .-
-~-.-
- ---
-~-
-- to IBM System/360.
Assembler Language
Student Text
Minor Revision (August 1970)
Requests for copies of IBM publications should be made to your IBM representative or
to the IBM branch office serving your locality. Address comments concerning the
contents of this publication to IBM Corporation, DPD Education Development -
Publications Services, Education Center, South Road, Poughkeepsie, New York 12602.
This student text is an introduction to System/360 Computing System Fundamentals and Introduction to
assembler language coding. It provides many examples of System/360. The student who is not ehrolle~ in a compre-
short programs shown in assembled form. Some elementary hensive programming course will tmd the P. I. book
programming techniques and the specific instructions illus- Fundamentals of Programming a valuable guide to problem
trated in the programs are discussed in simple, relatively analysis and program flowcharting.
nontechnical terms. Much of the text is based on infor- The text and programs of this book have been revised
mation in IBM System/360 Principles of Operation throughout, mainly to reflect changes in programming
(GA22-6821). This includes a brief review of relevant conventions attributable to the development of System/360
System/360 concepts and descriptions of selected assembler operating systems. Chapter 1 is new, and several sections in
language instructions for arithmetic, logical, and branching other chapters have been entirely rewritten. The sample
operations. Standard (flXed-point) , decimal, and floating- programs have been reassembled under the widely used
point arithmetic are discussed. The book also includes an Disk Operating System (DOS). As far as possible, usages
elementary introduction to assembler language and the limited to DOS have been avoided, and the programs and
assembler program, and chapters on base register addressing text in general are applicable to System/360 models 25, 30,
and on program linkages and relocation. The coding of 40,50,65, and 75, under any of the operating systems.
many other common programming techniques, such as the IBM publications that may be useful to the student are:
use of branches, loops, and counters, is shown. The use of IBM System/360 Principles of Operation (SRL manual
macro instructions is demonstrated, but not covered in GA22-6821)
detail. Program flowcharting and input/output operations IBM System/360 Reference Data (card GX20-1703)
are beyond the scope of the book. IBM System/360 System Summary (SRL manual
The publication is a sampler rather than a comprehensive GA22-6810)
textbook. It is intended for supplementary reading for the Number Systems (Student Text GC20-1618.)
student in a regular course of study on System/360 assem- Introduction to IBM System/360 Architecture (Student
bler language coding, and for the novice programmer. In Text GC20-1667) .
general, the reader will fmd that the program examples are Introduction to System/360 (P J. Course GR29-0256
quite simple at the beginning of each chapter, or ·major through -0259)
subject division, and become progressively more complex. Computing System Fundamentals (p. I. Course
If the going seems difficult, it is suggested tltat he simply GR29-0280 through -0282)
skip to the next subject and come back later. Fundamentals of Programming P J. Course SR29-OO19)
The student should have access to two IBM System/360 System/360 Assembler Language Coding (p. I. Course
System Reference Library (SRL) manuals for reference SR29-0231 through -0235)
purposes: the Principles of Operation and the assembler The form numbers of the assembler specification
specification manual for one of the System/360 operating manuals for the various System/360 programming systems
systems. (All publications and their form numbers are listed are:
at the end of the Preface.) He should also be familiar with Basic Programming Support (Tape System)-GC24-3335
fundamental concepts of data processing and the basic Basic Operating System-GC24-3361
operating principles of System/360. Two IBM programmed Tape Operating System } 4
instruction (p. I.) courses, or their equivalent, are pre- Disk Operating System GC24-341
requisite to a. full understanding of this student text: Operating System-GC28-6514
iii
Contents
FIGURES
TABLES
2-1 Extended Binary Coded Decimal Interchange Code (EBCDIC) for Graphic Characters 22
2-2 Hexadecimal Code . . . . . . . . . . . . . . . . . . 26
2-3 Hexadecimal and Decimal Integer Conversion Table . 27
3-1 Masks for testing various states of the condition code 39
7-1 Summary of Editing Functions . . " . . . . . . . . 88
8-1 DOS Linkage Registers .. . . . . . . . . . . . . . . 111
9-1 Equivalent Values of the Characteristics of Some Floating-Point Numbers 127
9-2 Instruction Set for the System/360 Floating-Point Feature . . . . . . . 130
vii
Chapter 1: Introduction
are represented by the frrst two characters (the frrst two listing in Figure 1-2? The mnemonic TITLE does not even
hexadecimal numbers, really) in the circled object code. In show up at all (it was in the source program), but we see
the example, the executable instructions include one of the that the assembly listing has the heading ILLUSTRATIVE
branching instructions (BALR, op code 05), Load (L, op PROGRAM. TITLE is an instruction to the assembler that
code 58), Add (A, op code SA), one of the Shift Left tells it to print a heading or title at the top of each page in
instructions (SLA, op code 8B), Subtract (S, op code 5B), the listing. Similarly, START and USING are instructions
Store (ST, op code 50), and so on. In assembler language, to the assembler; these concern the addressing plan it is to
the executable instructions are called machine instructions. follow. Although they will affect the way in which the
Not counting floating-point arithmetic instructions, assembler assigns addresses, they will have no direct func-
System/360 assembler language has about 100 different tion in the execution of the problem program. In contrast
machine instructions. I t is fairly easy to recognize and to machine instructions, they are called assembler
remember all of the mnemonics for them-certainly easier instructions. They may be defmed as instructions to the
than remembering the machine language operation codes. assembler program itself.
Some other examples are C for Compare, CVD for Convert Skipping the EO] for the moment, we see the mne-
to Decimal, SH for Subtract Halfword, STH for Store Half- monics DC (Defme Constant) and DS (Defme Storage).
word, M for Multiply, and BC for Branch on Condition. A These two instructions are also assembler instructions. DC's
full list of System/360 machine instructions appears in the generate object code for the values they define, but no
Appendix; floating-point instructions are given in the chap- operation codes. DS's actually reserve storage space of a
ter on that subject. Each machine instruction and what it specific size, but they too do not generate operation codes.
does is described in complete detail in the IBM Systems In other words, DC's cause the assembler to create object
Reference Library (SRL) manual IBM System/360 Princi- code for actual values and DS's reserve actual storage
ples of Operation (A22-6821). Many will be described in spaces, but they do not themselves give rise to any action
this bock in nontechnical language, but not in complete during program execution. Instead, they are used for either
detail. information or space by other instructions in the program.
If we look again at the assembly listing, we see that DATA,
Assembler Instructions CON, RESULT, etc., are operands of some of the execu-
What about the TITLE, START, and USING instructions table instructions.
that have not· generated any object code in the assembly Assembler-instruction mnemonics, which are also listed
2
Mflch/ne Instructions
in Machine language Machine instructions
LOC OBJECT CODE in assembler IOf/!/uaStl
,-.\-..---_../
000 100";:~
000100 05BO
000102 I' ,\
000102 5a2~ ~b2~\ 00124 LOAD REGISTER 2
0001065A'20 BCl2A 0012C ADD 10
00Dl0t 8B20 0001 00001 THIS HAS EFFECT OF MULTIPLYING BY 2
00010E 5B20 ~026 00128 NOTE RELATIVE ADDRESSING
OOOlle 5020 aD2E 00130
000116 5860 ~032 00134
00011A 5A60 ~b36 00138
0001lE" 4E60 ..B03E 00140 DEC IMAL
Figure 1-2. Assembly listing of the program in Figure 1-1. The executable instructions (see text) are circled in both assembler language and
the machine language translation.
in the Appendix, generally suggest their purpose. USING they have mnemonics like EOJ, READ, WRITE, OPEN,
indicates a particular register to be used by the assembler CLOSE, WAIT, WAITF, DTFCD, DTFIS, etc. The
for keeping track of storage addresses, EJECT tells the mnemonics for both the user-prepared and the IBM-
assembler to start a new page in the program listing, and supplied macros constitute an extension to System/360
END to terminate the assembly program. Assemblerinstruc- assembler language.
tions and the functions of the assembler program are The macros supplied by IBM are mainly for procedures
described fully in each of the SRL assembler language man- that affect other components of the IBM operating system,
uals for the various IBM operating or programming support- like the supelVisor and the input/output control system, and
systems (see Preface for list). It should be explained that they ensure accuracy and consistency in maintaining the
variations of the System/360 assembler program are avail- interrelations within the operating system. The EOJ (End of
able for different operating systems and sizes of computers. Job) in the program example is a supelVisormacro
Basically, they all work similarly, but some are more flexi- instruction. It generates just two statements, which are
ble and versatile than others. Many differences do exist, indicated in the listing by plus signs. The frrst is simply for
however, in the input/output (I/O) programming for identification, and the second is the executable SupelVisor
different systems. Largely for this reason, the subject of I/O Call instruction (SVC, op code OA).
will not be covered in this book. Most I/O routines are long and complicated, and for any
particular device and operating system are programmed in
Macro Instructions exactly the same way in program after program. Most of
the macros supplied by IBM are for these I/O routines. Some
In an entirely different category, System/360 assembler
of the Disk Operating System (DOS) macro instructions we
language includes another type of instruction, called a
shall use in this book, besides EOJ, are CALL, SAVE,
macro instruction or macro. If a programmer writes a series
RETURN, and PDUMP. The book does not cover the
of instructions for a routine that will be needed again and
preparation of new macros, but shows, in the chapter on
again during the program, he does not have to code the
subroutines, another method for reusing a sequence of
entire sequence each time. He can make up his own code
instructions. However, the programmer can save much time
name to represent the sequence, and, by using his code
and effort by using the macros that are already available in
word in a single statement whenever it is needed, he can
his system library. Their use will also ensure accuracy and
cause the sequence of instructions to be assembled and
standardization of frequently repeated procedures.
inserted. Incorporated in the system library, the sequence
can also be used in entirely separate programs and by all
programmers associated with a computer installation simply Summary
by writing one statement in the source program. The mne- To summarize, these are the three kinds of instructions
monics used for macro instructions are often unique to an used in System/360 assembler language, and what each does:
installation. Some macros are prepared and supplied by IBM; 1. A machine instruction specifies an actual operation
Introduction 3
to be performed by the computer when the object program programming time against the cost of machine time. A com-
is executed. The operation may be arithmetic, or the com- plex mathematical problem that can be run in a few
parison, movement, or conversion of data, or performing a minutes and will be run only once is a very different
branch. The instruction generates executable object code. situation from a program that runs for several hours and
2. An assembler instruction specifies an instruction to will be repeated every week.
the assembler program itself and is effective only at Here we can appreciate one of the important advantages
assembly time. It does not generate executable object code. of assembler language over the high-level languages: its effi-
3. A macro instruction specifies a sequence of machine cient use, in the hands of a skillful programmer, of
and assembler instructions to perform a frequently needed computer storage and time. High-level languages produce
routine. The machine instructions generate executable generalized routines so that a wide range of data processing
object code. needs can be met with a minimum of programming effort.
A routine can be written in assembler language exactly to
Why Learn Assembler Language? fit some particular data processing need, thus saving storage
The most important single thing to realize about assembler space and execution time.
language is that it enables the programmer to use all System/ As we shall see in the course of this book, there are often
360 machine functions as if he were coding in System/360 many ways of accomplishing the same data processing results.
machine language. Of all the programming languages, it is Sometimes the overall programming requirements of a com-
closest to machine language in form and content. The high- puter installation strain its capacity. If the particular
level languages such as FORTRAN, COBOL, and PL/I are problem arises of either not enough main storage space or
problem-oriented rather than machine-oriented. Their lan- not enough processing time, the problem may be solved by
guages are much like English or mathematical notation. assembler language. In such a situation, its flexibility
Depending on what is involved, one statement in these lan- permits the programmer to choose those programming
guages may be compiled into a series of two or eight or techniques that will provide just the kind of economy
fifty machine language instructions. The problem-oriented needed-time or space.
languages have the advantage of letting the programmer A knowledge of assembler language has some important
concentrate on what he wants to accomplish and not on benefits for a programmer working in a high-level language.
how it is to be done by the computer, and they may save It can be helpful to him in analyzing and debugging
considerable time in programming, program modification, programs. It also enables him to include certain assembler
and program testing. Choice of a programming language in language routines in his program to meet special systems or
any given situation usually involves weighing the cost of other requirements.
4
THE ASSEMBLER PROGRAM
Figure 1-3. Assembly of a problem program, PROGA. Note that PROGA is not executed during the assembly process.
Introduction 5
Briefly, here is how the assembler works. It reads source It always contains at least the name of the problem
statements as input data, checking for errors and flagging program, its total length, and its starting address on the
them for further processing. At frrst, it translates the parts assembler's location counter.
of the input (such as operation codes) that do not need S. The relocation dictionary (RLD) describes the
further analysis or calculation. Meanwhile, it constructs a address constants that will be affected by program
table of all the symbols used, in which it collects, as it goes relocation. This list is also passed on to the linkage editor.
along, such information as each symbol's length, its value or We have now reached the end of the assembly process.
location, and the statements in which it is referred to. From What happens next? Our object program is in relocatable
this table and other analyses of the source statements, the form, but it will not be executable until it has been
assembler can then assign relative storage addresses to all processed by the linkage editor.
instructions, constants, and storage areas. It uses a location
counter for this purpose (see LOC column in Figure 1-2). It Final Processing
does all the clerical work involved in maintaining the base The linkage editor program is another component of the IBM
register addressing scheme of System/360 computers. operating system. Its functions, which will not be described
During its operations, the assembler continues to note fully here, can provide great flexibility and economy in the
errors and to resolve any it can. use of main storage. The linkage editor also makes it
As shown in Figure 1-3, there are two kinds of output possible for a long and complicated program to be divided
from the assembler program. The primary output is the into separate sections, which can be programmed, assem-
object program in machine language; included with it is bled, and debugged by different programmers, and then
certain information tabulated by the assembler, which is linked together to be executed. The linkage editor is loaded
needed for relocating the program to an actual main storage into main storage and operates as a separate program under
location and for establishing links with separate programs. control of the control program, just as the assembler did.
(This information will later be passed on to the linkage Input to the linkage editor may be a single assembled pro-
editor for the next step in the processing.) The other gram or many separate programs. The linkage editor works
output from the assembler is a series of printed listings that on one after the other, building up composite dictionaries
are valuable to the programmer for documentation and of ESD and RLD data to resolve all references between
analysis of his program: individual programs and to set up necessary linkages. It also
1. The listing of the program (samples of these will be searches the system library and retrieves any programs
shown throughout this book) includes the original source referred to. It relocates the individual programs as necessary
program statements side by side with the object program in relation to each other, assigns the entire group to a
instructions created from them. Most programmers work specific area of main storage, and modifies all necessary
from this assembly listing as soon as it is available, hardly address constants to the relocated values of their symbols.
ever referring to their coding sheets again. After completion of the link-editing, our problem pro-
2. Probably next in interest to the programmer is the gram can be loaded into main storage and executed under
diagnostics listing, which cites each statement in which an supervision of the control program. Unless specified other-
error condition is encountered and includes a message des- wise, each machine instruction is executed in sequence, one
cribing the type of error. after the other. If there is separate input data, it can be
3. The cross-reference listing shows the symbol table brought in by I/O instructions in the program. Output-the
compiled by the assembler. results of program execution-also requires I/O instructions.
4. The external symbol dictionary (ESD) describes any The scope of this book does not go beyond the assembly
references in the problem program needed for establishing process. For a clear understanding of the detailed program
links with separate programs. It is possible for the pro- examples, however, it is essential for the reader to be able
grammer to combine his program with others, or to use to visualize at just what stage in the entire process each
portions of separate programs, or to make certain portions action occurs. For this reason, the complete process from
of his program available to other programs. The ESD is part programmer-written program to its fmal execution has been
of the tabular information passed on to the linkage editor. outlined in this section.
6
USE OF THE CODING FORM
Assembler language programs are usually written on special the assembler permits nearly complete freedom of format.
coding forms like the one in Figure 1-1, which will be However, lining up entries as shown makes it simpler to
repeated here for convenience. Space is prOVided at the top read a program, and following the form permits the pro-
for program identification and instructions to keypunch grammer to painlessly observe the few essential rules
operators, but none of this information is punched into required by the assembler.
cards. Some of these rules are as follows. (1) The entries must be
The body of the form is completely keypunched in in proper sequence. (2) If a name is used, it must begin in
corresponding columns of 80-column cards. Use of the column 1. (3) The entries must be separated by at least one
Identification-Sequence field (columns 73 - 80) is optional space, because a space (except in a comment or in certain
and has no effect in the assembled program. Program identi- terms enclosed in single quotes) is the signal to the assem-
fication and statement sequence numbers can be written in bler that it has reached the end of an entry. ( 4) Spaces must
part or all of the field. They are helpful for keeping the not appear within an entry, except as noted. (5) A state-
source cards in order and will also appear on the assembly ment must not extend beyond the statement boundaries,
listing. Indeed, the programmer can use an assembler normally columns 1 - 71.
instruction (ISEQ) to request the assembler to check the We have been using that word "normally" because the
input sequence of these numbers. programmer can override the specific column designations
The statement field is for our program instructions and by an ICTL (Input Format Control) assembler instruction,
comments, which are normally limited to columns 1 - 71. which can specify entirely different begin, end, and contin-
Each statement can be continued on one or more lines, uation columns. A statement is normally continued on a
depending upon which assembler program is used. A state- new line in column 16, with some character (often an X)
ment consists of: inserted in column 72 of the preceding line. Since the
1. A name entry (sometimes) normal spacing is generally the most convenient and is
2. An operation entry (always) easiest for a keypunch operator to follow, we shall use the
3. An operand entry (usually) spacing indicated on the form throughout this book.
4. Any comment we wish to make The purpose of using a name in a statement is to be able
It isn't necessary to use the spacing shown on the form, since to refer to it elsewhere. It is a symbol of eight characters or
t-----<?---")~...>.::0G4~_3_-;;;:;;oo-------------r-----_j I I I [ [ .LPAGE
I
OF
J J. ~1IIe.S IDATE
PUNCHING
INSTRUCTIONS I GRAPHIC
PUNCH [
I [ I CARD ELEQRO NUMBER
60
J: ,,:,';1':
, ,'.'
:'" 1:;1::
f: :,liC
c.vp ~.lJE.C
: :.' .:, --'-
: '. I ".' :', ..' ! I : : "
~ 'P't~':, .::' .':. ,': I i
Il'S F
BIN2- U F'7i' .:
pee "
:-:
! !
, I
Ii i
!
! I
8
AN ASSEMBLER LANGUAGE PROGRAM
Introduction 9
with other jobs. EOJ is the last executable (or machine) alignment, and it becomes the programmer's responsibility.
instruction in our program example. The END assembler instruction specifies that nothing
The DC's and DS's follow the executable part of the further follows, and it terminates the assembly process. The
program in a group, as is customary. These assembler instruc- END instruction must always be the last statement in a
tions were discussed earlier in this chapter. Defme Storage source program.
(DS) is used to defme and reserve an area of storage, which
may be used during execution of the program for work The Assembly Listing
areas or for storing a varying value. Defme Constant (DC) Let's inspect the assembly listing, repeated here as Figure 14,
allows us to introduce specific data into a program (a con- to see how the assembler handled things. We see that, except
stant simply means an unchanging value). for the TITLE statement, the original source program has
Each DC and DS must have a type specification that been reproduced without change on the righthand side of
designates the particular data format in which it is to be the listing. The object code created from the source instruc-
entered into internal machine storage. Some of the data tions is listed under that heading. The location counter
formats are the eight-bit character code (type C), the four-bit setting of each statement is shown in the leftmost column.
hexadecimal code (type X), zoned decimal numbers (type Z), The address of the second operand in each instruction is
packed decimal numbers (type P), and fixed-point binary
under the heading ADDR2. (All fust operands here happen
numbers (type F or H). A more complete list appears in the
to be in registers.) All entries to the left of the statement
Appendix and in the assembler language specification
number column are in the hexadecimal number system,
manuals listed in the Preface. In the program at hand and in which is the alphabet, so to speak, of System/360 machine
Chapter 3, where we shall be studying System/360 fixed- language.
point binary operations, however, all the constants are type The assembler instructions TITLE, START, USING, and
F or H (the F is for full word, H for halfword, implying END did not produce any object code, and, as we can see
length as well as giving the type). from an inspection of the location counter readings, do not
Fixed-point operatiot:ls work on flXed-length operands use any space in the object program. The location shown on
and in most systems require that they be located in storage each of these lines is simply the current setting of the
on halfword, fullword, or doubleword boundaries. In other location counter, which, after assembly of each instruction
words, the addresses must be multiples of 2, 4, or 8. When that will use storage space, was updated to show the next
F or H is used to signify the length of a DC or DS (D for available byte.
doubleword may also be used in a DS), the assembler will The START 256 sets the assembler's location counter to
perform the necessary alignment, skipping a few bytes if hexadecimal 000100, or 100-. The object code that is
necessary. In our program all the F -type constants and areas actually at location 100 (in bytes 100 and 101) and will be
will be on four-byte boundaries. The DS at DEC will reserve at the equivalent location in core storage is 05BO, the
an eight-byte space, aligned on a doubleword boundary. If machine language translation of the BALR instruction. Hex
the programmer modifies these terms, for example, by 05 is the BALR operation code, B is register 11 (B is the
specifying 2F instead of D, the assembler will not perform
ILLUSTRATIVE PROGRAM
10
hex equivalent of 11), and 0 is register zero (which means, (The subscript lOis used to indicate a number in the
in effect, no register and no branching). This instruction is decimal system. A subscript of 16 is used for hexadecimal,
in the RR (register-to-register) machine format, which has a and 2 for binary.)
length of two bytes and looks like this in storage (contents SLA is in the RS (register-and-storage) machine
are shown here in hex rather than binary): instruction format, also four bytes in length, and it is in
Op Code Reg1 Reg2 bytes lOA, lOB, IOC, and 10D.
I 0 5 I S \ 0 \
I
Op Code
8 S
Reg1 Reg3 Sase2 Displacement2
o 7 8 11 12 15
o 7 8 1112 15 16 19 20 31
The subscripts 1 and 2 refer, both here and in other instruc-
tion formats, to the frrst and second operands. In the RR The op code is 8B and the fITst operand is in register 2. The
format both operands are in registers. next four bits are never used in a shift· operation, the next
After the BALR was assembled, the location counter read four could be used for a base register for the second
102, which was the next available byte, and stayed that operand but are not in this case, and the fmal 001 merely
way until additional object code was generated. USING did indicates a shift of one binary place. No provision is made
not generate object code, so 102 was the setting when the for using an index register in this format. As we shall see
L 2,DATA was assembled. The asterisk in the USING later, some RS instructions, like Branch on Index High
means the current, updated location counter setting, which (BXH) and Store Multiple (STM) , have a third operand.
at that point was 102. The next five instructions are all in the RX format and
The next instruction, Load, is the fITst that will actually offer no new concepts. The reader may wish to brush up on
process program data. It is an RX (register-and-indexed- hexadecimal numbers and check that the displacements
storage) instruction, which has a machine format of four have been computed correctly, taking into account the rela-
bytes. It occupies bytes 102 to 105: tive address in the Subtract. We can see even in this simple
op Code Reg1 Index2 Sase2 Displacement2 example how much of the clerical burden' the assembler
takes over by automatically assigning base registers and
\5 8\21 0 \sI0 2 21 calculating displacements.
o 7 8 1112 1516 19 20 31
The assembled entries for the DC's are simply the
In this format, the first operand is in a register, the second requested constants, in hexadecimal. We note that the DS
in main storage. Reading the assembled bytes from left to entered nothing, but simply reserved space. A study of the
right, we have the op code 58 for Load and register 2 for address for the double word constant at DEC shows that
the register to be loaded, and the remaining code giVes the boundary alignment was performed. The fullword constant
address of the second operand. Zero means there is no BIN2 was placed at 138. Counting in hexadecimal, BIN2
index register, B (hex for 11) is the base register, and 022 is occupies four bytes: 138,139, 13A, and 13B. Although 13C
the displacement in bytes. The effective address, formed by was available for DEC, it is not on a doubleword boundary,
the assembler, is the sum of the contents of the base regis- nor is 13D, 13E, or 13F. So the assembler skipped these
ter (102), the contents of the index register (O or no four bytes and assigned DEC to 140.
register), and the displacement (022). These add up to The END assembler instruction terminates the assembly
hexadecimal 124. Looking down to the· assembled location of the program. The operand indicates the point to which we
of DATA, we see that it is 124, as it should be. wish control to be transferred when the program is loaded.
The Add instruction that follows is also in the RX for- In this case, it is to our fITst instruction in the object
mat, and again no index register is used. The base register program, named BEGIN, where actual execution of the
contents of 102 (258to) plus the displacement of02A (421O) program is to begin. Note that the location counter shows
gives a sum of 12C (30Oto), which is the location of CON. the value 100 at the END statement.
Introduction 11
ERROR ANALYSIS BY THE ASSEMBLER
Certain kinds of programming errors can be detected rather from the assembler program, which was described earlier in
simply by the assembler. In fact, some errors make it this chapter. The diagnostics listing for our program
impossible for the assembler to generate an instruction and example is shown in Figure 1-6. The assembler always gives
complete the assembly. The assembler carries out the a summary message, shown at the bottom, of the total
assembly as completely as possible, regardless of the number number of statements in error. If no errors are found, the
of errors, even if the first error detected makes it impossible happy message NO STATEMENTS FLAGGED IN THIS
for the object program to be executed. The idea is that, if ASSEMBLY is printed at the end of the symbol cross-
there are more errors, the programmer needs to know about reference table, and no diagnostic listing is printed.
all of them, not just the first one the assembler encounters. Let's see what the assembler has to tell us about statement
Figure 1-5 is the assembly listing of a program written 6. The message is on the first line of the diagnostics
deliberately with a number of errors in it, to demonstrate listing: UNDEFINED OPERATION CODE.
what the assembler can do and how it announces its We check the mnemonic for Shift Left Single and find of
findings. The first announcement is made on the program course that we should have written SLA instead of SLS.
listing itself, where every statement with a discernable error The assembler program cannot assume SLA was meant; we
is followed by a line prominently reading might have meant SL, SLR, SLL, or any other valid opera-
tion code. Since it cannot tell what was intended, it flags
*** ERROR *** the statement and does not assemble the object code or
When the programmer is warned of the existence of an even assign space to the instruction.
error, he can often see rather quickly what is wrong. The diagnostic message for statement 7 is UNDEFINED
Looking over the listing in Figure 1-5, he would probably SYMBOL. The undefined symbol is DATA4. This is
notice at once that the comma between operands in state- accepted as a valid symbol, since it follows all the rules
ment 9 is omitted, and that statement 19 is, from his point governing the writing of symbols. That is, it begins with a
of view (but not the assembler's), a bundle of typographical letter, uses only letters and numbers, does not contain
keypunching errors. special characters or blanks, and isn't more than eight
Some errors may not be so obvious. To help the pro- characters. Looking at the symbols or names listed in the
grammer analyze them, the assembler prints a separate source statements, we see we have dermed DATA and
listing of diagnostic messages. This is part of the output remember that we intended DATA+4 as the address of the
Figure 1-5. Assembly listing of the program rewritten with deliberate errors
12
DIAGNOSTICS
Figure 1-6. Assembly listing of diagnostic error messages for the program in Figure 1-5
next constant. To the assembler there is no relationship at warned that an error exists. It is his job to make his
all between DATA4 and DATA; they are simply different intentions known.
symbols. But if we write DATA+4, the assembler program UNDEFINED SYMBOL appears again for statement 11.
will recognize the plus sign as a special character that, From the programmer's viewpoint, a reverse situation exists
among other things, delimits the symbol DATA. from the one in statement 7. This time the instruction
Confronted with DATA4, the assembler does not assemble statement is as it should be, but the DC defming the symbol
the object code. This time, however, the valid mnemonic S shows IN 1 instead of BIN 1. There is no indication that
indicates that this instruction will be in RX format. So the these are related in any way or that one is not correct.
assembler assigns four bytes to the instruction. Statement 16 elicits the message DATA ITEM TOO
In statement 9, the Load instruction, we already know LARGE. This is perfectly clear. The decimal value
that our error was the omission of the comma in 6,BINl. 9,876,543,210' cannot be contained in a 32-bit binary full-
This made the assembler give two identical diagnostic word, and the hexadecimal value shown as four bytes has
messages: INVALID DELIMITER. From the mnemonic L, evidently been truncated.
the assembler anticipates an RX format, the L to be Statement 18 was awarded two error messages:
followed by a register number, a comma, and a storage UNKNOWN TYPE when the assembler program found no
operand. Finding a B instead of a comma probably led to type designation, and MISSING OPERAND when it
the first message. What about the second message? What scanned further on. Jumping ahead for a moment, we fmd
does it mean? that statement 22 has the message PREVIOUSLY
Here the error code in the second column of the diag- DEFINED NAME, and we see that DATA has already been
nostic listing may help. The meaning of each message is given in statement 15.
given in expanded form in a table of error codes in the In statement 19 the first letter of each entry is omitted.
assembler manuals. (The letters IJQ here simply stand for a The messages are INYALID DELIMITER, which may mean
particular assembler program, the Disk Operating System D almost any error of syntax, and INVALID SYMBOL, which
assembler.) If we were to look up IJQ039 in the table, we apparently applies to the name INI. What's the matter with
would find that it means "any syntax error". About a IN I? It begins with a letter and violates no rules we know of.
dozen possibilities are listed. An invalid delimiter is the It should be perfectly acceptable to the assembler. We are
usual error in assembler language syntax, hence the wording the only ones who know it is misspelled. Also, when the
of the message. Some other possibilities are (1) an unpaired message UNKNOWN TYPE is available, why single out the
parenthesis, (2) an embedded blank, (3) a missing delimiter, operand with its missing F as a syntax error? Four bytes of
(4) a missing operand, and (5) a symbol beginning with zeros have been generated. Why did the assembler assign a
other than an alphabetic character. Well, the first two specific length? Also, apparently no fault was found with
obviously don't apply to 6BINl, and it would be difficult the mnemonic C. How is that? The point is precisely that C
and unrewarding to make a choice among the others, is a valid operation code. So the assembler, being given this
especially considering the compounded error in the symbol definite "fact" (the most important single fact in any
in statement 19. What the two messages signify is that there instruction), performs its syntax scan and other operations
is no reliable evidence of what was intended or just which as if it were dealing with a Compare. The mnemonic C
specification was really violated. The programmer is amply indicates that the instruction is in the RX format requiring
Introduction 13
four bytes, that the first operand
I
must be a number listing is enough. The programmer will be interested in the
between 0 and 15 followed by a comma, and that the message itself only when he cannot identify the mistake.
second operand may be a symbol. But the operand field of This review of how the assembler analyzes programming
this Compare instruction contains simply the characters errors should also make it clear that many errors are
" '12' ". This then is the "symbol" the second message beyond the power of the assembler even to recognize. When
refers to. Indeed, both messages evidently apply to the we incorrectly write DATA4 for DATA+4, the assembler
operand field. To the assembler program nothing is wrong can detect it, but not if DATA4 itself is a legitimate
with the name or the operation code mnemonic. symbol. If we write SLL for SLA, the assembler will assume
For such reasons as these, the diagnostic messages given that SLL is what we mean; both are valid operation codes
by the assembler may often seem quite inaccurate from the with the same format. The ability of the assembler to
programmer's point of view. In many cases, the assembler detect and analyze errors can be very helpful to the
simply does not have enough clues to pin down the precise programmer. However, the message NO STATEMENTS
error, and the messages should not be taken literally. The FLAGGED IN THIS ASSEMBLY cannot be taken to mean
assembler program was designed to be as helpful as it can that a program has no errors or that it will necessarily
be, and the messages are an effort to help the programmer produce the right answers when it is executed.
diagnose the trouble. Usually the error flag on the program
14
MODIFYING AN ASSEMBLER LANGUAGE PROGRAM
After a program has been written, assembled, and com- changing almost every effective address in the program! The
pletely debugged, it frequently happens that some change insertion of the four-byte instruction "pushes down" the
must be made later. Many types of revisions are simple to storage spaces for the DC's and DS's, requiring a change in
make in an assembler language program. But let us see what the displacements of all the instructions that refer to the
happens to the locations of instructions and data when even constants.
a minor change is made. We shall base the example on the Figure 1-7 is the assembly psting of the modified
correct version of the program, as it appeared assembled in program. Scanning down the a~embled instructions, we see
Figure 1-4. that the displacements have been computed to reflect the
Let us suppose that for some unspecified reason it is change in locations. Continuing the comparison, however,
necessary to store the sum of BINI and BIN2 in binary we see that ADDR2 and the displacement in the Convert to
before converting it to decimal. We must insert an Decimal instruction are the same as in the earlier version.
instruction: Has there been a mistake?
The answer is the boundary alignment of the double-
ST 6,BINANS
word constants. In the earlier version, it was necessary to
just before the CYD. skip four bytes to provide an address for DEC that was on a
This is a rather simple sort of change and one that is double word boundary. The inserted instruction, in effect,
representative of the kind of modification made with routine filled that skipped space. The reassembly therefore left the
frequency on many programs. Yet it can have the effect of assembled address for DEC unchanged.
Figure 1-7. Assembly listing of the same program modified to store the binary contents of register 6
Introduction 15
Chapter 2: System/360 Review
The reader may fmd it helpful at this point to review some storage, a central processing unit (CPU), the selector and
basic facts about System/360 that are directly relevant to multiplexor channels, and the input/output (I/O) devices
assembler language programming. These are stated as briefly attached to the channels through control units. For basic
as possible in this chapter and will serve mainly as a information that applies to the material in this book, we are
reminder. A student who is familiar with the material may concerned principally with the CPU and main storage. In
skip any or all of the sections without loss. A student who this chapter, discussion will essentially be limited to these
needs more than a reminder is urged to go back to the machine units and their basic operating principles.
textbook or course materials he originally studied for an Since a knowledge of hexadecimal numbers is necessary
introduction to System/360. in assembler language programming, these will also be
The basic structure of a System/360 consists of main explained.
MAIN STORAGE
Main storage is also called core or processor storage to Bytes may be handled separately or grouped together in
distinguish it from storage on tape, disk, or other auxiliary fields. A halfword is a group of two consecutive bytes and
devices. It is closely involved in the operation of the CPU, is the basic building block of instructions. A word is a
although it may be either physically integrated with it or group of four consecutive bytes; a doubleword is a field
constructed as a stand-alone unit. Capacity may be from consisting of two words (Figure 2-1). The location of any
8,192 bytes to several million bytes, depending on the field or group of bytes is specified by the address of its
system model. Protection features are available that make it leftmost byte.
possible to protect the contents of main storage from access
or alteration. Byte
In general, instructions and data are stored along with
each other in whatever order they are presented to the hlOO'OOOll
machine., Particular areas of storage may be used over and o
over again by a succession of programs or groups of
Halfword
programs being executed. Each group overlays, or replaces,
the instructions and data of the one preceding. The pro-
grammer must therefore specify blanks or zeros where he 7 8 15
needs them; he can never assume he is writing on a clean
slate. During execution of his program, he can obtain a Word
printout or "dump" of an area of storage at any point in
the program by use of suitable instructions.
Bytes and Data Field Lengths Figure 2-1. Sample data formats
The system transmits information between main storage
and the CPU in units of eight bits, or a multiple of eight The length of fields is either implied by the operation to
bits at a time. Each eight-bit unit of information is called a be performed or stated explicitly as part of the instruction.
byte, the basic building block of all formats. A ninth bit, When the length is implied, the information is said to have a
the parity or check bit, is transmitted with each byte and flXed length, which can be either one, two, four, or eight
carries odd parity on the byte. The parity bit cannot be bytes.
affected by the program; its only purpose is to cause an When the length of afield is not implied by the
interruption when a parity error is detected. References in operation code, but is stated explicitly, the information is
this book to the size of data fields and registers exclude the said to have variable field length. This length can be varied
mention of the associated parity bits. in one-byte increments.
System/360 Review 17
Within any program fonnat or any flXed-length operand must be located in main storage on an integral boundary for
format, the bits making up the fonnat are consecutively that unit of infonnation. A boundary is called integral for a
numbered from left to right starting with the number O. unit of infonnation when its storage address is a multiple of
This general infonnation on data fonnats and field the length of the unit in bytes. For example, words (four
lengths wi1l be supplemented later by further details. bytes) must be located in storage so that their address is a
Lengths and the specific form of the contents of the fields multiple of the number 4. A halfword (two bytes) must
are discussed in the section on the arithmetic and logical have an address that is a multiple of the number 2, and
unit, under the headings for logical operations and the doublewords (eight bytes) must have an address that is a
specific types of arithmetic .. multiple of the number 8.
F or greatest efficiency in storage addressing, address
Addressing arithmetic is done exclusively in binary. In binary, integral
Byte locations in storage are consecutively numbered boundaries for halfwords, words, and doublewords can be
starting with 0; each number is considered the address of specified only by the binary addresses in which one, two, or
that byte. A group of bytes in storage is addressed by the three of the low-order bits, respectively, are zero (Figure 2-2).
leftmost byte of the group. The number of bytes in the For example, the integral boundary for a word is a binary
group is either implied or explicitly defined by the address in which the two low-order positions are zero.
operation. The addressing arrangement uses a 24-bit binary Variable-length fields are not limited to integral bound-
address to accommodate a maximum of 16,777,216 byte aries, and may start on any byte location.
addresses. This set of main-storage addresses includes some
locations reserved for the supervisor and other special Low-order Four Bits of Binary Address
purposes. How storage addresses are generated is described O~ 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010
in the section on program execution.
The available storage is normally contiguously address-
Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte Byte
able, starting at address O. An addressing exception is
recognized when any part of an operand is located beyond ,
l
the maximum available capacity of an installation. Except
for a few instructions, the addressing exception is recog- Halfword Halfword Halfword Halfword Halfword
,
t
nized only when the data are actually used and not when ~
the operation is completed before using the data. The Word Word Word
l
addressing exception causes a program interruption.
L. Double Word Double Word
,
t
Positioning on Integral Boundaries
Figure 2-2. Integral boundaries for halfwords, words, and double-
Fixed-length fields, such as halfwords and doublewords, words
18
CENTRAL PROCESSING UNIT
The central processing unit (Figure 2-3) contains the facili- operand bits and must have an even address, and the
ties for addressing main storage, for fetching or storing implied register, containing the low-order operand bits, has
information, for arithmetic and logical processing of data, the next higher address.
for sequencing instructions in the desired order, and for
initiating the communication between storage and external R Field Reg No. General Registers Floating-Point Registers
devices.
The system control section provides the normal CPU 1 32
Bits1 i64Bitsi
control that guides the CPU through the functions necessary 0000 0 1::::·'::::::;:;:::-:::::::::;::::::::::·-·:·-·:·1 E:-:-:-:·:·;·:·:-:·:·-·:·:·:-:·;·-·:·-·:·:·:·:·-·:·:·:·:.:.:.....:.:.:.;.:.:.:.:.;:::::::::::::::)
0001 1 1·:·:·:·:·····:·:··....···:·····:···:·:-:·:::1
to execute the instructions. The programmer-trainee will 0010 2 1:-:-;.:.-:-,-:·:-:-:·:·:-:-:-:-;-:-;-:-:·:-;·;.:·:-:·;-:.:.:.:.:.:.:.:.:.:.:.:.:.:.:.:•.•:-:J
probably be glad to know that the result of executing a 0011 3 ,.:::.:.; .............................:.:.:.:.
4 .;.;.:.:.:.;.;.:.:.:.:.:.:.:.:.:.;.:.;.:.:.;.:.:.:.:.:.;.:.:.;.;.:.;.:.;.:.:.:.:.:.;.:.:.:.;.'
0100 ;:::::::.:.:.:::.:.:.:.;.:.;.:.;.:.:.:.:.:.j
valid instruction is the same for each model of System/360. 0101 5
0110 6 f;·:·;·;·······:·····;·:·:·:·:·:·:·;.:·:·:·:) t.::;:::::·:·:·:···························;···:·;·:·:.:.;.:.:.:.;.;.:.:.;.:.;.:.;.:.:.:...;.;'
Storage
1----1 0111
1000
1001
7
8
9
f:·;·:·:·-··_··········-··_··········:·-·:·:1
t;::::·;···:·;·:·:·:·:-;·_··:·:·:·;·;·:·:-:j
.;.:.:.;.:.;.;.;.:.;.;.:::-:::;::::::::::::j
Address ..I
"I
I MAIN STORAGE
1010
1011
10
11
(.:-:.: .._...._........._......-.:.:.:.:.j
.:.:.;.:.:.:.:.:.:.:.:.:.:.:.;.;.:.:.:.;.:.j
L __ --._J .~
1100
1101
1110
12
13
14
;:;::;:.;::;;:;;.:.:.:.:;:.:.;.;.;.:.:.;.:.j
,:,;-:,-,;,;,:,:,;,',;,'·;·;·;·;·:·;·;·;·;·:1
1111 15 .;.;.;.:.:-:.:.:.:.:-:.:.:.;.;.;.;.;.:.;.;.:'
... Instructions
... Figure 2-4. General and floating-point registers
Arithmetic and Logical Unit
Computer Generated t-----"'T""----~------I F our floating-point registers are available for floating-
System ~ Address Variable-
Control
Fixed-Point Floating-Point
Fixed-Length Operations point operations. They are identified by the numbers 0, 2,
Operations
Operations 4, and 6 (Figure 24). These floating-point registers are two
words (64 bits) in length and can contain either a short
(one word) or a long (two words) floating-point operand. A
short operand occupies the high-order bits of a floating-
" point register. The low-order portion of the register is ignored
16 I Floating-p:int Registers -1 and remains unchanged in short-precision arithmetic. The
General instruction operation code determines which type of regis-
Registers
ter (general or floating-point) is to be used in an operation,
and if floating-point whether short or long precision.
Figure 2-3. Functions of the central processing unit
Arithmetic and Logical Unit
General and Floating-Point Registers The arithmetic and logical unit can process binary integers
~he CPU provides 16 general registe.!§., for flXed-point and floating-point fractions of flXed length, decimal
operands and \,\>ur flodtirig-poi'!!!egis!e.!J for floating-point integers of variable length, and logical information of either
operands. Physic illy , these registers may be in special flXed or variable length.
circuitry, in a local storage unit, or in a separate area of Arithmetic and logical operations performed by the CPU
main storage. In each case, the address and functions of fall into four classes: flXed-point arithmetic, decimal arith-
these registers are identical. metic, floating-point arithmetic, and logical operations.
The CPU can address information in 16 general registers. These classes differ in the data formats used, the registers
The general registers can be used as index registers, in involved, the operations provided, and the way the field
address arithmetic and indexing, and as accumulators in length is stated. Data formats are discussed under each of
f:!Xed-point arithmetic and logical operations. The registers the headings in this section. General information on field
have a capacity of one word (32 bits). The general registers lengths was given in the section on main storage.
are identified by numbers 0-15 and are specified by a
four-bit R field in an instruction (Figure 2-4). Some Fixed-Point Arithmetic
instructions provide for addressing multiple general registers The basic arithmetic operand is the 32-bit flXed-point
by having several R fields. binary number. Sixteen-bit halfword operands may be
For some operations, two adjacent general registers are specified in most operations for improved performance or
coupled together, providing a two-word capacity. In these storage utilization (see Figure 2-5). To preserve precision,
operations, the addressed register contains the high-order some products and all dividends are 64 bits long. A
System/360 Review 19
flXed-point number is a signed value, recorded as a binary Decimal Arithmetic
integer. It is called flXed point because the programmer Decimal arithmetic lends itself to data processing procedures
determines the flXed positioning of the binary point. that require few computational steps between the source
In both halfword (16 bits) and word (32 bits) lengths, input and the documented output. This type of processing
the fIrst bit position (0) holds the sign of the number. The is frequently found in commercial applications. Because of
remaining bit positions (l-lS for halfwords and 1-31 for the limited number of arithmetic operations perfonned on
fullwords) are used to designate the value of the number. each item of data, conversion from decimal to binary and
Positive fixed-point numbers are represented in true back to decimal is not justilled, and the use of registers for
binary fonn with a zero sign bit. Negative flXed-point intennediate results yields no advantage over storage-to-
numbers are represented in two's complement notation storage processing. Hence, decimal arithmetic is provided,
with a one bit in the sign position. In all cases, the bits and both operands and results are located in storage.
between the sign bit and the leftmost significant bit of the
Decimal arithmetic includes addition, subtraction, multipli-
integer are the same as the sign bit (i. e. all zeros for
cation, division, and comparison.
positive numbers, all ones for negative numbers). The
Decimal numbers are treated as signed integers with a
filled-in examples in Figure 2-5 show the equivalent of
variable-field-length format from one to 16 bytes long.
decimal +62 and -62 in flXed-point halfwords.
Negative numbers are carried in true fonn.
The decimal digits 0-9 are represented in the four-bit
Halfword
binary-coded-decimal (BCD) fonn by 0000-1001, respec-
Is I Integer- tively, as follows.
o 1 15
Digit Binary Code Digit Binary Code
Full Word 0 0000 5 0101
1 0001 0110
lsi
o 1
Integer
31
2
3
0010
0011
6
7
8
0111
1000
4 0100 9 1001
10 1 000 0000 0011 1110 I = +62 10 The codes 1010-1111 are not valid as digits and are
reserved for sign codes. The sign codes generated in decimal
arithmetic depend upon the character set code used. When
the extended binary coded decimal interchange code
111111 1111 1100 0010 1=-6210 (EBCDIC) is used, the codes are 1100 for a plus sign and
1101 for a minus. (When the USASCII set, expanded to
Figure 2-5. Fixed-point number formats. In the example the nega- eight bits, is preferred, the sign codes are 1010 and 1011.
tive number is in two's complement notation The choice between the two code sets is determined by a
mode bit.)
Because the 32-bit word size readily accommodates a Decimal operands and results are represented by four-bit
24-bit address, fixed-point arithmetic can be used both for BCD digits packed two to a byte (see Figure 2-6). They
integer operand arithmetic and for address arithmetic. This appear in fIelds of variable length and are accompanied by a
combined usage provides economy and permits the entire sign in the rightmost four bits of the low-order byte. Operand
flXed-point instruction set and several logical operations to fields may be located on any byte boundary, and may have
be used in address computation. Thus, multiplication, length up to 31 digits and sign (l6 bytes). Operands
shifting, and logical manipulation of address components participating in an operation may have different lengths.
are possible. Packing of digits within a byte and use of variable-length
Additions, subtractions, multiplications, divisions, and fields within storage results in efficient use of storage, in
comparisons are perfonned upon one operand in a register
and another operand either in a register or from storage. High-order Byte Low-order Byte
Multiple-precision operation is made convenient by the
two's-complement notation and by recognition of the carry
from one' word to another. A word in one register or a
double word in a pair of adjacent registers may be shifted
left or right. A pair of conversion instructions-Convert to
Binary and Convert to Decimal-provides transition
between decimal and binary number bases without the use
of tables. Multiple-register loading and storing instructions Figure 2-6. Packed decimal number format. The three-byte example
facilitate subroutine switching. shows decimal value +89,732
20 (8/70)
increased arithmetic performance, and in an improved rate Logical Operations and the EBCDIC Character Set
of data transmission between storage and files. Logical information is handled as fixed- or variable-length
Decimal numbers may also appear in a zoned format in data. It is subject to such operations as comparison,
the regular EBCDIC eight-bit alphameric character format translation, editing, bit testing, and bit setting.
(Figure 2-7). This representation is required for I/O devices When used as a f1Xed-Iength operand, logical information
that are character-set sensitive. A zoned format number
can consist of either one, four, or eight bytes and is
carries its sign in the leftmost four bits of the low-order
processed in the general registers (Figure 2-9).
byte. The zoned format is not used in decimal arithmetic
A-Iarge portion of logical information consists of alpha-
operations. Instructions are provided for packing and
betic or numeric character codes, called alphameric data,
unpacking decimal numbers so that they may be changed
and is used for communication with character-set sensitive
from the zoned to the packed format and vice versa. I/O devices. This information has the variable-field-length
format and can consist of up to 256 bytes (Figure 2-9). It is
High-order Byte
processed storage to storage, left to right, an eight-bit byte
,.-----A----.. ___ --...---......---f--.,--...,
IZone I Digit ZoneI I __ L-_..L..-_...L-_-'--_--L-_--I
at a time.
The CPU can handle any eight-bit character set, although
certain restrictions are assumed in the decimal arithmetic
8 9 7 3 + 2 and editing operations. However, all character-set sensitive
11111 1000 11111 1001 1111 I I
0111 1111 0011 1100 0010 I I/O equipment will assume either the extended binary
coded decimal interchange code (EBCDIC) or the USA
Byte 1 Byte 2 Byte 3 Byte 4 Byte 5
Standard Code for Information Interchange (USASCII)
Figure 2-7. Zoned decimal number format. The decimal number extended to eight bits. Use of EBCDIC is assumed through-
+89,732 requires five bytes out this book.
be placed in storage and gives the shortest execution times. Figure 2-9. Fixed- and variable-length logical information
The long length, used when higher precision is desired,
more than doubles the number of digits in each operand.
EBCDIC does not have a printed symbol, or graphic,
Four 64-bit floating-point registers are provided. Arith-
defined for all 256 eight-bit codes. When it is desirable to
metic operations are performed with one operand in a register
represent all possible bit patterns, a hexadecimal represen-
and another either in a register or from storage. The result,
tation may be used instead of the preferred eight-bit code.
developed in a register, is generally of the same length as
The hexadecimal representation uses one graphic for a
the operands. The availability of several floating-point
four-bit code, and therefore, two graphics for an eight-bit
registers eliminates much storing and loading of inter-
byte. The graphics 0-9 are used for codes 0000-1001; the
mediate results.
graphics A-F are used for codes 1010-1111. EBCDIC
eight-bit code for characters that can be represented by
Short Floating-Point Number (One Word)
well-known symbols is shown in Table 2-1. The hexa-
IS I Characteristic I Fraction decimal equivalents and punched card code are also shown.
o 1 7 8 31 For other symbols, System/360 control characters, and
Long Floating-Point Number (Double Word)
unassigned codes, see the complete 256-position EBCDIC
chart in the Appendix. It may be observed from the table
LIS_·LI_c_h_ar_a_ct_e_ri_stic~I_ _ _ _ _F_ra_c_ti_on_ _ _~~~______~ that the EBCDIC collating sequence for alphameric charac-
o 1 7 8 63 ters, from lower to higher binary values, is (1) special
Figure 2-8. Short and long floating-point number formats characters, (2) lower case letters, (3) capital letters, and (4)
digits, with each group in its usual order.
System/360 Review 21
Table 2-1. Extended Binary Coded Decimal Interchange Code (EBCDIC) for Graphic Characters
22
PROGRAM EXECUTION
Interplay of equipment and program is an essential consi- a loop, is to be repeated. All these tasks can be accom-
deration in System/360. The system is designed to operate plished with branching instructions. Provision is made for
with a control program that coordinates and executes all subroutine linkage, permitting not only the introduction of
I/O instructions, handles exceptional conditions, and super- a new instruction address but also the preservation of the
vises scheduling and execution of multiple programs. return address and associated information.
System/360 provides for efficient switching from one pro- Decision-making is generally and symmetrically provided
gram to another, as well as for the relocation of programs in by the Branch on Condition instruction. This instruction
storage. To the problem programmer, the control program inspects a two-bit condition code in the PSW, that reflects
and the equipment are indistinguishable. the result of a majority of the arithmetic, logical, and I/O
The CPU program consists of instructions, index words, operations. Each of these operations can set the code in any
and control words that specify the operations to be one of four ways, and the conditional branch can specify
performed. Some of its functions will be discussed here. any of these four settings, or any combination of them, as
The format of the machine instructions is basic to m;t.... _____ the criterion for branching.
understanding of how the CPU executes them and how it ", Loop control can be performed by the conditional
forms addresses of operands in main storage. A double word branch when it tests the outcome of address arithmetic and
called the program status word (pSW) contains detaile'd counting operations. For some particularly frequent combin-
information required by the CPU for proper program ations of arithmetic and tests, the instructions Branch on
execution: the instruction address, the condition code Count and Branch on Index are provided. These branches,
setting, etc. It is stored at a fIXed location. If a problem being specialized, provide increased performance for these
program aborts and the contents of storage are printed out,. tasks.
the PSW can be inspected by the programmer. He will find
much information to help him analyze the trouble, Instruction Format
including a code that identifies the cause of the interruption.
The length of an instruction format can be one, two, or
The interruption system permits the CPU to respond
three halfwords. It is related to the number of storage
automatically to conditions arising outside of the system, in
addresses necessary to specify the location of all operands
I/O units, or in the CPU itself. Interruption switches the in the operation. Operands may be located in registers or in
CPU from one program to another by changing not only main storage, or may be a part of an instruction. An
the instruction address but all essential machine-status instruction consisting of only one halfword causes no
information. reference to main storage. A two-halfword instruction
Programs are checked for correctness of instructions and provides one storage-address specification; a three-halfword
data as the instructions are executed. (The types of errors instruction provides two storage-address specifications. All
involved are not detectable during assembly.) This policing instructions must be located in storage on integral bound-
action distinguishes and identifies program errors and aries for halfwords. Figure 2-10 shows the five basic
machine errors. Thus, program errors cannot cause machine instruction formats, called RR, RX, RS, SI, and SS.
checks: each of these types of error causes a different type These format codes express, in general terms, the oper-
of interruption. ation to be performed. RR denotes a register-to-register
operation; RX, a register-and-indexed-storage operation;
Sequential Instruction Execution RS, a register-and-storage operation; SI, a storage and
Normally, the operation of the CPU is controlled by immediate-operand operation; and SS, a storage-to-storage
instructions taken in sequence. An instruction is fetched operation. An immediate operand is one contained within
from a location specified by the instruction address in the the instruction.
current PSW. The instruction address is then increased by F or purposes of describing the execution of instructions
the number of bytes in the instruction fetched to address in the SRL manual IBM System/360Principles o/Operation
the next instruction in sequence. The instruction is then (A22-6821), operands are designated as first and second
executed and the same steps are repeated using the new operands and, in the case of branch-on-index instructions,
value of the instruction address. third operands. These names refer to the manner in which
A change from sequential operation may be caused by the operands participate. The operand to which a field in an
branching, interruptions, etc. instruction format applies is generally denoted by the
number following the code name of the field, for example,
Branching RJ,B h L 2 ,D 2 ·
The normal sequential execution of instructions is changed In each format, the first instruction halfword consists of
when reference is made to a subroutine, when a two-way two parts. The first byte contains the operation code. The
choice is encountered, or when a segment of coding, such as length and format of an instruction are specified by the
System/360 Review 23
frrst two bits of the operation code: First Halfword Second Halfward Third Halfword
Byte1: Byte 2
Bit Positions Instruction Instruction
(0-1) Length Format
Register Register
00 One halfword RR : Operand 1 Operand 2
j~~
01 Two halfwords RX
10 Two halfwords RS or SI RR i Op Code
11 Three halfwords SS :0 7 8 11 12 15
I '
I ReQister Address of I
The second byte is used either as two 4-bit fields or as a Operand 1 , Operand 2 :
single 8-bit field. As shown in Figure 2-10, this byte can Rx~i-o-pc-od-e~I!ZJ~R~1~=x=2~i=B2~1~~D=2==~1
contain the following information:
:0 7 8 11 12 15 16 19 20 31
Four-bit operand register specification (Rh R2 , or R3 ) , I
: Immediate : Address of
Four-bit index register specification (X2 ) I Operand I Operand 1
, I~~
Four-bit operand length specification (LI or L2 )
Eight-bit operand length specification (L) 51
I
Eight-bit byte of immediate data (I 2) :0 7 8 15 16
, 19 20 31'
I
I
I Register Register Address of
In some instructions a four-bit field or the whole second ,
I Operand 1 Operand 3 Operand 2 I
~I
byte of the first halfword is ignored. In the Branch on
Condition instruction, which may be used in either the RR RS j
or RX format, the first four bits of the second byte are :0, 78 111215161920
RR I 07 (BCR) I I IM1 R2
I Length I Operand 1 Operand 2
In all instructions, the second and third halfwords always the instruction. It is included only in the address specified
have the same format: four-bit base register designation (Bl by the RX instruction format; or it may simply be omitted
or B2), followed by a 12-bit displacement (Dl or D2)' in an RX instruction. The RX format instructions permit
double indexing.
Generation of Main Storage Addresses Displacement (D) is a 12-bit binary number contained in
To permit the ready relocation of program segments and to the instruction format. It is included in every address
provide for the flexible specifications of input, output, and computation. The displacement provides for relative addres-
working areas, all instructions referring to main storage sing up to 4095 bytes beyond the base address, which is the
have been given the capacity of employing a full address. limit that can be expressed by 12 binary bits. In Chapter 1
The address used to refer to main storage is generated we saw how the displacements were calculated by the
from the follOWing numbers, all binary: assembler from symbolic addresses written by the pro-
Base Address (B) is a 24-bit number contained in a grammer.
general register specified by the program in the B field of We also saw that the three binary numbers are added
the instruction. (One way to insert a base address into a together to form the actual address. This sum is a 24-bit
register is to specify a BALR operation at the beginning of number, which can be represented by six hexadecimal
a program. The BALR operation does just that, getting the digits.
address of the next sequential instruction from the current The program may have zeros in the base address, index,
program status word, no matter where the program may or displacement fields. A zero is used to indicate the
have been relocated.) The B field is included in every absence of the corresponding address component. A base or
address specification. The base address can be used as a index of zero implies that a zero quantity is to be used in
means of relocation of programs and data. It provides for forming the address, regardless of the contents of general
addressing the entire main storage. The base address may register O. Initialization, modification, and testing of base
also be used for indexing purposes. addresses and indexes can be carried out by fixed-point
Index (X) is a 24-bit binary number contained in a instructions, or by Branch and Link, Branch on Count, or
general register specified by the program in the X field of Branch on Index instructions.
24
Interruptions and the Program Status Word
To make maximum use of a modern data processing the device and channel causing the interruption is stored in
system, some automatic procedure must be made available the old PSW; in addition, the status of the device and
to alert the system to an exceptional condition, the end channelis stored in a fIXed location.
of an I/O operation, program errors, machine errors, etc., Program interruptions are caused by various kinds of
and send the system to the appropriate routine following programming errors or unusual conditions resulting from
the detection of such an event. The system must have, in improper specification or use of instructions or data. The
effect, the ability to pause to answer the telephone and exact type of error is shown in an interruption code in the
then to resume the interrupted work. This automatic PSW.
procedure is called an interruption system.
It makes possible the operation of a system in a non-stop Finding the Source of a Program Interruption
environment and greatly aids the efficient use of I/O When a program interruption occurs, proviSion is always
equipment. The desire to make the interruption procedure made to locate the instruction that was being interpreted
as short and simple as possible means that the method- of and to identify the exact type of error involved, so that the
switching between the interrupted program and the pro- programmer can make the necessary corrections. For this
gram that services the interruption must be quite efficient. information he must go to the PSW in a printout of storage
It operates as follows: contents.
The complete status of the System/360 is held in eight Fifteen interruption codes are used for the different
bytes of information. This status information, which con- types of program interruptions, as follows.
sists of the instruction address, condition code, storage
Interruption Code Program Interruption Cause
protection key, etc., is saved when an interruption occurs,
1 00000001 Operation
and is restored when the interruption has been serviced. 2 00000010 Privileged operation
As soon as the interruption occurs, all the status infor- 3 00000011 Execu te
mation, together with an identification of the cauSe of the 4 00000100 Protection
interruption, is combined into a doubleword called the 5 00000101 Addressing
program status word (pSW).1:::- 6 00000110 Specification
7 00000111 Data
The PSW is stored at a fIXed location, the address of which 8 00001000 Fixed-point overflow
depends on the type of interruption. The system then 9 00001001 Fixed-point divide
automatically fetches a new PSW from a different fIXed 10 00001010 Decimal overflow
location, the address of which is also dependent on the type 11 00001011 Decimal divide
of interruption. Each class of interruption has two fIXed 12 00001100 Exponent overflow
13 00001101 Exponent underflow
locations in main storage: one to receive th~ old PS\:V when 14 00001110 Significance
the interruption occurs, and the other to supply the new 15 00001111 Floating-point divide
PSW that governs the servicing of that class of interruption. To take an example, one of the conditions that causes a
After the interruption has been serviced, a single instruc- "data exception" to be recognized is an incorrect sign or
tion uses the stored PSW to reset the processing unit to the digit code in an operand used in decimal arithmetic. In this
status it had before the interruption. case, the operation would be terminated, and all, part, or
none of the arithmetic result would be stored. Since the
Types of Interruptions result is unpredictable, it should not be used for further
The interruption system separates interruptions into five computation. The interruption code, binary 0000 0111, or
classes: hexadecimal 07, for a data exception would be recorded in
Supervisor Call interruptions are caused when the bit positions 24-31 of the program old PSW (always at
processing program issues an instruction to turn over main storage location 4010).
control to the supervisor in the control program. The exact The location of the instruction that was being inter-
reason for the call is shown in the old PSW. preted when the interrupt occurred can also be determined
External interruptions are caused by either an external from an inspection of the old PSW. The instruction address,
device requiring attention or by the system timer going past which is found in bit positions 40-63 of the PSW, is for the
zero. instruction to be executed next. To locate the preceding
Machine Check interruptions are caused by the machine- instruction, all that is needed is to subtract its length in
checking circuits detecting a machine error. bytes. This instruction length can be found in bit positions
I/O interruptions are caused by an I/O unit ending an 32 and 33 of the PSW, recorded there in binary as 1,2, or 3
operation or otherwise needing attention. Identification of halfwords.
System/360 Review 25
HEXADECIMAL NUMBERS
Hexadecimal Code
Hexadecimal numbers have been mentioned a number of graphic hex symbols per byte. The same hex coding system
times. In Chapter 1 we used them to represent machine is used regardless of the code in which the information is
language instructions,and we saw that the assembler listed recorded internally. The internal information may be
object code, location counter settings, and addresses in EBCDIC characters, zoned decimal numbers, signed binary
hexadecimal numbers. In System/360 hexadecimal code is a numbers, the eight-bit code used for System/360 operation
shorthand method of representing the internal binary zeros codes, or any of the other codes and formats in use. All are
and ones, one hex digit for each four binary bits. coded in some form of binary coding, and, since the
Hex numbers are a convenient way for the assembler eight-bit byte is the basic unit of System/360, they can
language programmer to specify masks in testing and readily be taken four bits at a time.
branching operations, and to specify hexadecimal constants Let's look at some examples. Each "box" represents a
(type X). Principally, he uses hexadecimal code to locate byte. Binary bits are shown in groups of four for con-
and interpret the contents of storage, which may be printed venience.
out when a program must be analyzed and debugged. In a
1. EBCDIC characters
later chapter, we shall see some "dumps" of storage and
Characters I B M 3
attempt to locate information in them.
I nternal form 1100 1001 1100 0010 1101 0100 1111 0011
Converting from binary to hex, or from hex to binary, is
Hex code C 9 C 2 D 4 F 3
simple. There are only 16 hex symbols, and their value is
based on the numerical value of four bits. We recall that 2. Zoned decimal number
four bits in the binary number system can express all values Decimal 8 9 7 3 + 2
from zero to 1510 , We also recall that the position of each I nternal form 1111 1000 1111 1001 1111 0111 1111 0011 1100 0010
bit determines its value: Hex code F 8 F 9 F 7 F 3 C 2
Some people fmd it easier to remember these binary 4. Signed binary number
positional values this way: (This fixed-point fullword is equivalent to decimal +89,732)
I nternal form
Hex code
0000 0 0 1000 8 8
0001 1 1 1001 9 9 Hexadecimal Number System
0010 2 2 1010 A 10
0011 3 3 1011 B 11 Turning back to the examples, we notice that internally the
0100 4 4 1100 C 12 characters and decimal numbers are, generally speaking,
0101 5 5 1101 D 13 coded separately in either four- or eight-bit binary codes.
0110 6 6 1110 E 14
0111 7 7 1111 F 15 The binary number in example 4, however, is recorded
internally in its actual value as an integer in a number
system with a base of 2. The O's and 1's are the only digits
All kinds of information, data, instructions, etc., in in this number system. Similarly, the hexadecimal equiva-
System/360 can be represented in hexadecimal code, two lent 15E84 is an integer in a valid number system with a base
26
of 16. Considering the binary and hex numbers in this It is this relationship that makes one hex digit equal
example in their entirety, they have exactly the same total arithmetically to four binary bits, two hex digits equal to
value. Each hex digit also equals the value of the four bits it two groups of four bits each, etc. All hex and binary digits
represents. We see from this that hex numbers can be used in must of course be kept in correct place order.
two different ways: (l) simply as a four-bit code into which Now we are ready to figure out some actual hexadecimal
each internal half-byte is translated, and (2) both as a four-bit values. Hex numbers are especially useful for calculating
code and as a valid number system with a base related in a main storage addresses and displacements. A storage
defmite way to the base of the binary number system. address, we may remember, is a 24-bit true binary number
In the familiar decimal number system, the base is 10, internally, always represented externally by the machine as
and there are ten digits, 0-9. In the decimal number 234, six hexadecimal digits.
we know that the 2, because of its position, equals 2 x 100, We shall use Table 2-3 for converting hex numbers to
or 200; the 3 equals 3 x 10, or 30; and the 4 equals 4 x 1, decimal, and decimal to hex. It is for integers only. The
or 4. The three values are in effect added together. We may table shows eight places, each place being the position of a
represent the place value of each digit in a whole number hex digit, starting from the right.
(not a fractional or mixed number) in this way: The table shows the equivalent decimal value of each
hexadecimal digit in each hex position from 1 to 8. To
convert a hex number to decimal, it is necessary only to
fmd the value of each hex digit in the column correspon-
In the same way, the binary number system has a base of ding to its position, and to add them together. To convert
2 and has two digits, 0 and 1. Its place values are: D34t6 to decimal, we start in column 3 because this is a
three-digit number. We fmd (1) DOOt6 = 332810 in column
Power of base 2
3, (2) 3016 = 4810 in column 2, and (3) 416 = 410 in column
Value in decimal 1 ; then (4) summing the decimal values, we get
The hexadecimal number system has a base of 16 and 3328
has 16 digits, 0-:9 and A- F. Its place values are: 48
4
338Oto = D3416
Systemj360 Review 27
take 338010 as an example. We look for the highest decimal convert hexadecimal values to decimal, however, do their
value in the table that will fit into 3380. The closest is calculations in decimal, and then convert back to hex. This
332810 in column 3, equal to the D. We make a note that can be done easily and quickly with the use of a conversion
this corresponds to DO<>t6 and subtract, as shown below. table.
The closest value below the remainder (5210) is 4810 in On the other hand, computer personnel often find it
column 2, and we note it is equal to 3016 , Subtracting useful to be able to do simple addition in hexadecimal.
again, we look for the best fit into the remainder of 410 , Until they become proficient, they can simply count on
ano find 410 ill column 1, equal to 416 , Adding the hex their fmgers. The rules for carrying are the same as in
values, we get the result 3380 = D34, which we know from decimal addition. In decimal, the highest digit value is 9.
our fust conversion example is correct. (The best way to When 1 is added to 9, the result is 0 and a carry of 1. Or, as
check the result of a conversion is to reconvert. Any lost we usually see it:
zeros are likely to be found in the process.) 99 999
9
Decimal Hex +1 +1 +1
3380 10 100 1000
3328 DOO
52
In hex, when 1 is added to the highest digit F, the result is
48 30 also 0 and a carry of 1:
4 4 FF FFF
F
D34 +1 +1 +1
Without looking back, let's convert 745,6381O to hexa- 10 (= 16 10 ) 100 (= 256 10) 1000 (= 4096 10 )
decimal: The follOWing list of equivalent values may help to
Decimal Hex crystallize the concepts of hexadecimal notation. Hex
745 638 numbers that end in zero are always multiples of 16. To
720 896 BOOOO avoid confusion hex numbers like 10, 11, 12, etc., should
24 742 be read as "one zero, one one, one two," and not as "ten,
24 576 6000 eleven, twelve."
166
AO Dec. Hex Dec. Hex Dec. Hex Dec. Hex
-1606 6 1 1 22 16 43 2B 80 50
B60A6 2 2 23 17 44 2C 81 51
3 3 24 18 45 2D
The easiest way to fmd the decimal value of a long 4 4 25 19 46 2E
5 5 26 1A 47 2F
binary number is to convert it to hex, and from hex to 6 6 27 1B 48 30 94 5E
decimal. Similarly, to find the binary value of a decimal 7 7 28 1C 49 31 95 5F
8 8 29 1D 50 32 % 60
number, the decimal number should be converted to hex, 97 61
9 9 30 IE 51 33
and from hex to binary. To get the binary equivalent of 10 A 31 IF 52 34 98 62
745,63810 , we would convert it to hex as in the last 11 B 32 20 99 63
12 C 33 21 100 64
example and merely substitute the four-bit code for each '. D 34,
13 22
hex digit in the result: 14 E 35 ~23 62 3E
15 F 36 24 63 3F
o B 6 0 A 6 64 40 240 FO
16 10 37 25
0000 1011 0110 0000 1010 0110 17 11 38 26 65 41
18 12 39 27
It is entirely feasible to perform all kinds of arithmetic 19 13 40 28 254 FE
calculations in hexadecimal arithmetic. The rules are the 20 14 41 29 78 4E 255 FF
21 15 42 2A 79 4F 256 100
same as in decimal arithmetic. Most programmers prefer to
28
Chapter 3: Fixed-Point Arithmetic
This chapter introduces and' discusses some of the flXed- most convenient. As might be expected, the flXed-point
point operations of the. standard instruction set in the instruction set uses only these three instruction formats:
Systemj360. These include the arithmetic and shifting RR, RX, and RS.
instructions as the central topic, with important consider- In the course of presenting the instructions and con-
ation also of certain logical operations ( comparison, sidering. programming methods used with the Systemj360,
branching), ,and loop methods. we shall review the basic ideas of the machine organization
Fixed-point instructions perform binary arithmetic on and operation.
flXed-Iength data of either a fullword or a halfword. The The presentation will be almost entirely through the
use of registers for arithmetic and other operations is thus medium of eight examples and a final extended case study.
)
NEWOH = OLDOH + RECPf - ISSUE
A program to carry out this calculation is shown in
Figure 3-1. We shall be concentrating on the four actual 1',:.,: ';;! ,:,;ii. /; $\17/1. :< I': ~~we.Hidlf.:; i.: .\ O:.::I..J'
processing instructions, but at the outset we shall display all l[ ·Ii ,:F . ;'X:, ';~Oi1t,.!, I:T·,;;·,'.[,' i:.' ;!;·'I,:.t I
programs in logically complete form. ot-il;o:1I ~C let 9'
I I
The assembler instruction PRINT NOGEN it2..~~.~,kn...2!x ~£JCPT l1>c P ,4' ,
lLssv£, ll>c. Ip' , I
~~:~:;~!;&ili~!'E~~;:a~T\7~f!;~f;~;rt~;;a
,J
Ni;Wlifl.:i. :: ;'\: ,: ;: . l>S;:. ,:;: tj,;';':: . ,'; " 't., . . . : m.,
,\ ..'; . '
"A't1ieif"St~;'~g~'" i;c~tions~arurillspla:eem~nts will still be part of :<.' x. :,-.:':.:r ; ;- Gil/) ,L :' 8C~-.r}.J '..', /' ,,' ",; )
the object program; they will be omitted only from the ,(;,,i~ :L";~;:~;~; '. ~, .::;'Jj;;>:, ·2·'·.il
printed listing.
The next three lines of coding are rather standard Figure 3-1. A program, written in assembler language, to perform a
preliminaries; instructioIl:s of this character will appear at simple computation in binary arithmetic
the beginning of all but highly specialized programs. To
review briefly, the START establishes a reference point for Now we reach the first processing instruction, where we
the assembly: the assembly listmg (shown later) will wish to concentrate our attention.
assume that the frrst byte is to be loaded into 256 as The Load instruction is classified as an RX format
shown. The BALR (Branch and Link Register) and the instruction, which implies a number of facts about it:
USING, as written here, together direct that register 11 1. The instruction itself takes up four bytes of storage.
shall be used as a base register wherever one is needed, and 2. The fields within the instruction are, from left to
inform the assembler that the base register at execution right: the operation code (eight bits), the number of the
time will contain the location of the frrst byte after the register to be loaded from storage (four bits), the number
USING. of the register used as an index register (four bits), the
Fixed-Point Arithmetic 29
number of the register used as a base register (four bits), have, of course, named the same general register as in the
and the displacement (twelve bits). Load instruction, since the intent is to add OLOOH and
3. The instruction involves a transfer of information RECPT together. Looking at the assembled instruction, we
between storage and a general register. see that things have been handled much as they were with
4. The effective address of a byte in storage is formed by the Load. Base register 11 has been assigned, there is no
adding the contents of the base register, the contents of the index register, and the displacement has been computed to
index register, and the displacement. If register zero is give the effective address of the storage location associated
specified for an index register or a base register, a zero value with RECPT (118).
is used in the address computation, rather than whatever After the execution of this instruction, register 3 will
register zero may contain. contain the sum of the storage quantities identified in our
The operation of the Load instruction is straightforward: program by OLDOH and RECPT.
obtain a fulIword (four bytes) from storage at the effective The Subtract instruction (S) in the next line subtracts
address specified, and place the word in the general register the quantity identified by the symbol ISSUE from the
indicated. The effective address must refer to a fulIword quantity now standing in register 3. The format and general
boundary, which means that the address must be a multiple operation of the instruction are very similar to Add.
of 4. Now we have the desired result in register 3. The prob-
Let us consider the complete line of coding for the Load lem statement required the result to be placed in another
instruction to see what each part does. location in storage, that is identified by the symbol
The letter L is the mnemonic operation code for Load; NEWOH. Placing the contents of a general register in stor-
this is converted by the assembler into the actual machine age is the function of the Store instruction (operation code
operation code for Load, 58. The 3 is the number of the ST). The general register contents are unchanged by the
general register we wish loaded with a word from storage. operation. The format is again RX, so address formation is
OLDOH is the symbolic address of the word in storage to as before.
be copied into general register 3. By writing the address in This completes the actions required by the problem
this fashion, we have indicated that the assembler should statement, but we must now indicate what we want done
supply the base register and the displacement, and that we next. The System/360 forces a program organization that
do not wish indexing. keeps the machine in operation as much of the time as
The assembly listing for this program is shown in Figure possible. What we have shown here is an End of Job macro
3-2. Looking at the machine instruction assembled from instruction, which is used in the Disk Operating System
this symbolic instruction, and remembering that all num- environment. As we saw in the preceding chapter, the EOJ
bers are shown in hexadecimal, we see that the operation macro generates a Supervisor Call instruction, SVC 14. The
code is 58, the general register is 3, the index register is use of -this instruction assumes that there is in storage, at
zero, the base register is B ( = 11 10), and the displacement is the time of execution of this program, a control program
01216 , Since the base register contains 102, the effective that runs the machine between jobs. We here indicate to the
address is 114, which is shown in the assembly listing under supervisor that this program has no further need for the
ADDR2 as the address of the second operand and which we machine.
see is the location of OLOOH. The program in Figure 3-2 does not include any instruc-
The Add instruction is also of the RX format. The tions for reading in data from an input device such as a card
operation is to add the fulIword at the storage address reader or magnetic tape unit, or for printing out or
specified, to the general register named. In our case, we punching out the results of our calculations. Input and
1 PRINT NOGEN
000100 2 STOCK START 256
000100 05BO 3 BEGIN BALR 1l ,0
000102 4 USING *,11
000102 5830 B012 00114 5 L 3,OLOOH
000106 5A30 B016 00118 6 A 3,RECPT
OOOlOA 5B30 BOlA OOllC 7 S 3,ISSUE
OOOlOE 5030 BOlE 00120 8 ST 3,NEWOH
9 EOJ
000114 00000009 12 OLDOH DC F'9'
000118 00000004 13 RECPT DC F'4'
OOOllC 00000006 14 ISSUE DC F '6'
000120 15 NEWOH DS F
000100 16 END BEGIN
30
output instructions vary considerably in different systems,
depending upon the operating (or programming support) 0000009+ 0000004+ 0000006+ 0000007+
system in use and the particular pieces of input/output
equipment available at an installation. Figure 3-3. Output of the program of Figure 3-2. The four numbers
In normal commercial practice, a computer program are OLDOH, RECPT, ISSUE, and NEWOH, in that
would be used, riot for calculations on just one set of data, order.
but on large series· of data that require similar treatment.
An example would be a program to calculate weekly pay numbers and sign, as shown in the frrst line of Figure 3-4.
for several hundred employees of a company, and the data In the second line, the same numbers are shown in hexa-
would include the hours worked, pay rate, withholding decimal as they normally appear in a dump.
amounts, etc., for each of them. In our program examples, We see that the first three numbers, which are positive,
our principal interest lies in how the assembler language have zeros before the significant digits. The last number,
instructions work, and so we will generally use only one set which is negative, has 1's to the left of the significant digit
of specific values for the purpose of illustrating what (hexadecimal F equals binary 1111). If we were to write out
happens in each step. this hexadecimal number, FFFFFFFD, in the binary form
We have simply entered the illustrative values for the actually in storage, we would have thirty 1's followed by
input data with DC instructions, and reserved space for the 01. Recalling how two's complement numbers are formed,
output with a DS. The F's in the DC's and the DS specify we see that the complement of this number is binary 11,
fullwords Qf four bytes. The Load, Add, Subtract, and which equals decimal 3. Checking with the given data and
Store instructions all operate on fuUwords. As we shall see the formula, we see that this is the correct answer, and, of
in later examples, there are corresponding halfword course, the decimal value was printed out as a minus 3.
instructions. Naturally, if a negative result were actually obtained in
The END instruction informs the assembler that the an inventory control program, it would indicate some kind
termination of the program has been reached and specifies of trouble, probably bad data; it is not possible to issue
in this case that the first instruction to be executed after more than there are on hand plus what was received. A
the program is loaded is the one with the name BEGIN, realistic program would include a test for the possibility of
that is, the BALR instruction. a negative result and the corrective action to be taken.
By using either a suitable assembler language routine or
macrO instruction, it is possible to get a "dump" of the
contents of the registers and selected areas of storage, and 0000009+ 0000004+ 0000016+ 0000003-
get Qur data and results out of the machine. Such a routine
produced the numbers, converted to decimal, that are
shown in Figure 3-3. The four items, in sequence, are 00000009 00000004 00000010 FFFFFFFD
OLDOH, RECPT, ISSUE, and NEWOH.
It might be interesting to run this program again with a
Figure 3-4. Output of the same program with a value for ISSUE
value of, say, 16 for ISSUE. We know that negative that causes NEWOH to be negative. Values are shown in
fixed-point numbers are represented in two's complement decimal in the fIrst line, hexadecimal in the second; the
form. Our output routine will make a conversion to true value for NEWOH is in complement form.
Fixed-Point Arithmetic 31
MULTIPLICATION
1 PRINT NOGEN
000100 2 GROSS START 256
000100 05BO 3 BEGIN BAlR 11 ,0
000102 4 USING *,11
000102 5850 BOOE 001LO 5 l 5,ISSUE
000106 5C40 B012 00114 6 M 4,PRICE
00010A 5050 B016 00118 7 ST 5,TOTAl
8 EOJ
000110 00000007 11 ISSUE DC F'7'
000 114 00000017 12 PRICE DC F'23'
000118 13 TOTAL OS F
000100 14 END BEGIN
32
The answer becomes apparent if we look at the product appreciates the necessity of knowing a good deal about his
as a hexadecimal number and note the part of it that would data and for testing it for validity if he is not sure of it. The
appear in register 5. The complete product is 1C9F4BOA4, purpose in showing these slightly surprising results is simply
that is, nine hexadecimal digits - a register can hold eight. to clarify how the machine operates, especially since many
So the 1, preceded by seven hexadecimal zeros, would be programmers will not have had previous contact with
the contents of register 4, as shown. The part in register 5 complement representation of negative numbers.
begins with the hexadecimal digit C, which is 1100 in
binary. This means that the leftmost bit is 1, which, when
C9F4BOA4 is taken as a number by itself, indicates a ISSUE PRICE TOTAL
negative number that is in two's-complement notation! 0081654+ 0081654+ 906110816-
Thus, in converting to decimal for Figure 3-8, System/360 REG 4 REG 5
performed as it was designed to do, recomplemented (to 0000001+ 906110816-
hexadecimal 360B4F5C), and came up with the decimal
equivalent of that amount. Figure 3-8. Output of the program with values for ISSUE and
This recitation of troubles is not meant to suggest any PRICE that lead to a TOTAL too large to fit in a
difficulty in using the System/360. Any programmer fullword
Fixed-Point Arithmetic 33
MULTIPLICATION AND DIVISION WITH
DECIMAL POINTS
The next example involves a little further practice with bering that the computer knows nothing of our behind-the-
multiplication, an application of the Divide instruction, and scenes understanding about decimal points, all we have to
a rather basic question of decimal point handling in binary. do to round off is to add 50 to the integer product. We will
The task is to increase a principal amount named PRINC think of the 50 as $0.0050, but to the computer it is 50.
by an interest rate of 3%. The principal is stored in pennies Having done this, we need finally to divide by 100 to
as in the previous example; for instance, 24.89 would be correct for using 103 in place of 1.03. This requires the
stored simply as the integer 2489. Later program segments Divide instruction, which as we might expect is a close
would have to insert any "graphic" decimal point that relative to the Multiply instruction. The dividend must be
might be desired for printing; at this point we make a in an even-odd pair of registers as a 64-bit number. This
mental note of the true situation, while pretending for requirement is already met by the way the Multiply leaves
programming purposes at the moment that the unit of the product in an even-odd pair (the machine was designed
currency is the penny. to make it simple to follow a Multiply with a Divide). The
One possible program is shown in Figure 3-9. (There are remainder is placed in the even register and the quotient in
other ways, as we shall see.) After the usual preliminaries the odd. Our quotient will be 2564 (we read: $ 25 .64) and
we load the principal into an odd-numbered register prepar- the remainder will be 17 (we don't care about this). The
atory {o~..!!l&. TheTnterest rate is shown as 103, quotient can now be stored back in the location for PRINC,
wfiiCffsnould be read as 1.03. This is a shortcut: instead of as required in the problem statement.
multiplying the principal by 0.03 and adding the product to The question will occur to many: why was it necessary
the principal, we multiply the principal by 1.03. The result to divide? Why not simply shift two places right to drop the
is the same either way; our way saves an addition. right two digits? The answer is, of course, that we could do
The absence of the decimal point is another matter. We precisely that in decimal, but this is binary. Shifting one
are saying here that instead of multiplying by 1.03, we will place to the right in decimal divides the number by 10;
multiply by 103; the product will be 100 times too large as shifting one place to the right in binary divides the number
a result. It will be necessary in a subsequent step to divide by 2. There is no number of binary shifts that divides a
by 100 to correct for this. The reason for this is that there number by a factor of decimal 100. Six places divides it by
is a question of how to represent a decimal fraction in 64, and seven places by 128. With this way of approaching
binary form. The question can be answered, as we shall see, the problem, we have no choice but to divide.
leading to a different program. For now, let us take what It should be kept clearly in mind that in all examples so
seems at first to be the easy way out and stay with integers. far we have explicitly stated that all quantities were to be
Using the sample principal mentioned above, 24.89, the viewed for programming purposes as integers, whatever we
product after multiplication is 256367. We shall assume on the outside might understand by the digits. This was by
that the product in all cases is short enough to be held in agreement, not necessity. We can work with binary num-
register 5 alone. bers that are taken to have "binary points" elsewhere than
We now wish to round off. We think of the product as at the extreme right. Let us, for instance, attempt to
$25.6367; the desired rounded value is $25.64. Remem- express the factor 1.03 as a binary number.
1 PRINT NOGEN
000100 2 INTA START 256
000100 05BO 3 BEGIN BALR 11 ,0
000102 4 USING *,11
000102 5850 B016 00118 5 L 5,PRINC
000106 5C40 BOlA OOllC 6 M 4, I NT
00010A 5A50 BOlE 00120 7 A 5,C50
00010E 5D40 B022 00124 8 D 4,C100
000112 5050 B016 00118 9 ST 5,PRINC
10 EOJ
000118 000009B9 13 PR I NC DC F'2489'
00011C 00000067 14 I NT DC F'103'
000120 00000032 15 C50 DC F'50'
000124 00000064 16 CI00 JC F'100'
000100 17 END BEGIN
Figure 3-9. Assembly listing of a program involving binary multiplication and division with the result rounded off
34
I t may be recalled from a study of the conversion rules of our product. The Scale factor method shown gives this.
that there will be in general no exact binary equivalent for a (In fact, the constant consists of a 1 followed by ten zeros.)
decimal fraction. If we try 1.03 we get an infinitely After rounding off we are left with eleven superfluous
repeating binary fraction. The first twelve bits are bits at the right end of the product. These can be shifted
off the end of the register with a suitable shift instruction.
1.00000111101
"Suitable" in this case means that the shift should be to the
The binary point is, of course, understood (by us). right, it should involve a single register, and it should be an
If we enter such a number as the constant (which we algebraic shift so that if the number were negative, proper
shall see how to do in a moment), we can multiply by it. sign bits would be shifted into the register. The instruction
The machine cares nothing for our understood binary points, is called Shift Right Single (SRA), in which we specify the
and carries out the multiplication. We must then take into register first and then the number of positions of shift
account the understood binary point in the product, accor- desired. Bits shifted off the right end of the register are lost.
ding to a literal translation of familiar rules: the binary After the shift we are ready to store the result.
point in the product will have as many places to the right as The point of doing all this is that we have replaced a
the sum of the number of places to the right of the binary Divide with a Shift, and the latter is considerably faster
points in the multiplier and in the multiplicand. If the con- than the former. In some applications the difference in time
stant has eleven places to the right, as written above, and could be Significant.
the principal is still understood to be an integer (zero places), If we print the result, we get a surprise: the answer is
then the product will have eleven places to the right. 2563 ($25.63); rounding seems not to have taken place.
Let us turn to Figure 3-10 to see how this much of the The trouble is that the binary "equivalent" of the decimal
revised program looks. number 1.03 was not exactly equivalent. To prove the
The Load is the same as before, as is the Multiply. The point, let us ask for 15 binary places in the fractional part
constant used for multiplication is different, however. of the constarit created for 1.03. We change the rounding
Down at INT we see that the DC is constant likewise, and make the shift 15 places. This time,
the printout shows 2564 ($25.64) as before.
FSll'l.03'
The moral of this story is that decimal fractions do not
The F stands for fullword, as before. The S stands for Scale usually have exact binary equivalents. Computations that
factor and is the number of binary places that are to be are required to be exact to the penny should be done in
reserved for the fractional part of the constant. We have integer form, as in the fust version of the program. (Even
indicated eleven places as the number of bits to the right of though a larger number of bits led to a correct answer this
the binary point in the factor as we write it before. time, it would not always do so, particularly for larger
The Add to round off is the same as before, but once principal amounts.)
again the constant is different. What we have after the This means, in most situations, that it would be most
multiplication this time is not an integer but a binary unwise to go the further possible step of representing penny
fraction. To the left of the assumed binary point we have a amounts as binary fractions. Unless approximate results are
whole number of pennies; to the right a fractional part of a acceptable, which they sometimes are, of course, the use of
penny. This time, to round off we need a constant that is anything but integer arithmetic leads to problems more
0.5 cent expressed in the same form as the fractional part severe than they are worth.
1 PRINT NOGEN
000100 2 I'NTB START 256
000100 05BO 3 BEGIN BAlR II ,0
000102 4 USING *,11
000102 5850 B016 00118 5 L 5,PRINC
000106 5C40 BOlA OOllC 6 M 4,INT
00010A 5A50 BOlE 00120 7 A 5,HALF
OOOlOE 8A50 OOOB OOOOB 8 SRA 5,11
000112 5050 B016 00118 9 ST 5,PRINC
10 EOJ
000 118 000009B9 13 PRI NC DC F'2489'
OOOlle 00000830 14 INT DC FSll'1.03'
000120 00000400 15 HALF DC FSll'0.5'
000100 16 END BEGIN
Figure 3-10. A different version of the program of Figure 3-9, using a scale modifier for constants
Fixed-Point Arithmetic 35
Some readers may be wondering whether binary arith- foundation of understanding for those with problems where
metic is worth the trouble. The answer is yes, of course. the advantages of binary arithmetic are worth the care that
Many applications of binary arithmetic raise none of the must be exercised in using it. It is true that many
questions suggested here and do not involve the possible applications will suggest staying with decimal arithmetic,
complications with complement form either. For the for users having the decimal instruction set, but even then
straightforward cases, it is barely necessary to know there will be more than a few occasions where binary
anything about the binary and complement matters. We operations are the only ones that make sense from a stand-
present examples like these to warn the unwary and to lay a point of time.
36
SHIFTING AND DATA MANIPULATION
Having introduced the shifting operation briefly in the made to be the same as the original "sign bit", that is, the
previous example, let us now turn to an application that original leftmost bit. Here, we were guaranteed in the
will involve considerably more shifting. problem statement that all three numbers are positive, so
We begin with a fullword, supplied by some other pro- we can ignore any question of what the leftmost bit in each
gram, in which three data items are stored in binary form: item might be. Whether it is zero or one, the number
represented is positive.
Bits Item name
The SRDL moves the rightmost eight bits into register 7;
0-11 A
from there we move them to the right-hand end of the same
12- 23 B
register, using a single-length logical shift that does not
24 - 31 C
affect register 6. What were originally the rightmost eight
We are required to separate the three data items and bits of the full word are now properly positioned in register
store each in a separate halfword storage location, with 7 to be stored in a halfword location with the Store
names for the latter as shown. All three numbers .are Halfword (STH) instruction. The action here is to store the
positive .. rightmost 16 bits of the register named, in the two bytes
The program shown in Figure 3-11 is a more or less identified by the effective address. The register is not
straightforward matter of shifting and storing, but a few disturbed by the operation of the instruction. This is an RX
notes are necessary to make clear what is happening at format instruction; it could be indexed if we had occasion
certain points. to do so.
The numbers in the Comments field are sample contents Now we again shift the two registers together to get the
of registers 6 and 7 as they would appear during execution twelve-bit B item into register 7. From there we move it on
of the program if the original word were hexadecimal over to the right-hand end of 7 and store it. A further shift
78ABCDEF. These sample values, of course, were entered of what was originally the leftmost twelve bits is not
when the source program was punched; it is quite impos- needed, since they are now in the right-hand end of 6, from
sible for the object program to print anything on the whence they may be stored.
assembly listing. Actually, the restriction to positive numbers is not too
We begin by loading the fullword into an even-numbered difficult to remove. It would have to be agreed that the
general register. This permits us to continue with a double- leftmost bit of each item was its sign bit, that is, that in
length shift that moves bits from the named even-numbered generating the fullword each negative item was in com-
register into the adjacent odd-numbered register, which we plement form and of such length as to fit in the item size
think of as being to the right. This is what "double" means allotted. With this assumption, the program of Figure 3-12
in Shift Right Double Logical (SRDL). The "logical" refers properly expands the sign bits of the items and stores any
to the handling of sign bits and means that zeros are negative items in halfwords in complement form. The
entered at the left of register 6. This is in contrast to the "expansion" of the sign bit is one of the functions of an
"algebraic" shifts, in which the bits entered at the left are algebraic shift, as noted above. The program must also be
1 PRINT NOGEN
000100 2 SHIFTA START 256
000100 05BO 3 BEGIN BALR 11,0
000102 4 USING *,11
000102 5860 B022 00124 5 L 6,FWORO 78ABCDEF 000001)00
000106 8C60 0008 00008, 6 SROL 6,8 0078ABCO EFOOOOOO
00010A 8870 0018 00018 7 SRL 7,24 0078ABCD OOOOOOEF
00010E 4070 B02A 0012C 8 STH 7,C 0078ABCO OOOOOOEF
000112 8C60 OOOC OOOOC 9 SRDL 6,12 0000078A BCOOOOOO
000 116 8870 ·0014 00014 10 SRL 7,20 0000078A 000008CO
OOOllA 4070 8028 0012A 11 STH 7,B 0000078A OOOOOBCO
00011E 4060 B026 00128 12 STH 6,A 0000078A OOOOOBCO
13 EOJ
000124 16 FWORO OS F
000128 17 A OS H
00012A 18 B OS H
00012C 19 C OS H
000100 20 END BEGIN
Figure 3-11. Assembly listing of a program to separate three quantities stored in one fullword
Fixed-Point Arithmetic 37
lOC OBJECT CODE ADDRl AODR2 STMT SOURCE STATEMENT
1 PRINT NOGEN
000100 2 SHIFTB START 256
000100 05BO 3 BEGIN BAlR 11 ,0
000102 4 USING *,11
000102 5860 B02A 0012C 5 l 6, FWORD 78ABCOEF 00000000
000106 8C60 0008 00008 6 SRDL 6,8 0078ABCO EFOOOOOO
00010A 8A70 0018 00018 7 SRA 7,24 0078ABCD FFFFFFEF
00010E 4070 B032 00134 8 STH 7,C 0078ABCO FFFFFFEF
000112 8C60 OOOC OOOOC 9 SRDL 6,12 0000078A BCDFFFFF
000116 8A70 0014 00014 10 SRA 7,20 0000078A FFFFFBCO
00011A 4070 B030 00132 II STH 7,B 0000078A FFFFF8CO
OOOllE 8C60 OOOC OOOOC 12 SRDL 6,12 00000000 78AFFFFF
000122 8A70 0014 00014 13 SRA 7,20 00000000 0000078A
000126 4070 B02E 00130 14 STH 7,A 00000000 0000078A
15 EOJ
00012C 18 FWORO OS F
000130 19 A OS H
000132 20 B OS H
000134 21 C OS H
000100 22 END BEGIN
Figure 3-12. Modified version of the program of Figure 3-11, making it operate correctly with negative quantities
changed to expand the sign of item A. The final two shifts other hand, interpreted the second and third numbers as
are added to do this. Actually, it could be done more negative because their leftmost bits were 1'so The three
efficiently and these extra steps avoided simply by changing output halfwords· are 078A, FBCD, and FFEF, showing
the SRDL in statements 6 and 9 to the algebraic SRDA. that the sign bits of the numbers were properly expanded.
Figure 3-13 shows the output of the two programs for
the sample input word of 78ABCDEF. The three parts of
the combined word, in hexadecimal, were therefore 78A, PROG SHIFTA 078A OBeD OOEF
BCD, and EF. In the first line of Figure 3-13 we see that PROG SHIFTB 078A FBCD FFEF
these have been put into halfwords by the first program as
078A, OBCD and OOEF, that is, as three positive numbers.
Figure 3:13. Output of the two programs executed with hexa-
In the second line we see that the second program, on the
decimal 78ABCDEF for the fullword
38
BRANCHES AND DECISION CODES
Fixed-Point Arithmetic 39
in B and C, and an interchange if necessary, gets the
Make
A,B,C
"middle" number in B and the smallest in C.
positive The program of Figure 3-15 involves some instructions
that we have not used before. The Load Multiple (LM)
instruction begins loading fullwords from the specified
storage location. The first word goes into the first-named
register. Successive fullwords go into higher-numbered regis-
ters until the second-named register has been loaded. In the
program, the result of the LM instruction will be to place A
in 2, B in 3, and C in 4.
Now three Load Positive Register (LPR) instructions
change any negative numbers to positive, leaving any posi-
tive numbers unchanged. This is an RR format instruction,
A< B meaning that both of its operands are registers. Here both
operands are the same register, as will frequently be the
Interchange case. The action is to take the value from a register, comple-
A and B
ment it if it is negative, and place the result back in the
same register. If it were necessary, two different registers
could of course be used.
Next comes a Compare Register (CR) instruction, which
is also in the RRformat. Thisinstruction does not change
the contents of either register, but simply sets the condition
code to zero if the two operands are the same, to 1 if the
frrst operand is low, and to 2 if the first operand is high.
(The comparison is algebraic, meaning that signs are taken
into account according to the rules of algebra, by which
A<C any positive number is greater than any negative number.
We know that our numbers are by now all positive, so this
Interchange feature does not concern us.)
AandC Next comes the Branch on Condition instruction, with a
mask of 10 (decimal) and a branch address of COMP2. The
mask of 10, checking with the table above, tests for condi-
tion code zero or 2. Following a Compare-type instruction,
these mean, respectively, that the first operand is equal to
or greater than the second operand. If the condition code is
either of these, we branch; otherwise the next instruction in
sequence is taken. The effect is: if the number in register 2
is already equal to or greater than the number in register 3,
we skip down to the second comparison, because A and B
are already in correct sequence.
B<C The interchange, if it is necessary, is performed by
moving the contents of register 2 to register 6, moving 3 to
Interchange 2, and finally moving 6 to 3. These transfers are made with
Band C
the Load Register (LR) instruction.
The remaining instructions repeat these operations twice
for the other comparisons. Finally, there is a Store Multiple
(STM) instruction to place the rearranged items back in the
original three locations, as required by the problem
statement.
Figure 3-16 shows before-and-after values of A, B, and C
Figure 3-14. Program flowchart of a method of sorting three num- for six possible original orderings of the three values. Each
bers into descending sequence. Any negative numbers pair of lines is one set. These are hexadecimal numbers; the
are changed to positive before sorting.
original value of A in the last set is -3.
40
LOC OBJECT CODE ADDRI ADDR2 STMT SOURCE STATEMENT
1 PRINT NOGEN
000100 2 SORT START 256
000100 05BO 3 BEGIN BALR 11 ,0
000102 4 USING *,11
000102 9824 B036 00138 5 LM 2,4,A LOAD REGISTERS WITH 3 NUfoABE~S
000106 1022 6 LPR 2,2 MAKE NU MBERS PO S IT I VE
000108 1033 7 LPR 3,3
00010A 1044 8 LPR 4,4
00010C 1923 9 CR 2,3 COMPARE A AND B
00010E 47AO B016 00118 19 BC 10,COMP2
000112 1862 11 LR 6,2 INTERCHANGE IF NECFSSARY
000114 1823 12 LR 2,3
000116 1836 13 LR 3,6
000118 1924 14 COMP2 CR 2,4 COMPARE A AND C
OOOllA 47AO B022 00124 15 Be 10,COMP3
000 11 E 1862 16 LR 6,2 INTERCHANGE IF NECF.SSty
000120 1824 17 LR 2,4
000122 1846 18 LR 4,6
000124 1934 19 COMP3 CR 3,4 COMPARE BAND C
000126 47AO B02E 00130 20 BC 10,OUT
00012A 1863 21 LR 6,3 INTERCHANGE IF NECESSARY
00012C 1834 22 LR 3,4
00012E 1846 23 LR 4,6
000 130 9024 B036 00138 24 OUT STM 2,4,A STORE SORTED VALUES
25 EOJ
000136 0000
000138 00000001 28 A DC F' 1 '
00013C 00000002 29 B DC F' 2'
.000 140 00000003 30 C DC F'3'
000100 31 END BEGIN
Figure 3-15. Assembly listing of a program to carry out the sorting procedure charted in Figure 3-14
Figure 3-16. Six sets of sample input and output for the program of Figure 3-15
Fixed-Point Arithmetic 41
FURTHER DECISIONS:
THE SOCIAL SECURITY PROBLEM
42
Suppose we have a man who earns $164.00 per week. the year, we get $7.22 as the tax. The second week, we
Multiplying by 0.044 and rounding to the nearest cent, we begin by computing 0.044 times $328.00, the new year-
get a Social Security tax of $ 7.22. In 47 weeks of working to-date gross; this gives us $14.43 _as the new year-to-date
at this rate, the man will accumulate year-to-date earnings Social Security, which we store. This week's tax is $14.43
of $7708.00 and a year-to-date Social Security tax of minus the previous year-to-date Social Security of $7.22,
$339.34. Now in the next week his full earnings are not or $ 7.21. In other words, where last week we were a
taxable, but only the part that takes him up to $ 7800, or fraction of a cent high, now we are a fraction of a cent
$92.00; the tax on this amount is $4.05. Adding $4.05 to low; the two tend to cancel each other. The offset may
his previous year-to-date Social Security, we get $343.39, not always be equal; however, we can never be more than
which is more than 4.4% of the $ 7800 maximum. half a cent off.
The difficulty is in the computation of the tax on one The test for reaching the maximum taxable amount is
week's earnings. Before rounding, the product of $164.00 now made in terms of the tax instead of the earnings. We
and 0.044 is $7.21600. When we round this to $7.22 we compute the Social Security on the new year-to-date
add nearly half a cent. For each of the 47 weeks we are earnings, then ask whether the result is greater than
adding nearly half a cent. $343.20. If so, the result is replaced by $343.20 and the
This would be inaccurate. Social Security tax is seldom tax is computed as before, by subtracting the previous
computed the way we have shown. year-to-date Social Security. If that was already $343.20,
Fortunately, correcting the trouble is not only fairly that is, if the max4num had already been reached, then
easy, but leads to a shorter program. The general approach the tax computed by this method is zero, as it should be.
is to compute 4.4% of the new year-to-date earnings, then If this week's pay goes over the taxable limit, the tax is
compute the tax by subtracting from this the previous year-, the difference between the maximum tax and the amount
to-date Social Security. The effects of the rounding error already paid, which is correct.
are thus balanced from week to week, and we are never The program shown in Figure 3-19 should not be too
more than half a cent off in the accumulated total. difficult to follow after the description of the process that
Consider the example given above. The frrst week of has just been given. The program is eight instructions
1 PRINT NOGEN
000100 2 FICAI START 256
000100 05BO 3 BEGIN BALR II ,0
000102 4 USING *,11
000102 5860 B052 00154 5 L 6,OLDYTD
000106 1856 6 LR 5,6
000108 5A6p B04E 00150 7 A 6,EARN
00010C 5060 B056 00158 8 ST 6,NEWYTD
000 110 5950 B066 00168 9 C 5,C7800
000114 4740 BOIC OOllE 10 BC 4,YES
000118 IB77 II SR 7,7
OOOllA 47FO B040 00142 12 B,C 15,STORE
OOOllE 5960 B066 00168 13 YE S C 6~C7800
000122 4720 B02C 0012E 14 BC i,OVER78
000126 5870 B04E 00150 15 L 7,EARN
00012A 47FO B034 00136 16 BC 15,MULl
00012E 5870 B066 00168 17 OVER78 L 7,C7800
000132 5B70 B052 00154 18 S 7,OLDYTD
000136 5C60 B06A 0016C 19 MULT M 6,C44
OOO13A 5A70 B06E 00170 20 A 7,HALF
0OO13E 5D60 B072 00174 21 0 6,CHUN
000142 5070 B062 00164 22 STORE ST 7, TAX
000146 5A70 B05A 0015C 23 A 7,OLDFICA
00014A 5070 B05E 00160 24 ST 7,NEWFICA
25 EOJ
000150 00004010 28 EARN DC F'16400'
000154 OOOBBFDO 29 OLDYTD DC F'770000'
000158 30 NEWYTD DS F
00015C 00008408 31 OlDFICA DC F'33800'
000160 32 NEWFICA OS F
000164 33 TAX OS F
000168 OOOBE6EO 34 C7800 DC F '780000'
00016C 0000002C 35 C44 DC F'44'
000170 000001F4 36 HALF DC F'500'
000174 000003E8 37 CHUN DC F'1000'
000100 38 END BEGIN
Figure 3-18. Assembly listing of a program based on the flowchart in Figure 3-17
Fixed-Point Arithmetic 43
shorter and considerably less complex. Both versions have mnemonics used after Compare instructions are BH (Branch
been tested with a variety of data; both give "correct" on High) for BC 2, BE (Branch on Equal) for BC 8, BNH
results in that they do what we expect, although of course (Branch on Not High) for BC 13, and so on. Additional
the results are not identical. extended mnemonics can be used after arithmetic opera-
The only new instruction used in this program is BL tions and Test under Mask instructions. They are supplied
UNDER, which means Branch on Low to the address with most System/360 assemblers and are a great conven-
UNDER. BL is an extended mnemonic code; it is translated ience in writing and checking conditional branching
by the assembler to the Branch on Condition operation instructions, since they specify the conditions. A full list is
code (47) with a decimal mask of 4. Other extended given in the Appendix.
1 PRINT NOGEN
000100 2 FICA2 START 256
0001.60 05BO 3 BEGIN BALR 11 ,0
00Oi02 4 USING *,11
000102 5850 B036 00138 5 L 5,OLDYTD
000106 -5-A-5{) ,B032 00134 6 A S,EARN
00010A 5050!B03A 0013C 7 ST 5,NEWYTD
00010E 5C40 B04A 0014C 8 M 4,C44
000112 5A50 B04E 00150 9 A 5,HALF
000116 5040 6052 00154 10 D 4,CHUN
00011A 5950 B056 00158 11 C 5,MAX
00011E 4740 B024 00126 12 BL UNDER
000122 5850 B056 00158 13 L 5,MAX
000126 5050 B042 00144 14 UNDE~ ST 5,NEWFICA
00012A 5B50 B03E 00140 15 S 5,OLDFICA
00012E 5050 B046 00148 16 STORE ST 5,TAX
17 EOJ
000134 00004010 20 EARN DC F'16400'
000138 OOOBBFDO 21 OLDYTD DC F'770000'
000 l3C 22 NEWYTD DS F
000140 00008408 23 OLDFICA DC F'33800'
000144 24 NEWFICA DS F
000148 25 TAX DS F
00014C 000OO02C 26 C44 DC F'44'
000150 000001F4 27 HALF DC F'500'
000154 00OO03E8 28 CHUN DC F'1000'
000158 00008610 29 MAX DC F'34320'
000100 30 END BEG HI
Figure 3-19. Assembly listing of a much better version of the program to calculate Social Security tax
44
SIMPLE LOOPS: FINDING A SUM
A frequent programming requirement is to perform some time through the loop, this instruction therefore adds the
operation on a set of values arranged in some systematic word at TABLE to register 8, which was cleared to zero.
way in storage. We shall examine some of the coding The next time through the loop, we want the full word at
methods available for such operations in the System/360, in TABLE+4 added to register 8. This can be accomplished by
terms of a very simple example. adding 4 to the index register. In this version of the pro-
For our illustrative problem, suppose that there are 20 gram, we do so with an Add instruction.
fullwords in consecutive fullword locations starting with Now we are at the point in the program where a test for
the one identified by the symbol TABLE. We are required completion must be made. The last of the 20 words is
to form the sum of the 20 numbers and place it in SUM. located at TABLE+76. We are modifying before testing,
We shall consider the three different ways of doing this. however. At the point where the loop has just been exe-
All three involve the use of an index register to modify the cuted with TABLE+76 for anFeffective address, we will now
effective address in an instruction. The contents of the have 80 in the index register. That is, therefore, the correct
index register are changed between repetitions of the loop. constant to use in testing for completion. We do so with a
The first version of the program is shown in Figure 3-20. Compare, then Branch on Condition witli a mask that asks
We shall use register 8 to accumulate the sum and register for a branch if the index was less than 80. We could use the
11 as the index register. We want register 8 cleared to zero extended mnemonic code BL and write the branch
so that the sum will be correct; as it happens, we want the instruction as BL LOOP; the object program would be the
index register cleared to zero also. Both operations are done same.
with Subtract Register instructions. The branch will be executed 19 times, giving 20 execu-
Now comes the instruction that does the actual tions of the Add at LOOP. After that, the branch is not
computing. We add to register 8 the contents of some full- executed, we store the total at SUM, and the program is
word in storage. The first time through the loop we want to completed.
add the word at TABLE. The instruction specifies that the The reader will no doubt have recalled the customary
contents of index register 11 should be used in computing the names for the parts of a loop. The part at the beginning that
effective address - but we just made those contents zero, so gets the loop started is the initialization section; here, it
the effective address is that of the word at TABLE. The first consists of the first two instructions. The part that does the
1 PRINT NOGEN
000100 2 SUMA START 256
000100 0530 3 BEGIN BALR 3,0
000102 4 USING *,3
000102 IBS8 5 SR S,8
000104 IBBB 6 SR 11 ,11
000106 5ASB 301A OOllC 7 LOOP A S,TABLE(11)
00010A 5ABO 306E 00170 S A 11,C4
00010E 59BO 3072 00174 9 C II ,C80
000112 4740 3004 00106 10 BC 4,LO(1P
000116 50S0 306A 0016C 11 ST B,SUM
12 EOJ
000 lIC 00000001 15 TABLE DC F'l'
000120 00000002 16 DC F'2'
000124 00000003 17 DC F'3'
000128 00000004 18 DC F'4'
00012C 00000005 19 DC F' 5'
000130 00000006 20 DC F'6'
000134 00000007 21 DC F '7'
000138 00000008 22 DC F'S'
00013C 00000009 23 DC F'9'
000140 OOOOOOOA 24 DC F'lO'
000144 OOOOOOOB 25 DC F' 11 '
00014S OOOOOOOC 26 DC F'12'
00014C OOOOOOOD 27 DC F'13'
000150 OOOOOOOE 2S DC F'14'
000154 OOOOOOOF 29 DC F'15'
000158 00000010 30 DC F '16' '
00015C 00000011 31 DC F'17'
000160 00000012 32 DC F'lS'
000164 00000013 33 DC F'19'
000168 00000014 34 DC F'20'
00016C 35 SUM OS F
000170 00000004 36 C4 DC F'4'
000174 00000050 37 C80 DC F'SO'
000100 38 END BEGIN
Fixed-Point Arithmetic 45
actual work of the loop is called the compute part, and here execution of a Subtract sets the condjtiQn code. A condi-
consists of the Add at LOOP. The modification section tion code of zero indicates that the result was zero, 1
:d~C:~t~~~~~}=-;~~~~~f~~~
changes something between repetitions; here, it is the modifi-
cation of the index contents by the Add. The testing section
determines whether the action of the loop has been com- regtste'"r. If tileprogram'Is correct an overflow cannot occur
pleted, and consists here of the Compare and the Branch on here, so the possibility does not concern us.) We want to
Condition. The sequence of the last three sections is not branch back to LOOP as long as the result of the subtrac-
always as in this example. And as we shall see in the third tion is either positive or zero, so the mask on the Branch on
version, the modification and testing can often be combined Condition is 10: 8 picks condition code zero and 2 picks
into one instruction. up code 2.
The second version shortens the repeated section of the The Store is as before.
loop by one instruction. Normally, we do not worry too Where in the first version there were four instructions in
much about trying to get the last microsecond out of pro- the repeated portion of the loop, here there are three. The
grams, but in heavily repeated parts it is worth some effort. final version reduces this number to the minimum, two.
The method will require us to go "backward" through the The technique is to use the Branch on Index' Low or Equal
table, which in this particular example is permissible; some- instruction (BXLE), which is a combination of an Add, a
times, of course, it would not be. As shown in Figure 3-21 we comparison, and a conditional branch.
again clear register 8. This time, however, instead of loading Let us assume we have three registers set up as follows:
the index register (11) with zero, we use a new instruction, Register 9 will be the index; it initially contains zero.
Load Address, to put 76 in it. The Load Address (LA) simply Register 10 will contain the amount by which the index is
pu ts the address part of the instruction itself in the designated to be incremented each time around the loop, 4. Register
register; there is no reference to storage whatsoever. In this 11 will contain the limit value, the value of the index which
case, 76 is actually the displacement and there is no base or is not to be exceeded, 76. If we have the instruction:
index register. If we wanted to state this specifically, the
BXLE 9,IO,LOOP
statement could be written LA 11 ,76(0,0).
Now when we execute the indexed Add instruction at the action will be as follows: The contents of register 10 (4)
LOOP, the effective address is TABLE+76. Following this, are added to register 9, which is the index and initially
we subtract 4 from the index register. As it happens, the contains zero. If the sum is less than or equal to the
1 PRINT NOGEN
000100 2 SUMB START 256
000100 0530 3 BEGIN BALR 3,0
000102 4 USING *,3
000102 1B88 5 SR 8,8
000104 41BO 004C 0004C 6 LA 11,76
000108 5A8B 301A OOllC 7 LOOP A 8,TABLE(llJ
OOOlOC 5BBO 306E 00170 8 S 11,C4
000110 47AO 3006 00108 9 BC 10,LOOP
000114 5080 306A 0016C 10 ST 8,SUM
11 EOJ
OOOllA 0000
000 lIC 00000001 14 TABLE DC F'l'
000120 00000002 15 DC F'2'
000124 00000003 16 DC F'3'
000128 00000004 17 DC F'4'
000I2C 00000005 18 DC F '5'
000130 00000006 19 DC F'6'
000134 00000007 20 DC F'7'
000138 00000008 21 DC F '8'
000I3C 00000009 22 DC F'9'
000140 OOOOOOOA 23 DC F '10'
000144 00000006 24 DC F ' II'
000148 OOOOOOOC 25 DC F' 12 '
00014C 00000000 26 DC F '13'
000150 OOOOOOOE 27 DC F'14'
000154 OOOOOOOF 28 DC F'15'
000158 00000010 29 DC F '16'
00015C 00000011 30 DC F' 17'
000160 00000012 31 DC F '18'
000164 00000013 32 DC F'19'
000168 00000014 33 DC F'20'
00016C 34 SUM DS F
000170 00000004 35 C4 DC F'4'
000100 36 END BEGIN
46
contents of register 11, the limit, the branch to LOOP is register, a third register is not used. In this case the BXLE
taken; otherwise the next instruction in sequence is taken. instruction assumes that R3 specifies the register to be used
The instruction is written in assembler language in the for both the increment and the limit. If we have the
general form: instruction:
BXLE R1 ,R3,D2(B2) BXLE 6,7,LOOP
Three factors, each of which must be located in a register 7 will be used by BXLE as the source of the incre-
register, are required by the BXLE instruction. An index ment and the limit.
must be in the register specified by R1. An increment must At fITst glance this instruction seems more complicated
be in the register specified by R3. A limit value must also than it is. Let us turn to an example to see how it works.
be in a register but the register is not explicitly specified in Figure 3-22 is the fmal version of our summing loop.
the instruction. The BXLE instruction will first add the We begin the program by loading the three registers that
increment to the index. It will then compare the resultant will be used by the BXLE instruction (registers 9, 10, and
index against the limit. If the index is less than or equal to 11), with the desired initial contents. We then proceed to
the limit, a branch is taken to the location specified by the Add instruction at LOOP, which is the same as in the
D2(B2); otherwise the next instruction in sequence is previous two versions. Next comes the BXLE, which
taken. The register containing the limit value is always odd- operates as described.
numbered and is chosen in the following way: The operation of the BXLE instruction is most easily
1. If the register specified by R3 is an even-numbered remembered if we think in terms of three registers repre-
register, the limit value is assumed to be in the next higher- senting the index,the increment, and theliinit, in that order.
numbered register. If We have the instruction: F o~ a sifUation where it is desi~e-d to ~backwards, in
°
BXLE 9,1 ,LOOP
which case the increment would be negative, the Branch on
Index High (BXH) instruction is available.
the limit value is in register 11, the next higher-numbered The BXLE and BXH instructions are very powerful and
register. very flexible. They will find heavy use in many practical
2. If the register specified by R3 is an odd-numbered applications, and are well worth the investment of effort
necessary to understand them fully.
000100
000100 .0530
000)02 _ _
000102 IB88
K c::>&~ /0 , 1
2 SUMC
3 BEGIN
4
5
PRINT
STm
BAlR
~R
NOG~
25~
3,0-
US~'NG ',*,3'-
8,8,
.
000104~~ 6 SR 9,9-~"
000106 4 0 04 00004 7 lA 10',4 . ·_··,
000 lOA BO' 004C -- 0004C 8 L,\ . 1"i , 16 \
00010~ 5AS9 ~OlA OOllC 9 -lOOP A 8, TA6LE(9)
000112 879A.aooc
000116 5080'§'06A
OOOllC
000120
.... "...~'
00000001
00000002
..
-
~,.-.:--.¥--
0010E
0016C
10
11
,. 12
15 TABLE
16 DC
BXlE
' ST
EOJ
'oC""
9,tO,[OOP
8,~M
........
F r
F'2'
000124 00000003 17 DC F'3'
000128 00000004 18 DC F'4'
00012C 00000005 19 DC F'5'
000130 00000006 20 DC F'6'
000134 00000007 21 DC F'7'
000138 00000008 22 DC F'S'
00013C 00000009 23 DC F'9'
000140 OOOOOOOA 24 DC F ' 10'
000144 OOOOOOOB 25 DC F '11'
000148 OOOOOOOC 26 DC F '12'
00014C 00000000 27 DC F'13'
000150 OOOOOOOE 28 DC F'14'
000154 OOOOOOOF 29 DC F'15'
000158 00000010 30 DC F '16'
00015C 00000011 31 DC F'17'
000160 00000012 32 DC F'18'
000164 00000013 33 DC F'19'
000168 00000014 34 DC F'20'
00016C 35 SUM OS F
000100 36 END BEGIN
Figure 3-22. Third and shortest version of program to form the sum of 20 numbers, using the BXLE instruction
In an attempt to draw together some of the things that have variations of a number of instructions that should be quite
been discussed in this chapter, we shall now consider a final familiar in their fullword forms.
problem that involves several different concepts. Before analyzing the operation of the program, it may be
Suppose we have in storage a group of halfwords giving helpful to summarize the functions of the registers used,
the temperature, to the nearest degree, on each of the days which will often be a valuable thing for the programmer to
of a month. There may be 28, 29, 30, or 31 of them; the do.
number is given by a halfword named DAYS. The table of
temperatures begins at TEMP and continues for a total of Register Usage
3 Base register
31 halfwords; if there are fewer than 31 days in the month
4 Index register
at hand, the last entries of the table are to be ignored. It is
5 Word of 1's
possible that the temperature reading may be missing for
6 Left half of dividend
some days; a missed reading is indicated in storage by a
7 Sum of temperatures-right' half of dividend
halfword of all 1'so We are to form the average of the tem-
8 Count of nonzero temperatures
peratures for the month, using only as many good readings
10 Increment for BXLE
as are found. If the entire table should happen to contain
11 Limit for BXLE
bad readings, a halfword of all 1's should be stored to indi-
cate that the average was not computed. In any case, we are The initialization consists of setting up the contents of
to store in NGOOD the number of good readings found. the seven registers used. by the program. The first one to be'
The average should be rounded off to the nearest degree. set to zero (6) is cleared by a Subtract Register, the others
The program shown in Figure 3-23 uses the halfword by Load Registers from 6. The Load Halfword to get the
1 PRINT NOGEI';
000100 2 AVGTEMP START 256
000100 0530 3, BEGIN BALR 3.0,
000102 It USING *., ]
000102 4850 3094 00196 5 LH 5,CNES
000106 IB66 6 SR 6.6
000108 1816 1 LR 1.6
00010A 1886 8 LR 8.6
00010C 41AO 0002 CCC02 9 LA 10.2
000110 48BO 3096 00198 10 LH 11.DAYS
0001L4 4BBO 3092 00 t<~4 11 SH 11.0NE
000118 8BBO 000 L 00C01 12 SLA 11.1
000 HC 1846 13 LR 4.6
00011E 4954 3054 00156 14 LOOP CH 5,TEMP(4)
000122 4180 302C 0012E 15 BE ZERO EXTENDED MNEMONIC FOR BC 8
000126 4A14 3054 00156 16 AH l,TEMP(4)
00012A 4A80 3092 C0194 11 AH 8,ONE
000IlE 874'" :J01C COllE 18 ZERO BXLE 4.10,LOOP
000132 4080 309A 0019C 19 STH 8.NGOOD
000136 1288 20 LTR 8.8
000138 4710 3040 00142 21 BNZ NOT EXTENDED MNE~ONIC FOR BC 1
00013C 4050 3098 0019A 22 STH 5,AVER STORE ONES IF NO GOOD DATA
23 EOJ STOP
000142 8B70 0001 OOCOI 26 NOT SLA 7,1 TO GET EXTRA BINARY PLACE IN QUOTIENT
000146 1068 21 OR 6,8 DIVIDE REGISTER
000148 4Al0 3092 00194 28 AH 7,ONE ROUND OFF
0001ltC 8Al0 0001 00001 29 SRA 1,1 DROP THE EXTRA BIT
000150 ItOl0 3098 C019A 30 S TH 1,AVER FINAL RESULT
31 EOJ END OF JOB
000156 0001 34 TEMP DC H'l'
000158 0002 35 DC H'l'
00015A
JlOill5C
0003
-DODlt.
--
36
...3.1
DC
DC.
H'3'
~4'
- - -~
- --
00018E 0010 61 DC H'29'
000190 001E 62 DC H'30'
000192 OOlF 63 DC H'31'
000194 0001 64 ONE DC H'l'
000196 FFFF 65 ONES DC X'FFFF'
000198 66 CAYS OS H
00019A 67 AVER OS H
00019C 68 NGOOD OS H
000100 69 END BEGIN
Figure 3-23. A program to compute average monthly temperature, which takes into account the possibility of omitted readings
48
number of days into register 11 automatically expands the The BXLE increments the index register (4) by 2 (which
halfword into a fullword, which would mean that the sign is in 10) and checks whether the index is now the same as
bit of a negative number would be filled out. With correct what we put in 11. If the index is low or equal, meaning
data, the word here cannot be negative, of course. The that the list has not been exhausted, we branch back to
number of days is to be used to terminate the summing . LOOP to go around again.
loop that adds up the temperatures. The loop should be When the loop is finished, we reach the Store Halfword
executed as many times as the number of days; it should be after the BXLE. Here we store the count of good readings
repeated (after the frrst time) one less time than the at NGOOD; this conceivably could be zero. Next we check
number of days. We accordingly subtract 1 from register 11 whether it was zero, using the Load and Test Register
after loading it. instruction (LTR). With the two register designations being
Since the table of data consists of halfwords, the index the same, as they an~' here, the effect of this instruction is
register will have to be incremented by 2 between loop to set the condition code according to the sign and magni-
repetitions, and the proper limit value is two less than tude of the count in (register· 8. The Branch on Condition
double the number of days. We can double a number quite instruction then asks whether the count was either positive
simply by shifting left one place in a binary machine. (If or negative and branches if so. If it was neither of these it
the table had consisted of fullwords, requiring an increment must have been zero, in which case we store the word of all
of 4, a left shift of two places would multiply the number 1's for the average in AVER, and stop.
of days by 4.) If there was at least one good reading, we are ready now
In the working part of the loop we frrst check to see to compute the average. In order to be able to round off to
whether the particular temperature is valid, by comparing the nearest degree, it is necessary to arrange the division so
with the word of all 1's that had been set up in register 5. that the quotient has one binary place in it; this can be
The Compare Halfword expands the halfword from storage done by shifting the dividend to the left one plact before
to a fullword by propagating the sign bit. This is necessary dividing. The division is done this time. with the Divide
to us, since the load halfword that put the word of all 1's in Register instruction, since the desired divisor ( the count) is
register 5 did the same thing. We next branch on equal to already in a register. Following the Divide Register we add
the instruction at ZERO, which would happen if the read- 1 to the rightmost bit position of the quotient register to
ing was bad. If it was good, the branch is not taken; we add round off. Having done so, we shift the quotient back to
in the temperature, add one to the count of good readings, the right to get rid of the extra bit and store the result.
and then reach the BXLE.
Fixed-Point Arithmetic 49
QUESTIONS AND EXERCISES
1. The L, A, S, and ST instructions all operate on a Write the program to store X in a fullword area in storage
(fullword, halfword). ~ed X, and Y in a halfword area in storage called Y.
2. The first operand of an instruction usually specifies the (?~he instruction BC 5,ROUT3 would branch to ROUT3
operand that (sends, receives) information. 0'the:
3. In a ST instruction the fIrst operand specifies the oper- a. Condition code is 5.
and that (sends, receives). Does the ST instruction, in this b. Condition code is 1, 2, or 3.
respect, follow the general rule, or is it an exception to the c. Condition code is 1 or 3.
general rule? 8. Write an instruction to branch unconditionally to an
4. Is the instruction M 7,QTY a legitimate instruction? If instruction called NEWONE.
not, why not? 9. There are four fullwords named Xl, X2, X3, and X4
5. The D instruction specifies _ _ _ _ _ _ _ _ __ sequentially located in storage. Write one instruction that
as the first operand, and the _ _ _ _ _ _ _ _ _ __ loads these four fullwords into registers 2, 3, 4, and 5
as the second operand. After completion of the divide respectively.
operation, where is the quotient located? Where is the 10. Write an instruction that clears register 5 to zero.
IDnderlocated? (U}) Consider the instruction named LOOP in Figure 3-20.
6. ssume that a fullword area of storage (reserved by a 'ikfw will the effective address of TABLE(1I) be formed?
(}
, to be addressed as XANDY, contains two positive 12. Write a single instruction that adds the contents of
items as below: register 6 to register 5, tests to see if the sum now in
x Y register 5 is equal to or less than the contents of register 7,
XANDY-o 19 20 31 and then branches to an instruction called NEWONE if the
answer is yes.
50
Chapter 4: Programming with Base Registers and the USING Instruction
A major programming feature of System/360 is the use of , possible to delegate to the assembler almost all the clerical
base registers for addressing main storage. One advantage is work of keeping track of base registers and computing
that compatibility is maintained between the small system displacements. With a full understanding of these tech-
with its short addresses and the large system with its longer niques, the programmer is able to leave the housekeeping to
addresses. The same instruction size and format accom- the assembler where appropriate, and to employ more
modates both. Also, through appropriate use of base sophisticated methods where needed.
registers it is possible to relocate assembled programs In this chapter we shall see how the automatic tech-
almost at will. Great flexibility in program organization is niques are called into operation and how the assembler
thus achieved, since storage locations can be reassigned as implements them; and we will explore a few slightly more
dictated by the needs of the particular "mixture" of advanced techniques. As in so many other aspects of
programs or program segments. programming, particular emphasis must be placed on the
Base registers are thus deeply involved in programming question of when various actions occur: during assembly,
and in program execution. However, as we shall see, it is linkage editing, or program execution.
Automatic computation of the addresses of all operands in .' the next instruction in sequence is taken as usual. For our
main storage requires the programmer to supply two items· purposes here, the second operand (R2) is always zero. For
of information to the assembler and one to the object- , instance, in the illustrative program we shall be considering
program. shortly, we have an instruction:
With the USING instruction, the programmer tells the.
BALR 11,0
assembler:
1. Which general registers may be used as base registers This places in register 11 the address of the next byte after
2. What each one will contain at the time the object the BALR, and there is no branch. Register 11 was
program is executed arbitrarily chosen as the base register for this program. It is
With this information the assembler can do its work of used as a base register for most of the programs in this text.
designating base registers and computing displacements. In actual practice, the choice of a base register cannot be a
It still remains to place in the base registers the values we.... completely arbitrary one. As mentioned earlier, most instal-
have promised the assembler will be there. This can in lations fmd it necessary to establish rather rigid conventions
principle be done in many ways, but the most common is for register usage. In addition, the various operating systems
to use the Branch and Link Register instruction (BALR). for System/360 make use of certain general registers for
The general format of this instruction is: supervisor routines, linkages between separate programs,
and other purposes. Under most operating systems, registers
BALRRl,R2
2 through 11 are freely available to the programmer and
Rl receives the address of the next byte after the BALR; should be used to avoid any complication.
R2 supplies a branch addreSs unless it is zero, in which case
These ideas may be made more concrete by considering an 102 and a displacement of 2A for an effective address of
example. Figure 4-1 is an assembly listing of a program the 12C, which is the address of the symbol TEN.
processing details of which do not concern us. The Shift Left Algebraic instruction is a little different.
The START instruction specifies that the assembled first All shift instructions have~the RS format, with the index
byte of the program is location 25610 = 10016 • We see that portion unused, but they stillmust specify a base register.
the BALR instruction has in fact been placed 31t 100. (All Even though the effective "address" is never used for a
numbers in the object program area of the assembly listing storage reference, it is possible to make effective use of a
- on the left-hand side - are hexadecimal.) The BALR variable number or positions of shift by varying the con-
instruction specifies that general purpose register 11 is to be tents of the base register. In this program, however, such is
loaded with the address of the next machine instruction. not the case and we need a base register designation of zen).
This, of course, is done at execution time by the machine. We see that this was done. The effective address is therefore
The USING instruction, which is an assembler instruction just the displacement of 1. The remainder of the program
and takes no space in the object program, informs the presents no new base register concepts.
assembler that general purpose register ,11 is available for As always,__ it is most important to distinguish between
use as a base register and will contain the address of the what is done at assembly time and what is done at
next machine instruction, as signified by the asterisk. The execution time. The assembler, in the example at hand, has
BALR is a two-byte instruction so the' next instruction, the filled in base register numbers where needed and has com-
Load, is placed at 102. This number;'shown in the location puted displacements. These base register numbers and
counter column in the USING statement, indicates what displacements become part of the actual instructions, as
the assembler assumed would be the contents of base listed down the left side of the assembly listing. In carrying
register 11. out the assembly operations, the assembler had to know
Let us look at the Load instruction to see how the what base register we wished to use and what we planned to
assembler handled it. Reading from left to right the opera- put in it; this information we provided with the USING.
tion code is 58, the register loaded with a word from The assembler cannot load the base register for the
storage is number 2, no index register is specified, the base execution of our program, since that can be done only
register is B16 = 11 10 , and the displacement is 02216 • With when the program is executed. We therefore provided the
base register 11 containing 102 and with a displacement of BALR instruction, which, at execution time, places the
22, we get an actual address of 12416 , as listed under address of the next instruction into the specified register.
ADDR2. Looking down the listing we see that 124 is in fact The remainder of the program can now be carried out, with
the address corresponding to the symbol DATA, as it effective addresses being developed as intended.
should be. The assembler program is actually processed in several
The Add instruction is similar. With base register 11 separate phases. One of its functions is to determine the
again automatically designated, we have a base address of length and location of each instruction, area, and constant.
1 PRINT NOGEN
000100 2 PROGE START 256
000100 05BO 3 BEGIN BALR 11 ,0
000102 4 USING *,11
000102 5820 B022 00124 5 l 2,DATA
000106 5A20 B02A 0012C 6 A 2,TEN
00010A 8B20 0001 00001 7 SLA 2,1
00010E 5B20 B026 00128 8 S 2,DATA+4
000112 5020 B02E 00130 9 ST 2,RESULT
000116 5860 B032 00134 10 L 6,BINl
00011A 5A60 B036 00138 11 A 6,BIN2
OOOllE 4E60 B03E 00140 12 CVD 6,DEC
13 EOJ
000124 00000019 16 DATA DC F'25'
000128 OOOOOOOF 17 DC F' 15 '
00012C OOOOOOOA 18 TEN DC F'10'
000130 19 RESULT OS F
000134 OOOOOOOC 20 BINI DC F' 12'
000138 0OOOO04E 21 B I N2 DC F'78'
000140 22 DEC OS 0
000100 23 END BEGIN
Figure 4-1. Listing of a program to show how the assembler calculates and supplies addresses of all storage operands. The processing
performed is not intended to be realistic.
52
While doing this, the assembler constructs a symbol table. the program, its name (given in the START statement,
As shown in Figure 4-2, this lists for each symbol used in PROGE in this case), the assembled locations of any
the program: its length in bytes, either its value or location relocatable address constants, and other details necessary to
(VALUE), the number of the statement in which it is perform the relocation;
defined (DEFN) , and all statements in which it is When the program is in executable form, all statements,
referenced. With the length and location of each instruction constants, reserved storage spaces, etc.-, remain in the same
and the base register information provided by the program- relative positions as in the assembly listing. Nothing needs
mer in the USING instruction, the assembler is able, in a to be changed to make the object program operate correctly
later phase, to calculate the base register and displacement from the new location or, at a later time, from still another
and to list these and the actual assembled addresses of all- location. All that is involved is the relocation factor.
operands as they appear in Figure 4-1. Suppose the linkage editor assigns location 320016 as the
In our program, we said with the START instruction starting address. When the program has been loaded, it begins
that the fust byte of the program should be assembled at with execution of the BALR instruction. Now, what is the
location 25610 = 10016 . Everything said so far has assumed address of the next instruction after the BALR? The answer
that the program will actually be loaded at 10Ot6. This is is 3202. This value goes into register 11 and becomes the
not so. In the first place, this location is within the low area base address. The displacements in the assembled instruc-
of main storage that is occupied by the supervisor and other tions have not changed, of course. The effective address in
parts of the control program, and could not be used for the Load instruction is now 3202 + 22 =3224. With the
program execution. Parenthetically, it should be explained new starting location, 3224 is exactly where DATA
that START 256 is not a standard programming practice. appears. All other addresses are correctly computed as well,
We have chosen it for the examples in the ftrst few chapters including the "address" in the Shift, which is completely
of this book to cause our assemblies to begin at some unchanged since no base register is used.
positive value, simply for illustrative purposes. The usual It is also possible for the programmer by use of a control
practice is to specify a zero START, which -greatly simpli- card to tell the linkage editor which starting location to
ftes the programmer's chore of calculating addresses, a assign. A complete relocation of the program after assembly
necessity when debugging a program. is thus a simple matter. In more complex program struc-
The second r,eason that our program will not be loaded tures, the linkage editor has more work to do than this
at location 10016 is that, regardless of the location we give example might suggest, but it is nevertheless feasible to
in the START statement, our assembled object program is execute programs from whatever storage locations may be
in relocatable form and it is not executable until processed convenient and available under any particular set of
by the linkage editor. The linkage editor is an IBM service circumstances.
program that is part of the operating or programming As we have noted, this simplicity of program relocation
support system. was one of the reasons for providing base registers in
The linkage editor assigns the actual starting address in System/360.
main storage for each object program in ajob input stream, The techniques of program relocation and the functions
and edits these into executable programs. It uses infor- of the linkage editor will be discussed in more detail in the
mation supplied by the assembler regarding the length of chapter on subroutines and program relocation.
CROSS-REFERENCE
Figure 4-2. Symbol cross-reference table constructed and listed by the assembler for the assembly in Figure 4-1
The displacement in an instruction is limited to a positive following instruction, we give that instruction a symbolic
number in the range 0-409510 = O-FFF16, since this is the name (HERE) and use the symbol. This gives exactly the
limit that can be expressed in an unsigned 12-bit number. same effect with respect to register 11, and permits us to
This means that an effective address cannot be less than the refer to the contents of 11 in terms of a symbol, which we
base address or more than 4095 greater, when an index shall need for loading register 9. (The choice of register 9
register is not being used. If a program must reference a was arbitrary.)
range of addresses greater than 4095, the easiest and most In loading the second base register, we cannot use a
common approach in routine programming is to use more BALR; we want register 9 to contain not the address of the
than one base register. next instruction, but 4096 more than whatever went into
It should be noted, however, that it takes a rather large 11. To accomplish this we use an address constant, named
program segment to exhaust the range of displacements BASE in this case, which is written with the address
using one base register. With average length instructions, it HERE+4096. We see that the constant BASE has been
takes a full pad of coding paper to use up 4096 bytes: It assembled as we instruCted: hexadecimal 1102 is 1000
will usually be desirable to break a program this large into greater than the value of the symbol HERE, and 100016
smaller segments anyway, so it will probably be extremely = 409610 .
rare in practice to need more than one base register because Base register 9 will thus be loaded with 110216 at
of program length. Long sections of storage for data or execution time. This information is given to the assembler
results are another matter. Frequently it may be advanta- with a USING that has the address HERE+4096.
geous to assign one base register to the program and It is worthwhile noting which base register was used in
another to data. This is done in the last example in this the Load instruction that loaded base register 9: we see that
chapter. the base register is 11 (which contains 102) and there is a
For now, to establish some basic ideas, let us make up a displacement of A (+10 decimal). The effective address is
program that does use more than 4096 bytes for combined thus 1OC, which we see is indeed the address of the constant
data and program. We shall not actually write an illustrative BASE. It is important to realize that at the time register 9 is
program that large, but we can simulate the effect of such a being loaded, the only base register available is 11; the
size by using the ORG assembler instruction to advance the effective address of the instruction that loads 9 therefore
location counter. cannot be more than 4096 greater than the contents of 11.
The partial program shown in Figure 4-3 was designed Thus the address constant BASE cannot be at the end of
with the sole purpose of illustrating base register ideas; the the entire program, which would be more than 4096 bytes
"processing" is not intended to be meaningful. After the away. We have chosen to place it at almost the beginning
usual START, we have a BALR to load base register 11 and branch around it. Other placements are possible, so
with the address of the next instruction. The USING long as they do not cause the assembler to try to use a
instruction is slightly different this time. Instead of using an displacement in the Load instruction at HERE that is
asterisk to denote the address of the frrst byte of the negative or greater than 4095.
Figure 4-3. Listing of an incomplete program with an Origin (ORG) assembler instruction to simulate a length of over 4096 bytes, thus
requiring two base registers
54
As an example of an attempt to use a negative displace- negative. The Load at FIRST refers to DATA. The base is
ment, suppose we were to put the address constant BASE 11, with a large displacement of FFE16 = 409410 , The Add
at the very beginning of the program; between the START refers to a location that is more than 4096 bytes away from
and the BALR: then the displacement in the Load would the beginning of the program, so base register 11 cannot be
need to be -6, which is impossible. used. We see that 9 has been indicated, with a displacement
Following the constant BASE, we have two instructions of E16 = 1410 , The following Branch on Condition references
that are meant to suggest the processing steps of the a storage location 2 greater than what was placed in register
program, and then a branch to an instruction near the end. 9, so register 9 is the base and the displacement is 002.
F or the sake of illustration, we want the program to look as Down at SECOND, the base registers and displacements
though it is more than 4096 bytes long. This we can simulate for getting DATA and TEN are exactly as they were before;
by an ORG that, in this case, advances the location counter these matters are unaffected by the location of the
by 4068. This arbitrary-appearing number was chosen to instructions. The assembled Branch on Condition to FIRST
put DATA at the end of a 4096-byte segment controlled by is precisely the same as the assembled Branch on Condition
base register 11, which means that the following instruc- that appeared earlier just before BASE.
tions and data are referenced by base register 9. The essential concept is that the assembler assigns
Let us now investigate how the assembler assigned base whatever base register is necessary to get a displacement less
registers and computed displacements. than 4096. If the program has been written so that two or
The next instruction is a Branch on Condition with a more base registers have contents that satisfy this rule, the
mask of 15, which indicates a branch on any condition, or assembler chooses .the one that leads to the smallest
an unconditional branch. This branch to FIRST involves a displacement. Later we shall see an instance in which this
location under the control of base register 11; if base rule for choosing base registers is important.
register 9 were specified, the displacement would have to be
We have suggested that it will be rare for a program segment obvious: use two base registers, the second of which refers
to be so long as to require more than one base register. On only to the data processed by the loop.
the other hand, it may be fairly common to want separate A program is shown in Figure 4-4. The loading of base
base registers for instructions and data, even though the registers is much as it was in Figure 4-3, except that this
instructions take far fewer than 4096 bytes. How this can time register 8 is loaded with the address corresponding to
happen is illustrated in the following problem. DATA, rather than with 4096 more than what register 11
Suppose we have six records in storage, each record contained. As a matter of fact, it turns out that register 11
consisting of 80 characters. The six records are in consecutive contains 10216 , and register 8 contains 12C16 • This will
storage locations; the first of the 480 bytes has the symbolic mean that the first byte of the area named DATA could be
address DATA. Within each record there are eight fields of obtained by adding a displacement of 2A to register 11, or
ten characters each, named FIELDl, FIELD2, etc. Each by adding a displacement of zero to register 8. As we noted,
field is in packed decimal format. We are required to add the assembler picks the way that gives the smaller displace-
FIELDI and FIELD2 and place the result in FIELD3. The ment. It is essential for us to be able to depend on this fact.
other fIVe fields are not used in this program. This proces- We see also that in this program the address constant for
sing is to be done for each of the six records, using a loop. loading register 8 has been placed 'at the end of the
Now the question is, how do we attack the loop? The instructions rather than in the instruction stream. This is
arithmetic will use decimal instructions, which have the SS permissible as long as we are sure that it is not more than
format and do not provide for use of an index register. We 4096 bytes away from the beginning of the program, which
could write instructions to modify the displacement of it obviously is not.
every instruction that refers to the records, but this is very It is assumed, for the purposes of this illustration of base
poor form if there is a better way available. register ideas, that the data is provided by another program
The solution proposed here is to modify the base register segment and will be used later by still another prpgram. We
contents to pick up the records in succession, which means therefore provide space for the data with DS instructions
that between loop repetitions we will add 80 to the base that allot space for the required number of characters but
register. But now we have a new problem. If only one base do not assemble constants to be entered. The DS for
register is used, how do we modify its contents and still get DATA, in fact, does even less than that: it provides a
a correct base for Branch instructions and for references to reference point for the symbol, but does not even reserve
program constants? The simplest answer is probably space since a zero is written for the duplication factor. Thus
1 PRINT NOGEN
000100 2 LOOPA START 256
000100 05BO 3 BEGIN BALRI 11 ,0
000102 4 USING *,11
000102 5880 BOLE 00120 5 LOOPI L ~;'BASF'
00012C 6 USiNG DATA,8
000106 0209 8014 8000 00140 0012C 7 LOOP2 MVC FIELD3,FIELDl
00010C FA99 8014 800A 00140 00136 8 AP FIELD3,FIELD2
000112 5A80 B022 00124 9 A 8,EIGHTY
000116 5980 B026 00128 10 C 8,TEST
OOOllA 4770 B004 00106 11 BNE LOOP2
12 EOJ
000120 0000012C 15 BASE DC A(DATA')
000124 00000050 16 EIGHTY DC F'80'
000128 0000030C 17 TE ST DC A(oATA+480)
00012' 18 DATA' OS OF
00012CfW 19 FIELDI OS CLlO
000136- 20 FIELD2 OS CLlO
000140 21 FIELD3 OS CLlO
00014A 22 FI ELD4 OS eLlO
000154 23 FIELDS OS CLlO
0001SE 24 FIELD6 OS CLlO
000168 25 FIEL07 OS CLlO
000172 26 F I ELD8 OS CLlO
000 l7C 27 OS 5CL80
000100 28 END BEGIN
Figure 4-4. Program with separate base registers for processing and data, showing how a base register can be used to provide indexing for
loop control
56
DATA and FIELD! b~th refer to the same byte. The point register, we would be in trouble with the address of the
of this approach is to have DATA for a name for the entire Branch instruction. The assembler would assume a certain
480-character storage area, and still use names for the fields value for the base register and compute a displacement
within the first record. An alternative approach would be to accordingly. After modifying the base register contents, we
use DATA as the name of the first field, DATA + 10 for the would no longer have the desired branch address.
second, DATA + 20 for the third, etc., but the loss of It is of course true that we are modifying the contents of
meaningful names would be a disadvantage. Another alter- base register 8 also, but we have carefully arranged that it is
native would be to omit the entry for DATA and use not used as a base for anything besides DATA. No con-
FIELDI wherever DATA appears earlier. This would also fusion is caused, therefore, because we have "cheated" by
be a little less meaningful, perhaps. The fmal DS reserves changing the contents of a base register from what we
400 bytes of storage for the remaining five records. promised the assember would be there. What we told the
The Move Characters in~truction at LOOP2 moves the assembler will lead correctly to the first record processed;
first field to the third field location. Reading across the by the time the contents are actually changed during
assembled instruction, which we note is in the SS format, execution, the assembler will no longer be on the scene to
we see: the actual operation code is D2, the length code is know that anything happened.
09, the base register for the fITst operand is 8, the In practice it would normally be necessary to process
displacement for the first operand is 014, the base register many blocks of six records, not just one. In that case we
for the second operand is also 8, and the displacement for would have to get register 8 back to its starting value. This
the second operand is zero. The length code of 9 is correct is done simply by re-executing the Load instruction at
for a field of length 10; the assembler picked up the implied LOOPl.
length from the DS entry for FIELD3, and subtracted 1 If a program like this were to be executed, it is perhaps
from the length to get the length code. Checking the obvious that something would have to be done during
address calculations, we see that a base address of 12C plus loading to take care of the address constants at BASE and
a displacement of 014 give an effective address of 140, TEST. It would clearly not be enough for the linkage editor
which is correct for FIELD3. A base address of 12C and a just to assign the initial program loading location. This
displacement of zero give the address of FIELD 1. matter is properly handled by an automatic flagging of all
The Add Decimal instruction that follows does the address constants in the relocation dictionary produced by
required addition. This instruction has two length codes, the assembler, and by suitable modifications performed by
both 9 in this case, for two fields of length 10. The the linkage editor.
displacement of OOA, together with the base address of In order to illustrate one last facet, suppose that there
12C, correctly lead to 136, the address of FIELD2. The were some compelling reason to place additional instruc-
addressing of FIELD3 is as before. tions after DATA. This could be done by a Branch to them.
Now we are ready to add 80 to the base register Suppose that within these additional instructions there were
associated with DATA and go back to process more records Branches to locations within the new group. What would the
if more remain. We add 80 to base register 8 and then base register situation be? With the size of program and data
compare with an address constant to test for completion of shown, either base register 11 or 8 could supply a displace-
the loop. What should the test constant be? Since we ment of acceptable size; the assembler could pick the one
modify before testing, and since there are 480 characters in leading to the smaller displacement, register 8. But the
the six records, we should stop repeating if at this point the contents of 8 change as the loop is executed; how can we tell
base register contains a number 480 greater than what it the assembler that 11 is wanted, not 8?
was to start. It was originally the equivalent of the symbol The answer is the DROP instruction, in which we would
DATA, so the test value ought to be DATA + 480, as say DROP 8 at the beginning of the new group of
shown. The Branch on Not Equal here is the extended instructions. This says to the assembler that general purpose
mnemonic for BC 7. If the branch is not executed, we are register 8 may no longer be used as a base register. The only
fmished and the next instruction ends the job. one left is then 11, so it is the one used, as desired.
If the program were written to use only one base
Consider the following programs. Note that some of the 4. Assume that the program, when loaded for execution, is
program statements have been omitted from the listings. located starting at 320016 instead of 20016 . In the spaces
The locations assigned to each instruction, constant, and provided, list:
area are listed in hexadecimal, as in all program listings. The a. The locations into which each instruction, area, and
locations are such that you should have no difficulty with constant (that is, each statement) is loaded ..
hexadecimal arithmetic. Questions 1 to 4 refer to Figure 4-5. b. The value placed in register 11 at execution time.
1. In the program in Figure 4-5, c. The effective address computed at execution time for
a. What instruction informs the assembler that registe:::;r:.--:e=c,:h~e:::.:n~c;ir:.:c~le:.:d:..;0::Jp~e::::;r,:;:;an~.:.-.._~
11 is to be used as a base register, and tells the assembler 5. Consi er t e program in ~_ _,.,...-z:;:
what value it must assume to be in that base register? provided, list:
b. What instruction causes register 11 to be loaded with a. The symbol table prepared by the assembler (symbol
the base address at execution time? and location only).
2. In the spaces provided in the diagram, b. The contents of base registers 9, 10, and 11 assumed
a. Write the value the assembler assumes to be in base by the assembler.
register 11. c. The base register and displacement for each encircled
b. Using the symbol table and answer 2a, write the base operand.
register and displacement appearing in the object instruc- d. The values actually placed in registers 9, 10, and 11 at
tion for each encircled operand. execution time, assuming the program is loaded at 1000 16 .
3. Using the specified base register and displacement, write e. The location of each statement at execution time.
(in the spaces provided) the effective address developed f. The effective address computed at execution time for
during assembly for each encircled operand. each encircled operand.
S 2~ 000234
ST 2@SULD 000238
58
During execution with
During assembly program loaded at 100016
1'1 1'1
LOCATION STORAGE OPERAND LOCATION ADDRESS
OF OF OF
STATEMENT Base Displace- STATEMENT STORAGE VALUE LOADED INTO
Reg. ment Address OPERAND* BASE REGISTERS
PROGH START 0 During During
assembly execution
BEGIN BALR 11,0 000000 (assumed) (actual)
USING FIRST ,11
11
FIRST Be 15,SKIP 000002
DATA De F'3472' 000008 10
Be 1~ 001504 -- --- - - -
Be ~ 002508 -- --- - - -
eK8 Be 8(hOOPl[) 002904 -- --- ---
END BEGIN
The decimal instruction set is an optional feature of 1010, 11 00, 111 0, and 1111 are taken to mean plus, and
System/360, but one that most users elect. Besides making 1011 and 1101 are recognized as minus. When a sign is
it possible to do arithmetic in the more familiar decimal, generated as a part of an arithmetic result, a plus is 1100
system, the decimal instruction set includes instructions for and a minus is 1101. As mentioned before, all reference to
editing data, that is, preparing data for printing by the binary codes in this book is to System/360 EBCDIC unless
insertion of characters such as commas, periods, and dollar another is specified.
signs. The decimal instruction set permits operations on, In the zoned format the rightmost four bits of a byte are
variable length data since the operations are performed in called the numeric portion of the byte and contain a digit.
storage areas rather than in registers. It includes the The leftmost four bits are called the zone and contain
following instructions: either a zone code or, in the case of the rightmost byte, the
Add Decimal sign of the number. The codes for signs are treated as
Compare Decimal described for the packed format. The code for all zones is
Divide Decimal 1111.
Edit Decimal instructions have precise requirements that
Edit and Mark operands be in packed or zoned format. The Pack and
Multiply Decimal Unpack instructions, standard instructions of the system,
Subtract Decimal are available for converting from one form to another. The
Zero and Add Move with Offset instruction, another of the standard
The student will find a detailed description of the basic instructions, is often used for shifting factors used or
operation of these instructions in the System/360 Principles developed in decimal arithmetic operations. Instructions for
of Operation. This chapter will provide examples of their converting from binary to packed and from packed to
use in various problem situations and will attempt to show binary are also part of the standard instruction set. We shall
how the programmer can make them a working part of his see examples of all of these operations later.
strategy. Decimal instructions use the SS (Storage-to-Storage)
Data operated upon by instructions in the decimal set format. The machine format is:
must be in one of two forms, packed or zoned, depending
on the instruction. As a generalization, we can say that the lop Code I I I I I I I
Ll L2 81 D1 82 D2
packed format is required for arithmetic and the zoned for In assembler format, as written in the source program, the
input/output. The two formats are shown in Figure 5-1. sequence of an SS instruction is:
Op code D 1(L1 ,B 1),D2(L 2 ,B2)
Byte I I Byte Byte
I I I I There are two addresses, both of course referring to core
lr-
D-i9-i-t"'"TI-D-i9-it--'-, D-i-9-it-'r-~ ~~-l Digit I Digit I Digit I I I
Digit Sign storage. Each address is formed from a base register con-
tents and a displacement. The address always refers to the
leftmost byte of an operand.
For each operand there is a separate length in most
Byte I Byte Byte
cases. In the machine instruction, the length code may vary
I I I
z-o-n-e-r-\-Di-9-it--rl-z-on-e-'I-~
,-\ __ -' Digit \zone I I I I
Digit Sign Digit
between 0000 and 1111, or zero and 15. These correspond
to lengths of one to 16. In other words, the actual length is
one greater than what appears in the length code of the
Figure 5-1. Formats of packed and zoned decimal numbers object program. In assembler language programming,
lengths will quite often be implicit in the data definitions,
In the packed format, two decimal digits are placed in but when we do write an explicit length, it is the, actual
each byte except the rightmost of the field, which contains length. The generation of the proper code in the machine
a digit and the sign of the entire number. Digits and sign instruction (one less than whatever we write) is the
occupy four bits each. The decimal digits 0-9 have the function of the assembler.
binary codes 0000-1001. The codes 1010-1111 are not With these preliminaries in mind, let us turn to an
valid as digits. In the sign position, the code combinations example.
60
ADDITION AND SUBTRACTION IN DECIMAL
1 PRINT NOGEN
000000 2 STOCKI START a
000000 05BO 3 BEGIN BALR 1l,0
000002 4 US ING *,11
000002 0203 B020 B014 00022 00016 5 MVC NEWOH,OLOOH
000008 FA33 B020 B018 00022 OOOlA 6 AP NEWOH,RECPT
OOOOOE FB33 B020 BOIC 00022 OOOlE 7 SP NEWOH, ISSUE
8 EOJ
000016 0000009C II OLDOH DC PL4 1 9'
OOOOlA 0000004C 12 RECPT DC PL4 1 4 1
OOOOlE 0000006C 13 ISSUE DC PL4'6'
000022 14 NEWOH OS Pl4
000000 15 END BEGIN
Figure 5-3. Assembly listing of the decimal arithmetic program in Figure 5-2
Decimal Arithmetic 61
The purpose of the Move Characters instruction is to get they are the same, as it happens. The Subtract Decimal (SP)
the old on-hand quantity into a location where we can instruction deducts the quantity issued.
perform arithmetic without disturbing the original There is no need for something equivalent to a Store
quantity. The decimal instructions make no use of the instruction; every instruction already involves two storage
general registers (except, of course, to specify the base), so addresses, one of which receives the result.
we must provide storage locations for all data. We do not The output in Figure 5-4 shows that the result has been
wish to destroy the old on-hand, so we must arrange for the correctly computed.
arithmetic results to go somewhere else. In this case, the
obvious place is NEWOH, where we want the eventual
result anyway. In other problems, as we shall see, it is often
necessary to provide temporary working storage.
The Add Decimal (AP, for Add Packed) instruction adds 0000009C 0000004C 0000006C 0000007C
the quantity received to the old on-hand, which by now is
in NEWOH. Note that the result of an arithmetic operation
is always stored in the first operand location. The two fields
in an Add Decimal instruction need not be the same length, Figure 5-4. Output of the program of Figure 5-3, showing OLDOH,
RECPT, ISSUE, AND NEWOH, in that order
since there are two length codes in the instruction. Here,
62
DECIMAL MULTIPLICATION
F or a simple example of decimal multiplication, let us Mite right. The second operand in an Add Decimal instruction is
a program for the computation of a new principal amount. permitted to be shorter than the ftrst (which holds the
We are given a principal (PRINC), here taken to be four result). When this is done, any carries that occur are
bytes, and an interest factor (INT), two bytes; we are to properly propagated.
compute the new principal amount after adding in the We are now ready to discard the, two digits at the right
year's interest. The interest rate of 3% is expressed as the end of the product. But this is not quite as simple as just
factor 1.03, so that a single multiplication does the whole not moving them to PRINC, because if we did that, PRINC
job. A program is shown in Figure 5-5. would not be a legal operand in any subsequent arithmetic
The Multiply Decimal (MP) instruction takes the second operation, since it would not have a sign. Before moving the
operand to be the multiplier; the ftrst operand initially result back to PRINC, therefore, we must move the sign
contains the multiplicand, and at the end of the operation from where it is to the byte just to the left. This we can do
contains the product. However, we cannot begin with a with a Move Numeric (MVN) instruction, which transmits
multiply instruction specifying PRINC as the multiplicand, only the numeric portions of the bytes. The instruction
as we might be inclined, because extra space is required. says: Take the numeric portion of the byte at PROD+5
The first operand is required to have at least as many (which is the rightmost byte of the PROD, and contains the
high-order zeros as the size of the multiplier fteld. We need, sign) and move it to the byte at PROD+4 (which is the byte
therefore, to move the principal to a working storage area to the left and will be the rightmost byte of PRINC after
having extra positions at the left. These extra positions the next instruction); the fteld to be moved is one byte
must be cleared to zero before the multiplication starts. long. The length for this instruction cannot be left to the
The Zero and Add (ZAP) does just what we need. The assembler; the implied length here would be 6 (the length
effect of the instruction is to clear the first operand of PROD), which would destroy the result. The Move
(pROD, in this case) to zero, then add the second operand Numeric instruction has only one length code, so we need
(PRINC) to it. PROD is two bytes longer than PRINC; give only one explicit length.
these extra four digit positions will be clear~d to zeros Finally, we are ready to move the result to the fteld
before PRINC is added in. This provides the zeros needed where it is required to be at the end of the program,
to satisfy the multiplication rule. PRINC .. Remember that PROD is six bytes long. The
Now we multiply. With the sample data shown, the leftmost byte contains two zeros, we assume, and the
result in PROD will be 00000256367C, as shown in the maximum size of the result is taken to be seven digits. The
comments fteld. We were regarding. 2489 as meaning validity of such an assumption as always, is the responsi-
$24.89, and 103 as meaning 1.03, so there are four places bility of the programmer. The rightmost byte of PROD
to the right of the understood decinial point in the product, contains a digit and sign that we now wish to drop. To
which we therefore regard as 0000025.6367 +. We would drop the leftmost byte, we Mite the address as PROD+l.
now like to round this' off to $25.64. This can be done in a To drop the rightmost, we need a length of 4, which
number of ways. Here we simply add a constant (ROUND) happens to be the implied length of PRINC, so no explicit
properly set up to add a 5 into the second place from the length is necessary.
1 PRINT NOGEN
000000 2 INTC ST ART 0
000000 05BO 3 BEGIN BALR 11,0
000002 4 USING *,11
5 * NUMBERS BELOW SHOW CONTENTS
6 * OF PROD AFTER INSTR IS EXECUTED
7 * C IS PLUS SIGN IN PACKED FORMAT
Figure 5-5. Listing of a program that performs decimal multiplication. Step-by-step results to be expected during execution are shown in the
comments field.
Decimal Arithmetic 63
DECIMAL DIVISION
Some of the operations in working with the decimal a rule stated in terms of digits.
instruction set are different enough from similar operations A very similar rule gives the relationship among decimal
in other machines that it may be well to pause and consider points. If we agree that by "decimal places" we mean the
them in somewhat more detail than we have devoted to number of digits to the right of an assumed decimal point,
other topics. Division is one such operation; Move instruc- the rule is:
tions, used as the equivalent of shifting and considered later
Number of places in dividend = number of places
in the section on shifting of decimal fields, is another.
in divisor + number of places in quotient
The Divide Decimal (DP) instruction is in the SS format.
The first operand is the dividend (the number divided into), In the example given above, we assume that all quantities
the second the divisor (the number divided by). After the are integers, that is, they have no decimal places. The rule
operation is completed, the first operand field holds the still holds, although in its most elementary form:
quotient (at the left) and the remainder (at the right). The
remainder is the same length as the divisor. Let us see how 0=0+0
this description works out in an example. Let us see what the result would be if we were to arrange
Suppose we begin with the symbolic locations DIVID the dividend of the example so that it has one decimal place:
and DIVIS as follows:
DIVIDbefore 0 0 0 0 4 2 4 6 0 +
DIVIDbefore 0 0 0 0 0 4 2 4 6 +
In other words, we now view the dividend as 4246.0. The
DIVIS 0 3 1 +
result is:
We have indicated DIVID as a "before" value, because after
DIVID after 0 1 3 6 9 + 0 2 1 +
the division the same field will contain both the quotient
and the remainder. All operands are in packed format, as The rule says that the quotient should have one decimal
with other decimal arithmetic operations. After executing place: the dividend has one and the divisor has zero. The
the instruction: quotient must therefore be interpreted as meaning 136.9.
(And if anything has to be done with the remainder, it
DP DIVID,DIVIS
should be taken as meaning 2.1.)
the contents of DIVIS would be unchanged; the contents of Suppose the dividend were shifted one more place to the
DIVID would be: left:
DIVID after 00 1 3 6 + 0 3 0 + DIVIDbefore 0 0 0 4 2 4 6 0 0 +
DIVID after 1 3 6 9 6 + 0 2 4 +
This means that 4246 divided by 31 in this way gives a
quotient of 136 and a remainder of 30. The divisor was two This result should be read as 136.96.
bytes, so the remainder is two bytes. The quotient takes up What would happen if we tried to set up the dividend
the remaining space in the first operand field. with yet one more shift to the left? There is room in the
The question of the lengths of the various fields can be dividend - but there is no more space in the quotient field.
answered with a useful rule: This constitutes a divide exception, which occurs whenever
the quotient is too large to fit in the field available to it. An
Number of bytes in dividend = number of bytes
interrupt occurs.
in divisor + number of bytes in quotient
It is possible to check for the possibility of a divide
It is perhaps most common to know the number of exception, given sample numbers. To do this, the leftmost
bytes in the divisor and the number desired in the quotient, digit position of the divisor is aligned with the second digit
the question being how much space to allow in the dividend position from the left of the dividend. When the divisor, so
in order to get the specified size of the quotient. If two of aligned, is less than or equal to the dividend, a divide
the three lengths are known, the formula can be used to get exception will occur. Take the situation suggested:
the length of the third.
Note that the formula is stated in terms of the number DIVIDbefore 0 0 4 2 4 6 0 0 0 +
DIVIS 0 3 1 +
of bytes, not the number of digits. The reason is that the
first operand field contains only one sign at the beginning, This is the alignment described by the rule. As aligned, the
when it is the dividend, but two afterward, when it contains divisor is smaller. We saw before that there would not be
both quotient and remainder. This change would invalidate enough room for the quotient.
64
This question does depend on the particular numbers To be completely confident that a divide exception
involved, of course. Suppose the quantities were aligned the cannot occur, we have to know the maximum possible size of
same way but that the dividend were 2246 instead of 4246: the dividend and the minimum possible size of the divisor,
or we must know the maximum size of the quotient.
DIVIDbefore 0 0 2 2 4 6 0 0 0 + Further examples of decimal division will be given after
DIVIS 0 3 1 + we have studied shifting, which is often needed to arrange the
dividend so as to give the necessary number of decimal
This is entirely acceptable. places.
Decimal Arithmetic 65
SHIFTING OF DECIMAL FIELDS
Shifting as such is not provided in System/360 decimal If the contents of SOURCE are no longer needed in their
operations. As in other variable-field-length computers, the original form, the following sequence is a bit shorter.
equivalent of shifting is performed by appropriate combin- SOURCE DEST
ations of data movement instructions. MVN
The matter is made somewhat more complex by the SOURCE+3(1),SOURCE+4 12 34 56 7S 9S 55 55 55 55 55
factor of packed formats, with two digits per byte and with ZAP
the special status of the sign position. This is a small price DEST,SOURCE(4) 12 34 56 7S 9S 00 12 34 56 7S
to pay for the increased storage economy of the two-digits- The Move Numeric moves the sign to the byte which will
per-byte arrangement. contain the sign in the eventual result. The Zero and Add
It is also necessary to exercise caution when overlapping picks up four bytes of SOURCE and adds them to DEST
fields are to be manipulated, in order to be sure that no after clearing DEST to zeros. The Zero and Add has two
data is destroyed. This is another occasion where it is length codes. For DEST we use the implied length of 5; for
absolutely essential to remember that all operands are SOURCE it is necessary to give an explicit length in order
addressed by the leftmost byte. to drop the last two digits.
Finally, suppose that for some reason it is necessary to
Shifting to the Right leave the shifted result in SOURCE, without resorting to
Let us begin with the simplest type of shift: a decimal right the expedient of simply moving the sign and appending
shift of an even number of places. Suppose that we have a zeros at the left.
five-byte, nine-digit number in SOURCE; we are to move it SOURCE
to a five-byte field named DEST with the last two digits MVN SOURCE+3(l),SOURCE+4 12 34 56 7S 9S
dropped and two zeros at the left. We can do this two ZAP SOURCE,SOURCE(4) 00 12 34 56 7S
ways: with or without disturbing the original contents of
The sign movement is as before. In the Zero and Add,
SOURCE. Let us do it first without disturbing them. the second operand is given as SOURCE(4), which means a
Suppose that the two fields originally contain: four-byte field the leftmost byte of which has the address
SOURCE DEST SOURCE; this is just 12 34 56 7S. The frrst operand is
12 34 56 78 9S 55 55 55 55 55 simply SOURCE, with its implied length of 5, which means
the whole field.
The S stands for a plus or minus sign, whichever it might
It is important to know that this type of overlap is
be. The instructions for accomplishing the shift could be as
permitted when the frrst operand field is at least as long as the
follows, where we have also shown the contents of the two
second operand, but not when it is too short to contain all
fields after the execution of each instruction:
significant digits of the second operand. A little study shows
SOURCE DEST that a violation of this rule would result in destroying bytes of
MVC
DEST+1(4),SOURCE 12 34 56 78 9S 55 12 34 56 78
the second operand before they have been moved.
MVN Let us now turn to a slightly more complex shift, one
DEST+4(1),SOURCE+4 12 34 56 78 9S 55 12 34 56 7S that involves an odd number of places. This requires the use
MVC of a special instruction designed for the purpose, the Move
DEST(l),ZERO 12 34 56 78 9S 00 12 34 56 7S with Offset. The action of this instruction can be described
In the first Move Characters instruction, an explicit as follows. The sign of the frrst operand is not disturbed;
length of 4 is stated; this length applies to both fields. With the second operand is placed to the left and adjacent to the
the first operand address being DEST+ 1, the four bytes of four low-order bits (the sign bits) of the frrst operand. Any
the destination are the rightmost four. The second operand unused high-order digit positions in the frrst operand are
is given simply as SOURCE, so the four bytes there are the filled with zeros.
leftmost. The last two digits (one byte) have been dropped. Looking at an example, take the fields described in the
But the sign has been dropped too, in the process. We previous illustration, but suppose that the shift must be
accordingly use a Move Numeric instruction to attach it to three positions instead of two.
the shifted number. This must be done with an explicit SOURCE DEST
length of one, to avoid disturbing any of the digits of MVO
DEST. Both addresses must be written with the "+4" to DEST,SOURCE(3) 12 34 56 78 9S 00 01 23 45 65
MVN
pick out the proper single character. Finally, we move one
DEST+4(1),SOURCE+4 12 34 56 78 9S 00 01 23 45 6S
byte of a constant named ZERO (not shown), which
contains zeros, to the first byte of DEST. This clears to In the Move with Offset, the second operand is given as
zero whatever may have been there before. SOURCE(3), which picks up a three-byte field starting at
66 (8170)
the left, namely, the bytes containing 12 34 56. The first Another way to clear the extraneous sign is available,
operand is DEST, wiL1. its L'l1plied length of 5. The digits using the And Immediate instruction. "Anding" two quan~
12 34 56 are moved to DEST with an offset of four bits, tities gives a result that has a one bit wherever both
or one digit, leaving 00 01 23 45 65 in DEST; the right- operands had l's, and a zero elsewhere. For instance, if we
most 5 is the one that was there to begin with. A fmal Move "And" 1100 and 1010, the result is 1000; only in the fust
Numeric attaches the source sigri to the destination field._ bit position did both operands have ones. In the And
If the shift is required to leave the result in SOURCE, Immediate instruction (NI) , both operands are exactly eight
only one instruction is needed, since the Move with Offset bits long. One of them is given by the byte specified by the
instruction has no effect on the sign of the fITst operand, address; the other is contained in the instruction itself
and the left end of the receiving field is filled with zeros. (which is the reason for the term "immediate"). The result
replaces the byte specified in storage.
SOURCE
MVO SOURCE,SOURCE(3) 00 01 23 45 6S In the example at hand, we wish to leave the fITst four
bits of the byte at DEST+2 just as they were; this can be
The overlapping fields here cause no trouble, since again the done by placing ones in the corresponding positions in the
'movement is to the right of the original contents. (Actually, part of the instruction that will be "And-ed". (This is
overlap of any type is permitted; it is the programmer's usually called the mask.) We wish to make the right four
responsibility to make sure that the result is meaningful.) bits of DEST+2 zero, whatever they were before; this can
be done by placing zeros in that part of the mask. The
Shifting to the Left mask, in short, should be 1111 0000, ~xpressed in binary.
A shift to the left presents slightly different problems. This To write the instruction, we can either convert this to its
time suppose that we have a source field of three bytes and decimal equivalent 240, or, better, write it in hexadecimal,
a destination of five. X'FO'. In other words, we can replace the last instruction
Before SOURCE DEST with either of the following:
12 34 5S 99 99 99 99 99 NI DEST+2,240
NI DEST+2,X'FO'
Let us take our problem, to move the number at SOURCE
to DEST, with four zeros to the right at DEST, and with Finally, consider a shift to the left of an odd number of
DEST left ready to do arithmetic. An acceptable sequence places. For an example, take the data of the preceding
of instructions is shown below. illustration, but suppose there are to be three zeros at the
SOURCE DEST right instead of four.
MVC DEST(3),SOURCE 12 34 5S 12 34 5S 99 99 SOURCE DEST
MVC DEST+3(2),ZEROS 12 34 5S 12 34 5S 00 00 Before 12 34 5S 99 99 99 99 99
MVN DEST+4(1),DEST+2 12 34 5S 12 34 5S 00 OS MVC DEST(3),SOURCE 12 34 5S 12 34 5S 99 99
MVN DEST+2(1),ZEROS 12 34 5S 12 34 50 00 OS MVC DEST+3(2),ZEROS 12 34 5S 12 34 5S 00 00
MVN DEST+4(1),DEST+ 2 12 34 5S 12 34 5S 00 OS
The first Move Characters needs an explicit length on NI DEST+2,X'FO' 12 34 5S 12 34 50 00 OS
DEST; otherwise, the length would, improperly for our MVO DEST(4),DEST(3) 12 34 5S 01 23 45 00 OS
problem, be interpreted from DEST as 5. The last two
bytes of DEST are unaffected by the fITst Move; a second The first four instructions are just the same as in the
clears them. A Move Numeric transfers the sign, and a previous example, except that the And Immediate is substi-
second Move Numeric clears the now extraneous sign that tuted for the Move Numeric. The final instruction now is a
went with the source data on the fITst Move Characters. Move with Offset that shifts one digit position to the right.
We are now prepared to approach a realistic problem in three decimal places in the quotient because there are three
decimal division. in the dividend and none in the divisor.) The dividend
Suppose that in a four-byte field named SUM we have evidently should be five bytes. As it happens - which will
the total of the number of hours worked by all the by no means always be the case - that is just how long it
employees in a factory, given to tenths of an hour. In will be as the result of the shifting we decided upon.
NUMBER we have the number of employees included in With this much background, let us now look at the
the sum; this is a two-byte number. We are to calculate the program shown in Figure 5-6. We assume that it is permis-
average workweek, to tenths of an hour, rounded, and place sible to destroy the original contents of SUM; if this were
it in a two-byte location named AVERAG. not so, it would be a matter of one extra instruction to
We begin the analysis of the problem knowing that the move the contents of SUM to a working storage location.
dividend (SUM) has one decimal place to start, and the Notice in the list of constants at the end of the program
divisor (NUMBER) has none. If we set up the division this that a one-byte constant named PAD has been established
way, we would get a quotient having one place; this would just after, and therefore to the right of, SUM. Now, instead
not permit rounding. Evidently we shall have to allow extra of actually moving the contents of SUM in order to
places to the right. One more would be sufficient, but this accomplish a shift, we simply extend the field by one byte.
would involve a shift of an odd number of places; it would This is the function of the first two instructions. We have
be simpler for us and faster in the machine to make a shift assumed, reasonably enough, that the sum is always posi-
of two places and simply ignore the extra digit. The tive, so a plus sign is moved with the first Move Characters,
dividend therefore should be set up like this: and the original sign is simply erased with the And
XX XX XX XO 0+ Immediate.
The Divide Decimal might seem to carry the possibility
The X's stand for any digits. of a divide exception. We must fall back on a knowledge of
Now we turn to the rule stating that the number of the data, which is the eventual foundation of any intelligent
bytes in the dividend is equal to the number of bytes in the programming. We simply observe that the average hours
divisor plus the number of bytes in the quotient. We know worked would not be as great as 100 hours - and anything
that we. have two bytes in the divisor as it stands. The less can be contained in the space provided.
quotient need be only three: there can be no more than Rounding is accomplished by adding 5 in the proper
two digits before the decimal point, there will be three after position. We move the sign to where it is needed, and fmally
the decimal point, and there will be a sign. (There will be transfer the result to the specified location in storage.
1 PRINT NOGEN
000000 2 AVG START 0
000000 OSBO 3 BEGIN BALR lltO
000002 4 US ING *,11
S * NUMBERS BELOW SHOW CONTENTS
6 * OF SUM AFTER INSTR IS EXECUTED
1 *
000002 0200 B028 B02F 0002A 00031 8 Mve SUM+411J.ZERO 01 93 64 8e oe
000008 94FO B021 00029 9 NI SUM+3,X'FO' 01 93 64 80 OC
OOOOOC FD41 B024 B029 00026 0002B 10 DP SUM(S) ,NUMBER 39 16 3C 21 ge
000012 FA21 B024 B020 00026 0002F 11 AP SUM(3),ROUND 39 81 3e 21 9C
000018 0100 B025 B026 00021 00028 12 MVN SUM+UIJ.SUM+2 39 8e 3e 21 ge
OOOOlE 0201 B02B B024 00020 00026 13 MVC AVERAG, SUM AVERAG WILL BE 39 8C
14 EOJ
000026 0193648C 11 SUM DC PL4'0193648'
00002A 18 PAD OS PLl
00002B 481C 19 NUMBER DC PL2'481'
000020 20 AVERAG OS PL2
00002F 050e 21 ROUND DC PL2'SO'
000031 oe 22 ZERO DC PL1' 0'
000000 23 END BEGIN
Figure 5-6. Assembled program showing decimal division and "shifting". Step-by-step results to be expected during execution are included
in the comments field.
68
FORMAT AND BASE CONVERSIONS
It is often necessary to convert from zoned to packed With the card column assignments we have described,_ this is
format and vice versa, and also to convert from binary to the EBCDIC representation of -379.
decimal and vice versa. In this section, we shall examine a The program begins with a new instruction: Insert
program that has been constructed as an exercise in mani- Character (IC). This is an RX format instruction that gets
pulating the form of data. For practice purposes, some new one character (byte) from the specified storage location and
instructions are introduced for these maneuvers, which places it in the rightmost byte position of the register
might be accomplished more simply in a realistic situation. named. The other hit positions of the register are not
We are given a fullword named REG, in binary format. disturbed. We do not know what might be in them, but it
Actual data for the three-byte field named PREM is read in will not matter, as it happens, since the following instruc-
directly from an input card on which the sign is in the tion clears them. This is an And to erase the numeric bits of
high-order pOSition, instead of the low-order. That is, a the high-order character of our sample data.
positive number was punched with a 12 zone over the Next we perform the similar operations on the low-order
leftmost digit, and a minus number was punched with an 11 byte, using register 6, except that this time we erase the
zone over the leftmost digit. We are required to place the zone bits.
sum of REG and PREM in ANS, as a decimal number in the Now we have in register 6 the numeric bits of the
normal zoned format, that is, with the sign in the zone of low-order byte, and in register 5 the zone bits that are to be
the low-order byte. The zone bits that result in a byte in attached to that byte. They can be combined with an Or
storage from a 12 zone on the card, are the zone bits Register (OR) instruction. "Or-ing" two operands is a
required for a plus sign in the EBCDIC zoned format in bit-by-bit operation that results in a 1 wherever either
storage. An 11 zone likewise is translated into the correct operand had aI, and zero where both had zero. The result
zone bits for a minus sign. Our problem, then, is simply to of this instruction is to combine the two groups of bits,
move the zone bits of the high-order byte to the zone bits leaving the result in register 5. This now is the byte that we
of the low-order byte. want in the low-order position, so we use a Store Character
In the program of Figure 5-7 we have shown at the right instruction (STC) to place it there.
of the fITst half-dozen instructions the contents of the last Insert Character and Store Character do not require the
eight bit positions of registers 5 and 6, to aid in under- character to be on any sort of integral boundary. They are
standing how the instructions operate on sample data the only index able instructions for which this is true. The
consisting of the three bytes: various decimal instructions do not require boundary align-
ment either, of course, but they are not indexable. The two
1101 0011 1111 0111 11111001
1 PRINT NOGEN
000000 2 CONVERT START 0
000000 05BO 3 BEGIN BALR 11 ,0
000002 4 USING *,11
5 * LAST BYTE (BITS 24 TO 311 OF REGS 5
6 * AND 6 AFTER EXECUTION OF EACH INSTR
7 * IS SHOWN BELOW
8 *
9 * REG 5 REG 6
000002 4350 B03A 0003C 10 IC 5,PREM 1101 0011
000006 5450 B032 00034 11 N 5,MASKl 1101 0000
OOOOOA 4360 B03C 0003E 12 IC 6,PREM+2 1101 0000 1111 1001
OOOOOE 5460 B036 00038 13 N 6,MASK2 1101 0000 0000 1001
000012 1656 14 OR 5,6 1101 1001 0000 1001
000014 4250 B03C 0003E 15 STC 5,PREM+2 1101 1001 0000 1001
000018 F212 B03D B03A 0003F 0003C 16 PACK WORK,PREM
00001E 5860 B042 00044 17 L 6,REG
000022 4E60 B046 00048 18 CVD 6,DOUBLE
000026 FA71 B046 B03D 00048 0003F 19 AP DOUBLE,WORK
00002C F357 B04E B046 00050 00048 20 UNPK ANS,OOUBLE
21 EOJ
000034 24 DS OF
000034 OOOOOOFO 25 MASK1 DC X'OOOOOOFO'
000038 OOOOOOOF 26 MASK2 DC X'OOOOOOOF'
00003C 27 PREM OS ZL3
00003F 28 WORK DS PL2
000044 29 REG OS F
000048 30 DOUBLE OS 0
000050 31 ANS OS Zl6
000000 32 END BEGIN
Figure 5-7. Assembled program showing various instructions for changing the format of data. Contents of registers 5 and 6 to be expected
during execution are given in the comments field.
Decimal Arithmetic 69
And (N) instructions, however, do require their operands to With the PREM amount fmally in packed format, we are
be on fullword boundaries. This is the purpose of the DS almost ready to do the addition - but not quite, because
OF before the DC's for the masks. the REG amount is still in binary. The next instruction,
At this point we have merely got the sign where it is accordingly, is a Load followed by a Convert to Decimal
expected to be in the zoned format of a decimal number. (CVD). Convert to Decimal takes the binary number in the
Now we must convert from zoned to packed format, which specified register and converts it to packed format decimal
is the function of the PACK instruction. The second in the location given, which must be aligned on a double-
operand names a field in zoned format; the fITst names the word boundary.
field where the packed format should be stored. Both fields At last it is possible to do the addition, which is done in
carry length codes. Here, we are able to leave the lengths decimal. A final instruction, Unpack (UNPK) , converts
implied: three bytes for PREM and two for WORK (two back from packed to zoned, as required in the problem
bytes allow space enough for three digits and sign in packed statement. This will leave the final answer with the sign in
format). The PACK instruction ignores all zones except the the zone bits of the low-order byte, which was stated to be
rightmost, which is taken to carry the sign. Therefore we the desired position for whatever processing might follow.
can leave the zone of the high-order byte as it was without If it were necessary to get the result into the same format as
disturbing the operation. PREM originally was, we could of course do so.
70
DECIMAL COMPARISON: OVERTIME PAY
Logical tests and decisions are as necessary in decimal The Compare Decimal (CP) instruction is not greatly
operations as elsewhere. System/360 provides a Compare different in concept from Compare instructions we have
Decimal instruction, and the condition code is set as a seen previously. The two operands are compared algebrai-
result of this and three decimal arithmetic instructions. cally; the condition code is set depending on the relative
For an example we take the familiar calculation of gross sizes of the two; neither operand is changed. The mask of
pay, with time-and-a-half for hours over 40. We have a 12 on the Branch on Condition will cause a branch if the
RATE, given in dollars and cents, and an HOURS, to tenths contents of HOURS are less than or equal to FORTY, in
of an hour. We are to place the total wages in GROSS. which case there is no overtime to compute, and we simply
There are several ways to approach the overtime compu- branch out to whatever follows.
tation. We choose here to begin by figuring the pay at the If the man did work more than 40 hours, we compute
straight-time rate, on the full amount in HOURS. We then his pay on the amount over 40, then multiply by 5, which
inspect the hours worked, and if it was not over 40 the job we view as having a decimal point, that is, as being one-half.
is finished. If there was overtime, we multiply the hours This is done because we have already computed the straight-
over 40 by the pay rate, and multiply this product by time pay on the amount over 40; now we need only to
one-half to get the premium, which is then added to the compute the extra premium. After the mUltiplication by 5
previous figure. Several other ways to arrange the sequence we round off, using a different rounding constant this time
of decisions and multiplications are obviously possible. This because the multiplication by 0.5 has added another deci-
one probably minimizes the computation time if most mal place. (It is necessary to check that WORK is long
employees do not work overtime; if most did work over- enough to satisfy the rule about at least as many zeros as
time, a different sequence might be a little better. the size of the multiplier. Assuming that no employee could
The program in Figure 5-8 begins with a three-instruction make $1000 in one week, the rule is satisfied.)
sequence to set up the multiplicand in a work area, After a Move Numerics to move the sign, we can add the
multiply, and round. The Move with Offset instruction rounded amount to GROSS to get the total pay. In the Add
drops one digit in the move; this is the extra digit that was Decimal, note the length of 3 to drop the last byte, which
rounded off. The Move with Offset instruction does not after rounding is extraneous. We now reach the termination
transmit the sign; we have shown GROSS as a DC to get a of the program, the same point to which we transferred if
plus sign there from the outset. Since the pay can never there was no overtime. In other words, both paths would
properly be negative, the plus sign will simply remain there lead, in a real program, to the same continuation point.
throughout the operation of the program.
1 PRINT NoGEN
000000 2 aT PAY START 0
000000 OSBO 3 BEGlN BALR 11.0
000002 4 USING *.11
S * NUM6ERS BELOW SHOW CONTENTS OF
6 * FIRST OPERAND (WORK OR GROSS)
7 * AFTER INSTRUCTION IS EXECUTED
8 *
000002 F83l BOS6 BOSO 000S8 000S2 9 ZAP WORK. HOURS 00 00 44 ~C
000008 FC3l BOS6 B04E 000S8 OOOSO 10 MP WORK, RAT E 00 78 OS OC
OOOOOE FA30 B056 BOSA 000S8 OOOSC 11 AP WORK,FIVE 00 78 05 SC
000014 F132 B052 BOS6 000S4 000S8 12 MVO GROSS,WORKI3) 00 07 80 SC
OOOOlA F9l1 BOSO BOSO 000S2 OOOSF 13 CP HOURS. FORTY
000020 47CO B04C 0004E 14 BC 12,OUT
000024 F831 BOS6 BOSO 000S8 000S2 15 ZAP WORK, HOURS 00 00 44 6C
00002A FB3l B056 BOSD 000S8 OOOSF 16 SP WORK, FORTY 00 00 04 6C
000030 FC31 B056 B04E 000S8 OOOSO 11 MP WORK,RATE 00 08 OS OC
000036 FC30 BOS6 BOSA 00058 OOOSC 18 MP WORK. FIVE 00 40 25 OC
00003C FA31 BOS6 60S6 000S8 OOOSD 19 AP WORK,FIFTY 00 40 30 OC
000042 0100 B058 B059 OOOSA 00056 20 MVN WORK+2( II.WORK+3 00 40 3C OC
000048 FA32 B052 60S6 00054 00058 21 AP GROSS .WoRK 131 00 08 20 8C
22 OUT EOJ
000050 17SC 2S RATE DC PL2' 1. 7S'
0000S2 446C 26 HOURS DC PL2'44.6'
0000S4 OOOOOOOC 27 GROSS DC PL4'0'
000058 28 WORK OS Pl4
OOOOSC SC 29 FIVE DC Pll' 5'
OOOOSO OSOC 30 FIFTY DC PL2'50"
00005F 400C 31 FORTY DC Pl2"40.0'
000000 32 END BEGIN
Figure 5-8. Assembled program that computes a man's gross pay, including any overtime pay, in decimal arithmetic. Results expected during
execu tion are shown in the comments field.
Decimal Arithmetic 71
THE SOCIAL SECURITY PROBLEM IN DECIMAL
For a little further practice in applying decimal operations, In the Multiply Decimal instruction that computes the
we may rewrite the Social Security calculation of Figure Social Security tax on the new year-to-date figure, we use a
3-19 in the chapter on flXed-point operations. The logic of constant for the 4.4% that has been set up with an extra
the decimal program shown in Figure 5-9 is the same as that zero at the right. This was done to put the product in a
of the earlier one. No new instructions are introduced, so a position where a Move with Offset would not be necessary.
few notes should be all that is required to explain the As it has been done, after rounding and moving the sign, we
program. can carry out all following operations on the Social
We begin by moving the old year-to-date to the new Security amount on the second, third and fourth bytes of
year-to-date location. The purpose is simply to get one of WORK. Since the implied length from the DS is 6, an
the two operands in the following addition where we want explicit length must be given. The explicit length specifica-
the result to be. Following is a Zero and Add to get the new tions in the two Move Characters (statements 17 and 19)
year-to-date into 'Yorking location where we can continue the are unnecessary, however, because NEWFICA and TAX are
processing witholJt disturbing the NEWYTD location. From defined as 3 bytes, and the assembler already has that
here on, the right side of Figure 5-9 shows the contents of irtformation.
the WORK field for sample data as shown in the DC Except for the points discussed here, the operations
instructions. closely parallel the program in the earlier version.
1 PRINT NOGEN
000000 2 FICA3 START a
000000 05BO 3 BEGIN BAlR 11,0
000002 4 USING *.11
000002 0203 B04F B04B 00051 00041) 5 MVC NEWYTD,OlOYTD
000008 FA32 B04F B048 00051 0004A 6 AP NEWYTD,EARN
1 '" CONTENTS OF WORK AFTER EXECUTION
8 OF EACH INSTR ARE SHOWN BELOW
9 '"
OOOOOE F853 B064 B04F 00066 00051 10 '" ZAP WORK.NEWYTD 00 00 07 86 40 OC
000014 FC51 B064 B05F 00066 00061 11 HP WORK,C44 00 34 60 16 00 OC
00001A FA52 B064 B061 00066 00063 12 AP WORK,HAlF 00 34 60 21 00 OC
000020 0100 B061 B069 00069 0006B 13 HVN WORK+3 ( 1) ,WORK+5 00 34 60 2C 00 OC
000026 F932 B064 B05e 00066 0005E 14 CP WORK(4) ,MAX 00 34 60 2C 00 OC
00002C 4140 B034 00036 15 BC 4,UNoER 00 34 60 2C 00 OC
000030 0202 B065 B05C 00061 0005E 16 HVC WORK+1 (3), MAX 00 34 32 OC 00 OC
000036 0202 B056 B065 00058 00067 11 UNDER HVC NEWFICA(3),WORK+1 00 34 32 OC 00 OC
00003C FB22 B065 B053 00061 00055 18 SP WORK+l(31,OLOFICA 00 00 52 OC 00 DC
000042 0202 B059 B065 0005B 00061 19 MVC TAX (3) ,WORK+1 00 00 52 OC 00 OC
20 EOJ
00004A 16400C 23 EARN DC Pl3'16400'
000040 0710000C 24 OLOYTO DC PL4'710000'
000051 25 NEWYTO OS Pl4
000055 33aooc 26 OLDFICA DC Pl3' 33800'
000058 21 NEWFICA OS Pl3
00005B 28 TAX OS PL3
00005E 34320C 29 MAX DC Pl3'34320'
000061 440C 30 C44 DC Pl2'440'
000063 05000C 31 HALF DC Pl3'5000'
000066 32 WORK OS Pl6
000000 33 END 8EGIN
Figure 5-9. Assembled program to calculate Social Security tax in decimal arithmetic. Results expected during execution are shown in the
comments field.
72
THE "INDIAN" PROBLEM takes the doubleword at YEARSP and converts to a binary
number in register 4, The Convert to Binary instruction
A certain programming exercise has been done by so many requires an aligned doubleword operand, which is why the
generations of IBM students that it is a classic. We present it DS for YEARSP was set up as it was instead of with a CL8.
here, worked out with the calculation in decimal and the The repeated part of the loop starts with a Multiply
counting in binary. Decimal that should by now be moderately familiar.
The Indians sold Manhattan Island in 1627 for $24. If PRINCP was set up to be long enough to hold the size of
the Indians had banked therr $24 in 1627, what number that previous runnings of the program have shown
would their bank balance be in 1965 at a 3% interest will be necessary. The programmer facing this problem
rate compounded annually? completely fresh would have to make some preliminary
To make the problem a little more interesting, let us calculations as to the possible size.
assume that the principal, $24,·the interest rate faCtor, 1.03, Now comes a familiar sequence of decimal instructions to
and the number of years, 338, are all initially in zoned round, move the sign, and shift right two digits (one byte).
format. The program of Figure 5-10 accordingly begins with One might be tempted to replace the Move Characters and
three PACK instructions to get from zoned to packed format. Zero and Add instructions with a single one of the sort:
The general scheme of the program will be to multiply the
MVC PRINCP+ 1(6),PRINCP
principal by 1.03 as many times as there are years. In other
words, we shall go around a loop repeatedly, each time thinking that a right-to-Ieft operation would permit this
performing a multiplication and subtracting 1 from a count. sort of overlap. A check of the Principles of Operation
When the count has been reduced to zero, the computation manual, howevet, discloses that Move Characters works
of the balance is completed. This counting down from 338 from left to right! The instruction suggested would there-
to zero could, of course, be done in decimal, testing for fore propagate the leftmost character through the entire
zero with a Compare Decimal instruction. It is better field! This can be quite useful on occasion, and is per-
programming practice, however, to remove time-consuming mitted, but it is hardly what we want here. Overlapping
operations from the repeated part of the loop wherever fields must be treated with caution.
possible. Doing the repeated combination of an Add The Branch on Count subtracts 1 from register 4; if the
Decimal, a Compare Decimal, and a Branch on Condition is result is not zero, a branch occurs. If the result is zero, the
much more time-consuming than another approach that is next instruction in sequence is taken. The loop will be
available to us. This other way is to convert the years to carried out 338 times, as required.
binary once, before entering the loop, then use a Branch on A fma! Unpack instruction puts the result into a location
Count (BCT) in the loop, a single instruction that will named BALANCE in zoned format. The answer obtained
subtract 1, test, and conditionally branch. by execution of our program is $523,998.22. Carrying the
The fourth instruction of the program is therefore· a calculations out to more decimal places would of course
Convert to Binary (CVB) instruction, which in our program give a more precise result.
1 PRINT NOGEN
000000 2 INDIAN START a
000000 05BO 3 BEGIN BALR 11,0
000002 4 USING *,11
000002 F263 B04A B040 0004C 00042 5 PACK PRINCP,PRINCZ
000008 F212 B051 B044 00053 00046 6 PACK I NTP, I NT Z
OOOOOE F272 B056 B047 00058 00049 7 PACK YEA RS P , YEAR Z
000014 4F40 B056 00058 8 CVB 4,YEARSP
000018 FC61 B04A B051 0004C 00053 9 LOOP MP PRINCP,INTP
00001E FA61 B04A BOSE 0004C 00060 10 AP PRINCP,ROUND
000024 0100 B04F B050 00051 00052 11 MVN PRINCP+5(11,PRINCP+6 MOVE SIGN
00002A D205 B060 B04A 00062 0004C 12 MVC TEMP,DRINCP DROP LOW-ORDER BYTE
000030 F865 804A B060 0004C 00062 13 ZAP PRINCP,TEMP
000036 4640 8016 00018 14 8CT 4,LOOP SUBTRACT 1 FROM REG 4
00003A F386 8066 804A 00068 0004C 15 UNPK BALANCE,PRINCP
16 EOJ
000042 F2F4FOCO 19 PR I NCZ DC ZL4'24.00'
000046 FIFOC3 20 I NTZ DC ZL3'1.03'
000049 F3F3C8 21 YEARZ DC ZL3'338'
00004C 22 PRINCP OS PL7
000053 23 I NTP DS PL2
000058 24 YEARSP DS D
000060 050C 25 ROUND OC PL2'50'
000062 26 TEMP OS PL6
000068 27 BALANCE OS ZL9
000000 28 END I:3EGIN
Figure 5-10. Assembled program to compute compound interest (the "Indian" problem), with counting in binary and calculations in
decimal arithmetic
Decimal Arithmetic 73
QUESTIONS AND EXERCISES 10. AssUme a 5-byte field called FACTOR, which contains
12345678 9S (S =sign)
1a. Write the assembler instruction to define a packed a. Write the instruction or instructions to store the
decimal constant of 3 to be named CON3 and to occupy 5 leftmost 8 digits (12345678) and the sign in a 6-byte field
bytes of storage. called RESULT.
b. Show how this constant appears on the assembly b. Write the instruction or instructions to store the
listing. leftmost 7 digits and the sign in RESULT.
2. A length code in an instruction is called implied if it is 11 a. The N I (And Immediate) instruction is a
supplied by the on the basis of _________ format instruction.
________ . An explicit length code is supplied b. Write the NI instruction(s) that will change the
bythe ______________ contents 'of a field named HOLD from 11 22 33 44 6S to
3. An explicit length code is (equal to, one more than, one 00223344 6S.
less than) the actual number of bytes to be dealt with. c. 11 22 33 44 6S to 11 22 33 04 6S.
4. The length code in the object instruction is (equal to, 12. What is the difference between the And Immediate and
one more than, one less than) the actual number of bytes to Or Immediate instructions?
be dealt with. 13. Decimal arithmetic can be performed only on (zoned
Sa. In an MP instruction, the first operand specifies the decimal, packed decimal) fields.
location of a storage area containing _ _ _ _ _ _ __ 14. What instruction converts information from zoned
b. Where is the product at the end of the multiplication? decimal to packed decimal form?
6. If there were two successive DC statements of: 15. What instruction converts information from packed
PRINC DC PL4'2489' decimal to zoned decimal form?
INT DC PLt 103' 16. Write DC's to store the number 578 as:
and PRINC were assigned a location of 158: a. A fIXed-point number.
a. Byte by byte, what would be in the storage locations b. A 3-byte zoned decimal number.
assigned to these constants? c. A 2-byte packed decimal number.
b. To what storage location would the operand INT-2 17. Write a DC to store the hexadecimal equivalent of
refer? 7510 •
7. A DP instruction specifies in its first operand the 18. Write an instruction that will place a byte named OLD
location of the , and in its second in the rightmost byte position of register 6 without dis-
operand the location of the . Where turbing the remaining positions of register 6.
will the quotient and remainder be after, the completion of 19. Write an instruction that will store the contents of the
a DP instruction? rightmost byte position of register 6 in a storage byte
8. Assume two fields: named OLD.
SOURCE containing 66 55 44 33 22 11 20. Consider the following excerpts from an assembly
DEST containing 11 22 33 44 55 6S (S = sign) listing. Mask is located at 13E.
Show the contents of SOURCE and DEST after the N 6,MASK
execution of the instructions below. In each case, assume
that before execution the contents of SOURCE and DEST
are as shown above.
a. MVC DEST+2(3) ,SOURCE MASK DC X'OOOOOOOF'
b. MVN DEST+3(1),DEST+5 a. Will the N 6,MASK instruction be successfully
c. MVO DEST ,SOURCE+2(2) executed? If not, why not?
9. Assume the same fields (SOURCE and DEST) as given in b. If not, what statement or statements could be
question 8. inserted to correct the condition?
Would the instruction ZAP DEST ,sOURCE be a legiti- c. How could the DC itself be rewritten to correct the
mate one? If not, why not? situation?
74 (8170)
Chapter 6: Logical Operations on Characters and Bits
So far we have been dealing mainly with the arithmetic long as he knows that any data examined will be regarded
operations of System/360. Now we turn to an area of strictly ·as a binary quantity. Some of the instructions do not
particular fascination to the programmer, one that opens up even examine data. The Move Numerics operation, for
a nearly unlimited range of flexibility and inventiveness in example, which was designed as a convenient way of
the performance of his task. The logical operations of moving just the numeric portions of zoned decimal numbers,
System/360 provide means for the testing and manipulation will move any group or groups of four bits that are in the right
of data in a logical sense, rather than arithmetic or algebraic. location just as cheerfully as it moves valid numerics.
Among these special assembler language instructions are: The programmer will fmd it important to differentiate
the Logical Compares, Test under Mask, some new Move carefully between the action of the flXed-point Compare
instructions, the Logical Shifts, Insert Character, Store and Shift instructions, which are algebraic, and the Logical
Character, and the highly versatile Ands, Ors, and Exclusive Compare and Shift instructions, which of course are not.
Ors. One or more forms of each of these instructions, which An L in the mnemonics of these logical instructions is a
are part of the System/360 standard instruction set, will be convenience.
demonstrated in examples in this chapter. Other logical In logical operations, processing is performed bit by bit
instructions-the standard Translate and the decimal feature from left to right, whereas arithmetic processing is generally
Edit instructions-have such highly specialized functions from right to left. Processing may be done either in storage or
that they will be the subject of a separate chapter. in general registers. Some of the instructions may be used in a
The most important thing for us to realize about the choice of four different formats: RR, RX, SI,' or SS.
logical instructions is that (except for the Edit instructions) Operands may be four bits, a byte, a word, a doubleword,
they treat all data as unsigned binary quantities, that is, all or as many as 256 bytes for variable-length data in storage.
bits are treated alike and no distinction is made between sign The programmer may select a single bit for attention. The
and numeric bits. Remember the data format for a System/ "Immediate" instructions (in the SI format) provide a
360 flXed-point number, with its sign in the frrst bit? And streamlined method of introducing one byte of immediate
for a zoned or packed decimal number, with its sign in the data in the instruction statement itself. The action of most
frrst four or last four bits of the final byte? Well, the logical of the logical instructions sets the condition code and thus
instructions are non-algebraic, and they treat all data as provides a basis for decision-making and branching.
unstructured logical quantities, not as numbers. Fixed- Since the logical operations are covered in detail in the
length data such as a word in a register is regarded this way: System/360 Principles of Operation, these introductory
remarks are limited to generalizations, which give only a
hint of their range and flexibility. The student is urged to
o 31 consult the Principles of Operation .for precise descriptions
of their action, for useful programming suggestions, and for
Variable-length data in storage is looked at this way: examples of their use. He will fmd it rewarding reading.
Io byte I
8
byte I ~ ==I 16
byte I byte I The program example in the frrst section of this chapter
demonstrates a method for sorting three items into
ascending sequence. The next two sections will :show
In practice, the operands are generally characters or groups examples of testing combinations of bits with a mask and of
of bits. setting specified bits on and off. Another program example
Since the logical operations do not recognize any signs as uses a self-checking number routine to illustrate logical
such, it is incumbent upon the programmer to know when operations on a sequence of characters. A fmal example
and where they are in his data. He can use signed numeric demonstrates a series of bit and byte manipulations on
data with whatever logical instructions may fill his needs as input data fields.
A frequent requirement in commercial data processing is digits. If we were working with the USASCII code, we
the comparison of two alphameric quantities, such as names would fmd, on the other hand, that the positions of letters
or account numbers, for relative "magnitude". Sometimes and digits are just the opposite.
this is done to establish correspondence between records in For our purposes here, we are not too concerned about
two files, both of which are in ascending sequence on the the intricacies of where the various characters are ranked by
name or account number, which is called the key. Another the machine's collating sequence; all we really need to
common application is· in arranging a group of records into know is that names will be correctly alphabetized and that
ascending or descending sequence on keys contained in the digits are consistently ranked somewhere.
records. Let us consider this problem, which is usually The Compare Logical Character instruction is in the SS
called sorting, although sequencing might in some ways be a format and operates on variable-length fields. There is one
preferable term. length code, which applies to both operands. The compari-
The problem will be to arrange three "records" of 13 son is from left to right, and continues either until two
characters each into ascending sequence on a five-character characters are found that are not the same, or until the end
key contained in the middle five positions of the record. of the fields is reached. As soon as two characters are found
The rearranged records are to be moved to three new record to be different, there is no need to continue the comparison.
areas named SMALL, MEDIUM, and LARGE. If we are comparing SMITH and SMYTH, we know that
The basic operation in the program will be an alphameric SMITH is "smaller" as soon as the I and Y are compared,
comparison of two five-character keys to determine relative regardless of what characters follow.
magnitude. This will be done with a Compare Logical With this much preliminary, let us consider the program
Character instruction (CLC). The word "logical" in the in Figure 6-1. Perhaps we should begin by looking at the
name means that in comparing two characters, all possible storage allocation. We see DS entries for A, B, and C, the
bit combinations are valid, and the comparison is made three original records; these are 13 characters each. Next
purely on binary values. In a table of EBCDIC character come three entries that defme the addresses of A, B, and C,
codes, we can see that, according to such a scheme, all as ADDRA, ADDRB, and ADDRC, respectively. When we
letters will be "smaller" than all digits; if punctuation write ADDRA as the operand in a Load, what we get in the
characters occur, they rank smaller than either letters or register is not A, but its address. Finally, there are DS's for
1 PRINT NOGEN
000000 2 SORT ABC START 0
000000 05BO 3 BEGIN BALR 11,0
000002 4 USING *,11
000002 9824 B012 00074 5 LM 2,4,ADDRA LOAD REGISTERS WITH ADDRESSES
000006 0504 2004 3004 00004 00004 6 CLC 4(5,2),4(3) COMPARE A WITH B
OOOOOC 47CO B014 00016 7 BC 12,)( BRANCH IF A ALREADY LE SS OR EQUAL
000010 1862 8 t"R 6",2 IF NOT EXCHANGE ADDRESSES OF A AND B
000012 1823 9 LR 2,3
000014 IB36 10 LR 3,6
000016 0504 2004 4004 00004 00004 11 X CLC 4(5,2),414) COMPARE A WITH C
00001C 47CO B024 00026 12 Be 12,Y BRANCH IF A ALREADY LESS OR EQUAL
000020 1862 13 LR 6,2 IF NOT EXCHANGE ADDRESSES OF A AND C
000022 1824 14 LR 2,4
000024 1846 15 LR 4,6
000026 0504 3004 4004 00004 00004 16 Y CLC 4(5,3),4141 COMPARE B WITH C
00002C 47CO B034 00036 17 BC 12,MOVE BRANCH IF B ALREADY LESS OR EQUAL
000030 1863 18 LR 6,3 IF NOT EXCHANGE ADDRESSES OF BAND C
000032 1834 19 LR 3,4
000034 1846 20 LR 4,6
000036 020C B07E 2000 00080 00000 21 MOVE MVC SMAll,0(2) ADDRESS OF SMALLEST IS NOW IN REG 2
00003C D20C B08B 3000 00080 00000 22 MVC MEDIUM,O(3) ADDRESS OF MEDIUM IS NOW IN REG 3
000042 D20C B098 4000 0009A 00000 23 MVC LARGE,0(4) ADDRESS OF LARGEST IS NOW IN REG 4
24 EOJ PROGRAM TERMINATION
00004A 27 A OS CLl3
000057 28 B OS CLl3
000064 29 C OS C1l3
000071 000000
000074 0000004A 30 ADORA DC AU)
000078 00000057 31 ADDRB DC AlB)
00007C 00000064 32 ADORC DC AIC)
000080 33 SMALL OS CLl3
000080 34 MEDIUM OS C1l3
00009A 35 LARGE OS Cll3
000000 36 END BEGIN
Figure 6-1. A program to sort three 13-character items into ascending sequence on keys in the middle of each item. The three items are in
A, B, and C, and when sorted will be placed in SMALL, MEDIUM, and LARGE.
76
SMALL, MEDIUM, and LARGE, where the results are to go. Now, when we continue to the comparison at X, what is
The processing begi11s by loading the addresses of A, B, the address situation? We know that we want to compare
and C into registers 2, 3, and 4, respectively, with a Load whichever of A and B was the smaller with C. Accordingly,
Multiple. Now we begin a sequence of comparisons and (if we write addresses using base registers 2 and 4. We cannot
necessary) interchanges that will put the thfee quantities say whether 2 contains th~ address of A or B; but,
into ascending sequence. We fITst compare A and B. If A is whichever it is, it is the address of the smaller of the two.
already equal to or smaller than B, we do nothing; but, if A That is all we need to know. After this comparison and
is larger, we interchange the addresses of A and B. Let us (possible) interchange, we are guaranteeed that base register
see how this works. 2 contains the address of the smallest of the three numbers.
The Compare Logical Character (CLC) instruction A fmal comparison using whatever addresses are by now
following the Load Multiple is written with explicit base in registers 3 and 4 gives us the address of the "middle"
registers and explicit lengths. The general format of the number in 3 and the address of the largest of the three in 4.
instruction is Now, at MOVE, we are able to write three instructions
that perform the rearrangement. In the fITst Move Characters,
CLC DI(LI,BI),D2(B2)
we pick up the smallest, using whatever is in base register 2.
As we have written the instruction here, the displacement The displacement this time is zero; we want the entire 13
for operand 1 is 4, the length of both operands is 5, the characters. The length can be left implicit this time; it will
base register for the first operand is 2, the displacement for be implied from SMALL, which is 13 characters long.
the second operand is 4, and the base register for the With the program loaded at 200<>t6, Figure 6-2 shows
second operand is 3. Exactly what character positions do the contents of registers 2, 3, and 4 at four points during
these addresses refer to? Remember that base register 2 execution of the program: at the beginning, at X, at Y, and
contains the address of A. This base, plus a displacement of at MOVE. The three actual data items used for A, B, and C,
4, gives the address of the fnth character. Since we said that in order, were I11ICCCCC1111, 2222BBBBB2222, and
the key was to be the middle fIVe characters of each record, 3333AAAAA3333. In other words, the items were in
what we have here is the address of the leftmost character reverse order according to their keys.
of the key of record A. The length of the key is given In practical applications there are usually far too many
explicitly as 5. Operand 2, likewise, gives the address of the records to be sorted internally for the keys of all of them to
key of record B. be held in base registers. On the other hand, the records are
The Branch on Condition asks whether the flISt operand ordinarily so long that it is a saving in time to work with
(the key of A) was less than or equal to the second operand addresses held in storage rather than with the records
(the key of B). If so, there is a branch down to the next themselves. The basic concept suggested here can readily be
comparison, at X, since A and B are already in correct generalized.
sequence.
If the Branch is not taken, we reach the interchange of A
AFTER EXECUTION
and B. Now, an actual interchange of two I3-character OF REG 2 REG 3 REG 4
records is a somewhat time-consuming operation; and, of
STATEMENT 5 0000204A 00002057 00002064
course, this example is only symbolic of real applications,
where the records to be sorted might be hundreds of STATEMENT 10 00002057 0000204A 00002064
characters long. It is much faster to interchange the STATEMENT 15 00002064 0000204A 00002057
addresses of A and B than to interchange the records
themselves; the addresses are only four characters instead of STATEMENT 20 00002064 00002057 0000204A
13, and, as written here, they are in registers rather than in
storage. Three Load Register instructions, which are Figure 6-2. The contents of registers 2, 3, and 4 at four points during
executed very rapidly, carry out the interchange. execution of the program in Figure 6-1, loaded at 2000
78
a bit-by-bit operation. In each bit position, the result is 1 if Setting Bits On and Off
the two operands had exactly one 1 in t..hat position; the
A problem related to the one we have been considering is to
result bit is zero if both operand bits were zero or if both
set a specified bit of a character or a word to be zero or 1. or
were 1. Suppose we write an Exclusive Or Immediate in
perhaps to reverse them from whatever they are. This mi~t
which the immediate portion is 00001000; the 1 here is in
be necessary, for instance, if we were writing a program to
the position for red. The result after the Exclusive Or
develop the wallpaper codes that we tested in the preceding
Immediate will be zero in this position if there had been a
section.
1, and vice versa.
Bearing in mind that fullword operands represent only a
In other words, if the result really 'were 00001000 after
minor amount of additional programming effort, let us see
the And Immediate, there would be all zeros after the
how to carry out these operand operations on one-character
Exclusive Or Immediate. If, on the other hand, there were a
operands.
zero in the position for red, there would now be a 1. And if
To set a specified bit to 1, an Or Immediate is sufficient.
there were a 1 in the position for orange, there would still
Suppose that we are still working with a character named
be a 1 there. In short, a zero result corresponds to an
PATTRN, which now uses all eight bits; and that we want
answer of "yes, there is red but no orange". As it happens,
1,3, 6, and 7 to be "on" (l). We are not interested in the
the various logical operations used here all set the condition
status of bits 0, 2,4, and 5. In other words, we want the
code; and, in the case of the Exclusive Or, a condition code
pattern to be DIDIDDll, where the D's stand for "don't
of zero means that the result was zero. The program can
care " or "1eave t hem whatever they were". This action is
thus be:
precisely what will result from an Or Immediate in which
MVC WO~,PATTRN the immediate part is 01010011 (53 hexadecimal). The Or
NI WORK,X'09' results in a 1 in any bit position in which either operand, or
XI WORK,X'08' both, had a 1. (The case of both having 1 is not excluded,
BC 8,YES (or BZ YES) as in the Exclusive Or. The ordinary Or is sometimes called
the "inclusive" Or to distinguish between the two.)
Test under Mask is a most useful instruction where it
The instruction could be
applies, and its usefulness is by no means limited to
color-blind wallpaper manufacturers. It is useful partly 01 PATTRN,X'53'
because it is selective, testing only the bits specified by the
mask, and partly because it gives a three-way description of If the required action is to set the same four bit-positions
the selected bits: all zero, mixed, or all 1'so It does have the to zero, regardless of their previous values, and leave the
drawback, however, that only one character can be tested at a others as they were, we would use an And Immediate with
time. zeros where we want zeros and 1's where' we want the
If it were necessary to extend the application to cover, previous contents undisturbed. The necessary immediate
say, 20 different yes-no descriptions, the Test under Mask portion is 10101100 (AC in hexadecimal). The instruction
instruction could not be used, except in combinations that is therefore
would get rather involved. In such a situation, we would NI PATTRN,X'AC'
turn instead to the RX forms of the logical instructions.
Mter moving the pattern to a register, which can hold a . The And places a 1 in bit positions in which both operand
bIts were 1, and zero elsewhere. Wherever we put zeros in
32-bit pattern, we would use an And to "select" the bits of
the immediate portion, therefore, there will be zeros in the
interest. The operand of the And instruction would be a
result, as required. Wherever we placed 1's there will be a 1
fullword in storage that has l's where there are bits of
if there was before, or a zero if there was a zero before.
interest in the pattern.
This is exactly what we need.
What we do next depends on our answers to certain
Sometimes it is necessary to change a bit to 1 if it was
questions.
zero, and to zero if it was 1. This is called complementing a
Question: Were any of the selected bits 1's?
bit. If we place 1's in the immediate portion wherever we
Action: We need only test the condition code, which tells
want this complementing action, the Exclusive Or Imme-
whether the result was all zeros or had at least one 1.
diate does precisely what is needed. Other bit positions will
Question: Were certain of the selected bits 1, with the
be unchanged. Assuming we are still working with bits 1,3,
others being zero?
6, and 7, the instruction is
Action: We execute an Exclusive Or to change to zero the
bits that should be 1's, then ask whether the result is all zero. XI PATTRN,X'53'
Working with larger groups of bits is thus seen not to be a
great deal more difficult than working with a single character.
I t is fairly common practice in business to devise account the check to fail. For instance, the check digit for
numbers for things like credit cards so that the number is 132456789 would be
self-checking; This means that one of the digits is assigned
(3 + 4 + 6 + 8) + 3 (1 + 2 + 5 + 7 + 9) = 93
to provide a certain amount of protection against fraud and
clerical errors. This digit is assigned by some fixed sequence The computed check digit of 3 is obviously not the same as
of operations on the other digits. the one in the number, so the account number is rejected as
We shall work in this section with a ten-digit account invalid.
number, the last (rightmost) of which is a check digit. This We wish now to study a program that will determine
digit is computed when the number is assigned. It consists whether an account number that has been entered into the
of the last digit of the sum found by adding together the computer is valid. We begin the program with a nine-digit
second, fourth, sixth, and eighth digits, together with three account number in ACCT, in zoned format. Immediately
times the sum of the first, third, fifth, seventh, and ninth following ACCT is a one-digit check digit named CHECK,
digits. For instance, if a nine-digit account number is also in zoned format.
123456789, the check digit is the last digit of the sum In the program in Figure 6-3 we begin by loading register
3 with a 1. This will be used to determine whether a digit
(2 + 4 + 6 + 8) + 3 (1 + 3 + 5 + 7 + 9) = 95
should be multiplied by 3 or not, as we shall see below.
The last digit is five, so the complete account number Register 4 is loaded with a 9; this is an index register, used to
would be 1234567895. get the digits in order from right to left. A Move Character
There is a certain protection against fraud here; unless puts a signed zero in SUM where the sum of the digits will be
the person attempting the fraud knows the system, there is developed. A Subtract Register clears register 5 to zero.
only one chance in ten that an invented account number At LOOP we begin the processing of digits. With index
will be a valid one. register 4 containing 9, the effective address the first time
More important, perhaps, there is considerable protection through the loop will be ACCT+8, which is the address of
against clerical error. If anyone digit is miscopied, the the rightmost digit. The index is reduced by one each time
erroneous account number will not pass the check. Further- around the loop by the Branch on Count Instruction, so we
more, most transpositions of two adjacent digits will cause pick up the digits one at a time, from right to left, as stated.
1 PRINT NOGEN
000000 2 ACCTNO START 0
000000 0560 3 BEGIN BALR 11,0
000002 4 USING *,11
000002 4130 0001 00001 5 LA 3,1 REG 3 WILL HAVE SIGN REVERSED IN LOOP
000006 4140 0009 00009 6 LA 4,9 COUNTER FOR 9 DIGITS IN NUMBER
OOOOOA 0201 B064 B066 00066 00068 7 MVC SUM, ZERO SUM OF DIGITS KEPT IN SUM
000010 1855 8 SR 5,5 CLEAR REG 5
000012 4354 B059 0005B 9 LOOP IC 5,ACCT-l(4) PICK UP 1 DIGIT OF INDEXED NUMBER
000016 8950 0004 00004 10 SLl 5,4 SHIFT lEFT 4 BITS
OOOOlA 5650 B06A 0006C 11 0 5,PLUS ATTACH A PACKED PLUS SIGN
OOOOIE 4250 B068 0006A 12 STC 5, DIGIT STORE IN TEMPORARY LOCATION
000022 FAlO B064 B068 00066 0006A 13 AP SUM,OIGIT ADD TO SUM OF DIGITS
000028
00002A
1333
4720 B038 0003A
14
15
lCR
BC
3,3
2,EVEN
REVERSE SIGN OF REG 3
SKIP NEXT 2 INSTR ON PLUS ODD TIMES THRU
I
00002E FAI0 8064 B068 00066 0006A 16 AP SUM, DIGIT IF NOT SKIPPED ADD DIGIT TO SUM
000034 FAI0 8064 B068 00066 0006A 17 AP SUM, DIGIT SAME. HAS EFFECT OF MULTIPLYING BY 3
00003A 4640 BOlO 00012 18 EVEN BCT 4,LOOP BRANCH BACK IF NOT All DIGITS PROCESSED
00003E 4350 B063 00065 19 IC 5,ACCT+9 PUT CHECK DIGIT IN REG 5
000042 8950 0004 00004 20 SLL 5,4 SHIFT LEFT 4 BITS
000046 5650 B06A 0006C 21 0 5, PLUS ATTACH SIGN TO PUT IN SAME FORMAT AS SUM
00004A 4250 B064 00066 22 STC 5, SUM PUT ONE BYTE IN LEFT BYTE OF SUM
00004E 0500 B064 B065 00066 00067 23 ClC SUMI1J,SUM+1 IS THIS BYTE SAME AS CHECK DIGIT
000054 4770 B058 0005A 24 BNE ERROR BRANCH TO ERROR ROUTINE IF NOT EQUAL
25 OUT EOJ PROGRAM WOULD NORMAllY CONTINUE HERE
28 ERROR EOJ
00005C 31 ACCT OS Cl9
000065 32 CHECK OS Cll
000066 33 SUM OS Cl2
000068 OOOC 34 ZERO DC Pl2'0'
00006A 35 DIGIT OS Cll
00006C 36 OS OF
00006C OOOOOOOC 37 PLUS DC XL4'OC'
000000 38 END BEGIN
Figure 6-3. A self-checking account number routine that recalculates a check-digit and verifies it
80
The digit inserted in register 5 is shifted left four bits. executed, have the effect of adding hI a digit three times
This puts the numeric part of the digit, which was in zoned instead of once, which is equivalent to multiplying and
format, into the leftmost four bits of an eight-bit byte at somewhat faster.
the right end of the register, and brings in four zeros at the At EVEN we Branch on Count back to LOOP if, after
right. Or-ing with PLUS puts a plus sign into the rightmost reducing the contents of 4 by one, the result is not zero.
four bits (note that the machine code generated by this DC The loop will therefore be executed the last time around
is OOOOOOOC) , and we have a one-digit byte in correct with 1 ill register 4, so the last digit picked up is at ACCT,
packed format for use with an Add Decimal. We therefore as it should be.
put the assembled digit into a working storage location at Once all 'nine digits have been added to sum, we are
DIGIT and add it to SUM. ready to see whether the last digit of SUM is the same as
Now comes the question of whether or not this is a digit CHECK. But it isn't quite that simple; the digit at CHECK
that is to be multiplied by 3. The rule requiring digits to be is still. ~ zoned fonn'!t. We accordingly go through the steps
so multiplied can be stated thus: the fITst digit is multiplied necessary to convert it to packed format, storing it for
by 3; after that, every other digit is so multiplied. In other comparison in the left byte of SUM, which we no longer
words, we need some technique for getting a branch every need. A Compare Logical Character with an explicit length
other time through the loop. The method shown here is to of one now determines whether the check digit that came
reverse the sign of the contents of register 3 every time, with the account number, which is now in SUM, is the same
then to ask whether the result is positive. The fITst time as the computed check digit, which is now in SUM+l. We
through we change a + 1 to -1; the answer is "no, the result have ended the error path as well as the normal path with
is not positive". The second time through we change a -1 an End of Job macro instruction. In a real situation
to + 1, and the answer is "yes, the result is positive". The additional steps would be included to enable inve:>tigation
third time through the + 1 gets changed back to -1, and the of an invalid account pumber, and both paths wouk branch
answer is no. In short, every other time we ask whether the back to LOOP to continue with the next account number
result of reversing the sign of register 3 is positive, the in the input stream.
answer will be yes. We accordingly Branch on Condition to There' are, of course, many other techniques for com-
EVEN if register 3 is positive. This means that for digits in puting check digits which give greater protection or make
even positions 2, 4, 6, and 8, the two additional Add the check digit operations simpler.
Decimal instructions will be skipped. These, if they are
.. 1 1 Pack COMB
in NUMERC
.. 1 1
rC~OGCCCCCO~OOQOOOOQOCOCCOOOGnOQoooooaoooooo
33:i 3 j 3333333313333333333333333333333333333333
(!44444414444414~4444444444444444444444444444 Figure 6-5. A flowchart of the steps required to solve the problem
1 PRINT NOGEN
000000 2 FORMAT START 0
000000 05BO 3 BEGIN BALR 11,0
000002 4 USING *,11
000002 41AO 0001 00001 5 LA 10,1 REG 10 IS USED AS AN INDEX
000006 IB99 6 SR 9,9 CLEAR REG 9
000008 439A B015 00011 7 LOOP IC 9, NUMBER-l( 10) INSERT 1 DIGIT IN REG <}--INDEXED
OOOOOC 5490 B08E 00090 8 N 9,MASKl STRIP OFF SIGN
000010 5990 BOA2 000A4 9 C 9,TEN IS NUMBER LESS THAN 10
000014 4140 B018 OOOlA 10 BL OK BRANCH AROUND EOJ IF OK
11 EOJ NOT A DIGIT
0000 lA 46A 0 B006 00008 14 OK BCT 10tLOOP REDUCE CONTENTS OF REG 10 BY 1 & BRANCH
00001E 4380 B01C 0007E 15 IC 8, NUMBER+6 IF HERE, ALL DIGITS CHECK~D OK
000022 5480 B092 00094 16 N 8,MASK2 STRIP OFF LAST DIGIT & FINAL SIGN BIT
000026 5980 B09A 0009C 11 C 8, PLUS COMPARE 3 REMAINING BITS WITH SIGN
00002A 4780 B02E 00030 18 BE OK2 BRANCH IF OK
19 EOJ NOT AN EBCDIC SIGN
000030 IB88 22 OK2 SR 8,8 CLEAR REG 8
000032 1898 23 LR 9,8 CLEAR REG 9 BY LOADING FROM REG 8
000034 l8A8 24 LR 10,8 CLEAR REG 10 BY LOADING FROM REG 8
000036 8B90 0001 00001 25 LOOP2 SLA 9,1 SHIFT REG 9 LEFT 1 BIT
00003A 438A B01D 0001F 26 IC 8,COMBI10) INSERT 1 BYTE IN REG 8--INDEXED
00003E 5480 B096 00098 21 N 8,MASK3 STRIP OFF DIGIT PART
000042 5980 B09A 0009C 28 C 8 t PLUS COMPARE WITH CODING FOR PLUS
000046 4180 B052 00054 29 BE YES BRANCH IF PLUS
00004A 5980 B09E OOOAO 30 C 8,MINUS COMPARE WITH CODING FOR MINUS
00004E 4180 B056 00058 31 BE NO BRANCH IF MINUS
32 EOJ NEITHER PLUS NOR MINUS
000054 5A90 BOA6 000A8 35 YES A 9,ONE IF PLUS ADD 1 TO CONTENTS OF REG 9
000058 5AAO BOA6 000A8 36 NO A lO,ONE ADD 1 TO REG 10 FOR LOOP TEST
00005C 59AO BOAA OOOAC 31 C 10,TEST COMPARE
000060 4110 B034 00036 38 BNE LOOP2 BRANCH BACK IF NOT FINISHED
000064 4290 B085 00081 39 STC 9,COOES STORE LAST BYTE OF REG 9
000068 940F B084 00086 40 NI COMB+1,X'OF' STRIP OFF OLD ZONE
00006C 96CO 6084 00086 41 or COM6+1,X'CO' ATTACH ZONED PLUS SIGN
000010 F241 6086 B07D 00088 0001F 42 PACK NUMERC t COMB CONVERT TO PACKED FORMAT
43 EOJ PROGRAM TERMINATION
000018 46 NUM6ER OS CL1
00001F 41 COMB OS CL8
000081 48 CODES DS CLl
000088 49 NUMERC OS CL5
000090 50 OS OF
000090 OOOOOOOF 51 MASK1 DC X'OOOOOOOF'
000094· OOOOOOEO 52 MASK2 DC X' 000000 EO '
000098 OOOOOOFO 53 MASK3 DC X'OOOOOOFO'
00009C OOOOOOCO 54 PLUS DC X'OOOOOOCO'
OOOOAO 00000000 55 MINUS DC X' 000000 DO'
0000A4 OOOOOOOA 56 TEN DC F ' I0'
0000A8 00000001 51 ONE DC F ' l'
OOOOAC 00000008 58 TEST DC F ' 8'
000000 59 END BEGIN
Figure 6-6. A program that checks a decimal field at NUMBER for validity and converts a composite field at COMB into separate binary and
packed decimal quantities. The flowchart in Figure 6-5 was used as a guide for the programming
84
Chapter 7: Edit, Translate, and Execute Instructions
This chapter will be devoted to several highly specialized and The other instructions covered in this chapter are Edit,
useful instructions that are part of the assembler language. Edit and Mark, Translate, and Translate and Test. These are
They call into play some new concepts, and their functions part of the System/360 logical operations discussed in the
and machine actions are different in many ways from any preceding chapter. We begin with a detailed demonstration
of the instructions we have encountered so far. Since they of how the Edit, and the almost identical Edit and Mark,
may be regarded as irregular verbs, so to speak, of System/ instructions work. These two instructions are invaluable
360 Assembler Language, we will subject each of them to aids to any programmer concerned with decimal arithmetic.
careful scrutiny. Translate· can be used for code conversion or to provide a
The Execute (EX) instruction is a special type of control function. The description of the Translate instruc-
branching instruction that causes one other instruction in tion is necessary for an understanding of the Translate and
main storage to be executed out of sequence without Test (TRT), which follows it. Detailed program examples
actually branching to its location. Since Execute can also are included, with special emphasis on the use of the
modify the remote instruction before it is executed, it powerful combination of TRT and EX in various applica-
offers considerable economy in the number of instructions tions. The programmer will find many additional
needed to achieve certain results. applications for the techniques demonstrated in this chapter.
The Edit instruction is one of the most powerful in the instructions necessary to do the job are:
repertoire of the System/360. It is used in the preparation
MVC WORK,PATTRN
of printed reports to give them a high degree of legibility
ED WORK,DATA
and therefore greater usefulness. It makes it possible, as we
shall see, to suppress nonsignificant zeros, insert commas After execution of the two instructions, WORK contains
and decimal points, insert minus signs or credit symbols, our edited result. PATTRN still contains the original pattern
and specify where suppression of leading zeros should stop and can transmit that original pattern to WORK for the
for small numbers. All of these actions are done by the editing of any new value in DATA. At PATTRN there
machine in one left-to-right pass. The condition code can be should be the following characters, written here in hexa-
used to blank all-zero fields with two simple instructions. decimal:
A variation of the instruction, Edit and Mark, makes
40 20 20 20 20 20 20 20
possible the easy insertion of floating currency symbols.
We shall study the application and results of this highly or as they would appear in an actual program, defined as a
flexible instruction by applying it to successively more hexadecimal constant:
complex situations. PATTRN DC X' 4020202020202020'
We begin with a simple requirement to suppress leading
zeros; no punctuation is to be inserted. We have a field to In EBCDIC, 40 is the hexadecimal code for a blank and 20
be edited, called DATA. It is four bytes long, and the decimal for the digit selector control character. Hex is used to
data is in packed format. The packed format for data to be specify control characters, since there are no written or
edited is a requirement of the Edit (ED) instruction, which printed symbols to represent them. In this section, all
is a decimal instruction. As we saw in an earlier chapter, patterns are shown exactly as they would appear in con-
data used in decimal arithmetic operations is always in stants, except of course that the spaces would be closed up.
packed format. If we happened to have source data in some In our example, suppose that at DATA there is
other form, we would have to pack it before editing.
00 01 00 Ot
The data to be edited is named as the second operand of
the Edit. The frrst operand must name a field containing a The edited result would be
"pattern" of characters that controls the editing; after
b b b b 1 000
execution of the instruction, the location specified by the
frrst operand contains the edited result. (The original where the b's stand for blanks. All zeros to the· left of the
pattern is destroyed by the editing process.) The pattern is frrst nonzero digit have been replaced by blanks; but
in zoned format, as is the result; the Edit instruction causes zeros to the right of the first nonzero digit have been
the conversion of the data to be edited from packed to moved to WORK without change. This is the desired action.
zoned format, since zoned format is what is needed for Figure 7-1 shows a series of values for DATA and the
most output operations. resultant edited results in WORK, using the pattern stated.
We said that in our example the data field to be edited Note that the high-order position of WORK contains the fill
was four bytes long, that is, seven decimal digits and sign, character, a blank. The values of DATA are packed decimal;
which we shall assume to be plus. The pattern must the edited results are changed during execution of the Edit
accordingly be at least eight bytes long: seven for the digits instruction to zoned decimal format.
and one at the left to designate the "fill character". The fill
character is of our choosing, but is usually a blank. This is
BDDDDDDD
the character that is substituted for nonsignificant zeros. 40 20 20 20 20 20 20 20
The leftmost character of the pattern in our case will be
1234567 1234567
the character blank (hexadecimal 40 in System/360 EBCDIC 0120406 120406
coding). The other seven characters will contain hexa- 0012345 12345
0001000 1000
decimal 20, a control character called a digit selector, which 0000123 123
is used to indicate to the Edit instruction that a digit from 0000012 12
0000001 1
the source data may go into the corresponding position. 0000000
Let us see how all this works out in our example.
Suppose we set up an eight-byte working storage field
Figure 7-1. Results of Editing source data in left-hand column. Two
named WORK into which we move the pattern (located in lines at top give editing pattern in symbolic fonn (B
an area called PATTRN). Then we will perform our edit represents a blank, D a digit selector) and in hexa-
using WORK and DATA as the two operands. The two decimal coding.
86
The fill character that we supply as the leftmost charac- The message characters inserted are, naturally, not
ter of the pattern may be any character that we wish. It is limited to commas. A frequent application is to insert a
fairly common practice to print dollar amounts with aster- decimal point as well as commas. Let us assume that the
isks to the left of the first significant digit in order to data values we have been using are now to be interpreted as
protect against fraudulent alteration. This is usually called dollars-and-cents amounts. We need to arrange for a comma
asterisk protection. to set off the thousands of dollars, and a decimal point to
To do this, we need only change the leftmost character designate cents. The characters in PATTRN, where 6B is a
of the pattern of the previous example. The hexadecimal comma and 4B is a decimal point, should be as follows:
code for an asterisk is 5C; hence the new pattern is
40 20 20 6B 20 20 20 4B 20 20
5C 20 20 20 20 20 20 20
The edited results this time are in Figure 7-4.
Figure 7-2 shows the edited results for the same DATA We see here something that would normally not be
values that we used in Figure 7-1. desired: amounts under one dollar have been edited with
the decimal point suppressed. We would ordinarily prefer to
have the decimal point. This can be done by placing a
*DDDDDDD significance starter in the pattern. This control character,
5C 20 20 20 20 20 20 20 which has the hexadecimal code 21, is either replaced by a
1234561 *1234561 digit from the data or replaced by the fill character, just as
0120406 **120406 a digit selector is. The difference is that the operation
0012345 ***12345
0001000 ****1000 proceeds as though a significant digit had been found in the
0000123 *****123 position occupied by the significance starter. In other
0000012 ******12
0000001 *******1 words, succeeding characters to the right will not be
0000000 ******** suppressed. (An exception to this generalization may occur
when we want to print sign indicators, a subject that will be
Figure 7-2. Editing results with an asterisk as the fill character explored later.)
40 20 6B 20 20 20 6B 20 20 20
Figure 7-4. Editing results with blank fill and the insertion of
The 6B is hexadecimal coding for a comma, and it is a comma and decimal point
message character. The edited result will contain commas in
the two positions shown, unless they are to the left of the The pattern for tills action, assuming we still want the
first nonzero digit, in which case they are suppressed. comma and decimal point as before, should be
Figure 7-3 shows the results for the same data values.
40 20 20 6B 20 20 21 4B 20 20
The effect is this: if nothing but zeros has been found by
BD,DDD,DDD the time we reach the significance starter (hex 21) in a
40 20 6B 20 20 20 6B 20 20 20 left-to-right scan, the significance starter will turn on the
1234561 1,234,561 significance indicator. This indicator will cause succeeding
0120406 120,406 characters to be treated as though a nonzero digit had been
0012345 12,345
0001000 1,000 found. The result is that the decimal point will always be left
0000123 123 in the result, as will zeros to the right of the decimal point.
0000012 12
0000001 1 The edited results this time are shown in Figure 7-5.
0000000 One useful point to remember is that the total number
of digit selectors plus significance starters in the pattern
Figure 7-3. Editing results with blank fill and the insertion of must equal the number of digits in the field to be edited.
commas Note that this is the case in all our examples.
CONDITIONS RESULTS
State of Significance
Pattern Previous State of Low-Order Source Result Indicator at End of
Character Significance Indicator Source Digit Digit is a Plus Sign Character Digit Examination
88
but, rather, sign indicators, such as a minus sign or CR for
credit. The action taken with the characters in the pattern *DD,DDS.DDBCR
5C 20 20 6B 20 20 21 4B 20 20 40 C3 D9
is the same now as it was before: they remain unchanged if
the significance indicator is on, but are replaced by the fill 1234567 *12,345.67***
0120406 **1,204.06***
character if the significance indicator is off. 0012345 ****123.45***
Let us set up a suitable pattern for the example data. Let 0001000 *****10.00***
0000123 ******1.23***
us print the letters CR for negative numbers, with one blank 0000012 *******.12***
between the rightmost digit and the C. In hexadecimal, CR 0000001 *******.01***
0000000 *******.00***
is C3 D9, so the pattern becomes -0098765 ****987.65 CR
-0000000 *******.00 CR
40 20 20 6B 20 20 21 4B 20 20 40 C3 D9
Figure 7-6 shows the results for sample data values as Figure 7-7. Same with asterisk rill
before, together with two negative values.
The explicit length of 12 is based on the most recent
pattern, which has a total of 13 characters. The MVC, as
BDD,DDS.DDBCR written, picks up the leftmost character and moves it to the
40 20 20 6B 20 20 21 4B 20 20 40 C3 D9 leftmost-plus-one position. It then picks up the leftmost-
1234567 12,345.67 plus-one character and moves it to the leftmost-plus-two
0120406 1,204.06 position, etc., effect propagating the leftmost character
0012345 123.45
0001000 10.00 through the field. This is precisely what we want if the fill
0000123 1.23 character is the one to be substituted.
0000012 • 12
0000001 .01 Figure 7-8 shows our familiar data values with zero fields
0000000 e.00 blanked, and Figure 7-9 shows them with zero fields filled
-0098765 987~65 CR
-0000000 .00 CR with asterisks. Only the fill character differs in the two
programs that would produce the results shown in Figures
7-8 and 7-9; the Edit, the Branch on Condition, and the
Figure 7-6. Editing results with blank. fill, comma and decimal point
insertion, significance starter, and CR symbol for nega- Move Characters are the same in both cases.
tive numbers
OOOOOOOCOOOOOCOOOOOOOOOC 0.000
Figure 7-10. Examples of multiple edits. On each line the first field is a combination of three items; all three were edited with one Edit,
giving the three results shown to the right. The editing pattern is shown in the text.
90
THE EDIT AND MARK INSTRUCTION
The Edit and Mark instruction (EDMK) makes possible the The Load Address instruction as written places in register
insertion of floating currency symbols. By this we mean the . 1 the address of the position one beyond the significance
placement in the edited result of a dollar sign (or pound starter. If significance is forced, this address remains in
sterling symbol) in the character position immediately to register 1, but otherwise the address of the frrst significant
the left of the frrst significant digit. This serves as protec- digit is placed in register 1 as part of the execution of the
tion against alteration, since it leaves no blank spaces. It is a Edit and Mark. The Branch on Count Register instruction
somewhat more attractive way to provide protection than with a second operand of zero reduces the frrst operand
the asterisk fill. register contents by.l and does not branch. There are, of
The operation of the instruction is precisely the same as course, other ways to subtract 1 from the contents of
the Edit instruction, with one additional action. The execu- register 1, but this is the easiest and fastest. In the Move
tion of the Edit and Mark places in register 1 the address of Immediate instruction we write an explicit displacement of
the frrst significant digit. The currency symbol is need~d zero and an explicit base register number of 1. The net
one position to the left of the frrst significant digit. effect is to move one byte of immediate data, a dollar sign,
Consequently, we subtract one from the contents of regis- to the address specified by the base in register 1. This is the
ter 1 after the execution of the Edit and Mark and place a desired action.
dollar sign in that position. Figure 7-11 shows the effect-on sample data values. Zero
There is one complication: if significance is forced by a fields could be blanked by methods we have already
significance starter in the pattern, nothing is done with discussed.
register 1. Before going into the Edit and Mark, therefore,
we place in register 1 the address of the significance starter
plus one. Then, if nothing happens to register 1, we still get
BDD,DDS.DDBCR
the dollar sign in the desired position by using the proce- 40 20 20 6B 20 20 21 4B 20 20 40 C3 D9
dure described above. 1234561 $12,345.61
Let us suppose that we are again working with a 0120406 $1,204.06
four-byte source data field, which we are to edit with a 0012345 $123.45
0001000 $10.00
comma, a decimal point, and CR for negative numbers. 0000123 $1.23
Accordingly, the pattern (in shorthand form) should be 0000012 $.12
0000001 $.01
0000000 $.00
bdd,dds.ddbCR -0098165 $981.65 CR
-0000000 $.00 CR
The significance starter here is six positions to the right of the
leftmost character of the pattern. The complete program to
give the required editing and the floating dollar sign is as Figure 7-11. Examples of the application of the Edit and Mark
follows: instruction to get a floating currency symbol
MVC WORK,PATTRN
LA I,WORK+7
EDMK WORK,DATA
BCTR 1,0
MVI O(1),C'$'
How It Works
Another powerful programming feature of System/360 is code (2 6 = 64), and provides us with one byte for every
the ability, through the Translate instruction, to convert binary value that we might receive. We give our table a
very rapidly from one coding system of eight or fewer bits name, TABLE, so that we will be able to refer to its symbolic
to another coding system. Using a conversion table, we can storage address regardless of where it is. To create the table, a
convert a string of characters from one form to another at DC statement like the following might be used. In this case,
speeds that compare favorably with that of decimal we are arbitrarily filling the unused bytes with FF's.
addition.
TABLE DC X'FFE3FFD64OC8D5D4FFD3D9C7C9D7C3E5C5E9
Suppose that we have an input stream in which the data ..•......... F2FFFFF7FIFFFF'
is in proper arrangement for processing, but is in Baudot
teletypewriter code. Before System/360 can process the Then, assuming each record is a maximum of 80 bytes in
input, it must be converted to EBCDIC. The Baudot code is length, we set up a storage area for the Baudot data that is
a five-bit code with shifting, which makes it the equivalent to be translated:
of a six-bit code. For simplicity, we will omit control
RECORD DS CL80
characters, punctuation marks, and fractions; for our
purposes, they are "invalid". As shown in Figure 7-12, our After moving the frrst input item to RECORD, the only
transmission receiving equipment adds two zero bits at the processing instruction that is necessary to convert it to
beginning of each character, which do not change its binary EBCDIC characters is:
value, and converts the code signals into the equivalent
TR RECORD,TABLE
binary bit patterns shown in the illustration, so that our
input stream is in the necessary eight-bit bytes. It remains The operation of this instruction is byte by byte, from left
for us to translate this stream into the corresponding to right, until the end of the frrst operand field. Like the other
EBCDIC characters by programming. logical instructions· we have studied, TR treats all data as
The Translate instruction (TR) is in the SS format with unstructured logical data, that is, as unsigned binary quan-
two storage operands. The frrst operand names the leftmost tities. Say the first byte of RECORD is 0000 1010 (hex
byte of a field to be translated; this field may be from one OA), which is R in Baudot code. The machine action will be
to 256 bytes in length. hi programming parlance, it is called to go to the address TABLE+OA (that is, the byte at OA
the argument. The second operand names the start of a list, within the table) and to replace the OA in RECORD by the
or table, that contains the characters of the code into which bit pattern it finds in that byte of the table. This is hex D9
we wish to make the translation. The table may be 256 or 1101 1001, which is R in EBCDIC. If the next Baudot
bytes in length or it may be shorter. It is called the byte is 0010 1100 (hex 2C) for the numeral 8, it will be
/unction. replaced by the contents of the byte at TABLE+2C: hex
Our first step before using the Translate instruction is to F8 or 1111 1000, which is 8 in EBCDIC. If the next
construct a table like the one in Figure 7-13. Note that it is 64 Baudot byte is either hex 04 or 24, a space, it will be
bytes in length, which is the maximum length of a six-bit replaced by hex 40, the EBCDIC blank, which we placed in
0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010 1011 1100 1101 1110 1111
BIT
POSITIONS HEX
0,1,2,3 VALUE- 0 1 2 3 4 5 6 7 8 9 A B C 0 E F
t
0000 0 T 0 sp H N M L R G I P C V
0001 1 E Z 0 B S y F X A W J U Q K
0010 2 5 9 sp 4 8 0
0011 3 3 6 2 7 1
Figure 7-12. Baudot teletypewriter code. This is a fIve-bit code that, with shifting, has the capacity of six bits, or 64 characters. Control
characters, punctuation marks, and fractions have been omitted.
92
Sqmbolic address 01' thIs bqte IS TABLE ThIS IS TABLE +07
I /
Address* 00 01 02 03 04 05 06 07 08 09 OA OB OC 00 OE OF
Contentst
;X l/{;%X'X /C y( l/{ y{ l/(;X 7c ~
Address 10 11 12 13 14 15 16 17 18 19 1A 1B 1C 10 1E 1F
Contents
Address
X 7z 70l/( X ;Yvc;{7xl/{7w l/{ /u /a X
20 21 22 23 24 25 26 27 28 29 2A
:x
2B 2C 20 2E 2F
Contents
/s;% X 7s70
:x :x
Address 30 31 32 33 34 35 36 37 38 39 3A 3B 3C 3D 3E 3F
Contents
X ;X;X
*Location of function byte within table, given in hex.
tContents of function byte. The actual bit configuration is shown in hex at upper left; character at lower right is EBCDIC
character represented by that bit pattern.
Figure 7-13. Table for translation of Baudot code to EBCDIC. Unused bytes may be filled with FF's to test for invalid characters.
the bytes at both TABLE+04 and TABLE+24. invalid characters by using a Compare Logical Immediate
There are some important things to note about our instruction.
translate table: The Translate instruction may be used to convert any
1. It contains the characters of the code into which we characters of no more than eight bits to any other charac-
are translating, the function bytes. ters, not necessarily from one standard code to another. It
2. It is in order, not by the binary sequence of the may be used to perform a control function, as in the
characters it contains, but by the binary sequence of the program example in which we shall see the instruction at
characters of the code from which we are translating, the work. At first glance, this program may seem to be rather
argument bytes. complicated, but it is simply a variation on an example of a
3. It is 64 bytes long, the length we determined was sorting technique that we discussed earlier.
equal to the maximum number of bit combinations we
An Example
might have to deal with in the Baudot code.
If we were confronted by the reverse situation and In the example we shall use the Translate instruction to
needed to translate from EBCDIC to Baudot code, using accomplish a reversal of letters and digits in the collating
the same letters, numbers, and blanks as before, we would sequence. When we compare a letter and a digit in normal
have to construct a 256-byte table in order to have the EBCDIC coding the letter will always show as "smaller"
required indexing or referencing capacity to 256 different than the digit. We shall assume that, for some special
addresses. (EBCDIC is an eight-bit code, and T = 256.) The reason, it is necessary to arrange things so that letters sort
table would contain the 38 characters of interest to us, but as "larger".
the contents of these function bytes would now have to be It should be realized that we need to reverse the ordering
in the Baudot code bit configuration, and they would be in of letters and digits as complete groups. It is therefore not
order by the sequence of the EBCDIC characters, which are possible simply to reverse the paths taken on the compari-
now the argument bytes. sons in the program. Consider an example. With EBCDIC
We have not so far mentioned the unused function bytes coding and the Compare Logical Character instruction, this
of our table in Figure 7-13. We could store blanks or zeros is the binary sequence, and the machine's normal collating
as constants, but a better procedure is available to us, sequence, of the following five items:
especially when a code without validity checks, like the
ADAMS
Baudot, is transmitted. If we fill the spaces with a single
JONES
unused character, such as hex FF (1111 1111), all invalid
SMITH
codes received would be translated to FF. After translation
12345
of each record, it would then be very simple to scan it for
56789
94 (8170)
LOC OBJECT CODE AODR1 ADDR2 STMT SOURCE STATEMENT
1 PRINT DATA,NOGEN
000000 2 SORTABC2 START 0
000000 05BO 3 BEGIN BALR 11.0
000002 4 USING *.11
000002 0204 B097 B070 00099
00072 5 MVC KEYA+4 (5). A+4 MOVE KEYS TO POSITION FOR TRANSLATE
000008 0204 BOA4 B070 000A6
0007F 6 MVC KEYB+4( 5). B+4
OOOOOE 0204 BOB 1 B08A 000B3
0008C 7 MVC KEYC+4(5),C+4
000014 DC04 B097 BOED OOOEF
00099 8 TR KEYA+4(5),TABLE TRANSLATE KEYS TO CHANGE COLLATE SEQ
00001A DC04 BOA4 BOED 000A6
OOOEF 9 TR KEYB+4(5),TABLE
000020 OC04 BOB 1 BOED 000B3
OOOEF 10 TR KEYC+4 (5).T ABL E
000026 9824 BOBA OOOBC 11 LM 2.4,ADDRA PUT ADDRESSES IN REGS 2, 3, 4
00002A 0504 202B 302B 0002B 0002B 12 CLC 43 (5,21.43 (31 COMPARE KEYA WITH KEYB
000030 47DO B038 0003A 13 BNH X BRANCH IF ALREADY IN SEQUENCE
000034 1862 14 LR 6,2 INTERCHANGE
000036 1823 15 LR 2,3
000038 1836 16 LR 3.6
00003A 0504 202B 402B 0002B 0002B 17 X CLC 43(5,2),43(4) COMPARE SMALLER OF A AND B WITH KEYC
000040 4700 B048 0004A 18 BNH Y BRANCH IF ALREADY IN SEQUENCE
000044 1862 19 LR 6,2 INTERCHANGE
000046 1824 20 LR 2,4
000048 1846 21 LR 4,6
0OO04A 0504 302B 402B 0002B 0002B 22 Y CLC 43(5,3),43 (41 COMPARE TWO LARGER KEYS
000050 4700 B058 0005A 23 BNH MOVE BRANCH IF ALREADY IN SEQUENCE
000054 1863 24 LR 6,3 INTERCHANGE
000056 1834 25 LR 3.4
000058 1846 26 LR 4,6
00005A D20C BOC6 2000 000C8 00000 27 MOVE MVC SMALL,O(2) MOVE USING ADDRESSES IN REGI STERS
000060 D20C BOD3 3000 00005 00000 28 MVC MEDIUM,O (3)
000066 020C BOEO 4000 000E2 00000 29 MVC LARGE,O(4)
30 EOJ
00006E 33 A DS C1l3
00007B 34 B OS C1l3
000088 35 C OS C1l3
000095 36 KEYA OS C1l3
0000A2 37 KEYB DS C1l3
OOOOAF 38 KEYC OS Cll3
OOOOSC 0000006E 39 ADORA DC A(A)
OOOOCO 0000007B 40 ADORB DC A(B)
0000(4 00000088 41 ADDRC DC AI()
0000C8 42 SMALL OS C1l3
000005 43 MEDIUM OS C1l3
0000E2 44 LARGE OS Cll3
OOOOEF 4040404040404040 45 TABLE DC Cl193' ,
0000F7 4040404040404040
OOOOFF 4040404040404040
000107 4040404040404040
OOOiOF 4040404040404040
000117 4040404040404040
OOOllF 4040404040404040
000127 4040404040404040
00012F 4040404040404040
000137 4040404040404040
OOO13F 4040404040404040
000147 4040404040404040
00014F 4040404040404040
000157 4040404040404040
00015F 4040404040404040
000167 4040404040404040
00016F 4040404040404040
000177 4040404040404040
00017F 4040404040404040
000181 4040404040404040
00018F 4040404040404040
000191 4040404040404040
00019F 4040404040404040
0001A7 4040404040404040
0001AF 40
0001BO 1112131415161718 46 DC X'111213141516171819'
0001B8 19
0001B9 40404040404040 47 DC CL7' ,
0001eo 2122232425262728 48 DC X'212223242526212829'
0001C8 29
0001C9 4040404040404040 49 DC Cl8' ,
000101
000109
000lDF
3233343536313839
404040404040
0102030405060708
50
51
52
DC
DC
DC
CL6' .
X'3233343536373839'
X'01020304050607080910'
000lE7 0910
0OOlE9 404040404040 53 DC Cl6' ,
000000 54 END BEGIN
Figure 7-14. A program to sort three fields named A, B, and C into ascending sequence on me-character keys in each field. The Translate
instruction is used to make digits sort ahead of letters.
96
THE TRANSLATE AND TEST INSTRUCTION AND
THE EXECUTE INSTRUCTION
The Translate and Test instruction (TRT) adds great power manner, it is to be printed, after which we return to set up
to the processing capability of System/360. It is related to and print the next address.
the Translate instruction and has the same format, but is The table required for this application must be 256
very different in operation. It is used to scan a data field for bytes in length in order to reference the complete range of
characters with a special meaning. Since it merits our close EBCDIC binary values. It will consist of 254 zeros, with
attention, we shall study it in the three remaining programs entrie~only in positions 5B (91) and 5C (92), corresponding
in this chapter. to dollar sign and asterisk respectively. For-- the dollar sign
As with Translate, we work with a table as the second we have chosen to enter 01 and for asterisk 02. These
operand that is accessed exactly the same way. That is, a choices are highly arbitrary; as we shall see, any other two
frrst operand argument byte addresses a particular entry in numbers would be just as good. All we need to know about
the table by an address computation. Once again the table the input stream is where the dollar signs and asterisks
must be in order by the binary sequence of the code of the appear; we care nothing about any other characters.
source material, which in this and the following sections The program in Figure 7-16 begins by placing in register
will be standard EBCDIC input. This time, however, we 3 the address of the frrst character of the input stream that
must put zeros in the table to indicate characters without we shall break into names and addresses. On the assumption
any special meaning and some nonzero value for each that there is only one such stream to process, this instruc-
character with a special meaning. tion is never repeated in this program. The next instruction
In further contrast to the Translate instruction, there is is returned to each time another name and address is to be
no change in the argument bytes as a result of the TRT processed. It places a 4 in register 9 to be used as a guard
operation, despite the "translate" in its name. Instead, the against incorrect input streams; if ever a name and address
argument bytes are merely inspected, byte by byte, from would seem to require more than the four lines we have
left to right. If the frrst argument byte references a function allotted, the program will stop. The next Load Address
byte that is zero, the next argument byte is inspected, and places in register 10 the address of the frrst line of the
so forth. If all the function bytes that are referenced are output. The next two instructions are overlapping Move
zero, the condition code is set to zero and the operation is Characters that clear to blanks the output areas. With
complete. However, if a nonzero function byte is refer- assumed line lengths of 120 characters, this makes 480
enced, the contents of that byte are placed by the machine bytes to clear. Since the' maximum length in a Move
in register 2 and the address of the argument byte is placed Characters is 256 bytes, two instructions are needed, each
in register 1. The condition code is set to 1 or 2, and the clearing two lines. The frrst MVC instruction clears to
operation is terminated. A condition code of 1 indicates blanks the frrst two lines and the first position of the third
that there are more argument bytes to inspect, a condition line. The second MVC instruction uses the blank now in the
code of 2 that the nonzero function byte is at the end of frrst position of the third line to blank the remaining
the field. The programmer may then make use of the positions of the third line and all of the fourth line.
information in the registers and in the condition code. Now we come to the Translate and Test. The frrst
This means that we can inspect a complete stream of operand starts at the address in register 3, which we set up
argument bytes, looking for whatever interests us: error with the starting address of the input stream; it is stated to
characters, end-of-message codes, blanks and commas that be a maximum of 120 characters in length. The second
separate parts of a line, or whatever. The following problem operand address names the table. If the input stream is
shows one way to use the instruction. correct, a dollar sign will be found within 120 characters.
We are given the starting address of a string of characters If, because of an error, there is no end-of-line dollar sign,
of unknown length. The string contains an unknown num- we will have a condition code of zero at the completion of
ber of names and addresses. Each name is of unknown the execution of the instruction. A Branch on Zero,
length; each address component is of unknown length; accordingly, takes us to an error exit (this could also be
there may be from one to four lines of address; we do not written as BC 8,ERROR).
know how many names and addresses there are. All we do In the normal case of fmding a dollar sign to indicate the
know is that after each "line" of information there is a end of the frrst line, what do we have in the registers?
dollar sign ($), after the last line of an address there are two Register 1 contains the address of the dollar sign that
dollar signs ($$), and at the end of the entire string there is stopped the Translate and Test. We wish to do a little
a dollar sign followed by an asterisk ($*). We are required arithmetic on this address without destroying it, so we move
to set up each name and address in four lines named it to register 4. Now we subtract from the address of the
LINE 1, LINE2, UNE3, and LINE4. Any unused lines must dollar sign the address of the frrst character of the line. The
be blanked. When an address has been assembled in this difference is the length of the line, in bytes. We are about
1 PRINT DATA,NOGEN
OCOOOO 2 MAILlIST START o
000000
000002
000002 IB22
05BO 3 BEGIN
4
5
BALR
USING
SR
·.11
ll,O
Figure 7-16. A program to print names and addresses. The input stream contains an unknown number of names and addresses, each name
and address contains a variable number of lines, and each line is of variable length.
98
ready to execute a Move Characters instruction in which we accordingly use a Load Address instruction to get the
will use this computed address; but in the instruction itself desired address into register 3. The instruction operates as
the length code is always one less than the actual length. So follows. The displacement of one is added to the contents
we now subtract 1 from the difference residing in register 1. of the base register to get an effective address. (If an index
What would it mean if this difference were now register had been specified, its contents would also have
negative? We shall see, in further analysis of the program, been added in.) This address is then placed in register 3,
that it would indicate the double dollar sign that denotes with no actual reference to storage. It would have been
the end of a name and address. We therefore Branch on legitimate to place the sum back in register 4, if that had
Minus (or BC 4) to OUT, where we would normally process been desired. Load Address provides a fast and simple way
the completed name and address. to add a small positive amount to a register.
Let us review the status of things. We have in register 3 In the next Load Address instruction we see register 10
the starting address of a group of characters that should be being incremented by 120 by use of the method just
moved; in register lOwe have the address to which they described. The purpose is to set up the next line as the
should be moved; in register 1 we have the correct length destination the next time around the loop. Finally we
code for a Move Characters instruction. We need either to Branch on Count back to inspect the input stream again. If
place that length code in an instruction - or do something this 'would mean trying for a filth line, the branch is not
equivalent. "Something equivalent" is precisely what the taken and we reach the error exit.
Execu te (EX) instruction provides. We say At OUT, which we reach on discovering either two
dollar signs in sequence or a dollar sign followed by an
EX I,MVCINS
asterisk, we would normally include a series of instructions
This means to execute the instruction at the second to print the output. Since input/output operations are
operand address named (MVCINS), after Or-ing together outside the scope of this book, we simply indicate by a
the last eight bits of register 1 and the length code portion No-Operation instruction that this action would occur here
of MVCINS. Looking down at MVCINS we see that a Move in the program. NOPR is an extended mnemonic for Branch
Characters instruction has been set up to do all the things on Condition with a mask of zero, which never causes a
just outlined as necessary, with the exception of the length. branch to occur.
The instruction set up at MVCINS says to move a group of Following the output operations we are ready to go back
bytes starting at the address given in register 3 to another for another name and address, unless this was the last one
location given by the address in register i O. Both displace- in the stream. Whether that was the case can be determined
ments are zero, because the base addresses are exactly what by looking at the function byte in register 2 to see whether
are wanted. The length code is zero in the instruction; the it is that produced by a dollar sign or by an asterisk, that is,
actual length is supplied by the last eight bits of register 1. a lora 2 respectively. A comparison with ENDCON, which
One line of the complete name and address is thus moved contains a 2 in proper form for a comparison with a
to a printing position. fullword register, makes the determination. If the function
The Execute instruction is a very serviceable tool in the byte is not that produced from an asterisk, we Branch on
hands of a resourceful programmer, especially when it is used Not Equal back to AGAIN to repeat the whole process.
in a loop that deals with varying conditions. It is an unusual Otherwise we reach the normal exit from the program.
branching instruction that causes one instruction anywhere Figure 7-17 shows successive groups of output, based on
in a program to be executed out of sequence. Then, unless the input stream assembled with the program.
the remote instruction itself happens to be a successful
branch, the program continues with the next instruction
after the Execute. As we have seen, Execute can actually SMITH
modify the remote instruction before execution. It can DETROIT
specify length codes, immediate data, register operands, or J. C. JACKSON
whatever information goes into the second byte in the 1234 MAIN STREET
CHICAGO, ILLINOIS
format of the remote instruction. It does this by Or-ing
with the last eight bits of a register, which the programmer F. C. R. ANDERSON
553 MAPLE PLACE APARTMENT 5C
may use to store information, do arithmetiC, or whatever. WHITE PLAINS, NEW YORK
We will see further examples of the Execute instruction in
D. D. ADAMS AND FAMILY
the next two programs. 505 GRATHSON
We are now about ready to go back for another look at APT. 31
READING, PENN.
the input stream. To do that, register 3 must contain the
address of the next valid data character in the stream.
Register 4 contains almost what we need; it has the address Figure 7-17. Four names and addresses produced by the program in
of the dollar sign just prior to the next valid character. We Figure 7-16
Another example of the powerful combination provided by hexadecimal values from an EBCDIC chart. For the
the Translate and Test instruction with the Execute instruc- delimiters, a value of 1 is used for ablank, 2 for a comma, 3
tion is provided by a simplified version of part of the work for a plus sign, and 4 for a minus sign. When the program is
an assembler must do. executed, these values will be moved into position in place
We are given an input stream consisting of one type of of zeros in TABLE, which will then be in storage, and of
operand field in an assembler language program. The field course the values will be in the specified bytes before
that we shall process will always consist of two operands: execution of the TRT instructions.
the first will be a general register, the second a symbolic Following a procedure somewhat similar to that used in
address of not more than six letters. Relative addressing the name and address program of the preceding section, we
with either an increment or a decrement mayor may not be now place in register 3 the address of the leftmost character
included in the second operand. Accordingly, our field will of the stream. A Translate and Test will stop after two or
start with one or two decimal digits, a comma, and from three characters, depending on whether the register number
one to six letters. After the final letter there will be has one or two digits. We now compute in register 4 the
either: (1) a blank, or (2) a plus or a minus sign followed proper length code, either zero or 1, and use an Execute to
by from one to four decimal digits and a blank. carry out a Pack instruction that is stored at PCKINS. This
We are required to place the register number in REG as a remote PACK takes its second operand from the address given
binary number, to place the symbol in SYMBOL, and to in register 3, its length from register 4, and places the result in
place in INC DEC the increment or decrement as a properly WORK. The latter was set up as a doubleword, so we may
signed binary number. now do a Convert to Binary, placing the result in register 5
We are, of course, defining away a great deal of the from whence we store it in REG. The first required action
actual work of an assembler program, which must sort out is complete.
many different kinds of instructions and operands, and We are now ready to get the symbol, after some
errors too. preliminaries. When we have found the delimiter after the
The task of the Translate and Test Instruction this time symbol (a blank, a plus, or a minus), it will be necessary to
will be to detect the "delimiters" that separate one part of comput~ the length of the symbol. In order to be able to do
the operand field from another. The delimiters in the job as this later, we need now to put in register 3 the address of
we have defmed it are the comma, the plus sign or the the first character of the symbol. This can be done with a
minus sign, and the blank. These set off register from Load Address instruction using register 1 as a base and a
symbol, symbol from increment or decrement, and mark displacement of 1. The same scheme (base register 1 and
the end of the address. We will need a translate table with displacement of 1) gives the correct starting address for the
entries in the positions corresponding to these four Translate and Test instruction also.
delimiters. Once again, after completing the Translate and Test, we
The input stream begins at symbolic location COL16, a compute the length of the symbol and use an Execute, this
name chosen to suggest where the operand field might time to move the symbol from its position in the input
begin on a card, although we realize that, in the System/ stream to SYMBOL. When this has been done, we inspect
360 assembler language, it is not required to begin there. the delimiter. If it is a blank, signified by a function byte of
The program of Figure 7-18 begins by clearing to blanks 1 in the TABLE, we are fmished because there is no
the location set up for the symbol. This must be done increment or decrement.
because we do not know whether the symbols we shall find If it is not a blank, then it must be either a plus or a
will always have six characters; therefore, any previous minus, always assuming for this example that there are no
contents of SYMBOL must be erased. A similar consider- errors. If it is a plus, we place a 2 in register 6; otherwise a
ation applies to INCDEC. There may or may not be an zero. The purpose of this will become clear in a moment.
increment or decrement, hence we are required to place zero At NEXT we once again place the address of the next
there. It seems to be a little easier to clear INCDEC at the character in the stream in 3, this time to be able to compute
beginning and then to leave it zero, if nothing is placed the length of the increment or decrement. The next six
there, rather than to clear it later if necessary. REG need instructions are much as they were before, resulting in the
not be cleared; we will always place something there. value of the increment or decrement being placed in register 5
This time we construct the function table by entering a in binary. It will be positive; the sign was not included.
constant of 256 bytes of zeros in storage, and use the Move Now we come to an Execute instruction used in a rather
Immediate instruction to insert arbitrary values in the different way for a rather different purpose. We have
EBCDIC positions corresponding to the four delimiters. To specified register zero for the Or-ing, which means that the
find the correct positions, we need only read off the executed instruction is not modified. Then we have indexed
100 (8170)
t.he address of the instruction to be modified. We will INCDEC and our assigned task is completed; we have placed
therefore execute either the instruction at MININS, if register various parts of the operand in separate locations where they
6 contains a zero, or the instruction two bytes later, if can be separately addressed. In the real world of an
register 6 contains 2. The net effect is to do nothing to assembler, many more operations would have to be per-
register 5 if the sign is plus, and to make register 5 negative formed on this operand. Our small task of separating the
if the sign is minus. various parts of the operand would facilitate these further
Having done this, we store the contents of register 5 at operations.
1 PRINT OATA,NOGEN
000000 2 ASSMBLR START a
000000 05BO 3 BEGIN BALR 11,0
000002 4 USING *,11
000002 0205 BOAO BOB6 000.11.2 000138 5 MVC SYMI30L,BLANK CLEAR LOCATION FOR SYMBOL
000008 1922 6 SR 2,2 CLEAR REGISTER 2
OOOOOA 5020 BOM OOOAC 7 ST 2,INCDEC CLEAR SPACE FOR INCRE~ENT OR nECR
OOOOOE 9201 B10E 00110 8 MVI TABLE+X'40',X'Ol' INSERT NONZERO VALUES IN TABLE
000012 9203 BIIC OOllE 9 MVI TABLE+X'4E',X'03'
000016 9204 B12E 00130 10 MVI TABLE+X'60',X'04'
00001.11. 9202 B139 00 13B 11 MVI TABLE+X'6B',X'02'
0000 lE 5830 BaBE OOOCO 12 L 3, AC0116 PUT STARTING ADDRESS IN REG 3
000022 DDOE BICE BOCE 00100 00000 13 TRT (OLl6, TABLE LOOK FOR FIRST DELIMITER
000028 1841 14 LR 4,1 COMPUTF LENGTH CODE OF REG NUMBER
00002A 1B43 15 SR 4,3
00002C 5940 BOC2 000C4 16 S 4,ONF
000030 4440 B090 00092 17 EX 4, PCKINS PACK REG NUMBER AND PLACE IN WORK
000034 4F50 BOAE 000130 18 CVB 5,WORK CONVERT TO BINARY ANO PUT IN REG 5
000038 5050 BOA6 000.11.8 19 ST 5,REG STORE REG NUMBER IN BINARY
00003C 4131 0001 00001 20 LA 3, l ! 11 SET UP FOR NEXT TRT
000040 0006 1001 BOCE 00001 00000 21 TRT 1(7,11 ,TABLE LOOK FOR NEXT DELIMITFR
000046 1841 22 LR 4,1 COMPUTE LENGTH OF SYMBOL
000048 IB43 23 SR 4,3
00004A 51340 BOC2 000C4 24 S 4,ONE
00004E 4440 B096 00098 25 EX 4,MVCINS PLACE RESULT IN SYMBOL
000052 5920 BOC2 000C4 26 C 2,ONE WAS DELIMITER A RLANK
000056 4780 B08E 00090 27 BE OUT, . BRANCH IF SO
00005A 5920 BOCA oooce 28 C . 2,THRE,~ WAS DELIMITER A PLUS SIGN
00005E 4780 B068 0006.11. 29 BE' PLS BRANCH IF SO
000062 4160 0000 00000 30 LA 6,0 SET UP FOR LATER REMOTE INSTRUCTION
000066 47FO BObC 0006E 31 B NEXT
00006A 4160 0002 00002 32 PLS LA 6,2 SET UP FOR LATER REMOTE INSTRUCTION
00006E 4131 0001 00001 33 NEXT LA 3.1(1) SET UP FOR NEXT TRT
000072 0004 1001 BOCE 00001 00000 34 TRT 1(5,ll,TABLE LOOK FOR NEXT DELIMITER
000078 1841 35 LR 4,1 COMPUTE LENGTH OF INCDEC
00007A 1B43 36 SR 4,3
00007C 51340 BOC2 000C4 37 S 4.0NE
000080 4440 B090 00092 38 EX 4, PCKI NS THIS IS INCREMENT OR DECREMENT
000084 4F50 BOAE 000130 39 CVB 5,WORK CONVERT TO BINAqy AND PUT IN REG 5
000088 4406 B09C 0009E 40 EX O,MININS(61 COMPLEMENT IF SIGN WAS MINUS
00008e 5050 BOAA OOOAC 41 ST 5,INCOEC STORE RESULT
42 OUT EOJ PROGRAM TERMINATION
000092 F270 BOAE 3000 OOOBO 00000 45 PCKINS PACK WORK,0(0,31 EXECUTE INSTR ADOS LENGTH FROM REG 4
000098 0200 BOAO 3000 000.11.2 00000 4b MVCINS MVC SYMBOL(O'j ,0!31 DITTO
00009E 1155 47 MININS LNR 5,5
OOOOAO 1055 48 LPR 5,5
0000A2 49 SYMBOL OS CL6
0000.11.8 50 REG OS F
OOOOAC 51 INCOEC OS F
OOOOBO 52 WORK OS o
0000B8 404040404040 53 BLANK DC CLb' ,
OOOOBE 0000
ooooeo 00000100 54 AC01l6 DC A( COLlb)
0000C4 00000001 55 ONE DC F'l'
0000C8 00000002 56 TWO DC 1"'2'
OOOOCC 00000003 57 THREE DC F',3' .'
000000 0000000000000000 58 TABLE DC 25bX'OO'
000008 0000000000000000
OOOOEO 0000000000000000
0000E8 0000000000000000
OOOOFO 0000000000000000
0001B8 0000000000000000
0001CO 0000000000000000
0001C8 0000000000000000
000100 FIF1bBC1C2C3C4C5 59 COL16 DC C'11,ABCOEF+1234 '
000108 Cb4EFIF2F3F440
000000 bO END BEGIN
Figure 7-18. A program to break down the operands of an assembler language instruction into its constituent parts, using TRT and EX
The following illustrative program applies techniques that length provided that the frrst operand DESC in storage is
are highly useful in certain commerical applications, and one byte to the right of the second operand BLANK.
that the features of System/360 make particularly easy to Checking statements 50 and 51 of the assembly listing, we
accomplish. The task is the processing of blocked tape see that this is so.
records (that is, many logical records in one physical block) The Translate and Test instruction references a table in
with a variable number of records per block and with which the only nonzero entry corresponds to an equal sign.
variable-length records. We shall take a record layout, The effective address of the frrst operand in the Translate
furthermore, that places certain frxed-length items after the and Test is just the contents of register 7 because the
variable-length portion of the record. explicit displacement is zero. The length of 60 sets a limit
Each record in a block to be processed by the program on the search for an equal sign. If no equal sign is found
of this example will contain four fields, with characteristics within 60 bytes, the condition code will be zero; a Branch
as follows: on Condition transfers to an error routine if this happens.
We now are ready to move the description from its place
Field Length Type
in the block to the space from which it will be printed. This
DESC variable, at most 60 characters alphameric
can be done readily enough once we have available the
ACCT 7 characters alphameric
length code of the description. Register 1 after the
QOH 4 bytes binary
Translate and Test contains the address of the equal sign.
DOLL 4 bytes binary
Subtracting from this address the address of the frrst byte
The frrst field is a variable-length description of a stock of the description gives the length of the description in bytes;
item; it is alphameric and at most 60 characters. The next one less than this number is the length code of the
field is an account number, of exactly seven alphameric description. With this number in register 3, we can Execute
characters. The third field is four bytes long. It is a binary a remote Move Characters instruction that moves the
number giving the quantity on hand. The fourth and last description from the block storage area to a location from
field is also a four-byte binary number giving the year-to- which it can be printed.
date sales of the stock item to the nearest dollar. However Just before doing so, however, we have a Branch on
long the description may be, its fmal character is always an Minus instruction to detect a negative number after the
equal sign to serve as a sentinel marking the end of the computation of the length code of the description; this
variable-length portion of the record. There is an unknown would happen only if the first character of the· "descrip-
number of records. Immediately following the last record is tion" were an equal sign, which would signal the end of
another equal sign, which is the last character in the block. the block.
We are required to process such a block, which we Getting the account number from the block area to the
assume has already been read into core storage. We are to printing location is an easy matter. We know that the
set up a line for printing that contains the account number, account number begins one byte beyond the address of the
the quantity on hand, the sales, and the description, in that equal sign, which is contained in register 1. The effective
order. The numeric quantities are to be in zoned format. address of the account number is therefore just register 1 as a
After printing a line for each record in the block, we are to base with a 1 for displacement. The address of the quantity
print the total dollar sales from all records on a separate line. on hand is just eight bytes beyond the address in register 1.
The program is shown in Figure 7-19. After the usual Here we must be careful of word boundaries. The quantity on
preliminaries we clear register 4 and store the resulting zero hand was said to be a four-byte binary number, but,
in TOTAL in order to be sure that the accumulator for total because of the variable length of the description, it may not
sales is zeroed. Register 7 is next loaded with the address of be aligned on a word boundary in the block storage area.
the frrst character of the block; register 7 will always We therefore use a Move Characters instruction to move it
contain the address of the frrst character of the next record to a temporary storage area that is defmitely aligned on a
as the loop is repeated. The MVI instruction inserts a one in word boundary. TEMPI is on a word boundary because the
the equal sign position of our translate table. This will DS says so.
occur during execution, of course. Now this binary quantity can be loaded into a register
In the body of the loop we frrst blank out the space and converted to decimal in a doubleword. From here it is
assigned to the description because, in general, it will be unpacked to the location from which it will be printed,
possible for a long description to be followed by a short named QOH.
one; without a prior blanking, the end of the previous line The same sequence of operations gets the year-to-date
would still be there. The MVC instruction used here will sales into DOLL. Because the sales are still in register 4 in
blank out the DESC area for its entire 60-byte implied binary, they can be added to the total for the block.
102
lOC OBJECT CODE ADDR1 ADDR2 STMT SOURCE ST AT EMENT
000242 OOOOOOOOOOOCoOOO
00024A 0000000000000000
000252 0000000000000000
00025A 0000000000000000
000262 0000000000000000
000000 69 END BEGIN
Figure 7-19. A program to prepare for printing a series of variable-length blocked records, each consisting of four fields. Total dollar sales are
computed at the same time.
Edit, Translate, and Execute Instructions 103
This completes the actions needed to make our frrst line The sample block that appears at RECORD involves a
of information ready for printing, and we would normally little bit of trickery. One of the essential aspects of the
include a printer output routine at this point. There may assignment is that the binary fields appear in the block not
still be another record in the block, so we branch back to aligned on word boundaries. In real life such a block would
AGAIN to see whether there is. During execution, the have been set up by a previous program. Here, in attemp-
program will continue to go through the loop each time ting to set it up with DC entries, we run into the automatic
there is another record. After the final record, the equal boundary alignment that is normally performed on full-
sign delimiter that follows it will produce a result of -1 for words. This action can be overridden~ however, by specifying
the length-code computation, and this will cause the a length modifier. A length of 4 is, of course, the same as the
program to branch (on the Branch on Minus instruction) to implied length of a fullword; the whole purpose is to
our EO] macro at OUT. prevent boundary alignment.
104
QUESTIONS AND EXERCISES
For questions 1-6, show the c(;mtents of WORK after the that would be in bits 8-31 of general register 1 after execu-
execution of ED WORK,SOURCE. The characters in WORK tion of the EDMK instruction:
have the following meanings: a. PATRN
b. PATRN+1
Hexadecimal
c. PATRN+2
Character Meaning Equivalent
q. PATRN+3
B Blank 40
9. Does the ED instruction affect general register I?
S Significance starter 21
10. What would be in location AREA as a result of the
D Digit selector 20
fo1l6wing operations?
Comma 6B
Decimal 4B AREA DC X' 00020103'
C C C3 C3 TABLE DC C'ABCD'
R R D9 D9 TR AREA,TABLE
* * 5C a. ABCD
F Field separator 22 b.DBCA
c. DCBA
1. WORK BDDDDDDD
d. ADBC
SOURCE 0001540+
e. ACBD
2. WORK BDDDDDDDCR
11. What would be in general registers 1 and 2 as a result of
SOURCE 0005721+
the following operations:
3. WORK BDD,DDSDDBCR
SOURCE 0000001- AREA DC X' 00010203'
4. WORK BDDD,DDCR TABLE DC X'OOOOOlOO'
SOURCE 00000+ TRT AREA,TABLE
5. WORK BSD,DDDDDCR a. Address of AREA+3 and X'03' respectively
SOURCE 0000010+ b. Address ofTABLE+2 and X'Ol' respectively
6. WORK BDD,DDS.DDCRFDD,DDSDDBCR c. Address ofTABLE+3 and X'04' respectively
SOURCE 0010143-0000107- d. Address of AREA+2 and X'Ol' respectively
7a. Write a DC named PATRN to set up the editing pattern 12. Assume the following sequence:
for a 9-digit amount to be printed a~ follows:
CONI DC F'l 0'
BX,xxx,xxx.XXBBB (for a positive amount)
WORK DC CLI6'1234567899123456'
BX,xxx,xxx.XXBCR (for a negative amount)
AREA DS CL20
Insignificant zeros should print as blanks. However,
L 2,CONl
amounts less than one dollar must be punctuated with a
MVI AREA,C' 0'
decimal point.
MVC AREA+1(19),AREA
b. If SOURCE contains 00925OO01-and we execute
EX 2,MOVE
ED PATRN,sOURCE, what would PATRN then contain?
B ROU2
c. What would PATRN contain if EDMK instead of ED
MOVE MVC AREA(O),WORK
were the operation?
What will AREA contain after the instruction B ROU2 is
8. PATRN DC X'4020206B2020214B20204OC3D9'
executed?
EDMK PATRN ,sOURCE
13. What would AREA contain if the EX instruction were
Assume SOURCE contains 0123456-. Choose the address
EXO,MOVE?
Subroutines are an important element in programming. required in the main program. The open su brou tine is not
Storage space is conserved when a subroutine at one storage normally branched to but is inserted into the main program
location is branched to from many points in a main section and as such has little or no difficulty communicating with
instead of being inserted each time it is needed. Programming, the main program. The closed subroutine, which is the kind
compilation, and debugging time are conserved when an we shall investigate in this chapter, is included once in a
existing subroutine can be incorporated into a new program. program and in storage no matter how many times it is
A subroutine is a set of instructions that performs a branched to. Since the subroutine may be entered from
particular function. It may be used in more than one many points in the main program, communication of data
program or more than once within a .single program. teo the subroutine and of results back to the main program
Subroutines have been used in scientific programming for can be a problem unless standards are set.
many years. Common subroutines used are the sine, cosine, In this chapter we shall be concerned primarily with the
and square root functions. Subroutines have now become standards that have already been established for subroutine
equally important in commercial programming. In many communication. By demonstrating the techniques in actual
cases, a main program may be little more than a sequence program examples, we shall answer questions like:
of branches to subroutines, some of which may be used How does the subroutine know where to return in the
many times, some only once. When a long and involved main program?
program is to be written, it is frequently divided into a How does the main program pass data to the subroutine?
number of separate subroutines to be written by different How does the subroutine pass results back to the main
programmers. After the general plan is determined, each program?
part may be relatively simple to program, and a consider- How can one program reference areas in another pro-
able saving of time can be achieved. Each section can be gram that the assembler does not know about?
assembled and debugged independently. Much of the above is accomplished through register
Subroutines may be classified as either "open" or addressing. For the rest we will look to functions of the
"closed". An open subroutine is included each time it is assembler and the linkage editor.
The basic idea of a subroutine is to put it in storage at one an example. It is not our purpose now to explore new ideas
place, then branch to it whenever its function is needed. If in information processing, so we chose an unrealistically
we are using a square root subroutine, for instance, we put simple job for the subroutine to do: to double a number
it in one section of storage available for use as needed. by shifting it left one place. Communicating data and the
Then, at any point in the main program that we need to location of results between the main routine and the
take a square root, we branch to the square root sub- subroutine is handled easily by placing the number to be
routine, compute the square root, and branch back to the doubled in a register, in this case register 3, before the
point in the main program where we left off. branch to the subroutine, and leaving the doubled result in
This raises two questions: How does the subroutine register 3 on the return to the main program. Figure 8-1 is a
know where to return when its work is finished? How does listing of a single program consisting of a main, or calling,
the main program provide the subroutine with information routine and a subroutine.
on the location of the number to be processed and where The START, BALR, and USING instructions in Figure
the result is to be left? 8-1 are still necessary; they are unchanged by the fact that a
The question of where to return is answered by a linkage subroutine will be used. Next comes the first processing
that places in a register the address of the next instruction instruction of the main routine, to load register 3 with a
after the one that branches to the subroutine. In System/ number that is to be doubled by the subroutine. Register
360 we do this with the Branch and Link Register (BALR) 15 is then loaded with the address of the subroutine, using
instruction that we have seen so frequently for loading a an address constant, in preparation for branching to the
base register. But now we specify a second operand other subroutine with the BALR.
than zero, so that it really is a branch. The technique is to Address constants, a subject we have not so far encoun-
place in a register, usually 15, the address of the first tered, provide a means of communicating between separate
instruction of the subroutine. Then, if we have chosen parts of a program or between separately assembled
register 14 to hold the link, we write the instruction programs. We could have used other means in this single
BALR 14,15. When executed, this instruction places in assembly, but since address constants will appear throughout
register 14 the address of the next byte after the BALR, the rest of this chapter, they are well worth some study. An
and causes a branch to the address in register 15. At the end address constant (adcon for short) is a storage address that
of the subroutine it is merely necessary to specify an is translated into a constant. Unlike other types of DC's, it
unconditional branch to the address in register 14. This is is enclosed in parentheses. We are particularly interested
done with a Branch Register Unconditional (extended here in two types of address constants: A and V.
mnemonic BR). An A-type address constant may be absolute (its value
We can make these ideas much more clear by considering does not change upon program relocation) or it may be
1 PRINT NOGEN
000000 2 lINKl START 0
000000 05BO 3 BEGIN BALR lI,O
000002
5830
4
5
USING
L
*3,FIRST
011
FIRST NUMBER TO B~ DOUBLEC
000002 B022 OC024
000006 58FO BOlE 00020 6 L 15,ADSRI SUBROUTINE ACDRESS
OCOOOA 05EF 7 BALR 14.15 LINKAGE RETURN ADDRESS GOES INTO 14
OCOOOC 5030 B02A CCC2C 8 ST 3,Ar..;Sl RETURN POINT FROM SUBROUTINE
000010 5830 B026 OC028 9 L 3,SECOND SECOND NUMBER TO BE COUBLED
000014 5aFO BOlE C0020 10 L 15,ADSR1 SUBROUTINE ACCRESS AGAIN
000018 05EF 11 BAlR 14,15 LI NKAGE
OCOOIA 5030 B02E C0030 12 ST 3,ANS2 STORE SECOND RESULT
13 EOJ END OF JOB
000020 00000034 16 ADSRI DC A(SRII SUBROUTINE ACDRESS
000024 00000001 17 FIRST DC F' l'
OC0028 00000004 18 SECOND DC F'4'
De002C 19 ANS 1 OS F
000030 20 ANS2 OS F
21
22 * THI S IS THE END OF THE ~AIN PROGRAM
23
*• THE SUBROUTINE ~AV USE ITS OWN BASE REGISTER
24 WhICH ~UST BE LOADED Ar..;O IDENTIFIED
25
*
OC0034 05AO 26 *SR 1 BAlR 10,0
OC0036 27 USING ·,10
000036 8B30 0001 CCCOI 28 SLA 3,1 THIS IS THE eNLY PROCESSING INSTRUCTION
OOOOH 07FE 29 BR 14 UNCONDITIONAL BRANCH TO ~AIN ROUTINE
OCOOOO 30 END BEGI/\
Figure 8-1. Listing of a single program that consists of a main, or calling, routine and a subroutine. Standard linkage registers are used.
108
relocatable. The storage address is calculated by the assem- place, which doubles the number, and the processing is
bler and is stored in binary integer form. If no length is fmished. We are now ready to return to the instruction
specified, it is stored as a fullword, aligned to a fullword following the BALR in the main routine. This address is
boundary. We note that in statement 16 the object code for precisely what is in register 14 now, so an unconditional
the DC named ADSRI is 00000034. The operandisA(SRl); branch to the address specified in register 14 is the correct
the A stands for address and the SRI in parentheses is the return. The BR instruction is unconditional.
same as the label of the first machine instruction in the On returning to the main routine, we store the doubled
subroutine, which is at location 000034. number at ANS 1 and proceed to load another number into
A V-type address constant, which we shall see later, is register 3 for doubling by the subroutine. We again go
similar to the A-type, but it must be relocatable. It is used through the operations of loading register 15 with the
to reserve storage for the address of a symbol that is address of the subroutine and linking to it. Although it is
defined in a program or program segment external to the true that register 15 still has the address of the subroutine
program it appears in. During assembly the V-type constant in it from the last time, we prefer, even in this example, to
is given a zero value, and it is placed in the assembler's load it again as a matter of good programming habit.
external symbol dictionary, to be resolved later by the Figure 8-2 shows the values of FIRST, SECOND, ANSI,
linkage editor. and ANS2, in that order, after the execution of the
The BALR as written in statement 11 takes its branch program in Figure 8-1.
address from register 15 and places in register 14 the address
of the next instruction. The Branch and Link (BAL)
00000001 00000004 00000002 00000008
instruction can sometimes be used instead of BALR,
thereby avoiding the loading of a register before branching.
The restriction is that the address of the subroutine must be Figure 8-2. Values of FIRST, SECOND, ANS1, and ANS2, respec-
within the range of addresses of the current program base tively, after execution of program in Figure 8-1
register. This will not always be true, and will never be true
for separately assembled routines, as we shall discuss later. In Figure 8-3 we add a feature to the program. Shifting a
BALR is probably a good habit even when not strictly number left can, of course, result in loss of a bit from large
needed. numbers. Let us arrange things so that such a loss would be
We have now branched to the subroutine, which in this signaled back to the main routine as an error. Our method
highly simplified example consists of just one processing of signaling may be as follows. If such a loss of information
instruction. The contents of register 3 are shifted left one occurs, the subroutine would return to the instruction after
1 PRINT NOGEN
oeoooo 2 LlfIoK2 START a
000000 05BO 3 BEGIN BALR ll.O
000002 4 L:SING *.11
000002 5830 B02E eCC30 5 L 3.FIRST FIRST NUMBER TO BE DOUBLED
000006 5aFO B02A CC02C 6 L 15,ADSRl SUBROUTINE ADORESS
OOOOOA 05EF 7 BALR 14,15 LINKAGE-RETURN ADDRESS
OOOOOC 47F0 B026 00028 8 B ERROR ERROR RETURN
000010 5030 B036 CCC38 q ST 3,"'I'\SI RETURN POINT FROM SUBROUTINE
000014 5830 B032 CC034 10 L 3.SECOND SECOND NUMBER TO BE DOUBLED
000018 S8FO BOZA 0002C II L 15.ADSRl SUBROUTINE ADDRESS AGAIN
OOOOIC OSEF 12 BALR 14,15 LINKAGE
OOOOlE 47F0 B026 CCC28 13 B ERRCR ERROR RETURN
000022 5030 B03A CCC3C 14 ST 3,ANS2 STORE SECOND RESULT
15 EOJ PROGRA~ TERMINATION
18 ERROR E OJ ERROR PROGRAM TERMINATION
00002A 0000
ooonc 00000040 21 ACSRI DC AI SR I}
000030 00000010 22 FIRST DC F'16'
OC0034 7FFFFFFF 23 SECOND DC X'7FFFFFFF'
OC0038 24 ANSI OS F
00003C 25 ANS2 OS F
26 *
27 * TH IS IS THE EI';O OF THE ~AIN PROGRAM
28 * THE SUBROUTINE ~AY USE ITS OWN BASE REGISTER
29 * wHICh MUST BE LOADED AfIoD IDENTIFIED
30 *
000040 05AO 31 SR 1 BALR 10.0
OC0042 32 LJS ING *,lC
000042 8B30 oeOl COGOI 33 SLA 3,1 THIS IS THE ONLY PROCESSII';G INS TRUC TlON
000046 4110 EOOO CCCOO l4 BO 010,14) GO TO ERROR RETURN
00004A 47FO E004 CCC04 35 B 410,14} UNCONCITIONAL BRANCH TO MAIN PROGRAM
OCOOOO 36 END BEGIN
Figure 8-3. The program of Figure 8-1 modified to give the subroutine a choice between two return points
110
STANDARD LINKAGE REGISTERS
So far we have seen a typical subroutine linkage in action, stream immediately following the BALR. This is a point
with a variation that allows a choice between two return from which the subroutine can readily obtaillthem.
points. Communication of data and results between the Figure 8-5 illustrates the use of most of these techniques
main program and the subroutine was made easily because and includes a subroutine that averages a series of numbers.
the programmer knew which registers were used for what The main program stores two series of numbers as lists in
purpose in both. Supposing they had been written by consecutive full word locations. The average of each list is to
different programmers? be calculated and stored, so the subroutine will be used
To ease the problem of assuring proper communications twice and each time will return to different points in the
between program segments, which often are written by main program. To simplify the averaging routine, each list
different programmers, standard register assignments and begins with the total number of entries in the list. Each list
techniques have been defmed in each of the IBM operating is identified by its starting address. This address is to be
or programming support systems. (They are similar, but communicated to the subroutine, along with the address at
not identical, in all System/360 operating systems.) which the subroutine is to store the average.
Standard register assignments in the Disk Operating System There are several possible ways to give the necessary
(DOS) are shown in Table 8-1. The items in this chart will information to the subroutine. We chose one that is repre-
be explained in the following pages of text, as their use is sentative, using BALR and A-type address constants:
discussed. These registers are used for the purposes shown,
BALR 1,15 Link to subroutine
both by programmers and by the DOS macros. The DOS
DC A(LISTl) Address of first parameter list
macros for subroutine linking are CALL, SAVE, and
DC A(AVER 1) Address of second parameter list
RETURN.
The address of the fITst word of the list and the address at
Table 8-1. DOS Linkage Registers which the average should be stored will immediately follow
the BALR that branches to the subroutine. The subroutine
Register Register
Number Function Contents
will be required to pick up the information it needs from
this parameter list. It can fmd it because it will have the
o Parameter register Parameters to be passed to the address of the first word after the BALR in register 1,
su brou tine. loaded there by the BALR. Of course, prior to this we had
Parameter register Parameters to be passed to the to load the address of our subroutine entry point into
or su brou tine. register 15. This was done by use of the L?ad Address (LA)
Parameter list Address of a parameter list to be instruction. In addition the return address was loaded into
register passed to either the control pro- register 14. The return address must be carefully calculated
gram or a user's subroutine. to assure that the proper return point is stored. This address
13 Save area Address of the register save area is the current value of the assembler's location counter at
register to be used by the subroutine. the start of this instruction plus the length of the LA (4
bytes) plus the length of the BALR (2 bytes) plus the
14 Return register Address of the location in the
main program to which control length of the two address constants (8 bytes). This could
should be returned after execu- also have been accomplished by labelfug the return point
tion of the subroutine. and using that in a Load Address instru_ction. In any case,
15 Entry point Address of the entry point in the
after we branch to the subroutine, register 1 contains the
register subroutine. address of the flIst DC in the parameter list.
What about register 13, and what is a "save area"?
Usually the subroutine will need to use the same registers
Let us examine the standard linkage registers. We have that are used in the main program, but for different
been using register 14 for the return register and register 15 purposes. The main program may use the registers for base
for the entry point register. Data may be passed to a sub- addresses, index addresses, intermediate results, or other
routine using registers 0 and 1. However, a more common data vital to the main program. To keep this data from
practice is to use register 1 to hold the address of a parameter being destroyed by the subroutine it has become conven-
list, because we usually have more data than will fit in two tional to store the contents of these registers in an area
registers. (The expression "parameter list" merely signifies a called a save area and defined by the main program. This
list of numbers of any desired value.) The parameter list area is 18 words ill length in most System/360 systems and
may consist of either data or the addresses of data. its address is stored in register 13 prior to branching to the
Addresses are used more often so that data of varying subroutine. It is aligned on a doubleword boundary. In a
lengths can be handled easily. One common technique is to standard save area, word 1 is used only by PL/I. Words 2
write the data and/or data addresses in the instruction and 3 are used to trace subroutines that are branched to by
Subroutine Linkages and Program Relocation 111
LaC OBJECT CODE ADDRI ACDR2 STMT SOURCE STA TEMENT
1 PRINT NOGEN
000000 2LlNK3 START 0
OCOOOO 0580 3 BEGIN BALR 11,0
00C002 4 USING *, II
000002 4100 B086 COC88 5 LA 13, SAVEARE A ADDRESS OF SAVEAREA
000006 6 CNOP 2,4 CONDITIONAL NO-OP FOR ALIGNMENT
000006 41FO BoeE 00000 7 LA 15,AVER BRANCH ADDRESS
OCOOOA 41EO B016 CC018 8 LA 14,*+14 RETURN ADDRESS
OOOOOE OSH q BALR l,1S LINK TO SUBROUTlNE
000010 0000004C 10 DC AILISTlI ADDRESS OF FIRST PARAMETER LIST
OCOO14 0000007C 11 DC A(AVER11 ACCRESS OF RESULT
000018 S860 803E CC040 12 L 6,A GTHER PROCESSING
0000lC 51160 B042 oe044 13 A 6,B X
000020 S060 8046 00048 14 ST 6,C X
000024 41CO B086 CC088 15 LA 13,SAVEAREA ADDRESS OF SAVEAREA
OC0028 0700 16 CNOP 2,4 CONDITICNAL NO-OP FOR ALIGNMENT
00002A 41FO BOCE COCDO 11 LA lS,AVER
00002E 41EO B03A C003C 18 LA 14,*+14 RETURN ACDRESS
000032 051F 19 8ALR 1,15 LINK TO SUBROUTlNE
OCOO34 00000060 20 DC A(lIST21 ADDRESS OF SECOND PARAMETER LIST
0000~8 00000080 21 DC AIAVER21 ADDRESS OF RESULT
22 EOJ PROGRAM TERMINATION
00003E 0000
OC0040 00000038 25 A DC F'S6'
OC0044 00000040 26 B DC F'77'
000048 27 C OS F
00004C 00000004 28 LISTl DC F'4' NUMBER OF ENTRIES IN LIST 1
OCOOSO OOOOOOOA 29 DC F'10'
OC0054 oooeoooc 30 DC F'lZ'
oe0058 00000013 31 DC F'19'
OC005C OOOOOOOF 32 DC F'15'
000060 00000006 33 lIST2 DC F'6' NUMBER OF ENTRIES IN liST 2
OC0064 OOOOOOOB 34 DC F'll'
000068 00000002 35 DC F'2'
OCOO6C 00000004 36 DC F'4'
000070 FFFFFFFD 37 DC F'-3'
OC0074 00000005 38 DC F'5'
OC0078 FFFFFFFF 39 DC F'-l'
oooon 40 AVER 1 OS F
oe0080 41 AVER2 OS F
000088 42 SAVEAREA OS 90
43 *
44 THE E~O OF THE MAIN PROGRA~
45
*
46 *
AVER SAVE (14,121 SAVE REGISTERS
000004 0590 49 BALR 9,0
oeOO06 50 USING *,9
000006 5851 0000 OOCOO 51 L 5.0111 STARTING ADDRESS
OOOODA 4160 0004 00C04 52 LA 6,4 INCREMENT
OCOOCE 5845 0000 cecoo 53 L 4,0(51 NU~BER OF ENTRIES
CUOOE2 1874 54 LR 7,4 Nu~BER OF ENTRIES
CCOOE4 8H70 OC02 ce002 55 SLA 7,] FOUR TIMES NUMBER OF ENTRIES
OOOOE8 lA75 56 AR 7,5 LIMIT
OOOOEA 5B70 903A 00110 57 S 7,=F'I' REDUCE BY 1 SO LOOP WILL NOT REPEAT
OCOOEE 1822 58 SR 2,2 CLEAR TO ZERO
OOOOFO lBB 59 SR 3,3 CLEAR TO ZERO
OOOOF] 5A35 0004 eee04 60 LOOP A 3,4(51 ACD A VALUE FROM THE LIST
OOOOF6 R756 90lC CCOF2 61 BXLE 5,6,LCOP
OOOOFA 1D24 62 DR 2,4 DIVIDE BY NUMBER OF TERMS
OOOOFC 5851 0004 00C04 63 L 5,411) PICK UP ADDRESS OF RESULT
OCOIOO 5035 0000 oecoo 64 ST 3,0(5) STORE RESULT
65 RET UR N (14, 12 I RETURN TO THE MAIN PROGRAM
000000 69 END BEGIN
000110 00000001 70 =F'1'
Figure 8-5. A program with a subroutine that averages a series of numbers. The subroutine will be used twice and will store the results at
AVERI and AVER2.
subroutines. Word 2 is the save area address of a preceding of the registers in the save area. This is accomplished through
rou tine. Word 3 is the save area address of a succeeding the use of the SAVE macro in DOS, or by regular assembler
routine. Words 4-18 are the contents of registers 14-12, language Store instructions in systems where this macro is
respectively-that is, all the general registers except register not available. Register 14 is specified as the first register to
13. be stored, and all additional registers are stored simply by
Note that early in the main program after the usual specifying the last register to be stored. Thus the registers
preliminaries, we load register 13 with the address of the are stored in the order 14, 15, then 0 through 12. The
save area. Then follows the CNOP (which we will discuss instruction generated by the SAVE macro is STM 14, 12,
later on), and the loading of the entry point and return 12( 13). Therefore the registers are stored in the save area
addresses. In the subroutine we begin by saving the contents (its address is designated by the contents of register 13)
112
starting at a point that is twelve bytes past the beginning of To compute the average, which is simply a matter of
the area (we recall that the flIst three words of the save area dividing the contents of registers 2 and 3 (the sum of all the
are reserved for other data). Now the subroutine can use numbers in the list) by the contents of register 4 (the number
the registers for its own purposes and, when its processing is of entries in the list), a Divide Register instruction (DR) is
fmished, can restore the registers to their status when the used. The quotient is the average, which is in register 3. We
subroutine was entered. This entire procedure is nonnal are now ready to store the average; where does it go? The
practice; it can almost never be assumed that any registers answer is to be found by looking at the fullword address
are available to the subroutine unless their contents are flIst that is four bytes beyond the address specified by the con-
saved. tents of register 1; the address of the average is placed in
Let's proceed with the work performed by the sub- register 5 by the Load. A Store instruction using this
routine. Statement 51 gets the address of LIST 1 by a Load address now completes the work of the subroutine. By use
instruction in which the effective address is simply the con- of the RETURN macro, we restore the registers that had
tents of register 1. After execution of this LOAD, the been saved and branch back to the main routine.
address in register 1 (OOOO4C) is placed in register 5 for The RETURN macro is coded identically to the SAVE
subsequent use. Stepping through the list will be done with macro, that is, th~ operands are the starting and ending
a Branch on Index Low or Equal instruction (BXLE), so we registers to be restored, RETURN 14,12. It restores the
proceed to set up the other parameters required. Register 6 saved data to the specified registers and returns to the main
is accordingly loaded with a 4, the increment between loca- program via the return address in register 14. The coding
tions that must be added on each repetition of the loop. generated by the RETURN macro isa Load Multiple (LM)
With register 6 containing the increment, register 7 must instruction and an unconditional branch.
contain the final address, that is, the starting address plus Back in the main routine, we do some simple processing
four times the number of entries. using register 6. We can use the same registers as w~ used in
We load register 4 with the number of entries, which is the subroutine because the SAVE and RETURN macros
the flIst full word in each list. It is to be left in register 4 for allow each section of programming to view the registers as
computing the average later. For purposes of controlling their own.
the loop, we move it to register 7, shift left two places (in We then wish to average another list, LIST2. At statement
effect multiplying by four), and add the starting address. 15, note that we must again place the address of the save
Since the BXLE will repeat the loop on an equal, we must area in register 13 because we must enter the subroutine
now reduce the value in register 7 by 1, using the literal again. The execution of the subroutine follows the same
tenn =F' l' to introduce the value one. After clearing lines as before, although this time it operates on different
registers 2 and 3, we are ready to go into the loop. data and places the result in a different place.
A literal tenn in assembler language is a way of intro- The CNO~ assembler instruction, which we have not dis-
ducing data into a program in a machine instruction, and is cussed so fai~ appears twice in the main program during the
(in that one sense only) like immediate data in an SI preparations for each branch to the subroutine. The func-
instruction. It is simply a constant preceded by an equal sign. tion of the CNOP (Conditional No-Operation) is to make
It represents data rather than a reference to data. It can be sure that the two address constants appear in storage
used to enter a number for calculation, an address constant, immediately after the BALR.
or words or phrases for printing out a message. Unlike If the instruction before the BALR ended on a fullword
immediate data, a literal term is not assembled into the boundary, the BALR (a two-byte instruction) would then
instruction in which it appears. The assembler generates the occupy the flIst two·bytes of the next word. The assembler,
values of all literals in a program, collects them, and stores automatically aligning on a fullword boundary an A-type
them in a "pool," usually at the end of the program. Their constant for which no length is specified, would skip two
addresses, rather than their values, are assembled into the bytes before locating the constant. Then, when the BALR
instructions in which they are used, and so literals are is executed, register 1 would contain the address of the
considered relocatable. byte following the BALR instruction, but this address
The Add instruction at LOOP uses as its address the would not be correct for the parameter list.
contents of register 5, which is the index register for the loop. Before reaching the BALR we write the instruction CNOP
The address in register 5 is adjusted by 4 so that we will 2,4. If the assembler's location counter is already set to a
address the first number to be averaged rather than the value that is two bytes greater than a fullword boundary,
number of entries. Between loop repetitions, register 5 is the CNOP is ignored, as is the case in statement 6. If not, as
incremented by the contents of register 6, which we set at 4. is the case in statement 16, the assembler inserts a Branch
Each time register 5 is lower than, or equal to, register 7 on on Condition (BC) instruction with a mask of zero, which
comparison, we will branch back to LOOP. The looping stops never causes a branch and therefore is equivalent to a "No-
when all entries in the list have been added to register 3. Operation". It occupies two bytes and thus causes the para-
114
PROGRAM RELOCATION
In an operating system environment, a program must be the programmer by use of the START statement or another
processed by the linkage editor program before it can be assembler instruction called CSECT. A program may consist
executed. During the process it is usually relocated, that is, of one control section or many control sections.
assigned a starting location in main storage other than the In an operating system environment, an object module
locations assigned during assembly. Most programs a:r;e run has two major characteristics:
more than once. A standard subroutine may be stored in a (1) It is relocatable. This means that all address constants
part of the system library in relocatable form and be used are in a form that can be modified to compensate for a change
very frequently. A different core location may be assigned in the starting location.
each time. We know that the storage location indicated by the (2) It is not executable.
START assembler instruction is tentative. The locations The object module may call for other object modules
calculated by the assembler merely establish the relative assembled at other times and stored in the system library in
storage locations of data and instructions within a program. relocatable form. Programmers frequently indicate standard
Most programs are assembled relative to zero, but are never I/O or other object modules to be included as subroutines
executed there because of restrictions on the use of lower in a new program. This is perfectly feasible. The linkage
core. System/360 was designed to run under a control pro- editor, which is a service program, will fmd all required
gram, and, under operating conditions, part of the control modules, process one after the other, and combine them
program is always resident in the low region of main storage into a single, executable load module (or program phase, as
for handling interruptions, error recovery routines, etc. In it is called in some systems).
many systems this occupies several thousand bytes. In Chapter 1 we described the output of the assembler
Problem programs must be executed beyond this area. program. The major items of input to the linkage editor
Relocation is necessary for a number of other reasons program are the object code (or text), the external symbol
not of direct interest to the programmer. These are (1) the dictionary (ESD) , and the relocation dictionary (RLD).
overall storage requirements of other programs that are to (Linkage editor control cards are also included, but will not
go into core at the same time and (2) various operating be covered in this book.)
considerations dependent upon the type of installation, The text consists of the actual instructions and data fields
operating system environment, etc. of one or more control sections in the module. The diction-
aries contain the information necessary for the linkage
The Linkage Editor editor to resolve references between different modules.
When the capabilities of the linkage editor are added to F or each control section in an assembly, the ESD contains
program relocatability, great programming efficiency can be its length in bytes, assembled address, and any name given in .
achieved by dividing a large program into separate sections the START or CSECT statement. Also included is infor-
for coding. Each section can be written by a different mation about any V-type address constants, external
programmer and compiled and checked out separately. It is references (a linkage symbol used in this control section but
even possible to code some of the subroutines in a different defmed in another), and entry points (a linkage symbol
programming language. Each part of the programming defmed in this control section but used in another).
operation is greatly simplified. Time is saved by having The relocation dictionary contains all address constants
several people work independently and simultaneously on that appear in an assembly. RLD information includes (1) the
the program. When all the routines have been compiled, control section in which the adcon is used as an operand, (2)
they are in relocatable form and can be link edited in any the control section in which it is defmed, (3) whether it is a
sequence. The linkage editor will assign storage locations V-type or other type, (4) how long it is, and (5) the assem-
and match up all address references between the routines, bled address where it is stored.
so that the entire program can be executed correctly as one The linkage editor, working under control of the job
program. If it should be necessary to correct a routine, only control program, builds up composite dictionaries of the
that one routine would have to be reassembled or recom- ESD and RLD data found in the object modules. It resolves
piled and then link edited again with the other routines. all linkages between different control sections as if they had
This facility also makes it relatively simple to maintain a been assembled as one object module. It relocates each con-
large program that may have to be updated from time to trol section as necessary and assigns the entire load module
time. (or program phase) to a contiguous area of main storage. It
The output of the assembler (or any language translator) is adds the relocation factor to the location given by the
called an object module. It may consist of a single program or assembler's location counter at the start of each assembly.
many. We should perhaps use the more exact term control I t modifies all relocatable address constants to contain the
section. A control section is the smallest separately reloca- relocated value of their symbols. (Except for adcons, no
table unit of a program. It is an entity declared as such by address values within the instructions and data fields are
1 PRINT NOGEN
2 ENTRY AVER
OCOOOO 3 L1NK4 START 0
000000 05BO 4 BEGIN BALR 11 ,0
000002 5 uSING *,11
000002 41DO B08E CC090 6 LA 13,SAVEAREA ADDRESS OF SAVEAREA
7 CALL AVER,(LIST1,AVERl) LINK TO SUBROUTINE
000018 5860 B046 CC048 14 L 6,A OTHER PROCESSING
OOOOlC 5A60 B04A ce04C 15 A 6,B X
OC0020 5060 B04E cee50 16 ST 6,C )(
Figure 8-7. A slightly different version of the program in Figure 8-5, modified by use of two macro instructions, CALL and PDUMP
116
the same. As our program example is organized, the macro addresses. BEGIN will give us the beginning of the program,
requires (1) the symbolic address of the entry point and BEGIN+200 is more than enough space to take us
(AVER) as operand, which generates a V-type address through to the end, as we know from the previous assembly
constant, and (2) the separate ENTRY AVER statement. of a similar program. Execution of the PDUMP macro will
Since this is not a typical example of the ENTRY assembler make no difference in execution of the program; processing
instruction, it would be preferable to wait for the next will continue with the next sequential instruction. (Some
program example before discussing it. The addresses of the other types of dumps result in termination of the program.)
parameter lists also appear in the operand field of the
CALL macro, in parentheses, and will be in register 1 (the Reading a Dump
parameter list register) when the called subroutine is entered. Figure 8-8 shows the entire dump that was printed out (this
The first three literals that appear at the end of the is done by a line printer) during the first execution of the
assembly appeared in the instructions generated by the program in Figure 8-7. After ass~mbly the program was link
PDUMP and CALL macros. As it was written, the CALL edited, loaded at 3000, and executed almost to the end.
generates a V-type address constant rather than the A-type. The point at which we see the dump is immediately after
We note that zeros and not the address of AVER are assem- execution of the PDUMP macro. The EOJ macro instruc-
bled in statement 80. This address will be supplied later by tion has not yet been reached.
the linkage editor. A hexadecimal format is used because it represents the
Our plan for the program shown assembled in Figure 8-7 is binary contents exactly. The contents.of all the registers are
to have it link edited, and, using linkage editor control cards, shown at the top of the printout. General registers 0-7 are
have it loaded and executed first at storage location 300016 , in the first line, and 8-15 in the second, a fullword each.
and then at 400016 • Re-assembly is not necessary. The linkage The doubleword floating-point registers 0, 2, 4,. and 6 are in
editor can override these cards, but will accept the instruc- the third line.
tions if they do not create a problem. Normally the Next comes the hex dump of main storage. The Six-digit
programmer is not involved in the question of where a pro- column at the left shows the storage location of the first
gram is to be loaded. The storage area from which a program byte in each line. There are 2016 (or 3210 ) bytes to a line,
executes is properly an operational, not a programming, divide4 into fullwords. Locating an address is simplified by
decision. the wide space in the center of each line; the next byte
The DOS PDUMP macro causes the system, during pro- after this space is simply hex 10 beyond the location in the
gram execution, to print out a hexadecimal dump of all the lefthand column. For example, in the line that begins at
registers and any particular area of storage we are interested 003020, the BO in the fifth fullword is at location 003030.
in. Such a dump is often used for program checkout, and The last two bytes in this line are at 00303E and 00303F.
learning to read one is a worthwhile exercise. We decide we The entire storage area shown is from 003000 to 0031FF,
want to see the state of affairs in storage at just the point since the boundaries given in the PDUMP macro were
when all calculations have been executed and the results BEGIN and BEGIN+X'200'. Printing of repeated lines of
stored, so we insert the PDUMP just before the EOJ. It will zeros at the end is suppressed.
be reached just once, after the second execution of the At the extreme right, any alphameric characters in a line
subroutine. are also represented in characters. In many cases this is very
The programmer must supply two address expressions in
helpful in interpreting the hexadecimal material and speeds
the operand field of the PDUMP to show the beginning and
up analysis of a dump. It is not particularly useful in our
end of the storage area wanted. One or both of the
program, however, so the characters will be omitted to let
addresses may be given in registers, but, since we want a
us get a closer look at the hex. The reader may wish to arm
dump from two different core locations, we use symbolic
003000 05B04100 B08E58FO B12641EO B016051F OC003054 00003084 5860B046 5A60B04A ••••••• 0 •••••••• .......•. - ...- ..
003020 5060B04E 4100B08E 070058FO B12641EO BC3A051F 00003068 oe003088 4110B116 &- ••••••••• 0 ••••
003040 4100B11E OA020AOE 00CCC038 00000040 C0000085 00000004 OOOOOOOA OOOOOOOC
003060 00C00013 OOOOOOOF 00000006 OOOOOOOB 00000002 00000004 FFFFFFFO 00000005
003080 FFFFFFFF OOOOOOOE 00000003 OOOOOCOO OCOOOOOO 00000000 00000000 0000303C
0030AO 00003008 00003000 60003034 OOOOFFFF OC002800 0000FF84 FFFFFF7C 00000085 ••• Q•••• - ••••••• ••••••••••• i ••••
0030CO 00002798 00004142 OA0407F1 00002810 40003002 00003698 90ECOOOC 05905851 ••••••••••• 1 ••••
0030EO 00004160 00045845 00C01814 8B700002 1A755B70 904E1B22 IB335A35 00048156 •• $ •••••••••••••
003100 901C1024 58510004 50350000 98Ecoeoc 01FEOOOO COOOCOOO 5B5BC207 C4E40401 •••••••• &••••••• •••••••• SSBPDUMP
003120 00003000 00003200 00003008 OOOOOCOI oeoeoooo 00000000 00000000 00000000 ••••••••••• Q••••
003140 00000000 --SAME--
0031EO 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 .............•..
\
Figure 8-8. Hex dump of registers and storage produced by execution of the PDUMP macro in the program in Figure 8-7. At right, EBCDIC
characters are represented by characters.
GR 0-7
GR 8-F
!
t
00003120\ 00003118 OCOOFFFF 0000.2800
000041421 OA0407Fl OCCC2810 4~~~
I CCOOFF84 fFFFFFIC
CC003698 e C03 9 a 0 0
OQOO~Q!J00002798
30 8
F P REG I 443lF8001 8F5C28F5 443IF800 8F5C28F5 4 752F lEa 6828F5C 1 02000000 80000000_/ sr CALL
003000 \Cj"S'"e:g41DOll BO 8 El?'8FOB.iT264HtO--fro.~r6051
1=----0 CC'03054 ®Jt[l9~ 5 A60 B04 A- 2ND CALI..
003020 'S-060B04E 4100B08E([[Q..C·5"8Fo.....Brnm~3A051F O~06B 4110B116
001040 4100BIIE OA020AOE OCCCC038 00000040 CC000085 4OOOOOOOA OOOOOOOC
003060 ooeooo 13L9~2..9_9.__0_2_9 ----,- - 00ceOC08 occoe002 06-000004FFFFfFfo 00000005
003080 FFFFFFFF~OOOOOO OOOOOCOO ocooceoo 00000000 00000000 0000303C
0030AO 00003008 olloo3000"""60003034 OOOOFFFF 'f CCC02800 0000FF84 FFFFFF1C 00000085
0030CO 00002798 00004142 OA04C7F1 00002810 ( 40C03002 0000369~890ECOOOC 05905851
OOlOEO 00004160 C0045845 00001874 1 8B700002 1A755B70 904EIB2 IB335A35 00048756
003100 901CID?4 S8S1000~ S03soooo198ECOOOC 07FEooeo OOCOOOOO 5B5BC201 C4E40401
003120 .l2:CJ::q2~~!f6-<[:E(rqp3T(fo~r(rOQ..()30oJtI OOOOOCO 1 oeoooooo OOOOCOOO ceooocoo 00000000
003140 i 00000000 --SAME-- \ i
Figure 8-9. Hex dump of the program (Figure 8-7) loaded at 3000
i
GR 0-7 0000412 0 00004118 OOOOFFFF
GR 8-F . 0000414210A0407F1 00002810 It~02
OOOOFF84
00003698 ;~:~::~ 0
O;'Qoo~
40
000027= )
0«0040Q..~Y
FP REG l 3f28F5C21! 8F5C28f5 3F28F5C2 8f5C28f5 49078C88 02000000 80000000 Isr CALL
00000000
! 07FEOOOOloOOOOOOO 5B5BC207 C4E40407
OOOOOOOO!OOOOOOOO 00000000 00000000
I
00000000\00000000100000000 00000000
1
1
t . , I I
2 AlJCONS A DCON UST2 START OF LIST 1 START OF S{J8RO{JTlNE-
= A (8€GIN) ::.I/(AVER) SAVE AREII THIS IS lOCATlON4008
= A (lI£GINt- X '200,)
Figure 8-10. Hex dump of the program (Figure 8-7) loaded at 4000
118
updated to the next available byte, 3002) into register 11 storage area that is used during a program will be the result
for use as a base address. We see that 3002 is still in register of the last processing in it before execution of the PDUMP.
11. (System/360 uses the rightmost 24 bits of a register for To check on the matter of maintaining linkages when a
its addressing scheme and ignores the leftmost byte. The 40 program is relocated, let's look at registers 11 (the base
here has no effect.) register), 14 (the standard return register), and 15 (the stan-
Next the LA (41DO B08E) puts the address of dard entry point register) in both dumps. These are different
SAVEAREA into register 13. This address in the instruction by the amount 1000, the difference between a relocation
is in the form of a base register and displacement. Will it be factor of 3000 and one of 4000. We also note that,
correct now that the program has been relocated? The beginning at word 4 in the save area (this program does not
address is arrived at by adding 003002 (the contents of base use words 1,2, and 3), we have the contents of registers 14,
register 11) and 08E (the displacement) = 003090. The 15, and 0 through 12 as they were in each case when the
assembly shows 000090 for SAVEAREA, and we shall see SAVE was executed. The code and data produced by the
that this is where the SAVE macro stores the contents of CALL macro can be checked fairly closely by going back to
the registers. the assembly of the program in Figure 8-5. In this program
Skipping the CALL, the next instruction (5860B046) the CALL generated a V-type address constant for the
loads the value of A into register 6. It looks for A in location address of the subroutine, and it was assembled as 000000.
003002 + 046 = 003048. In the assembly, at 000048, we have The linkage editor supplied the values 30D8 and 40D8 from
a DC named A for a fullword of decimal value 56 (this is calculations on ESD and RLD data (although, as we know,
hex 38), and that is the value at location 003048 in the a V-type adcon is not really necessary in a single assembly).
dump. Continuing in the same fashion with t.Ite next The PDUMP generated two A-type adcons, and the linkage
instruction (5A60B04A), we see that B (7710 or 4D 16 ) is editor supplied their new values simply by adding the relo-
added to A in register 6. The total in register 6, which is not cation factor (3000 and 4000 in these examples) to the
affected by any later instruction, is 85. This is the hex assembled values.
equivalent of decimal 133, and it is correct. The next We may also see, from a comparison of the instructions
instruction (5060B04E) does indeed store the total of 85 in and data constants in both dumps, that the linkage editor
C, location 003002 + 04E = 003050. where a fullword was does not change any assembled object code except for relo-
reserved by aDS. cat able address constants. To fmd a storage address, the
In this way it is entirely possible to follow the workings CPU simply uses a base-plus-displacement calculation. No
of a program. Registers that are not used in a program may matter where in main storage a program is loaded, the
have values left over from previous runs-the floating-point relative locations of elements within the program always
registers here, for example. The contents of any register or remain the same.
The preceding examples have shown how it is possible for a We seem to need some way to say to the assembler:
program to keep track of addresses within itself during pro- "AVER is a symbol that is used in this program but defined
gram relocation. We now tum to the important related elsewhere. Whenever you find the symbol AVER, which
question: how do two programs that are assembled separ- will be only in address constants, assemble zeros and mark
ately keep track of addresses in each other, even if they are the location as one that will be supplied during the link
both relocated by different amounts? editing of the object program".
Let us investigate this question in terms of the program This is precisely what the assembler instruction EXTRN
in Figures 8-5 and 8-7. This time we shall assemble the main does. We place the EXTRN at the beginning of the pro-
program and the subroutine separately. This method allows gram, identify AVER in the operand field, and leave the
subroutines, written and tested separately, to be used in pame field blank. This will cause the action outlined above.
any program. Out of the two assemblies we shall get two The symbol AVER will then be treated, not as an unde-
object programs which we wish to be able to load at the fined symbol, but as an external symbol defined outside
same time, relocating them by different amounts, and have this program.
everything work just as it did before. Once again, we shall Figure 8-11 is the assembly listing of the main program.
use AVER as the entry point into the subroutine, but this It includes the CALL macro instruction the same as before.
time the assembler will have no way of knowing its assem- An assembler TITLE instruction has been used in order to
bled location. In the single assembly in Figure 8-5, when we get identification (in this case, MAIN) into the object deck
wanted to load the address of AVER into register 15, the in columns 73-76, thus distinguishing this object deck
assembler simply calculated a base-plus-displacement from others. Just before the START is the EXTRN.
address. If we were to take the main program part of Figure Nothing is printed on the program listing to describe the
8-5 and assemble it, AVER would be an undefined symbol, action of the EXTRN. What it does is to cause an external
and the assembly could not be completed. reference to be listed in the assembler's external symbol
2 PRINT NOGEN
"3 EXTRN AVER
000000 4MAINl START a
oeoooo OSBO 5 BEGIN BALR II ,0
oeOO02 6 USING *,11
000002 4100 B096 00098 7 LA 13,SAVEAREA ADDRESS Of SAVEAREA
8 LOAD SUBR
14 CAll AVER,ILIST1,AVER11 LINK TO SUBROUTINE
000020 5860 B04E 00050 21 L 6,A OTHER PROCESSING
000024 SA60 BOS2 ocasio 22 A 6,B X
000028 5060 BOS6 ceOS8 23 ST 6,C X
00002C 4100 8096 00098 24 LA l3,SAVEAREA ADDRESS OF SAVEAREA
25 CALL AVER,ILIST2,AVER21 LINK TO SUBROUTINE
32 PDUMP BEGIN,BEGIN+X'200' CUIoIP ROUTINE
37 EOJ PROGRAM TERMINATION
000050 00000038 40 A DC F'S6'
000054 00000040 41 B DC F'77'
oeCOS8 42 e OS F
oooose 00000004 43 llSTl DC F'4' NUMBER OF ENTRIES IN LIST 1
000060 OOOOOOOA 44 OC F'lO'
oe0064 OOOOOOOC 45 DC F'12'
oe0068 00000013 46 DC F'19'
00006C OOOCOOOF 47 DC F'lS'
OC0070 00000006 48 II S T2 DC F'6' NUIoIBER OF ENTRIES IN LIST 2
oe0074 OOOOOOOB 49 DC F' 11 '
OC0078 00000002 SO DC F'2'
oe007C 00000004 51 DC F'4'
000080 FFFFFfFD 52 DC F'-3'
oe0084 00000005 53 DC F'S'
oe0088 FfFFFfFF 54 DC F'-I'
OC008C 55 AVERl OS F
000090 56 AVER2 OS F
000098 57 SAVE AREA OS 90
58 *
59 * THE END OF THE MAIN PRCGRAM
60 *
000000 61 END BEGIN
OOOOEO E2E4C2C940404040 62 =CL8'SUBR'
OCOOES 5B5BC2C7C4E4D407 63 =CL8'SSBPDUI1P'
OOOOFO 000eoooOOOC00200 64 =A(BEGIN,BEGIN+X'200')
oeoore OOOOOOCO 65 =V(AVER)
Figure 8-11. The same main program assembled separately. The EXTRN assembler instruction and the LOAD macro have been added.
120
dictionary. When the linkage editor encounters the named tains a symbol defmed in an unnamed control section~ but
symbol in another control section, it will resolve the ESD the (DOS) linkage editor cannot process the resulting deck.
item. It happens that the V-type address constant Except for the LOAD macro in the main program and
=V(AVER) generated by the CALL macro is also entered in another PDUMP in the subroutine, the balance of the two
the ESD (and the relocation dictionary), so we have some programs in Figures 8-11 and 8-12 is the same as before.
duplication of effort here. Normally, with an EXTRN The subroutine, we recall, is to be entered twice. The
statement, we would set up the linkage through use of an LOAD macro was used to bring in the separate subroutine
A-type address constant. load module (or program phase), although this might have
The subroutine (Figure 8-12) has been assembled separ- been done by other means.
ately with its own START statement. What about AVER, After completion of the assemblies, the two programs
which is defmed here by being used as the name of a were link edited, and the main program was loaded at 3000
statement? Does the symbol have to be identified in any and the subroutine at 4000. Execution produced three
way? The answer is yes, it does. If the subroutine had been dump printouts (Figures 8-13, 8-14, and 8-15). These are
assembled just as it was in Figure 8-7, there would be shown in the order in which they were executed. Figure
nothing to indicate to the assembler (and later to the link- 8-13 shows a printout of the contents of the registers and
age editor) that there was anything special about AVER. the storage area of interest produced by the PDUMP during
But there is something special: this symbol is used in the the first execution of the subroutine, Figure 8-14 during
link editing process to supply information missing in the the second execution. Figure 8-15 was produced by execu-
main program. The assembler cannot know this without tion of the PDUMP in the main program. Various locations
explicit notification, because we are not assembling the two in the dumps are identified to help the reader follow the
programs at the same time. What is used is the ENTRY sequence of operations in the registers and main storage, as
assembler instruction, which says that the symbol given in described below. A careful study of the dumps will help to
the operand field is used by some other program, but is make clear exactly how communication between programs
defmed in this one. AVER also appears in the program in is maintained and how control is returned to the correct
Figure 8-12 as the name of a statement, as required. points, even with separate assembly and relocation by
If AVER were the name of the program (that is, if it different factors. This capacity is not limited to just two
were given in either a START or CSECT statement), it programs or control sections. A subroutine may link to
would be listed in the ESD without further ado, and the another subroutine, which may link to another, etc. Also,
ENTRY statement would not be necessary. However, we one control section can refer to many external symbols and
have chosen to name the subroutine SUBR. It is important, have many entry points from other programs.
for linkage purposes, for the subroutine to have a name. The sequence of events, in brief, during execution of the
The assembler can process an ENTRY statement that con- programs in Figures 8-11 and 8-12 was as follows. We can
2 PRINT NOGEI\
3 ENTRY AVER
000000 4 SUBR START 0
5 AVER SAVE (14,12) SAVE REGISTERS
000004 0590 8 BALR 9,0
000006 9 LSING *,9
000006 5851 0000 oecoo 10 L 5,0(1) STARTING ADDRESS
OOOOOA 4160 0004 OCC04 11 LA 6,4 INCREMENT
OCOOOE 5845 0000 cecoo 12 L 4,0(5) NUMBER OF ENTRIES
000012 1814 13 LR 1,4 NUMBER OF ENTRIES
000014 8B10 0002 00C02 14 SLA 1,2 4(NUMBER OF ENTRIES)
000018 lA15 15 AR 7,5 LIMIT
00001A 5B70 9052 CCC58 16 S 7,=F'I' REDUCE BY 1 SO LOOP wILL NOT REPEAT
00001E IB22 11 SR 2,2 CLEAR TO ZERO
000020 1B33 18 SR 3,3 CLEAR TO ZERO
000022 5A35 0004 CCC04 19 LOOP A 3,4(5) ADe A VALUE FROM THE LIST
000026 8156 901C CCC22 20 BXLE 5,6,LCOP
OC002A 1024 21 DR 2,4 OIVIDE BY NUMBER OF TERMS
00002e 5851 0004 00C04 22 L 5.4( 11 ?ICK UP ADDRESS OF RESULT
000030 5035 0000 OCCOO 23 ST 3,0(5) STORE RESULT
24 PDUMP AVER,AVER+X'ICO'
29 RE TURN (14,12) RETURN TO THE MAIN PROGRA'"
000000 33 END AVER
000048 5B5BC207C4E4D4D7 34 =Cl8"UBPDU"P'
000050 0000000000000100 35 =A(AVER.AVER+X'100'1
OC0058 00000001 36 =F'l'
Figure 8-12. The same subroutine assembled separately. The START and ENTRY assembler instructions and the PDUMP macro have been
added;
Subroutine Linkages and Program Relocation 121
SU8R. 8ASE MAINf 845£ ADDRESS INCR£MENT END OF
A'O'Ol?E55 AVERI ADDRESS LIST' OF A'(ERt POR LOOP LOOP
\ ; t // f
'; \ ..... \
(QI.C:Q~dliQ~) 0 Jll,Olia 0 nQo(iQ~ 0
, .
004000 f9ciECI:r~ 5851 00004160 00045845 00001814 8B100002 1A155B70 90521B22 IU){)I<ESS
004020 rTS335A=35 00048156 90 1C 1024
I
004040 000C01FE 00000000 . .5B5BC201 ~:~!~~~~ ){=~~~~g/~~~~:~~~ ~~g~~g~~ g~g~~~~~
004060: 00000000 --SAME--4
0040EOI 00000000 oeooooo~/oooooooo OOOOOOOO! 00000000/00000000 00000000 00000000
I ! i I f
SAVE BAlt< 9,0 START OF ST 3) 0(5) STA~T OF POUMP MACRO
MACI<O liTERAl. POOl.
Figure 8-13. First dump produced by the subroutine in Figure 8-12, SUBR
)
\ ~iOJl.~
/ 1
0 c(003n9:d r",-_l,_-
)
PORI LOOP LOOP
odWlilli1J
GR 0-7 00004050 00004048)OCCCCOOO
GR 8-F 00004142 6q{LQ~.Q.@ 00002810 , 00003698 e0003098 0 00004000
FP REG 4431F800 8F5C28F5 4431F800 4752F1E8 6828F5C1 02000000 60000000 ReTURN
004000 90ECOOOC 05905851 00004160 00045845 CC001874 8B700002 1A755B10 905~~;;;--ADORESS
004020 lB335A35 00048756 901Cl024 58510C04 50350000 41109042 4100904A OA0298EC
004040 OOOC07FE 00000000 5B5BC201 C4E40401 OC004000 00004100 00000001 00000000
004060 00000000 --SAME--
0040EO 00000000 00000000 OOOOCOOO OOOOOCOO OCOOOOOO 00000000 00000000 00000000
Figure 8-14. Second dump produced by the subroutine in Figure 8-12, SUBR
Figure 8-15. Dump produced by the main program in Figure 8-11, MAINI
122
follow these events fairly clearly in the dumps, remem- loaded the save area address in register 13 and executed the
bering that each dump is produced at just one particular second CALL.
point during processing. 8. Beginning at the same location as before (4000),
1. The calling program MAIN1 began with execution of SUBR was executed again in its entirety. The contents of
the BALR 11,0 that is at 3000, then LA, then the LOAD the registers were stored, the registers used, and the con-
macro. tents restored in the same way; and then control was
2. The LOAD caused the subroutine load module to be returned to MAINI. The dump in Figure 8-14 was produced
entered into core beginning at 4000, and control to be before the registers were restored.
returned to MAIN 1. 9. This time control was returned to MAINI at location
3. Next, in MAIN 1, execution of the CALL macro (see 3044, where the PDUMP macro was immediately executed,
Figure 8-5 for the actions included) branched to and turned producing Figure 8-15. Next came the EO] at location
control over to the called program SUBR. It also informed 304E, and, with the Supervisor Call instruction (OAOE),
SUBR where to find the parameter list and where to place control went back to the control program.
the final result. We note that the last two fullwords in the The remaining coding in the dump in Figure 8-15 is not
CALL macro, as shown in the dump in Figure 8-15, are the executable, but consists of the constants and storage areas
addresses of LIST 1 and AVER 1. we set up in the original program and also those generated
4. SUBR was executed once, beginning with the SAVE by the various macros. We note that the last item (at 30F8)
macro at 4000, which stored the existing contents of all the is a value of 4000 for =V(AVER), the address constant for
general registers in the save area beginning at location 3098. AVER. This was assembled as 00000000. The value was
Every instruction in SUBR was executed in turn, including supplied by the linkage editor.
repetitions of the loop, tluough the PDUMP macro. The Two observations can be made from this review of the
reader may wish here to go back to the discussion about the programs' execution. The frrst is that program "linkage is
subroutine in Figure 8-5 for a detailed review of the process- closely related to the specification of base registers for each
ing included. program. Throughout execution, the base-plus-displacement
5. The dump in Figure 8-13 was produced at this point. addressing system continues to work efficiently on the basis
We note that the averaging calculations in SUBR used regis- of the values originally assigned by the assembler. Second,
ters 2, 3, 4, 5, 6, and 7, and that its base address was in communication between programs is easily maintained as
register 9. All this is reflected in the contents of these regis- long as the data and addresses needed by each is in a known "
ters in Figure 8-13. location. When routines are written by different program-
6. The final instruction in SUBR, the RETURN macro, mers and assembled separately, communication is simplified
restored the original contents of the registers from the save by use of standard linkage registers for specific functions.
area and returned control to MAIN 1 at location 3020 Although details differ in certain respects, the necessary :
(L 6,A in statement 14). linkages can be e~tablished similarly in all the operating
7. MAINI then did its processing in register 6, and systems by use of either regular assembler language
stored the result (85) at C (the fullword at 3058). It again instructions or macro instructions.
1a. What functions does BALR 14,15 perform? each of the following:
b. What functions does BAL 14,SUB perform? a. CNOP 0,8
c. What instruction is used to return to the main program h. CNOP 0,4
after either a. or b. above? c. CNOP 4,8
2. Match register numbers with their conventional usage. d. CNOP 6,8
REGISTER e. CNOP 2,8
1 a. return address f. CNOP 2,4
13 b. address of subroutine entry Sa. What is generated by a SAVE (14, 12)?
14 c. save area address h. What is generated by a RETURN (14,12)?
15 d. address of parameter list 6a. When a program is branching to an instruction not
3. List 5 operations that are performed by the CALL defined within the confines of that program, what instruc-
macro. tion is needed?
4. The CNOP updates the value in the instruction counter h. When a program is to be branched to from another
during the fIrst phase of the assembly process. If the program, what may be used to identify the label of the
counter is now at a value of 000402, what will it be after instruction to be executed first?
124
Chapter 9: Floating-Point Arithmetic
With the growing use of mathematical and statistical fmal results for purposes of reserving sufficient space. Also,
methods to solve business and industrial problems, floating- he does not run the risk of losing high-order digits from a
point arithmetic, long the province of scientists and -register. He can, in fact, perform most calculations almost
engineers, is being used more and more by commercial as directly as he would by hand.
programmers. Although FORTRAN and PL/I are far more The System/360 floating-point feature performs the
efficient for the programmer who wants to solve a complex same arithmetic calculations as decimal and binary instruc-
mathematical problem, _floating-point arithmetic can sim- tions: addition, subtraction, multiplication, and division.
plify programming in assembler language when the values There are also similar instructions for comparing, loading,
used in a computation cover a very wide range or are and storing. Just one different kind of instruction is
unpredictable. This is so because, in floating-point opera- included: the Halve instruction, which has the effect of
tions, the machine automatically keeps track of the decimal dividing by two. The entire floating-point instruction set,
or binary point and the alignment of intermediate arith- although it may appear long and complicated (the list is
metic results. The programmer need not expend the time presented later in this chapter), consists only of variations
and effort required to do this in involved decimal or binary of these basic operations. These variations permit the pra-
calculations. grammer to choose between (1) long-precision and short-
Floating-point arithmetic may also save considerable precision numbers, (2) normalized and unnormalized
storage space when the values used are either very small or addition or subtraction, and (3) register-ta-register and
75
very large. A value up to approximately 7 x 10 can be storage-ta-register operations.
expressed in just four bytes. That number is equivalent to 7 This brief chapter describes how floating-point numbers
followed by 75 zeros. Represented in packed decimal, it are represented in System/360, shows a few examples of
would use up over 30 bytes of storage. Since all floating- floating-point instructions, and explains the new terms used
point numbers are exactly either four or eight bytes in in the preceding paragraph. It is a simplified introduction to
length (at the option of the programmer), he reaps some the subject for the non-mathematician who may have some
additional benefits. He does not need to estimate the maxi- curiosity about floating-point operations or who may
mum possible sizes of his data, intermediate results, and anticipate using the floating-point feature.
Floating-point numbers are expressed in a form similar to for long precision. The format of a short floating-point
that commonly used for scientific notation, which is a con- number is as follows:
cise means of expressing very large or very small numbers.
For example, the mean distance from the earth to the sun is Characteristic (or
Fraction
Exponent + 64)
roughly 93,000,000 miles. In scientific notation, we would
give this number as 9.3 . 107• This expression consists of o 1 7 8 31
two factors, the significant digits multiplied by a power of This format allows 24 bits for the fraction. A long floating-
10. The exponent 7 indicates that the base lOis to be point number has the same arrangement, except that the
multiplied by itself seven times, and this will give the entire fraction is 56 bits in length:
number the proper magnitude. The number base need not
be 10, but it is the most common a:nd the easiest for us to
understand. The base might be 2 or 8 or 9 or 12 or what-
Characteristic (or
Fraction
~S~_E_xp_o_n_en_t_+_6_4_)~________________- - J
0 .
o 1 7 8 63
ever. In fact, in System/360 it is 16. Let's look at a couple
of other examples of scientific notation in base 10. A light A value may be expressed in either short or long form; the
year, which is a common term for expressing large dis- short form will give greater speed and use less space, the
tances, represents a distance of 5,880,000,000,000 (or long will give greater precision.
5.88 . 10 12) miles. A unit that may be used for measuring In either format, the first bit is the sign of the fraction, 0
the wavelength of light is 0.00000001 (or 0.1 . 10-7) for plus, 1 for minus, and indicates whether the entire num-
centimeters. ber is positive or negative. The next seven bits are used for
A number in this form of notation is generally, but not the exponent, which in System/360 is· called the character-
always, expressed with one integer to the left of the deci- istic by analogy with logarithms. The characteristic also
mal point. Sometimes it is more convenient to place it else- includes a sign (but in an indirect way that will be
where, either to make some numerical relationship clearer explained shortly), giving us a plus exponent for large
or to simplify computation. In such a case, the exponent is values (over 1) and a minus for small values (below 1). For
simply increased or decreased by the same number as the example, 16 1 = 16 and 16- 1 = 1/16. Similarly, _16'"1 = -16
number of places the decimal point is moved. The following and -16- 1 = -1/16. The characteristic is a power of 16, of
shows equivalent values for our three examples. course, not 10, and is a 7-bit binary number with a range of
values from 0 to 12710 , The fraction is expressed in hexa-
93,000,000 = 9.3 . 107 = 93.0· 106 = .93 . 108 = .093 . 109 decil1Ull digits, 6 digits for short precision and 14 forlong,
and in a normalized number its value is between 1/16 and
5,880,000,000,000 = 5.88 .10 12 =5880.0· 109 1. The fraction 1/16 is 0.1 in hexadecimal, with a bit
=.588 . 10 13 =.00588 . 1015 pattern of 0001. Note that normalization applies to hexa-
0.00000001 = .1 . 10-7 = 1.0· 10-8 = .01 . 10-6 decimal digits, not bits, and that the three high-order bits
= .000001 . 10-2 may be zero. The decimal point does not appear in storage,
but is understood.
In System/360 a floating-point number, written as a The method devised for indicating the sign of the charac-
decimal number by the programmer, is converted internally teristic in System/360 floating-point numbers is to use what
by the machine to a form very much like the underscored is called excess-64 notation. This avoids the complications
examples. In these, the part of each value to the left of the of a second sign. As we mentioned, seven bits can represent
multiplication sign is a fractional quantity, without any a range of values from 0 to 127. If 6410 is always added to
whole numbers before the decimal point. Note that the first the actual exponent, a range from -64 through +63 can be
digit after the decimal point is a nonzero digit. A number in represented without further indication of a sign. In this
this form is known as a normalized number. The final scheme, a characteristic of 65 is equivalent to an exponent
example in each group of examples shows the form of an of +1, 66 to +2, and so on up to 127, which is equivalent to
unnormalized number, in which the fraction has one or +63. In the low range, a characteristic of 63 is equivalent to
more high-order zeros. an exponent of -1, 62 to -2, and zero to -64. Table 9-1 is
Floating-point numbers are fixed in length, either a full- given to help in understanding the actual value of some
word (32 bits) for short precision or a doubleword (64 bits) frequently used characteristics.
126
Table 9-1. Equivalent Values of the Characteristics of Some Each constant is specified by a decimal number, which we
Floating-Point Numbers see may be an integer, a fraction, or a mixed number. A
decimal point may be placed before, within, or after the
Actual number, or it may be omitted. A number without a decimal
Characteristic power Decimal value point is assumed by the machine to be an integer. The
Dec. Hex of 16 of characteristic number may be signed or unsigned, and a number without a
sign is assumed to be positive.
68 44 +4 65,536.0 The assembled object code for the floating-point num-
67 43 +3 4,096.0 bers appears at the left in the listings (see Figure 9-1). This
66 42 +2 256.0 is a hexadecimal representation of the actual storage
65 41 +1 16.0 contents. The first two digits represent the sign plus the
64 40 0 1.0 characteristic. The remaining digits represent the fraction.
63 3F -1 0.0625 (or 1/16) The decimal pomt is understood and does not appear in
62 3E -2 0.00390625 (or 1/256) storage. The same numbers are shown in the comments
61 3D -3 0.000244140625 column in Figure 9-2 in a form that is easy to read. A plus
60 3C -4 0.0000152587890625 or minus sign is printed, depending upon whether the first
bit is a zero or a one. The two digits following the sign give
the characteristic, the frrst 4igit representing the value of
Although the programmer does need to understand the the frrst three bits of the seven-bit characteristic. A decimal
internal form of floating-point numbers, he will never have a
point (actually hexadecimal point) is printed preceding
to do the calculations to break down a value into its hexa- the fraction.
decimal exponent and fraction. The machine does that with In these figures some of the decimal values specified are
the greatest of ease. To enter a value into storage in an integers between 1 and 15. We see that they are represented
instruction, the programmer need only defme a constant, in floating-point numbers by the corresponding hexa-
giving the value in 4ecimal (with or without a decimal decimal digit in the fraction, with a characteristic of 41. To
point) and specifying its type as E for a short floating-point take the 9 as an example, +41.900000 should be considered
number or D for a long numbeL Here are some examples: as
DC E'138.25' 1 9
DC E'138' 16 . 16'
DC E'.00138' Decimal 16 becomes +42.100000, which we consider as
DC E'9.3E+7'
DC D'9.3E+7' 2 1
16 '16-
The last two show how the expression 9.3 . 107 is specified
as a constant. The E inside the quotation marks simply Decimal 32 becomes +42.200000, or
indicates an exponent. 2 2
Figures 9~1 through 9-6, which follow, show various 16 '16'
assembly listings. of DC entries of floating-point numbers.
Figure 9-1. Assembly listing of decimal integers specified as short floating-point constants
Figure 9-2. A listing of the same examples as in Figure 9-1, showing them in the comments field in a form that is easy to read
128
section. In E'12.78E+8' the decimal value is 12.78' 108 , tations, it is suggested that a student interested in the
which we see becomes +48.4C2CBC in hexadecimal. In subject refer to his assembler specification manual.)
D'-0.OOOS7E-S' the decimal value is-0.000S7· 10-5 . This In reviewing the hexadecimal values given by the
like all the examples we have seen, is converted to a assembler, we notice that in all the illustrations there are
floating-point number in normalized form, that is, with no some fractions in which the fIrst digit is 1. Hexadecimal 1,
high-order zeros in the fraction. The fraction is always of course, is equivalent to binary 000 1. It is important to
normalized unless the programmer specifies a decimal num- realize that normalization refers to hexadecimal digits
ber with a scale factor. (Since scaling has not been discussed rather than to bits, and a normalized fraction may have as
in this book and is not needed for our elementary compu- many as three leading zero bits.
Figure 9-4. Some fractional and mixed decimal numbers expressed as short floating-point constants
Figure 9-6. Some decimal values with exponents expressed as floating-point constants
Four special registers, used only by the floating-point Table 9-2. Instruction Set for the System/360 Floating-Point Feature
instructions, are part of the System/360 floating-point
feature. They are 64 bits in length and are numbered 0, 2, Name Mnemonic Format
4, and 6. All 64 bits are used for long-precision operands
and results, and only 32 bits for short-precision (except for Lo~d(Long) LDR RR
the product in Multiply). Use of registers for floating-point Load (Long) LD RX
arithmetic avoids the many operations that would other- Load (Short) LER RR
wise be necessary for storing and loading results and Load (Short) LE RX
operands. All floating-point operations are register-to- *Load and Test (Long) LTDR RR
register (RR) or storage-to-register (RX), and most of the *Load and Test (Short) LTER RR
instructions are available with a choice of either format. *Load Complement (Long) LCDR RR
All floating-point instructions are also available with a *Load Complement (Short) LCER RR
choice between the use of long or short numbers. In *Load Positive (Long) LPDR RR
addition, the programmer may select an Add or Subtract *Load Positive (Short) LPER RR
instruction in the execution of which the intermediate and *Load Negative (Long) LNDR RR
fmal results are normalized or are not normalized. All these *Load Negative (Short) LNER RR
choices mean a long list of instructions in the floating-point
instruction set (as we see in Table 9-2~ there are eight separ- *Add Normalized (Long) ADR RR
ate Add instructions), but the basic functions are simply to *Add Normalized (Long) AD RX
Add, Subtract, Multiply, Divide, Halve, Compare, Store, *Add Normalized (Short) AER RR
and Load. The Load instructions also provide the program- *Add Normalized (Short) AE RX
mer with the ability to control the signs of operands. Note *Add Unnormalized (Long) AWR RR
that the mnemonics of instructions for long precision are *Add Unnormalized (Long) AW RX
distinguished by the letter D, and for short precision by the *Add Unnormalized (Short) AUR RR
letter E. In Add Unnormalized and Subtract Unnormalized, *Add Unnormalized (Short) AU RX
these change to W and U. *Subtract Normalized (Long) SDR RR
Perhaps the best way to get an idea of how the instruc- *Subtract Normalized (Long) SD RX
tions actually operate is to study an example. Figure 9-7 is *Subtract Normalized (Short) SER RR
an assembly listing of a program to evaluate the following *Subtract Normalized (Short) SE RX
formula, using short precision throughout. *Subtract Unnormalized (Long) SWR RR
*Subtract Unnormalized (Long) SW RX
A+1L::£ )2 *Subtract Uimormalized (Short)
*Subtract Unnormalized (Short)
SUR
SU
RR
RX
Y = ( 3.17 _22D
*Compare (Long) CDR RR
The fIrst processing instruction is Load Short (LE) ,
*Compare (Long) CD RX
which places the value of D in floating-point register 2. The
*Compare (Short) CER RR
fact that the 2 in this instruction refers to a floating-point
*Compare (Short) CE RX
register, rather than to a general purpose register, is implied
in the operation code; floating-point is understood by the Halve (Long) HDR RR
assembler when it encounters the code LE. This short oper- Halve (Short) HER RR
ation will load the left half of the double-length register,
Multiply (Long) MDR RR
leaving the low-order half unchanged. Any previous value in
Multiply (Long) MD RX
the low-order 32 bits, will ordinarily have no signifIcant
Multiply (Short) MER RR
effect on later operations. Multiply (Short) ME RX
The second instruction multiplies the contents of
floating-pomt register 2, which we just loaded, by the con- Divide (Long) DDR RR
stant 2 in floating-point form. The result is left in the same Divide (Long) DD RX
register, destroying the previous contents. No other register Divide (Short) DER RR
is involved, in contrast to flXed-point multiplication. The Divide (Short) DE RX
lower half of the floating-point register is involved, Store (Long) STD RX
however, because the entire register is used for the result of Store (Short) STE RX
a Multiply operation. In short precision, the fraction of the
product has 14 hexadecimal digits, of which at least two are
I *Operation sets condition code.
always zero.
130
LOC OBJECT CODE ADDR1 ADDR2 STMT SOURCE STATEMENT
PRINT NOGEN
000000 2 SHORTFP ST ART a
000000 05BO 3 BEGIN BALR 11.0
000002 4 USING *.11
000002 7820 B032 00034 5 LE 2,D LOAD FLOATING POINT REGISTER 2 WITH 0
000006 7C20 B036 00038 6 ME 2,FTWO MULTIPLY 0 IN REGISTER 2 BY 2
OOOOOA 3322 7 LCER 2,2 REVERSE SIGN OF PRODUCT
OOOOOC 7A20 B03A 0003C 8 AE 2,CON1 ADD CONSTANT 3.17
000010 7840 B02A 0002C 9 LE 4,B LOAD FLOATING POINT REGISTER 4 WITH B
000014 7B40 B02E 00030 10 SE 4,C SUBTRACT C
000018 3444 11 HER 4,4 USE HALVE INSTRUCTION TO DIVIDE BY 2
00001A 7A40 B026 00028 12 AE 4,A ADO A
OOOOIE 3042 13 DER 4,2 DIVIDE NUMERATOR BY DENOMINATOR
000020 3C44 14 MER 4,4 SQUARE THE QUOTIENT
000022 7040 B03E 00040 15 STE 4,Y STORE THE FINAL RESULT
16 EOJ
000028 19 OS OF
000028 41123456 20 A DC E'1.1377772805'
00002C 43356800 21 B DC E'854.50'
000030 43252600 22 C DC E'594.3750'
000034 3E2D3EFD 23 D DC E'6.904E-4'
000038 41200000 24 FTWO DC E'2'
00003C 4132B852 25 CONI DC E'3.17'
000040 26 Y OS F
000000 27 END BEGIN
Figure 9-7. Assembly listing of a program to perform simple computations in short floating-point arithmetic
In the execution of a Multiply instruction, the machine exponents. The decimal numbers are not all exact equiva-
normalizes both operands, if the fractions have leading lents, because exact equivalents of fractional quantities
zeros, before any arithmetic is performed. This is done by often do not exist in base 10 and base 16. Inspection will
shifting the fraction left until the leftmost hexadecimal show that these discrepancies are small for most practical
digit is a nonzero digit and reducing the characteristic by purposes; they can be made much smaller by the use of
the number of shifts required. When this is done before the long precision, as will be seen later.
arithmetic process (as it is in both Multiply and Divide), the We noted before that the product fraction of a short-
action is called prenormalization. With both operands precision Multiply is 14 hexadecimal digits in length,
prenormalized, the product will either be normalized including some trailing zeros. Normally, after the ME opera-
already or have at most one leading zero. In the latter case, tion in Figure 9-8, we would expect to find at least some
the product fraction is shifted left one hexadecimal posi- nonzero dJgits in the low-order half of register 2. In this
tion to postnormalize it, and the product characteristic is case, however, the two fractions that are multiplied yield
reduced by one. only six significant digits (.2D3EFD x .200000 =
In floating-point multiplication, the arithmetic process is .SA7DFA 000000), so the low-order half of the register
very simple and follows the familiar rules for exponents. contains eight zeros. The more usual situation can be seen
I t consists of adding the characteristics and multiplying the in register 4 after execution of the MER instruction.
fractions. To illustrate the procedure, let's consider a simple The next instruction in our program, the Load Comple-
problem in base 10: to multiply 12,300 by 60. Expressed ment (RR), reverses the sign of the product as written here.
with decimal exponents, this is (.123· 105) . (.6.10 2 ). (The instruction can also be used with two different register
Multiplying the fractions, we get .123 .. 6 = .0738. Adding numbers.) It would of course be acceptable programming
the exponents, we get 105+2 = 107 . Together, they give practice to have stored the constant 2 as a negative number .
.0738 . 107 = 738,000. In System/360, of course, the Now we add the constant' 3.17, using an Add Nor-
machine also has to subtract 64 from the characteristic of malized instruction. Floating-point addition starts with a
an intermediate product because, with both operands in the comparison of the two operand characteristics; if they are
excess-64 notation, adding the characteristics gets the extra the same, addition of the fractions takes place immediately.
64 into the product twice instead of once. Otherwise, the fractional part of the number with the
F or those who wish to follow the arithmetic in the pro- smaller characteristic is shifted right, as many places as the
gram example, the details are given in Figure 9-8. Each line difference in characteristics, until they agree. When this is
shows the contents of the two registers used for computa- done, the decimal points (hexadecimal points, really) are
tion after the execution of each of the floating-point "lined up", as addition requires. The fractions are then
instructions. The operation codes are given in the left-hand added. The larger of the two characteristics becomes the
column. The program used for this output specified the "provisional" characteristic of the sum; we say provisional
addition of a point in printing the hexadecimal register con- because it may have to be adjusted for a possible overflow
tents. The decimal equivalents are in the usual form for carry in the fraction or for postnormalization.
floating-point numbers and show the true value of the If the addition caused overflow of the fraction, the
Figure 9-8. The contents of floating-point registers 2 and 4 after execution of each of the short-precision instructions in the program in
Figure 9-7
132
division, wrJch is standing in register 4. A Multiply (RR, registers may be seen in Figure 9-10. Here the full capacity
Short), in which the quantity in register 4 is specified for of the registers is used in each operation, and the increase in
both operands, does the job. Finally, a Store puts the result precision of the arithmetic results can readily be seen.
in the fullword storage location Y. Except for the length of operands and results and the fact
Figure 9-9 shows a listing of the same program, with that in short precision the low-order halves of the registers
identical decimal values, rewritten to do all processing in are generally ignored, there is no difference in the execu-
long precision. Step-by-step changes in the contents of the tion of the instructions for long and short precision.
1 PRINT NOGEN
000000 2 LoNGFP START 0
000000 05BO 3 BEGIN BAlR 11,0
000002 4 USING *,11
000002 6820 B03E 00040 5 LD 2,0 LOAD FLOATING POINT REGISTER 2 WI TH D
000006 6C20 B046 00048 6 MO 2, FTWo MUL TIPl Y D IN REGISTER 2 BY 2
OOOOOA 2322 7 LCDR 2,2 REVERSE SIGN OF PRODUCT
OOOOOC 6A20 B04E 00050 8 AD 2,CONl ADD CONSTANT 3.17
000010 6840 B02E 00030 9 LD 4,B LOAD FLOATING POINT REGISTER 4 WI TH B
000014 6B40 B036 00038 10 SO. 4,C SUBTRACT C
000018 2444 11 HDR 4,4 USE HALVE INSTRUCTION TO DIVIDE BY 2
0000 lA 6A40 B026 00028 12 AD 4,A ADD A
OOOOlE 2D42 13 DDR 4,2 DIVIDE NUMERATOR BY DENOMINATOR
000020 2C44 14 MDR 4,4 SQUARE THE QUOTIENT
000022 6040 BOS6 00058 15 STD 4,Y STORE THE FINAL RESULT
16 EOJ
000028 19 DS 00
000028 4112345SF31EI1BO 20 A DC D'I.1317772805'
000030 4335680000000000 21 B DC 0'854.S0'
000038 4325260000000000 22 C DC D'S94.3750'
000040 3E2D3EF06BOI0972 23 0 DC 0'6.904E-4'
000048 4120000000000000 24 FTWO DC 0'2'
OOOOSO 4132B8S1EB851EB8 25 CONI DC 0'3.11'
000058 26 Y DS 0
000000 27 END BEGIN
Figure 9-9. Assembly listing of the same program as in Figure 9-7, modified to perform all computations in long floating-point arithmetic
Figure 9-10. The contents of floating-point registers 2 and 4 after execution of each of the long-precision instructions in the program in
Figure 9-9
1. Write the DC instructions for the following short 4. After execution of each of the following sets of instruc-
floating-point numbers: tions, what will be in the registers used?
3.14159265 a. LE 2,A
-2.78 AE 2,B
38754 x 106 HER 4,2
.00000278 given A = 41789ABC and B = 41876544 in hexadecimal
-.000236 x 10-7 short floating-point.
2. Write the DC instructions for the following long floating- b. What would be the results of the same instructions if
point numbers: A =41200000 and B =446oo044?
3.141592653589793 c. LE 6,A
-2.78 SR 6,6
-0.003 x 10-3
3.8 X 1030
ADC E'15'
0.000000008
3. Show the hexadecimal form that the following DC d. L 3,A
entries will generate in storage. (Note that 16777216 equals A 3,B
166 and that .59604644 x 10-7 equals 16-7.)
DC E'32' ADC E'1.0'
DC fi3i BOC X' 01000000'
DC E'16777216' 5. Write a program segment to calculate the value of X in
DC E '.59604644E-7' short floating-point arithmetic and put it into storage:
DC E' -.59604644E-7'
DC E'-16777216' X = A-(BxC)
A+(BxC)
134
Answers to Questions and Exercises
LOCATION
1\
STORAGE OPERAND LOCATION
" ADDRESS
OF OF OF
STATEMENT Base Displace- STATEMENT STORAGE VALUE LOADED INTO
Reg. ment Address OPERAND· BASE REGISTERS
PROGH START tJ During During
BEGIN BALR 11,0 000000
001000 assembly execution
(assumed) (actual)
USING FIRST,ll
FIRST BC 15,SKIP OOOOOZ
001001- 11 00000$ OO/oot
DATA DC F'347Z' 000008 (JO/OO8 10 0010/11. 00200].
9 1J1J1P02 (J0300;"
BASEl DC A(FIRST+4096) 0000Z4
OOIOJ.f
BASEZ DC A(FIRST+819Z) 0000Z8 001028
SKIP L 1~ 000104 -
e OJ7- 0000].4 001104-
--
001011-
USING FIRST+4096,10
L 9~ 000108 8 026 OO(JOJB PO/lOB 0010J8
USING FIRST+819Z,9
BC 001504
9 902 ()Ot9()4 00Ji04 003904-
Answers to questions 5
136 (8/70)
position in which both operands had 1s, and zeros else- 4a. 05
where. b. 2C (the fmal C is the code for a plus sign)
b. For the Or Immediate instruction a 1 in the bit posi- c. 43
tions in which either or both operands had aI, and a zero 5. 8 bits, 1 byte
where both operands had zeros. 6. 2048 bits, 256 bytes
13. Packed decimal 7. '(b) Alphameric characters. Despite their plausibility,
14. PACK a and c are not correct in the general case because or"
15. UNPK (Unpack) possible difficulty with sign codes.
16a. DC F'S78' or DC H'S78' 8. ( c) An inequality. All codes are valid.
b. DC ZL3' 578' 9. (a) 5, (b) 2, (c) 3 plus the contents of general regis- .
c. DC PL2'S78' ter 1, (d) the computed effective address for FIELD, not
17. There are at least four ways to write the DC state- the word stored at that address
ment. Keep in mind that 4B is the hexadecimal equivalent 10. Among the many ways to solve this are the following:
of 7510 • CLC FIELD(I),FIVE
a. DC F'7S' would generate the 4-byte constant: BC 6,NOTS'
00 00 00 4B.
b. DC H'7S' would gerierate the 2-byte constant: ,FIVE DC X'OS'
00 4B. or:
c. DC X'4B' would generate the I-byte constant: 4B. CLI FIELD,X'OS'
The advantage of methods a and b over method c is that BC 6,NOTS
or:
the programmer does not have to convert frorn decimal to
TM FIELD,X'OS'
hexadecimal. A disadvantage is that more space is used than
is perhaps necessary. BC 12,NOTS
d. The statement DC FLl'7S' would remove this TM FIELD,X'FA'
disadvantage since the characters Ll specify that the length BC S,NOTS
(L) of the constant is to be 1 byte. Thus a I-byte field of 11. The second byte of the BC instruction, containing the
4B would be generated. A point to remember is that when mask Ml and index X2 fields.
a length is stated for an F-type constant no boundary align- 12. (d) The 01 instruction changes the BC 0 instruction,
ment is performed by the assembler. which never branches, to a BC 15 instruction, which
18. IC 6,OLD branches unconditionally. Hence, after the first time
19. STC 6,OLD around, the sequence between the BC and symbolic address
20a. No. MASK is not located on a fullword boundary. ADDR is always skipped.
The N instruction requires the operand in storage to be on a 13. The instruction sequence between the BC instruction
fullword boundary. and the address ADDR will be alternately executed and
b. The statement DS OF could be inserted immediately skipped.
before the DC defIning MASK. 14. N S,MASK
c. DC F'IS'
MASK DC X'FFOOOooO'
138
Appendix
SYSTEM/3GO MACHINE INSTRUCTIONS
SLL
RS
RS
8D
89
Rl,D2(B2)
Rl,D2 (B2)
R5 i Op Code I I I I
R1 R3 B2 02 I
* Shift Right Double SRDA RS 8E Rl,D2(B2) :0
I
7 S 1112 1516 1920
Appendix 139
CONDITION CQDE SETTINGS EXTENDED MNEMONIC CODES FOR THE BRANCH
ON CONDITION INSTRUCTION
EBCDIC CHART
The 256-position chart at the right, outlined by the heavy Fifteen positions, indicated by circled numbers, are excep-
black lines, shows the graphic characters and control char- tions to the above arrangement. The card hole patterns for
acter representations for· the Extended Binary-Coded these positions are given below the chart.
Decimal Interchange Code (EBCDIC). The bit-position Following are some examples of the use of the EBCDIC
numbers, bit patterns, hexadecimal representations and chart:
card hole patterns for these and other possible EBCDIC
characters are also shown. Character Type Bit Pattern Hex Hole Pattern
To fmd the card hole patterns for most characters, parti-
tion the chart into four blocks as follows:
Zone Punches I Digit Punches
CJl
a Lower Case 10000001 ~1 12 - 01- 1
Block 2: Zone punches at bottom of table; Control Character, 00 11 0000 30 12 - II - 0 - 91- 8 - 1
function nat yet I
digit punches at left 1
Block 3: Zone punches at top of table; digit
assigned
..
UJ punches at right
Block 4: Zone punches at bottom of table;
digit punches at right
Bit Positions
01234567
140
EBCDIC CHART
00 01 10 II
0000
CD CD
NUL DLE
® ®
»
0011 TM C
0101 NL LF Rs N V 5
0110 Bs ETB UC o w
1000 CAN y H Q Y
1001 EM z 9
1010 SM ®
1011 CUI CU2 CU3
1111
142
Index
In this index, assembler and macro instructions are identified ISEQ (input sequence checking) 7
as such. Machine instructions are listed by name in capital ORG (set location counter) 54,55
letters. PRINT (print optional data) 29,94
START (start assembly) 9,61,115
Adcon (see address constant) TITLE (identify assembly output) 2,9,120
ADD (A) 9,11,30,42-44,113 USING (use base address register) 3,9,10,51-57
Incrementing an indexed address 45,4 7 Assembler language
ADD DECIMAL (AP) 57,62,71,73,81 Basic concepts 9,10
ADD HALFWORD (AH) 48 Comparison with high-level languages 4
ADD NORMALIZED (AD) 133 Description 1- 4
ADD NORMALIZED (AE) 131 Types of instructions 3,4
Address arithmetic Assembler program 1,5,6,52,53
Use of binary for 18,20 "Assembler" program example 100,101
Address calculations by assembler 6,10,11,55,57 Asterisk in a comment, use of 8
Address changes in program modification 15 Asterisk in an instruction, use of 11
Address constant Averaging problem 48,49,68
A-type 108,111,113,119
in examples 76,94,101,103,108,112,116 Base address 24,51,118,123
to load base register 54,56 Base register 9,11,24,51-57,123
Modification by linkage editor 57,115,119,123 Use of zero 30
for subroutine linkage 108 Base register range restriction 109
to test completion of loop 57 Base registers, use of multiple 54-57
V-type 109,115,117,119 Base address chosen by assembler 56
Address, effective 30,52 Baudot teletypewriter code 92
Addressing byte locations 18 Binary arithmetic (see fixed-point operations)
Addressing main storage 9,18,19,24,30,51 Binary-coded decimal (BCD) data format 20
Addressing registers 19 Binary-decimal number conversion 28
Address specification Binary fractions 35
Use of zero in 10,11,24,30 Bit 17
Alignment, boundary (see boundary alignment) Bit manipulation 82,83
AND (N) 69,70,79,83 Bits, setting on and off 79
AND (immediate) (NI) 67,68,78,79,83 Blanking storage area 100,102
Argument 92,93,97 Boundary alignment 10,15,18,102
Arithmetic and logical unit 19 Of DC's and DS's 10
Arithmetic instructions, effect on condition code 140 Of machine instructions 23
Assembler coding form 7 Use ofCNOP instruction 113,114
Assembler instruction Use of DS zero duplication factor 70
In assembler language 2,4 Branch if Zeros (BZ) extended mnemonic 99
List of 142 BRANCH AND LINK (BAL) 109
Assembler instructions mentioned in text BRANCH AND LINK (BALR) 9,10,24,51,52,108,109,111
CNOP (conditional no operation) 113,114 Branching 23,39
CSECT (identify control section) 115 BRANCH ON CONDITION (BC) 40,42-44,71,78;79,81
DC (defme constant) 2,10,11,31,127 102
DROP (drop base address register) 57 After COMPARE 45,76
DS (defme storage) 2,10,11,31,56,61,70 BRANCH ON CONDITION (BC, BCR)
ENTRY (identify entry-point symbol) 121 with EDIT 89
EJECT (start new page) 3 Extended mnemonic code 44,78,79,83,140
END (end assembly) 10,11,31 No-Operation (NOP, NOPR) 39,140
EXTRN (identify external symbol) 120 Test of condition code 39
ICTL (input format control) 7 Uses 23,24
Index 143
BRANCH ON COUNT (BCT) 23,73,80,83,99 Constant, address (see address constant)
BRANCH ON COUNT (BCTR) 23,91 Constants, assembling of
Branch on Equal (BE) extended mnemonic 49 Effect of PRINT DATA on 94
BRANCH ON INDEX HIGH (BXH) 23,4 7 Constants, types of 9,127,142
BRANCH ON INDEX LOW OR EQUAL (BXLE) 23, Control characters in EDIT 86-90
46-49,113 Control program 5,30,115,123
Branch on Low (BL) extended mnemonic 44 Control section 115
Branch on Minus (BM) extended mnemonic 99,102 Conversion
Branch on Not Equal (BNE) extended mnemonic 99 Binary-hexadecimal-decimal numbers 26-28
Branch on Not High (BNH) extended mnemonic 94 Character codes 92,93
Branch on Overflow (BO) extended mnemonic 110 Zoned-packed formats 69,70,81
Branch Unconditional (B) extended mnemonic 98,101 CONVERT TO BINARY (CVB) 73,100
110,113 CONVERT TO DECIMAL (CVD) 9,70,102
Branch Unconditional (BR) extended mnemonic 108 Core storage (see main storage)
Branch, unconditional 39,42 Counter, location 6,9,10,54,115
Branching alternate times through loop 81 CPU (central processing unit) operations 19
Branching by use of Execute instruction 99 Cross-reference table 6,8,52
Byte 17,18 CSECT assembler instruction 115
Currency symbols, floating 91
CALL macro instruction 116,117,120,123
Calling program 108 Data constants (see DC assembler instruction)
Capacity of main storage 17 Data exception 25
Capacity of registers 19 Data format 17,20-22,60,75,126
Central processing unit (CPU) 19 (See also individual types of data)
Character codes 21 Data introduced in instructions 75,113
Characteristic in floating-point number 126,127 DC assembler instruction 2,10,11,31,127
Character testing and manipulation 80,82,83 Types of constants 142
Check bit 17 Decimal-binary number conversion 28
Check digit, use of 80 Decimal data format 20,21,60
Clearing storage area to blanks 100,102 Decimal data manipulation 82,83
CNOP assembler instruction 113,114 Decimal digits, clearing excess 63,71
Code conversion by use ofTR 92,93 Decimal feature instruction set 60,139
Coding form, use of 7 Decimal-hexadecimal number conversion 27,28
Collating sequence, EBCDIC 21,76 Decimal operations 20,21,60-73
Collating sequence, changing normal 93,94 Addition and subtraction 61-62
Comma and decimal point insertion 86-88 Comparison 71,72
Comments, use of 8 Division 64,68
COMPARE (C) 42-44,45,83 Effect on condition code 140
COMPARE (CR) 40 Format conversions 69,70
CUMP ARE DECIMAL (CP) 71 Multiplication 63
C01v1PARE HALFWORD (CH) 49 PrOviding storage locations for data 62
Compare instructions, logical contrasted to arithmetic Requirement for packed format 21,60
76 "Shifting" 66-68
COMPARE LOGICAL (character) (CLC) 76,77,81,93,94 Decimal places, rule for number of 64,68
COMPARE LOGICAL (immediate) (CLI) 93 Decimal point and comma insertion 86-88
Comparison of alphanumeric characters 76,77 Decimal point in binary numbers 34,35
Complementing bits 79 Decimal point in floating-point arithmetic 125,127
Composite number problem 82,83 Decimal signs, clearing excess 67
Condition code 23,39 Decision-making 23,39,42-44
after COMPARE 40 Delimiters, scan of data fields for 97,100
in EDIT 89 Diagnostic messages 6,12-14
List of instructions that affect 130,139 Dictionaries 6,115 (see also ESD and RLD)
Masks for testing 39 Digit selector 86-90
Summary of resul t settings 140 Disk Operating System (DOS) macros 111
after TEST UNDER MASK 78 Displacement 11,24,51-57
in TRT 97 Assignment of smallest 56
144
Restrictions in size and sign 54,55 Extended binary coded decimal interchange code
DIVIDE (D) 34,42-44 (See EBCDIC character set)
DIVIDE (DDR) 133 Extended mnemonic code 44,78,79,83,140,142
DIVIDE DECIMAL (DP) 64,68 Externai interruption 25
Before and after results of operation 64 External references 115
DIVIDE (DER) 132 External symbol 120,121
DIVIDE (DR) 49,113 External symbol dictionary (ESD) 6,109,115,119,121
Dollar amounts, editing of 87-91 EXTRN assembler instruction 120
Dollar sign, insertion of floating 91
DOS (Disk Operating System) macros 111 F (fullword) 31
Doubleword 10,17,18 Field length 17
Doubling a binary number by shifting 49 Characters 21
DROP assembler instruction 57 Fixed-length (fIXed-point numbers) 20
DS assembler instruction 2,10,11,31 Variable length (decimal numbers) 20
Length modifier in 61 Field separator 90
Zero duplication factor in 56,70 Fill character 86-90
Dumps, "reading" 117-119,121-123 Fixed-length data, alignment of 10,18
Fixed-point operations 19,20,29-50
EBCDIC character set 21,11 Addition 30
Collating sequence 21 Decimal point in 34,35
Complete 256-position chart 140,141 Division 34,35
EDIT AND MARK (EDMK) 85,86,91 Effect on condition code 140
Use of register 1 91 Multiplication 32,33,34,35
EDIT (ED) 85-90 Number format 20,82
Editing Subtraction 30
Conditions and results, summary of 88 Floating currency symbols 91
Dollar amounts 87-91 Floating-point operations 21,125-133
Multiple fields 90 Advantages of using 125
Pattern, rule for length 87 Constants 127-129
EJECT assembler instruction 3 Instruction set 130
END assembler instruction 10,11 ,31 Number format 126-129
Entries on coding form, rules for 7,8 Registers 19,21,130
ENTRY assembler instruction 121 Flowchart, program 40,42,82
Entry point 121 Format
Entry point register 111 Machine instruction 10,11,23,24,139 (see also RR,
EOJ (End of Job) macro instruction 3,9,30 RX, SI, RS, SS)
Error analysis by assembler 12-14 Data 17,20-22,60,75,126 (see also specific data
Error code 13 formats)
Error detection by CPU 23 Fraction in floating-point number 126,127,130
Error detection by use ofTRT 97 Fullword 10,17,18,20,31
Error messages 12-14 Function bytes 93,97
Error return 110 Function table 92-94,97,100
ESD (external symbol dictionary) 6,109,115,119,121
Even, odd registers General registers (see registers, general)
in BXLE 46,47 Graphic characters 21 ,22,141
in fIXed-point multiplication 32 Guard digit 132
Exception 25,32,114,132
Excess-64 notation 126 Halfword 10,17,18,20
EXCLUSIVE OR (immediate) (XI) 79 Halfword operands, machine instructions using 48
EXCLUSIVE OR (XR) 78 HALVE (HDR) 133
EXCLUSIVE OR (XR, X, XI, XC) 78 HALVE (HER) 132
Executable instructions 1,3 Hexadecimal code 10,11,21
EXECUTE (EX) 85,99,100,102 For EBCDIC characters 22,86-93,141
Explicit length specification 60,61,77 F our-bit binary code 26
Exponent 126,127,131 Interpreting in storage printout 26,117-119,121-123
Exponent overflow and underflow 132 Uses of 26,27
Index 145
Hexadecimal-decimal number conversion 27,28 Listings produced by assembler 6
Hexadecimal dump of storage area 117 Literal 113,117
Hexadecimal numbers 26-28,33 LOAD ADDRESS (LA) 46,47,48,80,91,97,100,111
LOAD AND TEST (LTR) 49
ICTL assembler instruction 7 LOAD COMPLEMENT (LCDR) 133
Immediate operand 23,24,75,78,79 LOAD-COMPLEMENT (LCER) 131
Implicit length 60,61,77 LOAD HALFWORD (LH) 48
Indexed addressing 45,46 LOAD (L) 9,11,29,30,42-44,70,113
Index, limit value of 46,47,49 LOAD (LD) 133
Index register 24,45,46,49,80,83 LOAD (LE) 130
Index register zero 11 Load location, program 53,117
"Indian" problem 73 LOAD (LR) 40,42,43,48
Initialization of program 48 LOAD macro instruction 121,123
INSERT CHARACTER (IC) 69,80,83 Load module 115,116
Instruction address 23 LOAD MULTIPLE (LM) 40,77
Next sequential In PSW 25 LOAD POSITIVE (LPR) 40
Length code in PSW 25 Location counter 6,9,10,54,115
Instruction e){.ecution out of sequence 99 Logical instructions, using RX forms of 79
Instruction format 10,11,23,24,139 Logical operations 21
(See also RR, RX, SI, RS, and SS) Logical operations 75-104
Instruction sets, System/360 Effect on condition code 140
Decimal feature 60,139 Summary of 75
Floating-point feature 130 Long precision 130,133
Standard 29,139 Loop control 23
Integral boundaries 18 Looping with an index 45-49,80,83,113
Interchanging addresses instead of records 77 Loop, parts of 45
Interchanging contents of registers 40,76,94 Loop reiteration by loading of base address 57
Interest problem Loops, counting in 73,80,81
In decimal arithmetic 63
In fixed-point arithmetic 34,35 Machine check interruption 25
Using both decimal and binary 73 Machine instruction format 10,11 ,23,24,139
Interruption, program 25 (See also RR, RX, SI, RS, SS)
Interruptions, types of 25 Machine instructions
Interruption system 23,25 In assembler language 1,4
Invalid delimiter 13 (See name of individual instruction)
Invalid symbol 13 Machine instructions, list of 130,139
Inventory problem Machine language 1
In decimal arithmetic 61 Machine operations, basic concepts of 9,10
In fIxed-point arithmetic 29 Macro instructions 3,4
I/O devices, requirement for zoned decimal format 21,60 Effect of PRINT instruction on listing 29,94
I/O interruption 25 (See individual mnemonics)
I/O operations Macros for subroutine linkage, DOS 111
Use of DC's and DS's as substitute 31 Main storage 17,18
ISEQ assembler instruction 7 Addressing 24
Use of in decimal arithmetic 20
Main storage area, contents of, printed out 117,118,122
Keys, sorting on 76,77,93-96
Mask
Use of hexadecimal code 26,69
Leading zeros, suppression of 86-88 Use in testing 24
Left "shifting" in decimal operations 67 Mask fIeld in machine instructions 24
Length code in machine instructions 60,61 Message characters 87-90
Length modifIer in DC 61 Mnemonics 1,2,3
Limit value of index 46,47,49 Machine instructions, list of 139
Linkage editor 6,53,109,115-118,121,123 Assembler instructions, list of 142
Linkage registers 111 Mnemonic code, extended 44,78,79,83,140,142
Linkage subroutine 107-124 MOVE (characters) (MVC) 57,61,66,68,73,77,86,90,94
146
Propagating character through field, use for 89,97,102 Program listing 6
MOVE (immediate) ("Mvl) . 100 Programming errors 11.-1 q.
Move instructions, use for "shifting" decimal fields 66,67 Programming support system 5
MOVE NUMERICS (MVN) 63,66,71,73,75 Program phase 115
MOVE WITH OFFSET (MVO) 60,66,67,71 Program status word (pSW) 23-25
MULTIPLY DECIMAL (MP) 63,73 Propagating character through field 89,97,102
MULTIPLY (M) 32-35,42-44 PSW (program status word) 23-25
MULTIPLY (MD) 133 Punch card patterns for EBCDIC code 22,140,141
MULTIPLY (MDR) 133
MULTIPLY (ME) 130,131 Recomplement 33
MULTIPLY (MER) 133 Records, processing fixed-length 45
Records, processing fIXed-length blocked 56,57
Name of program Register contents shown in printout 117-119,121-123
In CSECT statement 115 Registers, floating-point 19,130
In START statement 9,115 Registers, general 19,20
Naming fields in a storage area 57 Available to programmer 51
Negative fixed-point numbers 20,31,38 Clearing to zero 42,45
Negative floating-point numbers 128 Functions in a program summarized 48
No-Operation (NOP) extended mnemonic 113,114 Saving contents of 111,112
No-Operation (NOPR) extended mnemonic 39,99,140 Specification 24
Normalization 131 Standard assignments 111
Normalized number 126,129 Registers, general, use of
Notation, scientific 126 with BXLE instruction 46,47
Number base 27,126 in fIXed-point multiplication 46,47
Number of places in decimal division 64,68 by operating system 51
Numerical place values in base 2, 10, and 16 27 in shifting operations 37
for subroutine linkages 108,111
Object code 1,5,10,115 Registers 1 and 2, use of, by TRT 97
Object deck 120 Register zero 10,11
Object module 115 Register 1, use of, by EDMK 91
Object program 5,10 Relative addressing 9
Operand 1,8,20,21,23 Relocatability 115
Operating system 5 Relocation dictionary (RLD) 6,115,119
Operation code 1,23,24 Relocation factor 53,115
ORG assembler instruction 54,55 Relocation, program 24,53,115-119
OR (immediate) (01) 79,83 RETURN macro instruction 113,123
OR(O) 69,81 Return point, subroutine 108,110,111
Overflow in floating-pOint fraction 131,132 Return register 111
Overlapping fields in decimal operations 66,67,73 Right "shifting" in decimal operations 66
Overtime pay problem 71 RLD (relocation dictionary) 6,115,119
Rounding errors, accumulated 43
PACK (PACK) 60,70,73,83,100 Rounding off 34,35,42,43,49
Packed decimal numbers 20,60,61,69,70,81 In decimal arithmetic 63,68,71
Parameter list 111 , 11 7 RR instruction format 11,23,24
Parity bit 17 RS instruction format 11,23,24
Pattern field in EDIT 86,87 RX instruction format 11,23,24,29
PDUMP macro instruction 117,121
Pool, literal 113 Save area 111 , 112, 123
Postnormalization - 131,132 SAVE macro instruction 112,113
Prenormalization 131,132 Scale factor
PRINT assembler instruction 29,94 For binary constant 35
Printout of storage area contents 117,118,122 Scanning data fields for delimiters 97,100
Program checkout, use of dump for 117 Scientific notation 126
Program execution 6,23-25,118-119,121-123 Sequential instruction execution 23
Use of main storage in 17 Setting bits on and off 79
Program interruption 25 Shifting, fIXed-point 34,37,38,113
Index 147
Shifting, logical contrasted to algebraic 37,38 SUBTRACT NORMALIZED (SE) 132
"Shifting" of decimal fields 66,67 SUBTRACT (S) 9,30
SHIFT LEFT SINGLE (algebraic) (SLA) 9,11,49,52,83, Decrementing an indexed address 46
110 SUBTRACT (SR) 42,43,45,48,80,113
SHIFT LEFT SINGLE LOGICAL (SLL) 80 Supervisor 5
SHIFT RIGHT DOUBLE (algebraic) (SRDA) 38 SUPERVISOR CALL (SVC) 30,123
SHIFT RIGHT DOUBLE LOGICAL (SRDL) 37,38 Interruption 25
SHIFT RIGHT SINGLE (algebraic) (SRA) 35,38 Suppression of leading zeros 86-88
SHIFT RIGHT SINGlE LOGICAL (SRL) 37,38 Symbol (cross-reference) table 6,8,52
Short precision 130 Symbolic address 9,24,30
Sign bits Syntax error 13
In algebraic shifting 35
In fixed-point numbers 20,32 Table, function 92-94,97,100
In logical shifting 37 Table of decimal-hexadecimal values 28
Propagation in halfword instructions 49 Table requirements for Translate instruction 92,94
Sign control in EDIT 88 Table requirements for TRT instruction 97,100
Significance exception 132 Table, use ofMVI to insert values in 100,102
Significance indicator 87-90 Teletypewriter code, Baudot 92
Significance starter 87-91 Testing bit combinations 78,79
Sign of numbers Testing characters 82,83
EBCDIC 20 Testing, terminating loop by 45
Fixed-point 20 Testing the condition code 23,32
Floating-point 126,128 Tests
SI instruction format 23,24,139 Of address arithmetic 23
Social security tax problem Of counting 24
In decimal arithmetic 72,73 With masks 24
In fixed-point arithemtic 42-44 TEST UNDER MASK (TM) 78,79
Sorting problem 39-41,76,77,93-96 TITLE assembler instruction 2,9,120
Source deck 5 TRANSLATE AND TEST (TR) 85,97-104
Source of program interruption, locating 2S Starting address for 100
Source program 5 Use to determine data length 102
Specification exception 32,114 Translate table 92-94
SS instruction format 23,24,56,60-73,139 TRANSLATE (TR) 85,92-94
Standard instruction set 29,139 TRT table 97,100
Standard linkage registers 111 Two's-complement notation 31,33
START assembler instruction 9,52,53,115 Type specification of constants 10,86,127,142
Use of zero in 61
Status, program (in PSW) 25
Undefined symbol 12,13
Storage addressing 18,24
Unnormalized number 126
Storage, main 17,18,20
UNPACK (UNPK) 60,70,73,102
STORE CHARACTER (STC) 69,80,83
USASCII code 20,76
STORE HALFWORD (STH) 37
USING assembler instruction 3,9,10,51-57
STORE MULTIPLE (STM) 40,112
STORE (ST) 9,30,43,44,113 Valid data, checking for 44,93
STORE (STD) 133 Variable-length data, use by SS-format instructions 60
STORE (STE) 133 Variable length of decimal data 20·
Subroutine 107-123 Wallpaper problem 78,79
Assembled separately 120-122 Work areas in storage
Entry point 111 Setting up in decimal operations 63,71
Program design 107
Register availability for 113 ZERO AND ADD (ZAP) 63,66,73
Relocatable 115 Zeros, suppression of leading 86-88
SUBTRACT DECIMAL (SP) 62 Zone and sign tests 82,83
SUBTRACT HALFWORD (SH) 49 Zoned decimal numbers 21,60
SUBTRACT NORMALIZED (SD) 133 Conversion to packed 69,70,81
148
READER'S COMMENT FORM
A Programmer's Introduction 8C20-1646-6
Please comment on the usefulness and readability of this publication, suggest additions and
deletions, and list specific errors and omissions (give page numbers). All comments and sugges-
tions become the property of IBM. If you wish a reply, be sure to include your name and address.
COMMENTS
.. fold fold
."
fold fold
• Thank you for your cooperation. No postage necessary if mailed in the U.S.A.
FOLD ON TWO LINES, STAPLE AND MAIL.
SC20-1646-6
Your comments on the other side of this form will help us improve future editions of this
publication. Each reply will be carefully reviewed by the persons responsible for writing
and publishing this material.
Please note that requests for copies of publications and for assistance in utilizing your
IBM system should be directed to your IBM representative or the IBM branch office
serving your locality.
FOLD FOLD
FIRST CLASS
PERMIT NO. 142
POUGHKEEPSIE, NEW YORK
IBM Corporation
Education Center, Bldg. 005
South Road
Poughkeepsie, New York 12602
I ••• """""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""" •
FOLD FOLD
-- --
--- - --
------- International Business Machines Corporation
-- -----
-
-
- _---
.-~-
-. -
®
Data Processing Division
112 East Post Road, White Plains, New York 10601
(USA only)
SC20-1646-6