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 MVCs 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 x07 and x02.

 

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 C1

FIELDA DC CL3ABC

FIELDB DC CL3DEF

FIELDC DC CL41234

...

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 MVCs:

A DC C123

B DC CABCD

C DC CPQ

... Result:

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,=CXY 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(LC),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 .