MVC is an instruction which is designed to copy a collection of consecutive bytes from one storage location to another. As you can see from the instruction format above, the instruction carries with it the number of bytes to be copied, as well as the beginning addresses of the source and target fields. Notice that the instruction does not specify the ending addresses of either field - the instruction is no respecter of fields. MVC copies LL1 + 1 consecutive bytes from the storage location designated by B2D2D2D2 to the storage location designated by B1D1D1D1. The copying occurs one byte at a time from Operand 2 to Operand 1, and within each operand, from lower to higher numbered addresses.
The length (LL1) determines the number of bytes which will be copied. The length is usually determined implicitly from the length of operand 1 but the programmer can provide an explicit length. Consider the two example MVC’s below,
Object code Assembler code
FIELDA DS CL8
FIELDB DS CL5
D207C008C010 MVC FIELDA,FIELDB Implicit length
D202C008C010 MVC FIELDA(3),FIELDB Explicit length
In the first example, the length implicitly defaults to 8, the length of FIELDA. In the second example, the length is explicitly 3. Notice that the assembled length (LL1) is one less than the implicit or explicit length. This can be seen in the object code above where the assembled lengths are x’07’ and x’02’.
The copying operation is usually straightforward, but can be more complicated by overlapping the source and target fields. Keep in mind that the copy is made one byte at a time. Consider the following examples,
Object code Assembler code
ONE DC C’1’
FIELDA DC CL3’ABC’
FIELDB DC CL3’DEF’
FIELDC DC CL4’1234’
D202C008C00B MVC FIELDA,FIELDB After FIELDA = ’DEF’
D201C00EC008 MVC FIELDC,FIELDA After FIELDC = ’ABCD’
D201C008C007 MVC FIELDA,ONE After FIELDA = ’1111’
In the first MVC above, 3 consecutive bytes in FIELDB are simply copied to FIELDA. In the second example, 4 consecutive bytes are copied into FIELDC (implicit length = 4) from FIELDA. Since FIELDA was only 3 bytes long the fourth byte was copied from the first byte of the next field - FIELDB. The third MVC is complicated by the fact that the source and target fields overlap. We will examine the third move in some detail.
The example above depends heavily on the fact that the source and target fields overlap and that bytes are copied one at a time. In fact, it is common to use this technique to clear fields. Assume you have a buffer you would like to clear to spaces. By defining a single blank directly in front of the field you want to clear and moving the blank field to the buffer, the blank can be propagated throughout the buffer:
MVC BUFFER,BLANK BLANK IS PROPAGATED
BLANK DC C’’ BLANK MUST IMMEDIATELY PRECEDE…
BUFFER DS CL133 …THE BUFFER
Some Unrelated MVC’s:
A DC C’123’
B DC C’ABCD’
C DC C’PQ’
MVC A,B A = ’ABC’ B = ’ABCD’
MVC A+1,B A = ’1AB’ B = ’CBCD’
MVC A+1(2),B A = ’1AB’ B = ’ABCD’
MVC B,=C’XY’ B = ’XY??’ Two bytes copied from
the literal pool, two
unknown bytes are copied
MVC B,B+1 B = ’BCDP’ Left shift
MVC B+1,B B = ’AAAA’ First byte is propagated
MVC C,A C = ’12’ A = ’123’ Truncation
MVC A(L’C),C A = ’PQ3’ Explicit Length attribute
MVC A(1000),B Assembly Error - max length is 256 bytes
MVC A,B(20) Assembly Error - Op-1 determines length
1. Pay attention to the lengths of the fields involved in any MVC statement. If the target field is longer than the source field, bytes following the source may be transferred. If the target field is shorter than the source field, bytes from the source may may be truncated.
2. Be careful of using literals in an MVC, since stray bytes in the literal pool will be moved if the specified length is longer than the literal. Lengths can also be specified in a literal (=CL133’ ‘). The following typical error MVC BUFFER,=C’ ‘ can be fixed as MVC BUFFER,=CL80’ ‘.