of the first-operand and second­
operand lengths.
When the second-operand length is
one or zero, destructive overlap
cannot exist.
7. Special precautions should be taken
if MOVE LONG is made the target of
EXECUTE. 5ee the programming note
concerning interruptible instruc­
tions under EXECUTE.
8. Since the execution of MOVE LONG is
interruptible, the instruction
cannot be used for situations where
the program must rely on uninter­
rupted execution of the instruction
or on the interval timer not being
updated during the execution of the
instruction. Similarly, the
program should normally not let the
first operand of MOVE LONG include
the location of the instruction or
of EXECUTE because the new contents
of the location may be interpreted
for a resumption after an inter­
ruption, or the instruction may be
refetched without an interruption.
9. Further programming notes concern­
ing interruptible instructions are included in the section "Interrup­
tible Instructions" in Chapter 5, "Program Execution." MOVE NUMERICS
[55]
'D1 ' L I ~~ B2 I B, I ~_, --L.-_L-- o 8 16 20 32 36 47
The rightmost four bits of each byte in the second operand are placed in the rightmost bit positions of the corre­
sponding bytes in the first operand.
The leftmost four bits of each byte in
the first operand remain unchanged. Each operand is processed left to right. When the operands overlap, the result is
obtained as if the operands were proc­ essed one byte at a time and each result
byte were stored immediately after
fetching the necessary operand bytes. Condition Code:
unchanged.
Program Exceptions: The code remains
Access (fetch, operand 2; fetch and
store, operand 1)
1. An example of the use of the MOVE NUMERICS instruction is given in
Appendix A.
2. MOVE NUMERICS moves the numeric
portion of a decimal-data field
that is in the zoned format. The
zoned-decimal format is described
in Chapter 8, "Dec i ma 1
Instructions." The operands are
not checked for valid sign and
digit codes.
3. Accesses to the first operand of MOVE NUMERICS consist in fetching
the rightmost four bits of each
byte in the first operand and
subsequently storing the updated
value of the byte. These fetch and
store accesses to a particular byte
do not necessarily occur one -imme­
diately after the other. Thus,
this instruction cannot be safely
used to update a location in stor­
age if the possibility exists that
another CPU or a channel may also
be updating the location. An exam­
ple of this effect is shown for OR (01) in the section "Multiprogram­
ming and Multiprocessing Examples"
in Appendix A. MOVE WITH OFFSET MVO Dt(Lt,Bt),D2(L2,B2) [SS]
'F1' I L, I L2 I B, I ~, B2 ~~ 0 8 12 16 20 32 36 47
The second operand is placed to the left
of and adjacent to the rightmost four
bits of the first operand.
The rightmost four bits of
operand are attached as the
bits to the second operand,
operand bits are offset by
positions, and the result is the first-operand location.
the first
rightmost
the second
four bit
placed at
The result is obtained as if the oper­
ands were processed right to left. When
necessary, the second operand is consid­
ered to be extended on the left with
zeros. If the first operand is too
short to contain all of the second oper­
and, the remaining leftmost portion of
the second operand is ignored. Access
exceptions for the unused portion of the
second operand mayor may not be indi­
cated.
When the operands overlap, the result is
obtained as if the operands were proc­
essed one byte at a time, as if each
result byte were stored immediately
Chapter 7. General Instructions 7-27

after fetching the necessary operand bytes, and as if the left digit of each second-operand byte were to remain available for the next result byte and
need not be refetched.
Condition Code: The code remains Unchanged. Program Exceptions:
Access (fetch, operand 2; fetch and store, operand 1)
Programming Notes
1. An example of the use of the MOVE WITH OFFSET instruction is given in Appendix A.
2. MOVE WITH OFFSET may be used to shift packed decimal data by an odd
number of digit positions. The
packed-decimal format is described 1 n Chapter 8, "Decimal Instruc­
tions." The operands are not
checked for valid sign and digit
codes. In many cases, however,
SHIFT AND ROUND DECIMAL may be more
convenient to use. 3. Access to the rightmost byte of the
first operand of MOVE WITH OFFSET consists in fetching the rightmost
four bits and subsequently storing
the updated value of this byte.
These fetch and store accesses to the rightmost byte of the first operand do not necessarily occur
one immediately after the other.
Thus, this instruction cannot be safely used to update a location in storage if the possibility exists
that another CPU or a channel may also be updating the location. An
example of this effect 15 shown for OR (Or) in the section "f'1ultipro­ grarnming and Multiprocessing
Examples" in Appendix A.
4. The storage-operand references for MOVE WITH OFFSET may be multiple­ access references. (See the section "Storage-Operand Consisten­ Cy" in Chapter 5, "Program Execution.") MOVE ZONES MVZ [SS] ~ __ 'D_3 __ ' __ ~ ____ L __ ~I __ B_l~I~~, B. I ~~ o 8 16 20 32 36 47
7-28 System/370 Principles of Operation The leftmost four bits of each byte in
the second operand are placed in the
leftmost four bit positions of the
corresponding bytes 1n the first
operand. The rightmost four bits of each byte in the first operand remain unchanged.
Each operand is processed left to right.
When the operands overlap, the result is
obtained as if the operands were proc­
essed one byte at a time and each result
byte were stored immediately after the
necessary operand byte is fetched.
Condition Code: unchanged.
The code remains Program Exceptions:
Access (fetch, operand 2; fetch and
store, operand 1)
Programming Notes
1 . An example of the use of the MOVE ZONES instruction is given in
Appendix A.
2. MOVE ZONES moves the zoned portion
of a decimal field in the zoned
format. The zoned format is described in Chapter 8, "Decimal Instructions." The operands are not checked for valid sign and
digit codes.
3. Accesses to the first operand of MOVE ZONES consist in fetching the
leftmost four bits of each byte in
the first operand and subsequently
storing the updated value of the
byte. These fetch and store
accesses to a particular byte do not necessarily occur one imme­ diately after the other. Thus, this instruction cannot be safely used to update a location in stor­
age if the possibility exists that another CPU or a channel may also
be updating the location. An exam­ ple of this effect is shown for the OR (01) instruction in the 5~ction "Multiprogramming and Multiprocess­
ing Examples" in Appendix A. MULTIPLY MR [RRJ , lC' o 8 12 15