IBM Assembler Mannual

IBM 370 ASSEMBLY LANGUAGE
IBM 370 ASSEMBLY

LANGUAGE
BASIC COURSE
1 / 118
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
2 / 118
CONTENTS
Introduction
Basic Concepts
Instructions
Symbols, literals, expressions, Constants and data areas, location
counter
Integer operations
Decimal operations
Floating point operations
Data transfer and Logical operations
Bit manipulations
Branching
Assembler Directives
JCL aspects
Subroutines, linkage 24 bit mode
Macros and conditional assembly
MVS system Macros
VSAM Macros
Linkage Conventions, 24 & 31 bit addressing, mixed mode
addressing issues
References
1. High level assembler for MVS & VM & VSE, Programmers Guide MVS & VM edition
2. High level assembler for MVS & VM & VSE, Language Reference MVS & VM edition
3. MVS Programming Assembler Services guide
4. MVS Programming Assembler Services reference
5. MVS assembly language by McQuillen and Prince
6. Assembly language programming for the IBM370 and compatible computers by
Michael D. Kudlick.
INTRODUCTION
What is Assembly Language
Lowest-level of programming on a system

Symbolic forms of representing machine language instructions
Usually represents a single machine instruction
Machine dependent
More Difficult to use than a high-level language
Advantages over high-level language

Very efficient and tight code can be developed
Disadvantages
Applications development time is more
Applications are machine dependent
Difficult to learn and understand
Advantages over machine language
Use of mnemonic operation codes helps remembering the instructions

Symbols can be used
Macros can be used to generate repeated codes
Conditional assembly enables tailoring the code generated
3 / 118
back
BASIC CONCEPTS
4 / 118
back
IBM-370 MACHINE ARCHITECTURE
Main storage Addressed by 24 bits or 31 bits

One single address space contains code and data
Byte is the least addressable unit
Instruction execution is faster if data is aligned on a full word boundary
Instruction categories
Fixed point Arithmetic,
Decimal Arithmetic,
Floating point Arithmetic,
Logical Operations,
Branching,
Status Switching,
Input Output
Programmer accessible Hardware Registers are
Program Status Word (PSW) 64 bits wide
General Purpose Registers (GPRs)
Floating Point Registers (FPRs)
Control Registers (CRs) 0-15 each 32 bits wide
Access Registers (AR'S) 0-15

PSW
64 bits in length
Contains the Condition Code (two bits)
Address of the next instruction to be executed.
PSW Key field

GPR'S
numbered 0-15 and 32 bits wide
Used as accumulators in Fixed point arithmetic
Used as base and index registers in computing the effective address
Two consecutive registers can be used to hold 64bit operands addressed by even register
AR'S
Numbered 0-15 each 32 bits wide
Used to point to address / data space

FPR
Used for floating point operations
Numbered 0,2,4,6 each 64 bits wide
64 bits in length
Can contain short or long operand
Two adjacent registers can be used as 128 bit register for extended precision
CR'S
Control registers each of 32 bits are available
Used by the IBM control program
Instructions to access / modify them are privileged and can be issued only by the OS.
INPUT/OUTPUT
Data processing and I/O processing are concurrent
Consists of Channel subsystem, Control Unit and I/O unit
5 / 118
ASSEMBLY STATEMENT FORMAT

NAME FIELD
OPERATION FIELD
10
OPERAND FIELD
16
REMARKS *
SEQUENCE
72
Fixed Format. Can be changed only through ICTL Assembler Directive

Blank lines are invalid
Fields in a statement are separated by one or more blanks
Name / label field if present must start in column 1 and maximum 8 characters in length
To continue a statement to next line, type a non blank character in column 72 and
continue the next line from column 16
Comment lines start with character ('*') on column 1
6 / 118
INSTRUCTIONS
TYPES OF INSTRUCTIONS
machine instructions
Assembler instructions (directives)
Macro instructions
Example :
PRINT
NOGEN
TEST1
CSECT
STM
14,12,12(13)
BALR
12,0
USING
*,12
ST
13,SAVE+4
LA
13,SAVE
MVC
DATA1,DATA2
PUTMSG
WTO
'message'
L
13,SAVE+4
LM
14,12,12(13)
SR
15,15
BR
14
DATA1
DS
CL100
DATA2
DS
CL100
SAVE
DS
18F
END
back
Assembler Directive
Machine instruction
Machine instruction
Assembler Directive
Machine instruction
Machine instruction
Machine Instruction
Macro instruction
Machine instruction
Machine instruction
Machine instruction
Machine Instruction
Data Definition
Data Definition
Data Definition
Assembler Directive
INSTRUCTIONS FUNDAMENTALS
Two, four, or six bytes in length
Should begin on a half-word boundary
First byte normally contains the operation code. In some instructions it is two bytes.
Operation code specifies the function of the instruction
Operand designation follows the operation code

Operands
Entities that are involved in operations defined by operation code
Operands can be either implicit or explicit
Four types of operands

Register operand
Example
AR 3,2
immediate operand
Example
MVI DATA,X'F1'
Storage operand
Example
L 3,FIELD1
Implied operand,
Example
LM 14,12,SAVE
REGISTER OPERAND
Identified by R field in the instruction
Specifies either GPR or FPR
Operand access is faster
Example AR 1,2
IMMEDIATE OPERAND
Contained with in the instruction itself
7 / 118
Eight bit value

Self defining term or an absolute symbol can be used
Example :
MVI DATA,B'10000000'
STORAGE OPERAND
Resides in memory
Address is not specified explicitly
Base and 12 bit offset with (in some instructions) index register is used
Program can be relocated
If Register 0 is used as a base or index register its contents are ignored
12 bit displacement
BALR instruction is used to load base register
If symbols are used assembler resolves it to base displacement form
Effective address = (base register) + (Index Register) + 12 bit displacement

(note that some instruction formats do not support index register)
base register should be made to contain the base address at run time
Size of storage operand is implied by the instruction for some instructions
For some instructions Length field(s) is/are embedded in the instruction
Storage operands can be specified in implicit form as a re-locatable expression

Example
L 3,DATA
L 3,DATA+4
Storage operands can be specified in the Explicit form

Example
L 3,4(1,2)
Explicit addresses are of the form
D2(X2,B2)
or
D2(B2)
or
D2(L2,B2)
or
D1(L1,B1)
or
D1(B1)
Absolute addresses are also assembled in base displacement form.

However the value in the base register will not change on relocation
Implicit addresses are those where a single re-locatable or absolute expression is specified
Example
L
4,DATA
L
3,DATA+4
LA
2,1000
.
.
DATA DS
F
IMPLIED OPERAND
The instruction implies the operand
Example
TRT
D1(L,B1),D2(B2)
Registers 0,1 participate in this operation
8 / 118
INSTRUCTIONS CLASSIFICATION
FIRST HALF WORD
SECOND HALF WORD
THIRD HALF WORD
RR FORMAT
OP CODE
R1
R2
12
15
RRE FORMAT
OP CODE
R1
16
RX FORMAT
OP CODE R1
24
X2
12
B2
16
R2
28
31
D2
20
31
RS FORMAT
OP CODE
0
R1
8
R3
12
B2
16
D2
20
31
SI FORMAT
OP CODE
0
I2
B1
16
DI
20
31
S FORMAT
OP CODE
B2
16
SS FORMATS
OP CODE
L1
L2/I3
8
OP CODE
12
20
B1
16
L
8
D2
D1
20
B1
16
31
B2
32
D1
20
D2
36
B2
32
47
D2
36
47
EXAMPLES :
RR type instruction
AR 2,3
reg 2 <== reg 2 + reg 3
RS type instruction
BXH 1,3,D2(B2)
reg 1 <== reg 1 + reg 3
If reg1>reg3 then branch
RX type instruction
L 1,D2(X2,B2) reg 1 < == memory referenced by (D2 +X2 +B2)
S type instruction
LPSW D2(B2)
SI type instruction
NI D1(B1),I2
Storage type instruction
MVC D1(L,B1),D2(B2)
PACK D1(L1,B1),D2(L2,B2)
9 / 118
10 / 118
SYMBOLS, LITERALS, CONSTANTS, DATA AREAS, LOCATION COUNTER

back
SYMBOLS
A sequence of
one to
eight
characters as specified
below under
ORDINARY,VARIABLE,SEQUENCE symbols
Absolute value assigned to a symbol by using 'EQU' assembler instruction with an absolute
value operand
A re-locatable value is assigned to a symbol by using it in the name field of a machine
instruction
Symbols can be used in operand fields to represent registers, displacements, lengths,
immediate data, addresses etc.
Example :
LABEL001
MVC
S1,S2
BR
QUIT
QUIT
BR
14
S1
DS
CL100
S2
DC
CL100'THE QUICK BROWN FOX'
COUNT
EQU
10
Ordinary Symbols
Optional
used in the name and operand field of machine/assembler instructions
Up to eight Alphanumeric characters A-Z,$,#,&,0-9
First character must be alphabetic A-Z
Rest can be alphanumeric

Example
ABCD0001
Variable Symbols
First character must be an ampersand
second character must be alphabetic
Up to six alphanumeric characters

Example
&ABC0001
Sequence Symbols
First Character must be a period
Next Character must be alphabetic
Up to six alphanumeric characters

Example
.ABC0001
Advantages of symbols
Easier to remember and use
Meaningful symbol names instead of values
For address the assembler calculates the displacement
Change the value at one place (through an EQU) instead of several instructions
Printed in the cross-reference table by the assembler

Symbol Length attribute
TO
DS
FROM
DS
ADCON
DC
CHAR
DC
DUPL
DC
CL80
CL240
A(OTHER)
C'YUKON'
3F'200'
L'TO = 80
L'FROM = 240
L'ADCON = 4
L'CHAR = 5
L'DUPL = 4
11 / 118
Self Defining terms

Can be used to designate registers, masks, and displacements within the operand entry
Decimal self-defining term
An unsigned decimal integer
maximum number of digits 10
Maximum value 2**31-1
Hexadecimal self-defining
A Hexadecimal integer within apostrophes and preceded by a X
Maximum number of digits 8
Maximum value 2**31-1
Character self-defining term
A character string within apostrophes and preceded by a C
Maximum number of characters 256
EXAMPLES:
15
241
B'1101'
X'F'
X'F1F2'
C'ABCD'
C'&&'
C''''''
UPTO 2,147,483,647
UPTO 32 BITS
UPTO 8 HEX DIGITS
UPTO 4 CHARACTERS
TWO AMPERSANDS TO REPRESENT ONE
TWO APOSTROPHES TO REPRESENT ONE
Literals
FIELD
ZERO
FLAG
LOCORE
L
L
MVC
L
L
DC
MVC
MVI
MVI
.
.
EQU
DS
LA
LA
.
EQU
Absolute expressions
FIRST
A
B
C
ABSA
ABSB
ABSC
1,=F'200'
2,=A(SUBRTN)
MESSAGE(16),=C'THIS IS AN ERROR'
3,=F'33'
BOTH ARE SAME
3,FIELD
BOTH ARE SAME
F'33'
FLAG,=X'00'
SAME EFFECT
FLAG,X'00'
SAME EFFECT
FLAG,ZERO SAME EFFECT
X'00'
C
4,LOCORE
4,1000
SAME EFFECT
SAME EFFECT
1000
An expression is absolute if it's value is unchanged by program relocation
CSECT
DC
F'2'
DC
F'3'
DC
F'4'
EQU
100
EQU
X'FF'
EQU
B-A
12 / 118
ABSD
EQU
*-A
All these are absolute expressions:ABSA
15
L'A
ABSA+ABSC-ABSC*15
B-A
ABSA+15-B+C-ABSD/(C-A+ABSA)
Relocatable expressions
A relocatable expression is one whose value changes with program relocation.
FIRST
CSECT
A
DC
H'2'
B
DC
H'3'
C
DC
H'4'
ABSA
EQU
10
ABSB
EQU
*-A
ABSC
EQU
10*(B-A)
The following are relocatable expressions:A
A+ABSA+10
B-A+C-10*ABSA
Location Counter
Location counter is incremented after instruction or constant is assembled

to the next available location
Assembler checks boundary alignment and adjusts location counter if reqd.
While assembling the current line the location counter value does not change
Location counter
000004
000007
000008
00000C
000010
000018
000018
000020
000028
000030
Source Statements
DONE
DC
CL3'SOB'
BEFORE
EQU *
DURING
DC
F'200'
AFTER
EQU *
NEXT
DS
D
AFTNEXT
EQU *
NEXT1
DS
D
NEXT2
DS
D
ORG *+8
NEXT3
DS
D
Example :
LOOP
EQU
B
.
.
.
B
*
*+80
LOOP
13 / 118
ATTRIBUTES OF SYMBOLS :
Length attribute
Referred to as L'symbol
For a symbol defined by "DC' or 'DS', it is the implicit or explicit length.
For a symbol referring to a machine instruction, it is the length of the instruction.
For a 'EQU' symbol, it is the length of the left most term or supplied by the second operand
Example :
A
AA
S1
S2
S3
BUF
BUF2
BUF3
DS
DS
DS
AR
EQU
EQU
EQU
EQU
EQU
EQU
EQU
F
20FL4
XL3
1,2
A+4
102
X'FF +A'
C'YUK'
A,256
*+10
*,80
length
4
4
3
2
4
1
1
1
256
1
80
Type attribute
Referred to as 'T' symbol
Gives the one character type code of the symbol
A,Y,V,S
For the related Address Constants
B,C,D,E,F,H,Z,P
For the related data constants
I
For machine instruction
M
For a Macro instruction
J
For a control section name
T
For a EXTRN symbol
$
For a WXTRN symbol
N
For a self defining term
O
Null string
CONSTANTS AND DATA AREAS
Run Time Constants

DC directive
Literals
Self defining terms
Assembly time constants
EQU statement
Constants can be absolute/re-locatable

A re-locatable constant has a unbalanced re-locatable term
DC instruction
To reserve storage and initialise it with values
Location counter advanced by the number of bytes associated with the specified type
Not true constants, the values can be changed in the program
Similar to specifying initial values in variable declarations of a high level language
DC
DUPLICATING FACTOR TYPE
SYNTAX
LENGTH MODIFIER CONSTANT
{NAME}
DC
14 / 118
{DUP}TYPE{MOD}{V1,V2,...VN}
Run time constant

DC
DC
DC
DC
DC
DC
DC
DC
DC
DC
DC
DC
DC
DC
DC
DC
DC
DC
DC
DC
DC
DC
DC
DC
DC
DC
DC
DC
DC
DC
DC
DC
DC
DC
TYPE
BYTES ALLOC
F'100,-10,200'
12
F'123'
4
F'-123'
4
3F'23'
12
H'20'
2
H'123,23,-34'
6
B'11000001'
1
X'FFFFFFFF'
4
X'FF01FF01'
4
C'ABCDEF'
6
C'abcdefg''A&&SS@#..' 16 , note double & and '
P'-1234'
3
P'1234'
3
P'-34'
2
Z'1234'
4
E'-3.25E10'
4
E'+.234E-10'
4
E'-2.3E15'
4
A(LOOP1)
4
V(LOOP1)
4
S(FIELD2)
2
C'USER01'
6
F'100,200'
Two full words with value 100,200
CL3'JAN,FEB'
Months contain 3 bytes value "JAN'
3H'2,4,8,16'
12 half words with the given value
B'10001000'
1
C'SAMPLE STRING'
13
P'123'
2
ZL10'123'
10
PL4'123'
4
E'1.25'
4
D'2.57E65'
8
AL3(THERE)
3
V(EXTSYM)
4
DEFINE STORAGE (DS)
To reserve storage
Storage is not initialised
Location counter advanced by bytes allocated

DS
DUPLICATING FACTOR TYPE
SYNTAX
{NAME}
EXAMPLES
DS
DS
DS
{DUP}TYPE{MOD}
DS
DS
DS
DS
80C
CL80
F
10F
H
2CL3
LENGTH MODIFIER
Bytes allocated 4
40
2
6
80
L'A=1
80
L'A=80
DS
DS
DS
DS
DS
15 / 118
4D
0F
0D
0CL8
100H
32
0
0
0
200
used to force a word Boundary

used to force a double word boundary
length attribute is 8
A self defining term is an absolute constant that can be written as a

A binary integer
B'1001'
A decimal integer
3
A hexadecimal integer
X'4A'
A sequence of text characters C'ABCD'
These can be used as immediate operands in any instruction which needs an
immediate operand.
Example
CLI
0(8),C'Z'
A literal is a symbolic representation of a constant to which the assembler assigns an address

FCON
DC
L
L
L
MVC
LOAD
MOVE
F'1'
5,FCON
5,=F'1'
2,=F'-4'
MSG,=C***Error ***'
The first two statements are exactly equivalent to the third.
A convenient means of introducing constants without the use of 'DC' instruction

Storage is allocated for literals at the end of the first CSECT (Literal Pool). To avoid
addressing problems, use a LTORG at end of each CSECT
Storage allocation can be forced at any point by 'LTORG" assembler instruction
Two literals are the same if their specifications are identical
Assembler translates a literal into a base register and a displacement

A equivalence constant allows a programmer to define a value for a symbol and use it
wherever there is a need to employ that value.
R1
HERE
OFF
ON
Y
Z
W
EQU
EQU
EQU
EQU
DC
EQU
EQU
CLI
BE
CLI
BE
1
*
X'00'
X'FF'
F'4'
4
Y
W is equivalent to Y
STATUS,ON
POWERON
STATUS,OFF
POWEROFF
Data Alignment
Instructions have to be aligned on half-word boundary
Data can be specified to be aligned to

Double word
D
(Divisible by 8)
Full-word
F
(Divisible by 4)
Half-word
H
(Divisible by 2)
Location counter skipped as per alignment requirement

Example :
000100
DC
C'ABC'
000103
000104
000108
000109
000110
000111
000112
present
16 / 118
skipped
DC
DC
F'4'
C'A'
skipped
skipped
skipped
DC
F'560'
IF ASSEMBLER OPTION ALIGN IS SPECIFIED

Assembler checks storage addresses (labels) to ensure that they are aligned on boundaries
required by the instruction.
Data areas are aligned on boundaries implicit with their type if no length modifier is
LOCTN COUNTER
000010
DATA
000014
PROGRAM
DC
C'ABC'
DS
F
ASSM. AT WORD BDRY
IF NOALIGN IS SPECIFIED
Constants and data areas are not automatically aligned
Assembler does not check storage addresses for boundary alignment.

LOCTN COUNTER
PROGRAM
000010
DATA
DC
C'ABC'
000013
DS
F
ASSM. AT NEXT LOC
Example
FIRST
SAVE
A
B
C
ABSA
ABSB
CSECT
STM
14,12,12(13)
BALR 12,0
USING *,12
ST
13,SAVE+4
LA
13,SAVE
WTO
'ASM1 REPORTING'
L
3,=F'200'
LA
3,ABSB
MVC
DATA1(6),=C'ABCDEF'
MVC
DATA1,=CL20'ABCDEF'
L
13,SAVE+4
LM
14,12,12(13)
SR
15,15
BR
14
DS
18F
DC
A(SAVE1)
DC H'2'
DC H'3'
DC H'4'
EQU 10
EQU *-A
DC
F'100'
DC
F'-100'
DC
H'100'
DC
3H'100'
DC
C'ABCEFGH'
DC
CL20'ABCDEFGH'
DATA1
DC
DC
DC
DC
DC
DS
END
17 / 118
10C'AB'
P'123'
P'-123'
PL5'-123'
3PL5'-123'
CL20
18 / 118
INTEGER OPERATIONS
back
FIXED POINT ARITHMETIC

ADD
SUBTRACT
MULTIPLY
DIVIDE
ARITHMETIC COMPARE
LOAD
STORE
ARITHMETIC SHIFT
CONVERT TO BINARY
CONVERT TO DECIMAL
AR,A,AH,ALR,AL
SR,S,SH,SLR,SL
MR,M,MH
DR,D
CR,C,CH
LR,L,LH,LTR,LCR,LPR
ST,STH,STM
SLA,SRA,SLDA,SRDA
CVB
CVD
Constants used
Fixed Point
Binary
Hexadecimal
Character
Decimal
Address
Type
H and F
B
X
C
P
Y,A,S,V,Q
19 / 118
INTEGER ARITHMETIC
GPR's are 32 bits with bit 0 as a sign bit

Negative numbers stored as two's complement
Both Full word and Half Word instructions are supported
GPR/GPR and GPR/Memory instructions available
Half words converted to full word by extending sign bit to the left
Two's Complement
Decimal
0
0000
+1
0001
+2
0010
+3
0011
+4
0100
+5
0101
+6
0110
+7
0111
Binary
0
-1
-2
-3
-4
-5
-6
-7
Decimal
0000
1111
1110
1101
1100
1011
1010
1001
Binary
Addition and Subtraction

+6
+(+1)
0110 -6
1010 +5
0101 -5
1011
0001 +(-1) 1111
+(+6) 0110 +(-6) 1010
--------------------0111
1001
1011
0100
00
11
01
10
No overflow
No overflow
Overflow
Overflow
If the carry into the sign bit is different from the carry out of it, there is an overflow condition.
L
Copy full word from memory to GPR

RX
L
3,A
GPR3
Before
0246 0357
After
000A 00B0
R1,D2(X2,B2)
Memory Field A
000A 00B0
000A 00B0
ST
Copy a full word from GPR to memory RX

ST
3,A
GPR3
Before
0123 0456
0123 0456
R1,D2(X2,B2)
Memory field A
0ABC 0DEF
0123 0456
LH
Copies a half word from memory to GPR

LH
3,A
GPR3
Before
0159 0260
After
0000 4321
RX
R1,D2(X2,B2)
Memory Field A
4321
4321
STH
Copy a half word from GPR to memory RX

STH
3,A
GPR3
Before
0123 0456
0123 0456
R1,D2(X2,B2)
Memory field A
0DEF
0456
20 / 118
LM
Copies 1 to 16 Full words from memory RS

R1,R3,D2(B2)
to consecutive GPR,s
LM
2,4,A
GPR'S
Memory Address
Before
2:00001234
A+0:0001ABCD
3:00003456
A+4:0002BCDE
4:00005678
A+8:0003CDEF
After
2:0001ABCD A+0:0001ABCD
3:0002BCDE A+4:0002BCDE
4:0003CDEF A+8:0003CDEF
STM
Copies 1 to 16 Full words to memory

From consecutive GPR,s
STM 2,4,A
Before
After
LR
Copies one GPR to another

LR
3,4
Before
After
ADDITION
A
AR
SR
AH
Adds a memory field to GPR

Example 64+10=74.
A
3,=F'10'
Before
After
RS
R1,R3,D2(B2)
GPR'S
2:00001234
3:00003456
4:00005678
2:00001234
3:00003456
4:00005678
Memory Address
A+0:0001ABCD
A+4:0002BCDE
A+8:0003CDEF
A+0:00001234
A+4:00003456
A+8:00005678
RR
R1,R2
GPR3
GPR4
ABCD EF00
1234 5678
1234 5678
1234 5678
RX
GPR3
0000 0040
0000 004A
R1,D2(X2,B2)
Memory
0000 000A
0000 000A
Subtracts a memory field from GPR

RX
Example 64-10=54
S
3,=F'10'
GPR3
Before
0000 0040
After
0000 0036
R1,D2(X2,B2)
Adds a GPR to another GPR

Example 4096+(-1)=4095
AR
6,5
Before
After
R1,R2
RR
GPR6
0000 1000
0000 0FFF
Subtracts a GPR from another GPR

RR
Example 4096-(-1)=4097
SR
6,5
GPR6
Before
0000 1000
After
0000 1001
Memory
0000 000A
0000 000A
GPR5
FFFF FFFF
FFFF FFFF
R1,R2
GPR5
FFFF FFFF
FFFF FFFF
Adds a half word memory field to a GPR

RX
Example 80+8=88
AH
10,=H'8'
GPR10
Before
0000 0050
0008
After
0000 0058
0008
R1,D2(X2,B2)
Memory
21 / 118
Example 80+(-8)=72
AH
10,=H'8'
Before
After
SH
GPR10
0000 0050
FFF8
0000 0048
FFF8
Memory
Subtracts a half word memory field from RX

Example 8-80=-72
SH
10,=H'80'
GPR10
Before
0000 0008
After
FFFF FFB8
R1,D2(X2,B2) a GPR
AL
Add Logical
RX
R1,D2(X2,B2)
ALR
Adds a GPR logically to another GPR
RR
R1,R2
Memory
0050
0050
Range of result in the GPR is from -2**31 to 2**31-1

If an overflow occurs (carry into sign bit and carry out are different) hardware interrupts occur if
not suppressed through a program mask
For logical additions the operands are assumed to be unsigned
Condition code is set (zero, negative, positive or overflow)
MULTIPLICATION
|--------------consecutive GPR'S------------------------|
|---even numbered GPR--|--odd numbered GPR---|
Before multiplication
Any number
After multiplication
64 bit product V1 X V2
M
Multiply
Example 2 X 3 = 6
L
7,=F'2'
M
6,=F'3'
Before
After
RX
GPR6
any number
0000 0000
MR
Multiply one GPR with another RX
Example 65536 X 65536
L
4,=F'65536'
MR
6,4
GPR6
Before
0000 0000
After
0000 0001
MH
V1
R1,D2(X2,B2)
GPR7
0000 0002
0000 0006
Memory
0003
0003
R1,D2(X2,B2)
GPR7
0001 0000
0000 0000
GPR4
0001 0000
0001 0000
Multiply a GPR with a half word RX

R1,D2(X2,B2)
from a memory field
Example 2 X 5 = 10
L
7,=F'2'
MH
7,=F'5'
GPR7
Memory
Before
0000 0002
0005
After
0000 000A
0005
22 / 118
DIVISION
|--------------consecutive GPR'S-----------------------------|
|---even numbered GPR----|----odd numbered GPR----|
Before Division
64 BIT DIVIDEND V1
After Division
32 BIT REMAINDER
D
DIVIDE even odd GPR pair by memory
Example 7 / 2 = quotient =3, remainder=1
L
9,=F'7'
L
8,=F'0'
D
8,=F'2'
GPR8
Before
0000 0000
After
0000 0001
Rem +1
DR
32 BIT QUOTIENT
RX
R1,D2(X2,B2)Field
GPR9
0000 0007
0000 0003
Quot +3
Divide one even/odd pair GPR with another
GPR
Memory
0002
0002
Divisor +2
R1,R2
Example 150 / -40

L
9,=F'150'
L
8,=F'0'
L
10,=F'-40'
DR
8,10
Before
After
GPR8
0000 0000
0000 001E
rem +30
GPR9
0000 0096
FFFF FFFD
Quot -3
GPR10
FFFF FFD4
FFFF FFD4
Divisor -40
Note: Since the dividend was a positive number extending the 32 bit positive quantity to 64 bit
was achieved by simply setting the high order bits (next reg) to F'0'. However for a negative
dividend sign extension is needed and this can be done by multiplying the low order reg by +1.
The condition code is NOT set by the MULTIPLY and DIVIDE instructions.
To test the result use the LTR instruction.
ARITHMETIC
C
CR
CH
COMPARE
Compare GPR with memory field
Compare a GPR with another
RR
Compare GPR with a memory half word RX
RX
R1,D2(X2,B2)
R1,R2
R1,D2(X2,B2)
Condition code is set ( equal, V1<V2, V2>V2)

LCR
Load complement register
Example
LCR
3,3
Before
After
LCR
3,4
Before
After
LPR
Load positive register
RR
GPR3
FFFFFFFA
00000006
GPR3
87654321
80000000
**ovfl set
RR
R1,R2
R1,R2
GPR4
80000000
80000000
Example
LPR
LPR
LPR
23 / 118
5,4
Before
After
GPR5
000000AB
00000006
GPR4
FFFFFFFA
FFFFFFFA
Before
After
GPR4
FFFFFFFA
0000000AB
GPR5
000000AB
000000AB
GPR8
12345678
80000000
***ovflw
GPR7
80000000
80000000
4,5
8,7
Before
After
LNR
Load negative register
Example
LNR
4,5
RR
Before
After
LPR
4,5
R1,R2
GPR4
FFFFFFFA
FFFFFF55
GPR4
Before
00000011
After
000000AB
Condition code is set( zero, positive , negative, overflow)
GPR5
000000AB
000000AB
GPR5
FFFFFF55
FFFFFF55
24 / 118
DECIMAL OPERATIONS
back
ADD
SUBTRACT
MULTIPLY
DIVIDE
DECIMAL COMPARE
MOVE DECIMAL DATA
WITH 4 BIT OFFSET
SHIFT DECIMAL DATA
SET TO ZERO AND ADD
CONVERT ZONED TO
PACKED
CONVERT PACKED TO
ZONED
AP
SP
MP
DP
CP
Constants used
Decimal
Zoned
Type
P
Z
MVO
SRP
ZAP
PACK
UNPK
BCD Representation (Packed Decimal)

0011
0111
AREA1
AREA2
0010
1000
0101
1001
1100
1101
+325
-789
DS
DC
PL5
P+12345678
X325C
X789D
Only permissible (and mandatory) modifier is the length modifier example PLn
Padding is always at the left with Zeroes
Truncation is from the left and choice of length modifier is crucial

OPCODES are Arithmetic, Comparison, Copying from storage to storage, Conversion to
and from Packed decimal format.
Most instructions are

SS1
D1(L,B1),D2(B2)
(length < 256)
SS2
D1(L1,B1),D2(L2,B2) (length < 16)
ZAP
Zero and add packed
Example
ZAP
A(3),B(4)
SS2
Before
After
AP
Add packed
Example
AP
A(2),B(3)
B
0023456C
0023456C
A
099C
100C
B
00001C
00001C
999C
000C
(ovfl cond)
00001C
00001C
A
099D
100D
B
00001C
00001C
SS2
Before
After
Before
After
SP
A
Dont Care
23456C
Subtract packed
SP
A(2),B(3)
SS2
Before
After
25 / 118
Before
After
999C
000C
(ovfl cond)
00001C
00001C
Before
After
123C
113C
00010C
00010C
MP
Multiply packed
SS2
Length of L2 must be between 1 and 8 and less than L1.
L1 must have at least L2 bytes of high order zeroes
Example
MP
A(4),B(2)
A
B
Before
0000999C
999D
After
0998001D
999D
DP
MP
A(3),B(2)
Before
After
00999C
98001D
**ovflw**
999D
999D
MP
A(2),B(2)
Before
After
012C
012C
**error**
012C
012C
Divide Packed
SS2
DP
D1(L1,B1),D2(L2,B2) L1 (Dividend) and L2(divisor)
L2 < L1
1<=L2<=8
The quotient and remainder is stored in the L1(dividend field) replacing
the dividend
QUOTIENT
REMAINDER
L1-L2 BYTES
L2 BYTES
DIVIDEND FIELD
Example
DP
A(4),B(2)
Before
After
DP
A(4),B(2)
Before
After
DP
A(2),B(1)
DP
A(2),B(3)
ERRORS
A
0000999C
001D001C
|
B
998D
998D
0000999C
3C
00333C0C
3C
|
Before
999C
3C
After
999C
3C
**Divide exception**
***L1-L2=1 (insufficient length for quotient)
Before
999C
00003C
After
999C
00003C
**specification exception**
***L1-L2=-1(impossible length for quotient)
26 / 118
Decimal overflow occurs when result is too long to fit into first operand and a significant digit
would be lost
Data exception occurs whenever

Sign fields are invalid
Operands overlap
The first operand of a MP instruction does not have sufficient zeroes.
COMPARISONS
CP
Compare packed
BE
BH
BL
SRP
SS2
D1(L1,B1),D2(L2,B2)
V1=V2
V1>V2
V1<V2
Shift and Round Packed
D1(L1,B1),D2(B2),I3
SS1
The first operand represents an address

The second operands low order 6 bits is the number of positions to be shifted and direction of
shift. Positive represents left shift and vacated positions on the left are filled with zeroes.
Negative represents a right shift and zeroes are inserted on the left. The sign is not disturbed in
any case. The third operand is the rounding to be applied in case of right shift and is an
immediate operand.
L
8,=XFFFFFFFD
SRP
A(5),0(8),5
before 031415926C
after
000031416C
CONVERSION BETWEEN EBCDIC, BINARY AND PACKED DECIMAL FORMAT
CVD
converts binary to packed decimal

32 bit binary to a 8 byte packed decimal field
Example
CVD 5,A
REG5
A
Before 7F FF FF FF any number
after
7F FF FF FF 00 00 02 14 74 83 64 7C
CVD
5,A
after
REG5
A
Before 80 00 00 00
dont care
80 00 00 00
00 00 02 14 74 83 64 8D
CVB
converts packed decimal to binary

8 byte packed decimal field to a 32 bit binary field
Example
CVB
5,A
REG5
A
Before dont care
00 00 00 00 00 00 01 6C
after
00 00 00 10
00 00 00 00 00 00 01 6C
CVB
5,A
REG5
Before dont care
after
FF FF FF F0
A
00 00 00 00 00 00 01 6D
00 00 00 00 00 00 01 6D
PACK converts EBCDIC to packed decimal

D1(L1,B1),D2(L2,B2)
Operand one will receive packed decimal field
Operand two is the EBCDIC field in zoned decimal format
Example
PACK A(4),B(4)
A
B
Before any
F1 F2 F3 C4
27 / 118
after
00 01 23 4C
F1 F2 F3 C4
UNPK converts packed decimal to EBCDIC

D1(L1,B1),D2(L2,B2)
Operand two is the packed decimal field
Operand one will receive the EBCDIC field
Example
UNPK A(8),B(4)
A
B
Before any
12 34 56 7D
After F0 F1 F2 F3 F4 F5 F6 D7
12 34 56 7D
ED
Converting a packed decimal number

to EBCDIC with editing
D1(L,B1),D2(B2) V1 is pattern, V2 is
packed fld
ED P(15),Y Before Y 0 0 1 2 3 4 5 6 7 D
Before P 40 20 6B 20 20 20 6B 20 21 20 4B 20 20 60 40
After P 40 40 40 40 F1 F2 6B F3 F4 F5 4B F6 F7 60 40
1st byte of pattern is the fill character, in this case a blank
Hex 20 is a digit selector
Hex 21 is a significance starter
Hex 6B is a ,
Hex 4B is a .
Every byte of packed decimal needs two bytes of EBCDIC code
00 12 3C
-----------------
Example of Packed Decimal Divide
FIRST
SAVE
MSG
QUOT
REM
LEN
A
CSECT
STM
BALR
USING
ST
LA
DP
UNPK
UNPK
OI
OI
LA
WTO
L
LM
LA
BR
DS
DC
DC
DS
DC
DC
DS
EQU
DC
14,12,12(13)
12,0
*,12
13,SAVE+4
13,SAVE
A,B
QUOT,A(L'A-L'B)
REM,A+L'A-L'B(L'B)
QUOT+3,X'F0'
REM+3,X'F0'
3,MSG
TEXT=(3)
13,SAVE+4
14,12,12(13)
15,0
14
18F
AL2(LEN)
C'QUOT='
CL4
C','
C'REM='
CL4
*-MSG-2
PL4'+0000999'
F0 F0 F1 F2 C3
DC
END
PL2'-998'
Example of displaying a Integer
FIRST
SAVE
MSG
DW
CSECT
STM
BALR
USING
ST
LA
LA
CVD
UNPK
OI
LA
WTO
L
LM
LA
BR
DS
DC
DS
DS
END
14,12,12(13)
12,0
*,12
13,SAVE+4
13,SAVE
4,2345
4,DW
MSG+2(16),DW
MSG+17,X'F0'
3,MSG
TEXT=(3)
13,SAVE+4
14,12,12(13)
15,4
14
18F
AL2(16)
CL16
D
28 / 118
29 / 118
FLOATING POINT OPERATIONS

ADD
SUBTRACT
MULTIPLY
DIVIDE
ARITHMETIC COMPARE
LOAD INTO FPR
STORE INTO AREAS
back
ADR,AD,AER,AE,AWR,AW,AUR,AU,AXR
SDR,SD,SER,SE,SWR,SW,SUR,SU,SXR
MDR,MD,MER,ME,MXR,MXDR,MXD
DDR,DD,DER,DE
CDR,CD,CER,CE
LDR,LD,LER,LTDR,LTER,LCDR,LCER,LPDR,LPER
LNDR,LDER,LRDR,LRER
STD,STE
Constants used
Type
Floating point
E,D,L
Floating-point Number representation
Consists of a signed hexadecimal fraction and an unsigned seven-bit binary integer ,called
as characteristic
Characteristic represents signed exponent in excess-64 notation
A normalised floating -point number has a nonzero leftmost hexadecimal fraction digit.
If one or more leftmost fraction digits are zeros, the number is said to be un-normalised.
A normalised number represents a quantity with the greatest precision.

Un-normalised numbers are normalised by shifting the fraction left, one digit at a time, until
the leftmost hexadecimal digit is nonzero and reducing the characteristic by the number of
hexadecimal digits shifted.
Addition and subtraction with extended operands, as well as the multiply, divide, and halve
operations, are performed only with normalisation. Addition and subtraction with short or long
operands may be specified as either normalised or not normalised.
Floating-Point Data format
Short floating-point number
Represented by 32 bits
Bit 0 is sign bit
Bits 1-7 are characteristic
Bits 8-31 are digit fraction
Can reside in the storage or in the floating point registers

Long floating-point number
Bit 0 is sign bit
Bits 1-7 are characteristic
Bits 8-63 are digit fraction
Can reside in the storage or in the floating point registers

extended floating point number
Bit 0 of high-order 64 bits is the sign bit
Bits 1-7 of high-order 64 bits contains are characteristic
Bits 8-63 of high-order 64 bits and bits 72-127 of low order 64 bits contains the 28 digit
fraction
Can only reside in the floating point registers

Floating Point instructions
Floating point registers 0,2,4,6 are used in the instructions
Only left half of FPR is used if short floating point number is specified
30 / 118
FPR 0 & 2,4 & 6 can be used to contain extended floating point
Instructions are available for data loading, arithmetic and comparison number
31 / 118
DATA TRANSFER AND LOGICAL OPERATIONS
MOVE
LOGICAL COMPARE
AND LOGICAL
OR LOGICAL
EXCLUSIVE OR
TESTING BINARY PATTERNS
INSERTING CHARS INTO GPR
STORE CHARS INTO AREAS
LOAD ADDRESS INTO GPR
LOGICAL SHIFT OF GPR
DATA TRANSLATION
EDIT
MVI,MVC,MVZ,MVCL
CLR,CL,CLC,CLCL,CLM
NR,N,NI,NC
OR,O,OI,OC
XR,X,XI,XC
TM
IC,ICM
STC,STCM
LA
SLL,SRL,SLDL,SRDL
TR,TRT
ED,EDMK
back
BYTE AND STRING MANIPULATIONS

IC
Insert character
RX
Copies 1 byte from memory to 8 right

most bits of a GPR
RX
Copies 1 byte (right most 8 bits) from

GPR to Memory
RS
Copies 1 to 4 bytes depending

on the mask from memory to GPR
RS
Copies 1 to 4 bytes depending on the

mask from GPR to memory
R1,D2(X2,B2)
STC
store Character
R1,D2(X2,B2)
ICM
Insert Characters under mask
R1,Mask,D2(B2)
STCM Store characters under mask
R1,R3,D2(B2)
MVI
Move Immediate
SI
Copies 1 byte from immediate
field of the instruction to memory
D1(B1),I2
MVC
Move Characters
SS
Copies 1 to 256 chars from one
memory field to another
D1(L,B1),D2(B2)
MVCL Move Characters Long
RR
Copies 1 to 2**24 chars from one

SS
Copies 1 to 256 bytes from one memory field to

another reversing the order of bytes Comparison
R1,R2
MVCIN
Move Inverse
COMPARISON (LOGICAL)
Unsigned 8 bit numbers (logical quantity)
Smallest byte is X00, Largest is XFF
Comparison starts from left most position (high order)
CL
32 / 118
Compare logical
RX
Compares a 4 byte string in memory to

contents of a GPR
RR
Compares 4 bytes from two GPRS
R1,D2(X2,B2)
CLR
Compare Logical Register

R1,R2
CLM
Compare Logical under mask
RS
Compares 1 to 4 bytes (determined by

mask) from a GPR to a memory field
SI
Compares an 1 byte immediate operand

to a byte in memory
SS
Compares 1 to 256 bytes from one

R1,M,D2(B2)
CLI
Compare Logical Immediate

D1(B1),I2
CLC
Compare Logical Characters
D1(L,B1),D2(B2)
CLCL Compare Logical Characters long
RR
Compares 1 to 2**24 characters from
one memory field to another.
BRANCHING
CL,CLC,CLCL,
CLI,CLM,CLR
Opcode
BE
BNE
BL
BNL
BH
BNH
CC 0
CC 1
CC 2
CC3
OPR1=OPR2
OPR1<OPR2
OPR1>OPR2
NA.
Meaning
OPR1=OPR2
OPR1!=OPR2
OPR1<OPR2
OPR1=>OPR2
OPR1>OPR2
OPR1<=OPR2
Notes:
Destructive overlap occurs when a to field starts from within a from field
How to modify length field at run time
EX
R1,D2(X2,B2).
The instruction at the memory address specified is executed after ORing bits 8-15(length field)
with bits 24-31 of R1 If the target instruction is a branch then the branch is made. If it is a BALR /
BAL then the return from the branch is made to the instruction following the EX instruction.
MOVEV
FROM
TO
LH
SH
EX
|
|
MVC
|
|
DS
DS
4,=H20
4,=H1
4,MOVEV
TO(0),FROM
10F
10F
33 / 118
CLCL and MVCL instructions

CLCL
R1,R2
MVCL R1,R2
R1
bits 8 to 31 is the TO address
R1+1 bits 8 to 31 is the length of TO field
R2
bits 8 to 31 is the FROM address
R2+1 bits 8 to 31 is the length of FROM field
bits 0 to 7 is the padding character to be used to lengthen the shorter string
S
T
DS
DS
LA
2,S
L
3,=LS
LA
4,T
L
5,=LT
ICM
5,X8,=X00
CLCL 2,4
|
|
|
CL1000
CL2000
TR and TRT instructions

TR
Translate
SS
TRT
Translate & test SS
instructions can be used to replace certain bytes of the

string with other bytes D1(L,B1),D2(B2)
instruction can be used to find one of a set of characters
in a string D1(L,B1),D2(B2)
Notes: Operand 1 is the argument string operated on by TR and searched by TRT

instruction Operand 2 is the Function string set up by the programmer and is 256 bytes
long
FN1
ARG1
DS
ORG
DC
ORG
DS
|
TRT
BC
BC
BC
CL256
FN1+C+
XFF
CL256
ARG1(256),FN1
8,NONE
4,MORE
2,ONE
Notes: How the instruction works is as follows. Read a byte from argument string. Use it as an
offset into the function string. In the TR instruction replace the argument byte with the function
byte. In the TRT instruction , if the function byte is non zero, a copy of that byte is inserted in bits
24 to 31 of GPR2 and the address of the byte is set into bits 8 to 31 of GPR1. Execution
terminates and a CC is set to 1 if more bytes remain to be scanned in the argument string. A CC
of 2 is set if there was a non zero byte in the function string and there were no more bytes to be
scanned as well. Else CC 0 is set
34 / 118
BIT MANIPULATIONS
SRA
SLA
SRDA
SLDA
Shift
Shift
Shift
Shift
back
Right Single Arithmetic

Left Single Arithmetic
Right Double Arithmetic
Left Double Arithmetic
RS
RS
RS (first operand is even odd GPR pair)
RS
When shifting left zeroes are inserted on the right and overflow is set if a bit value other than
the sign bit is lost from the shift.
When right shifting the low order bits are lost and the sign bit is propagated
If overflow occurs it can be checked by BO (branch on Overflow)
If overflow is not set condition code 0,1, or 2 is set

SRL
SLL
SRDL
SLDL
Shift
Shift
Shift
Shift
When right shifting the low order bits are lost and the zeroes are inserted on the right
When shifting left zeroes are inserted on the right and the high order bits are lost.
The condition code is never set
O
N
X
OR
NR
XR
OI
NI
XI
OC
NC
XC
Right Single Logical

Left Single Logical
Right Double Logical
Left Double Logical
RS
RS
RS (first operand is even odd GPR pair)
RS
Or
RX
And
RX
Exclusive Or
RX
Or GPRS
RR
And GPRS
RR
XOR GPRS
RR
Or Immediate
SI
And Immediate
SI
Exclusive Or ImmediateSI
Or Memory fields
SS
And Memory Fields
SS
Exclusive Or Mem Flds SS
TESTING BITS
TM
Test Under Mask
SI
D1(B1),I2
I2 is one byte.Bits corresponding to '0' bit(s) in the mask byte are not tested.
Associated Branch Instructions
BZ
BO
BM
Branch if Zeroes
Branch if Ones
Branch if mixed
All tested bits are '0' or all mask bits are '0'
All tested bits are '1'
Tested bits are a mix of '0' and '1'
BRANCHING INSTRUCTIONS
BRANCH ON CONDITION
CODE
BRANCH AND LINK
BRANCH ON COUNT
BRANCH ON INDEX
COMPARE
TEMPORARY BRANCH
35 / 118
back
BCR,BC
BALR,BAL
BCTR,BCT
BXH,BXLE
EX
BC
Branch on Condition
RX
M1,D2(X2,B2)
BE,BER,BNE,BNER,BL,BLR,BNL,BNLR
BH,BHR,BNH,BNHR,BZ,BZR,BNZ,BNZR
BM,BMR,BNM,BNMR,BP,BPR,BNP,BNPR
BO,BOR,BNO,BNOR,
NOP,NOPR,B,BR
All implemented using BC instruction
BRANCHING AND LOOPS
BCT
Branch on count
Subtract 1 from R1 and test for non zero.
Branch if non zero
BXH
LOOP
X
Y
Z
LIMIT
INCR
RX
R1,D2(X2,B2)
Branch on Index High

RS
R1,R2,D3(B3)
Increments or decrements Index
Counting iterations
Test to determine whether loop should be repeated
BHX is normally used with decrementing
BXLE is used with incrementing
R1 is the Index register
R2 contains the increment / R2+1 contains the limit
S3 is the branch address
L
L
L
L
A
A
BXLE
.
DS
DS
DS
EQU
EQU
ASSEMBLER DIRECTIVES
7,LIMIT
6,INCR
5,=F'0'
3,X(5)
3,Y(5)
3,Z(5)
5,6,LOOP
20F
20F
20F
Y-X
4
back
CSECT
36 / 118
Indicates the beginning of a control section

Smallest portion of the code which can be relocated
A program can have more than one CSECT
CSECTS can be continued across CSECTS or DSECTS
Separate location counter for each CSECT
Symbols are not addressable across CSECT s
RSECT
Defines a read only CSECT and makes the Assembler check for possible
violations. The assembler check is not fool proof.
DSECT
USING
Dummy Control Sections

To describe the structure of a block of data in memory without actually allocating memory
Acts as a template (for example with storage obtained dynamically at run time)
No code is generated
DC statement is not allowed in a DSECT
Example:
CUSTOMER DSECT
FIELD1
DS
CL3
FIELD2
DS
CL10
FIELD3
DS
CL10
FIELD4
DS
CL10
FIELD5
DS
F
CITY
DS
PL5
USING <symbol>, Rn
Symbol can be any relocatable symbol defined in the program
* can be used in the place of symbol
Fields in the DSECTs are accessed after
Establishing a base register with USING instruction at Assembly time
Initialising the Base Register with the address of the storage area at run time.
Rn, base register, to be used by the assembler for resolving the symbols in the base
displacement FORM
The location counter of the symbol is used as the base from which displacements are
calculated
Users responsibility to load the base register with base address
BALR instruction can be used to load the base address
Range of a base register is 4096 including the base
If the code size is more than 4096 bytes, multiples base registers have to be used
Example :
BALR
12,0
Load the base address
USING
*,12
Reg 12 is a base register
USING
PROG,10
Base for DSECT PROG
ORG
ORG
<EXPR>
If expr is specified, location counter is set up with expr value
If expr is not specified, location counter takes previous maximum value
Used to redefine the storage
Example:
BUFFER
DS
100F
ORG
DS
DS
DS
DS
ORG
A
B
C
D
37 / 118
BUFFER
CL80
CL80
CL80
CL80
DROP
DROP (R0,R1,...RN)
Specified registers are dropped as base registers
Example
BALR
12,0
USING
*,12
.
.
.
DROP
12
END
LABEL
Signals the end of a control section or program, Label is the entry point
EJECT
Force a form feed
The directive itself not printed in the listing
LTORG
Forces assembler to dump the literals collected up to that point
EXTRN, ENTRY
FIRST
SAVE
ASUB1
MSG
DATA
CSECT
ENTRY
STM
BALR
USING
ST
LA
WTO
LA
WTO
L
BALR
WTO
LA
WTO
L
LM
LA
BR
DS
DC
DC
DC
DC
END
See example below.
DATA
14,12,12(13)
12,0
*,12
13,SAVE+4
13,SAVE
'IN ASM4 BEFORE CALL TO SUB4'
3,MSG
TEXT=(3)
15,ASUB1
14,15
'IN ASM4 AFTER CALL TO SUB4'
3,MSG
TEXT=(3)
13,SAVE+4
14,12,12(13)
15,4
14
18F
A(SAVE)
V(SUB4)
AL2(L'DATA)
CL20'DATA BEFORE CALL'
SUB4
CSECT
EXTRN
STM
BALR
USING
ST
LA
WTO
L
MVC
WTO
L
LM
SR
BR
DS
DC
END
SAVE
ADATA
WXTRN
38 / 118
DATA
14,12,12(13)
12,0
*,12
13,SAVE+4
13,SAVE
'IN SUB 4 BEFORE CHANGING DATA'
3,ADATA
0(20,3),=CL20'DATA AFTER CHANGE'
'IN SUB 4 AFTER CHANGING DATA'
13,SAVE+4
14,12,12(13)
15,15
14
18F
A(DATA)
defines a weak external reference. A weak external reference does not trigger
a linkage editor auto call. Note that in the following example the linkage editor
does not object to SAVE1 remaining unresolved.
Example
FIRST
CSECT
WXTRN
STM
BALR
USING
ST
LA
WTO
L
LM
SR
BR
DS
DC
DC
END
SAVE
DATA
MSG
SAVE1
14,12,12(13)
12,0
*,12
13,SAVE+4
13,SAVE
TEXT=DATA
13,SAVE+4
14,12,12(13)
15,15
14
18F
AL2(L'MSG)
CL30'ASM1 REPORTING'
COM
SUB
SUB
SUB
Defines a common section. All common sections across CSECTS with the
same name map to the same storage. The storage for COMMON sections is
allocated at the time the load module is built.
CSECT
AMODE 31
RMODE ANY
SAVE
ACOM
COMMON
MSG
FIRST
FIRST
FIRST
SAVE
ASUB
ACOM
COMMON
MSG
STM
BALR
USING
ST
LA
L
LA
STH
MVC
L
LM
LA
BR
DS
DC
COM
DS
DS
END
CSECT
AMODE
RMODE
STM
BALR
USING
ST
LA
L
BALR
ICM
WTO
L
LM
LA
BR
DS
DC
DC
COM
DS
DS
END
14,12,12(13)
12,0
*,12
13,SAVE+4
13,SAVE
4,ACOM
5,15
5,0(0,4)
2(15,4),=CL15'THIS IS SUB'
13,SAVE+4
14,12,12(13)
15,0
14
18F
A(COMMON)
AL2
CL100
31
ANY
14,12,12(13)
12,0
*,12
13,SAVE+4
13,SAVE
15,ASUB
14,15
4,B'1111',ACOM
TEXT=(4)
13,SAVE+4
14,12,12(13)
15,0
14
18F
V(SUB)
A(COMMON)
AL2
CL100
39 / 118
40 / 118
JCL ASPECTS
back
COPY BOOKS
SOURCE
MACLIBS
ASSEMBLER
OBJECT LIBRARIES
OBJECT DECK
LINKER
LOAD MODULE
LOAD IN MAIN STORAGE FOR EXECUTION

program consists of Machine instructions
Assembler instructions
Macro Instructions.
Development cycle
Coding
Pre Assembly
Assembly
Linkage Edit
Program fetch
JCL:- IBM supplied catalogued procedures can be used. ASMACL is given below
which assembles and links a assembler program
//ASMACL
PROC
//*
//***
ASMACL
//*
//* THIS PROCEDURE RUNS THE HIGH LEVEL ASSEMBLER AND LINKS
//* THE NEWLY ASSEMBLED PROGRAM
//*
//C
EXEC PROG=ASMA90,PARM=(OBJECT,NODECK)
//SYSLIB
DD
DSN=SYS1.MACLIB,DISP=SHR
//SYSUTI
DD
DSN=&&SYSUT1,SPACE=(4096,(120,120),,,ROUND),UNIT=VIO,
//
DCB=BUFNO=1
//SYSPRINT
DD
SYSOUT=*
//SYSPUNCH DD
SYSOUT=B
//SYSLIN
DD
DSN=&&OBJ,SPACE=(3040,(40,40),,,ROUND),UNIT=VIO,
//
DISP=(MOD,PASS),
//
//L
//SYSLIN
//
//SYSLMOD
//
//SYSUT1
//
//SYSPRINT
EXEC
DD
DD
DD
DD
DD
41 / 118
DCB=(BLKSIZE=3040,LRECL=80,RECFM=FBS,BUFNO=1)
PGM=HEWL,PARM='MAP,LET,NCAL',COND=(8,LT,C)
DSN=&&OBJ,DISP=(OLD,DELETE)
DDNAME=SYSIN
DISP=(,PASS),UNIT=SYSDA,SPACE=(CYL,(1,1,1)),
DSN=&&GOSET(GO)
DSN=&SYSUT1,SPACE=(1024,(120,120),,,ROUND),
DCB=BUFNO=1,UNIT=VIO
SYSOUT=*
Important linkage editor parameters

LET allows you to specify severity level of an error to determine whether the load module is to be marked as
unusable.
MAP | NOMAP Use map if you want a generated map of the load module
NCAL Do not make an automatic search of the object libraries when linking
RENT Indicates module is re-entrant, NORENT marks it as non re-entrant
AMODE 24|31|ANY . Use this parameter to override the attribute established by the assembler in the
assembly process
RMODE 24|ANY overrides this attribute as set by the assembly process
Assembler
ALIGN instructs assembler to check for alignment where it is required
default ALIGN
DECK
Assembler generates object deck on SYSPUNCH

default NODECK
ESD
The External symbol dictionary is produced in the listing

default ESD
OBJECT instructs the assembler to generate an object data set on SYSLIN

default OBJECT
RENT instructs the assembler to check for possible violations of re-entrant
default NORENT
RLD
the assembler outputs the relocation dictionary in the listing

default RLD
SYSPARM SYSPARM ( parmvalue) max 55 chars

XREF(FULL) Ordinary symbol and literal cross reference listing produced including symbols that are not
referred to .
XREF(SHORT) Omits symbols not referred to.
Default XREF(SHORT,UNREFS)
Special Considerations when the member name and the CSECT name do not match.
Source File-1
FIRST
CSECT
SAVE
ASUB1
*ASUB2
STM
BALR
USING
ST
LA
WTO
L
BALR
WTO
L
LM
SR
BR
DS
DC
DC
END
42 / 118
14,12,12(13)
12,0
*,12
13,SAVE+4
13,SAVE
'IN ASM3 BEFORE CALL TO SUB1'
15,ASUB1
14,15
'IN ASM3 AFTER CALL TO SUB1'
13,SAVE+4
14,12,12(13)
15,15
14
18F
V(SUB1)
Does not pose problems
V(SUB2)
Does pose a problem
Source File-2
SUB1
SAVE
SUB2
SAVE1
CSECT
STM
BALR
USING
ST
LA
WTO
DC
L
LM
SR
BR
DS
CSECT
STM
BALR
USING
ST
LA
WTO
L
LM
SR
BR
DS
14,12,12(13)
12,0
*,12
13,SAVE+4
13,SAVE
'IN SUB 1'
F'0'
13,SAVE+4
14,12,12(13)
15,15
14
18F
14,12,12(13)
12,0
*,12
13,SAVE1+4
13,SAVE1
'IN SUB 2'
13,SAVE1+4
14,12,12(13)
15,15
14
18F
END
note that labels cannot be the same
The solution is to explicitly make the Linkage Editor include the module by the linkage editor
control statement input as below://LKED.SYSIN DD *
INCLUDE SYSLIB(SUB1)
/*
43 / 118
SUBROUTINES AND LINKAGES 24 BIT MODE

back
SUBROUTINE
Entry point Identified by a CSECT,START OR ENTRY assembler directives.
An entry is made in the ESD for each Entry point.
A CSECT can have multiple entry points specified by ENTRY directive
Internal Subroutine :-A subroutine present in the source module from which it is called.
External Subroutine :-A subroutine present in a different source module. Assembled and link
edited separately
Static Subroutine :- A subroutine which is known at the link edit time. Can be an internal or an
external subroutine.
Dynamic Subroutine:- A subroutine which is loaded at program run time using LOAD, LINK
macros
V-type address constant:- To refer a symbol defined in another CSECT.
External symbol directory (ESD) :- A table containing information about the name, location
and size off each all external symbols
Linking to subroutine
BALR R1,R2 Branch and link register
(R1) <--PC,PC <--R2)
BAL
R1,S2 Branch and link

(R1) <--PC,PC <--S2
The next instruction address is loaded in the register specified by the

first operand and the branch is taken to the address specified by the second
operand. If R2 is zero, then no branch is taken
Return from subroutine
BR
R1 Branch register
PC <--(R1)
Branch unconditionally to the address specified in the operand 1
Example:
MAIN
START
0
SETUP
.
BAL
14,SUB1
.
L
15,SUB2
BALR
14,15
*
EOJ
*
SUB1
DS
OH
BR
14
SUB2
DC
V(SUBROUT2)
END
Saving and restoring environment
Programs uses registers as base, index, and accumulators. If a program calls a subprogram, and
when the control returns, these register values should not be altered. To achieve this, the calling
program provides a SAVEAREA into which the called program saves the registers. Before the
control is returned from the subprogram, the registers are restored to their original values. Some
subprograms return to the called program a return code (set in GPR15) and a reason code. It is
a good programming practice to save and restore the environment. If this is done any subroutine
can be used by any program with out the need to identify which registers are modified by the
subroutine.
44 / 118
IBM convention for saving registers
Every calling routine has a save area of 18 full-words for the use of called routine
The calling routine passes the save area address in register 13
Every called routine saves the registers in this area before establishing addressability
Address of called routine is in register 15
Register 14 has the return address

SAVEAREA (18 Full words) layout
Savearea+0
Reserved for PL/1
Savearea+4
save-area of program which called this sub-program
Savearea+8
save-area of called sub-program called by this program
Savearea+12 Register 14
savearea+16 Register 15
savearea+20 Register 0
. .
. .
. .
Example
MAIN
START
0
STM
14,12,12(13)
BALR
12,0
USING
*,12
ST
13,SAVE+4
LR
2,13
LA
13,SAVE
ST
13,8(2)
.
.
.
LA
15,0
L
13,SAVE+4
L
14,12(0,13)
LM
0,12,20(13)
*
BR
14
SAVE
DS
18F
END
Advantages of SAVEAREA
Forward and backward pointers running through the save areas useful for
trace-back
Called program can first save the environment before acquiring storage in
case of re-entrant program
Parameter passing
Fixed and variable number of parameters can be passed to a subprogram
Parameters value are not passed directly
Each parameter is saved in the storage then an array is created containing he address of the
parameters in the order they are expected in the called program and the register 1 is loaded
with the starting address of this address array. The last address in the array should have bit '
0' set to ' 1'
45 / 118
For variable number of parameters, the high order bit of the last parameter is set to one to
indicate the end of parameter list
Example
LA
ST
LA
ST
LA
ST
LA
L
BALR
.
.
LA
L
BALR
.
P1
DS
P2
DC
P3
DC
PARM DS
2,PI
2,PARM
2,P2
2,PARM+4
3,P3
3,PARM+8
1,PARM
15,=V(PROC1)
14,15
1,=A(P2,P1,P3)
15,=V(PROC2)
14,15
CL8
F'20'
C'ABCDEFGHIJKL'
3F
Accessing the parameters

On entry the subprogram, R 1 contains the base address to the array of pointers pointing to
the parameters
Access the parameter pointer address from the array and using this access
the
parameter
If lot of parameters need to be accessed, them a DSECT can be used to access
the
parameters in which case the parameters have to be stored using the same DSECT in the
calling program
Example
LM
4,6,0(1)
L
4,0(4)
L
4,0(5)
L
4,0(6)
Fetch address of P1-P3

R4 has P1
R4 has P2
R4 has P3
Functions in Assembly language
To pass back a return value from function set register 0 to that value
The return value can be used to indicate error condition
A return code 0 means successful completion (return codes passed in GPR15)
Return codes are multiple of 4, so that it could be used to index into address table
Example
MAIN
CSECT
.
.
.
LA
L
BALR
ST
.
.
entry linkages
1,=A(I,J)
15,=V(MIN)
14,15
0,K
I
J
K
SAVE1
*
MIN
BIG
RESTORE
SAVE2
.
BR
DC
DC
DS
DS
CSECT
.
.
LM
L
L
CR
BGE
LR
B
LR
EQU
.
.
.
BR
DS
END
46 / 118
14
F'100'
F'120'
F
18F
entry linkages
4,5,0(1)
4,0(4)
5,0(5)
4,5
BIG
0,5
RESTORE
0,4
*
exit linkages
14
18F
Example of capturing PARM data from JCL
PICKING UP PARMS
FIRST
CSECT
STM
14,12,12(13)
BALR 12,0
USING *,12
ST
13,SAVE+4
LA
13,SAVE
L
13,SAVE+4
L
2,0(0,1)
LH
3,0(0,2)
STCM 3,B'0011',MSG
S
3,=F'1'
EX
3,IN1
LA
4,MSG
WTO
TEXT=(4)
LM
14,12,12(13)
LA
15,0
BR
14
SAVE
DS
18F
IN1
MVC
MSG+2(0),2(2)
MSG
DC
AL2(0)
DS
CL100
END
Passing Structures (like a COBOL 01 level item)
SUB
CSECT
STM
14,12,12(13)
SAVE
PARMS
A
B
RES
FIRST
SAVE
MSG
ASUB
DW
USING
ST
LA
LR
DROP
USING
LR
WTO
LR
L
USING
L
A
ST
L
LM
LA
BR
DS
DSECT
DS
DS
DS
END
CSECT
STM
BALR
USING
ST
LA
L
LA
BALR
L
CVD
UNPK
OI
WTO
LA
WTO
L
LM
LA
BR
DS
DC
DS
DC
DS
DS
SUB,15
13,SAVE+4
13,SAVE
12,15
15
SUB,12
2,1
'IN SUB'
1,2
2,0(1)
PARMS,2
5,A
5,B
5,RES
13,SAVE+4
14,12,12(13)
15,0
14
18F
F
F
F
14,12,12(13)
12,0
*,12
13,SAVE+4
13,SAVE
15,ASUB
1,=A(PARMS)
14,15
5,RES
5,DW
MSG+2(16),DW
MSG+17,X'F0'
'RESULT IS'
4,MSG
TEXT=(4)
13,SAVE+4
14,12,12(13)
15,0
14
18F
AL2(16)
CL16
V(SUB)
D
0F
47 / 118
PARMS
A
B
RES
DS
DC
DC
DS
END
0CL12
F'100'
F'200'
F
48 / 118
49 / 118
MACRO AND CONDITIONAL ASSEMBLY

Back
Macro
An extension of assembler language.
Provides convenient way to generate a sequence of assembler language statements
A macro definition is written only once
Macro invocation expands to the desired sequence of statements
Conditional assembly statements can be used to tailor the statements generated
Parameters can be passed to the macro
Expanded during the pre-assembly time and generates inline code

Macro definition
Can appear at beginning of a source module in which case it is called a source MACRO
System macros reside in a system library (ddname SYSLIB)
User macros reside in a user library or in the source program itself
Nested macro invocations possible

Format of a Macro definition
Header. Indicates the beginning of a macro definition (MACRO)
Prototype statement. Defines the macro name and the symbolic parameters
Body. Contains model statements, processing statements, comments statements and

conditional assembly statements.
Trailer. Indicates the end of a macro definition (MEND)

Prototype
Must be the second non-comment statement in every macro definition.
Only internal comments are allowed between the macro header and the macro prototype.
Format of the prototype statement:
{Name}
Name field
Operation
:
Operation field:
Operands
:
{Operands}
A variable symbol. The name entry in the calling macro instruction is

assigned to this symbol.
The name of the macro. The macro is invoked with this name.
Specify positional or keyword parameters. Maximum 240 parameters
can be passed
Macro
body
:
Contains the sequence of statements that are generated in the macro expansion.
Model statements from which assembler language statements are generated.
Processing statements that can alter the content and sequence off the statements
generated or issue error messages.
Comments statements.
Conditional assembly instructions to compute results to be displayed in the message created by the
MNOTE instruction, without causing any assembler language statements to be generated
Model Statement
Assembler language statements are generated at pre-assembly time from model
statement
Variable symbols can be specified to vary the contents of the statements generated
Statements generated must not be conditional assembly instructions
Variable Symbols
Prefixed with '&' character
50 / 118
Can appear in macros and in conditional assembly statements

Can be symbolic parameters, system variables or set symbols
System variables are read only and their value is maintained by the Assembler
Example
USER:
SYSTEM:
&L &NAME &VARI &PARAM(1)

&SYSNDX &SYSDATE &SYSECT
Concatenation (".")
Used when a character string has to be concatenated to a variable symbol

Concatenation character is mandatory
1) when an alphanumeric character is to follow a variable symbol
2) A left parenthesis that does not enclose a subscript is to follow a variable symbol
To generate a period, two periods must be specified in the concatenated string following the
variable symbol
Concatenation character is not required

1) when an ordinary character string precedes a variable symbol
2) A special character, except a left parenthesis or a period, is to follow a variable symbol
3) A variable symbol follows another variable symbol
4) Between a variable symbol and its subscript
String
&FLD.A
&FLDA
Symbol
&FLD
&FLDA
Value
AREA
SUM
Result
AREAA
SUM
&B
&D.(&B)
10
&D
100
100(10)
&I
&F
99
98
D'&I..&F'
D'&I.&F'
&A+3
&A
D'99.98'
D'9988'
A+3
Symbolic Parameters
Variable symbols included in macro prototype are supplied values by the macro call
Actual value supplied for a formal parameters is a character string (max=255chars)
Two kinds of symbolic parameters

Positional Parameters
Keyword Parameters
Null string for the omitted parameters
Defaults can be specified for keyword parameters
Parameters can be subscribed
Have local scope
Read only
Example
MACRO
MAC1 &P1,&K1=10
.
MEND
Invocation of above Macro:
START
0
.
51 / 118
.
.
MAC1 ONE,K1=12
.
MAC1 TWO
.
.
END
Example
MACRO
DIVIDE
M
D&TYPE
MEND
Invocation
MAIN
+
+
+
+
&R1,&R2,&TYPE
&R1,=F`1'
&R1,&R2
CSECT
.
.
.
DIVIDE
M
D
.
.
DIVIDE
M
.
.
DR
4,6
END
8,NUM
8,=F`1'
8,NUM
4,6,R
4,=F'1'
Processing Statements
Macro instruction
Conditional assembly instructions

Macro instructions
MNOTE instruction
<SEQ SYM> MNOTE <opt> <message>
To generate error messages or display intermediate values of variable symbols
Can be used in open code or in a macro
Opt specifies a severity code. If"," is specified then the severity code value is "1"
If opt is omitted or a `*' is specified, then the message is generated as a comment

Example:
MNOTE 2, Èrror in syntax'
MNOTE ,Èrror, severity 1'
MNOTE *, À comment'
MNOTE Ànother comment'
MEXIT instruction
<SEQ SYM> MEXIT
Exit from the current macro definition
Can be used only inside a macro definition

Comments
52 / 118
A "*" in column generates an ordinary comment which will appear in the listing
A ".*" sequence in column 1 generates an internal comment which will not appear in the listing
System Variables
Variables set by the system
&SYSDATE, &SYSPARM, and &SYSNDX can be used only within a macro
Name
Description
&SYSLIST
Provides alternate way of accessing positional parameters
&SYSPARM
To obtain the compile time parm value passed thru JCL EXEC statement
&SYSECT
To get the name of CSECT from where macro is invoked
&SYSTIME
To get time in HH.MM format
&SYSDATE
To get date in MM/DD/YY format
Example
Prototype statement : LOOP
VNAME
V1,V2,,V4,(V5,V6)
&SYSLIST(O)
=
LOOP
&SYSLIST(1)
=
V1
&SYSLIST(2)
=
V2
&SYSLIST(3)
=
NULL STRING
&SYSLIST(4)
=
V4
&SYSLIST(5)
=
V5,V6
&SYSLIST(5,1) =
V5
&SYSLIST(5,2) =
V6
N'&SYSLIST
=
5
N'&SYSLIST(5) =
2
Sublists
To specify variable number of parameters to a macro
One or more entries separated by commas and enclosed in parenthesis
Including the parenthesis, maximum length is 255 characters

Example
MACRO
&L
VAR
&P1,&P2,&KEY=(FO,F,O)
.
&KEY(1)
DC
&KEY(2)'&KEY(3)'
&P1(1)
DC
&P1(2) '&P1(3)'
DC
A&P2
.
MEND
invocation:
MAIN
+F1
+H20
+
START O
.
VAR
DC
DC
DC
END
(H20,H,200), (A,B,C),KEY=(F1,F,1)
F' 1'
H'200'
A(A,B,C)
Labels in macro
If ordinary symbols are used as label, then for each macro invocation, the same label will be
generated and duplicate symbol error will occur at assembly time. To avoid this &SYSNDX
system variable can be concatenated with a symbol, so that the label generated is unique.
Example
MACRO
LOOP&SYSNDX
Invocation
START
LOOP
+LOOP0001
EQU
+
BNE
LOOP
+LOOP0002
EQU
+
BNE
MAIN
53 / 118
LOOP
EQU
*
BNE
LOOP&SYSNDX
MEND
0
*
LOOP0001
*
LOOP0002
Conditional Assembly
Selectively assemble a sequence of instructions
Can be used in the open code or in the macros
Processed at the pre-assembly time
Many functions like a programming language is available

Variable declarations and assigning values
Arithmetic and logic functions
Character processing
Control facilities
Conditional assembly statement labels are called sequence symbols and are prefixed with "."
Set Symbols
Provides arithmetic, binary, or character data
Values can be varied at pre-assembly time
Can be subscripted (set symbol array)
Can be local(within a macro) or global (across other macros in this assembly)set symbols
Used as
Terms in conditional assembly expressions
Counters, Switches and character strings
Subscripts for variable symbol
Values for substitution
Global set symbols
Values can be accessed any where in the source
Has to be defined in each part of the program in which it is accessed (macro, open code)
Declared using
GBLA, for global arithmetic set symbols
GBLB, for global binary set symbols
GBLC, for global character set symbols
GBLA and GBLB have a default value 0 (zero)
GBLC has null string as default value
SYNTAX
GBLA <VARLIST>
GBLB <VARLIST>
GBLC <VARLIST>
Example
GBLA &TEST,&VAL
GBLC &NAME,&ID
GBLB &TRUE
54 / 118
Local set symbols
Values can be accessed only in the macro in which it is defined
Declared using
LCLA, for local arithmetic set symbols
LCLB, for local binary set symbols
LCLC, for local character set symbols
LCLA and LCLB have default value 0 (zero)
LCLC has null string as default value
SYNTAX
LCLA <VARLIST>
LCLB <VARLIST>
LCLC <VARLIST>
Example
LCLA
&CNT,&VAL
LCLC
&STR1
LCLB
&TRUE
Conditional Assembly Expressions
Three kinds
Arithmetic
Character
Binary
Can be used as operands of conditional branch instruction
To assign values to set symbols
Arithmetic expressions are formed using arithmetic operators
Character expressions can produce strings of up to 255 chars
Parameter substitution within quoted strings
Duplication factor for quoted strings
Boolean expression by combining arithmetic or character expressions using relational

operators
Assigning Values to Set Symbols
Global set symbols have to be defined before assigning values
Undeclared set symbols are defined as local set symbols
More than one element in an array can be assigned values in a single set statements
Set Arithmetic
<VAR SYMBOL> SETA <arithmetic expression>
To assign an arithmetic value to a SETA symbol
Value represented by SETC symbol variable string can be used as a term in an

arithmetic expression provided they contain only numeric digits.
Value represented by SETB symbol variable can also be used in arithmetic expression
Valid unary operators are +,-.Binary operators are +,-,*,/

Examples
&A
SETA 10
10
&B
SETA 2
2
&C
SETA &A + 10/&B
15
&D
SETA (&A+10)/&B
10
&A
SETA 11
11
&B
SETA &A/2
5
&A
SETA 1
1
&B
SETA &A/2
0
55 / 118
Set Binary
<VAR SYMBOL>
SETB <Boolean expression>
Example
&B
SETB 1
&A
SETB 0
To assign an binary bit value to a SETB symbol
Set Character
<VAR SYMBOL>
SETC <expression>
To assign characters value to a SETC symbol
The expression could be

A type attribute reference
A character expression
A sub string notation
A concatenation of sub string notations, or character expressions, or both
A duplication factor can precede any of the first three options

Example:
&C
SETC
'STRING0'
*
*
&C="STRING0"
*
&D
SETC
&C(4,2)
*
*
&D = "IN"
*
&E
SETC
'L''SYMBOL'
*
*
&E = "L'SYMBOL"
*
&F
SETC
'HALF&&'
*
*
&F="HALF&"
*
&G
SETC
'&D.NER'
*
*
&G="INNER"
*
&C1
SETC
3('ABC')
*
*
&C1 = ABCABCABC
*
Example
MACRO
&NAME
MOVE
&TO,&FROM
LCLA
&A1
LCLB
&B1,&B2
LCLC
&C1
&B1
SETB
(L'&TO EQ 4)
&B2
SETB
(S'&TO EQ 0)
&A1
SETA
&B1
&C1
SETC
'&B2'
&NAME
ST
2,SAVEAREA
L
2,&FROM&A1
Invocation
MAIN
HERE
+HERE
+
+
+
56 / 118
ST
L
MEND
2,&TO&C1
2,SAVEAREA
START
MOVE
ST
L
ST
L
0
FLDA,FLDB
2,SAVEAREA
2,FLDB1
2,FLDAO
2,SAVEAREA
Conditional Branch
<SEQ SYMBOL>
AIF
(<LOGICAL EXPR>).<SEQ SYMBOL>
The logical expression in the operand field is evaluated at pre-assembly time to determine if it is
true or false. If the expression is true, the statement named by the sequence symbol in the
operand field is the next statement processed. If the expression is false, the next sequential
statement is processed by the assembler.
Logical operators are EQ,NE,LE,LT,GE,GT
Example
AIF
(`&C' EQ `YES').OUT
.ERROR
ANOP
.
.
.
.OUT
ANOP
Unconditional branch
<SEQ SYMBOL> AGO <SEQ SYM2>
Branches to the statement identified by "SEQ SYM2"

Conditional Assembly Loop Counter
<SEQ SYMBOL>
ACTR <ARITHMETIC EXPRESSION>
Set a conditional assembly loop counter either within a macro definition or in open code.
Can appear any where in the program.
Each time AGO or AIF is executed the counter value is decremented by one and if its is zero
exit from the macro or stop processing the statements in the open code
Avoids excessive looping
Assembler has a default counter and it is initialised with 4096

NOP
<sequence symbol>
ANOP
Performs no operation
Used to define a sequence symbol which can be used in AIF and AGO
Data Attributes
<c> 'SYMBOL
Attribute
Description
T
Type of the symbol
Values returned by assembler are
A,V,S,Q
For the various address constants
57 / 118
B
Binary constant
C
Character constant
D,E,L
Floating point constant
F,H
Integer constants
P
Packed decimal constant
H
Hexadecimal constant
Z
Zoned decimal constant
I
Machine instruction
M
Macro
J
Control section
T
EXTRN symbol
N
Self defining term
O
undefined (omitted)
L
Length of symbol number of bytes
C
Number of characters contained by the variable symbol
N
Number of element in a sublist associated with the symbol
D
Defined attribute, indicates whether or not the symbol has been defined prior
Example
MACRO
TABLE
LCLA
&I
&SYSLIST(0) DS
0D
.WHILE
AIF
(&I GT N'SYSLIST).DONE
DC
D'&SYSLIST(&I)
&I
SETA
&I+1
AGO
.WHILE
.DONE
MEND
Macro help facility
<name>
MHELP
<value>
Controls a set of trace and dump facilities
Can occur anywhere in open code or in macro definitions
Remains in effect until superseded by another MHELP statement
More than one facility can be specified

Value Function
1
Macro Call Trace
2
Macro Branch Trace
4
Macro AIF Dump
8
Macro Exit Dump
16
Macro Entry Dump
32
Global Suppression
64
Macro Hex Dump
128
Mhelp Suppression
58 / 118
Example of TPUT MACRO

MACRO
&LABEL
TPUT &ADDR,
X
&LEN,
X
&FULLSCR
LCLC
&TEMPREG
*
AIF
('&LABEL' EQ '').NOLAB
&LABEL
DS
0H
.NOLAB
ANOP
.*
AIF
('&ADDR' EQ '').NOADDR
AIF
('&ADDR'(1,1) EQ '(').ADDRREG
LA
0,&ADDR
GET ADDRESS IN R0
AGO .NOADDR
.ADDRREG
ANOP
&TEMPREG
SETC '&ADDR'(2,K'&ADDR-2)
LR
0,&TEMPREG
GET ADDRESS IN R0
.NOADDR
ANOP
.*
AIF
('&LEN'(1,1) EQ '(').LENREG
LA
1,&LEN
GET LENGTH IN R1
AGO .CONT
.LENREG
ANOP
&TEMPREG
SETC '&LEN'(2,K'&LEN-2)
LR
1,&TEMPREG
GET LENGTH IN R1
.*
.CONT
ANOP
AIF
('&FULLSCR' EQ '').NFS
AIF
('&SYSCHARSET' EQ 'E').FLS
MNOTE 4,'TPUT OPTION FULLSCR MUST USE EBCDIC CHARACTER SET'
.FLS
ANOP
SVC 96
MEXIT
.*
.NFS
ANOP
SVC 94
MEND
Example of SAVE macro

MACRO
&LABEL
SAVE
&REGS,
&T,
&ID
.*
AIF
&LABEL
DS
0H
NOLAB
ANOP
AIF
('&ID' EQ '').CONTINU
.* This is a macro comment
B
12(15)
* This is a normal assembler comment
AIF
('&ID' EQ '*').IDHERE
DC
CL8'&ID'
AGO
.CONTINU
.IDHERE
ANOP
AIF
('&LABEL' EQ '').NOID
DC
CL8'&LABEL'
AGO
.CONTINU
.NOID
ANOP
DC
CL8'&SYSECT'
.CONTINU
ANOP
.*
AIF
('&REGS' EQ '').NOREGS
STM
&REGS(1),&REGS(2),12(13)
.NOREGS
ANOP
MEND
59 / 118
X
X
Example of RETURN macro

MACRO
&LABEL
RETURN
60 / 118
&REGS,
&T,
&RC=
.*
LCLA
&WORK,&VALU
AIF
DS
ANOP
0H
AIF
AIF
AIF
AIF
AIF
LA
ANOP
LM
BR
MEXIT
ANOP
SETA
LR
LM
BR
MEXIT
('&REGS' EQ '').NOREGS
(&REGS(1) GE &REGS(2)).RET1
(&REGS(2) EQ 15).RET1
('&RC' EQ '').RCT3
('&RC'(1,1) EQ '(').RCT2
15,&RC
.*
&LABEL
.NOLAB
.*
.RCT3
.RCT2
&VALU
.*
.RET1
&WORK
.RCT4
.RCT1
&VALU
.*
.NOREGS
.RCT6
.RCT5
&WORK
ANOP
AIF
SETA
AIF
LA
ST
ANOP
LM
BR
MEXIT
ANOP
SETA
ST
LM
BR
MEXIT
ANOP
AIF
AIF
LA
ANOP
BR
MEXIT
ANOP
SETA
LR
BR
&REGS(1),&REGS(2),12(13)
14
&RC(1)
15,&VALU
&REGS(1),&REGS(2),12(13)
14
('&RC' EQ '').RCT4
(15-&REGS(1))*4
('&RC'(1,1) EQ '(').RCT1
15,&RC
15,12+&WORK.(13)
&REGS(1),&REGS(2),12(13)
14
&RC(1)
&VALU,12+&WORK.(13)
&REGS(1),&REGS(2),12(13)
14
('&RC' EQ '').RCT6
('&RC'(1,1) EQ '(').RCT5
15,&RC
14
&RC(1)
15,&WORK
14
X
X
MEXIT
MEND
61 / 118
62 / 118
MVS SYSTEM MACROS

QSAM
back
DCB Macro
Included for every data set accessed by the program
Access method depends upon the parameters passed to the DCB
All parameters are keyword parameters specifying various options for the data set
Generates non executable code (control block) and should therefore be coded in the data area
Name
DCB DDNAME =External DD name in JCL,
DSORG =PS | PO,
MACRF =((G) | (P) | (G,P),M|L)
LRECL =,
BLKSIZE=,
RECFM =F | FB | FBA | V |VB,
DEVD=DA | TA | PR,
EODAD=,
Notes:-
G
P
G,P
M
L
F
FB
FBA
V
VB
Get,
Put,
Get and PUT
Move mode I/O
Locate mode I/O
Fixed unblocked
Fixed blocked
Fixed blocked with first character as a ASA control character. Used only for
printer output
Variable unblocked
Variable blocked
OPEN Macro
Name
OPEN (DCB-name{options...})
Logically connect a data set
Data set identified in the DCB is prepared for processing
Option Meaning
INPUT Input data set
OUTPUT
Output data set
UPDAT Data set to be updated in place
EXTEND
Add records to the end of the data set
DISP
Disp options (PASS,KEEP,DELETE,CATLG,UNCATLG)
Example
OPEN (EMPLOYEE,(INPUT),SALES,(OUTPUT))
CLOSE Macro
Name
CLOSE
(DCB-NAME {,option),...})
Logically disconnect a data set
Option
Meaning
REREAD
Position to the beginning of the data set
LEAVE
Position to the logical end of the data set
REWIND
Magnetic tape has to be positioned at the beginning
DISP
Disp options like PASS,KEEP,DELETE,CATLG, and UNCATLG
Example
CLOSE
(EMPLOYEE,SALES)
63 / 118
GET Macro (QSAM)

Name
GET
DCB-NAME, {area name}
Retrieve the next record
Control is returned after the record is read
In locate mode the address of the record is returned in R1
In move mode the record is moved to the user area
Example
GET EMPLOYEE, EMPREC
PUT Macro (QSAM)
Name
PUT
DCB-NAME,{area name}
Write a record.
Control is returned after the record is written
In locate mode the area name parameter is omitted and the system returns the address of
the I/O buffer in R 1. The data has to be moved to this area and it is written in the next
PUT call.
In moved mode, the system moves the record to an output buffer before the control is
returned.
Example
PUT
EMPLOYEE,EMPREC
Example
PRINT
CSECT
STM 14,12,12(13)
BALR 12,0
USING *,12
ST 13,SAVE+4
LA 13,SAVE
OPEN (SYSPRINT,OUTPUT)
LTR 15,15
BNZ OPENERR
LA 5,20
MVC OUTREC+1(132),=CL132'THIS IS LINE ONE.'
LOOP
PUT SYSPRINT,OUTCARD
BCT 5,LOOP
CLOSE SYSPRINT
L 13,SAVE+4
RETURN (14,12),,RC=0
OPENERR L 13,SAVE+4
RETURN (14,12),,RC=16
OUTCARD DC AL2(137),AL2(0)
OUTREC
DC CL133' '
SYSPRINT DCB DDNAME=SYSPRINT,MACRF=PM,DSORG=PS,
LRECL=137,BLKSIZE=1370,RECFM=VB
SAVE
DS 18F
END
JCL
//SYSPRINT
DD
Memory Management
SYSOUT=*
64 / 118
GETMAIN
To allocate virtual storage
Can be allocated on double word or page boundary
Storage is not initialised
Storage allocation above or below 16MB line
Use FREEMAIN
to release the storage
Register 1 contains the storage address
Syntax
Name GETMAIN
R,LV=lv,BNDRY=bndry,LOC=1oc
R
Register form
LV
Length value
BNDRY DBLWD/PAGE
LOC
BELOW/ANY (16MB line)
Example
GETMAIN
R,LV=4096,BNDRY=PAGE,LOC=ANY
Note: More details on GETMAIN are available in the chapter VIRTUAL STORAGE
MANAGEMENT
Example
This example uses DXD, CXD data types and Q type address constant
DXD refers to storage allocated in an external dummy section. A DSECT can also be
considered an external dummy section if it is used in a Q type constant. The CXD is
initialised by the linkage editor to the sum of the lengths of all external dummy sections in
the load module. It is used to getmain storage for the external dummy sections at run time.
The Q type address constants are set to the offset of the corresponding dummy sections.
ROUTINE A
AX
BX
LEN
CSECT
.
L
GETMAIN
LR
.
L
BALR
.
L
BALR
.
DXD
DXD
CXD
.
DC
DC
.
ROUTINE B
Name Operation
B
CSECT
.
L
AR
ST
.
G
DXD
D
DXD
.
GOFFS DC
DOFFS DC
.
65 / 118
3,LEN
R,LV=(3)
11,1
15,=V(C)
14,15
15,=V(B)
14,15
2DL8
4FL4
Q(AX)
Q(BX)
Operand
3,DOFFS
3,11
2,0(0,11)
5D
10F
Q(G)
Q(D)
ROUTINE C
Name Operation
Operand
E
DSECT
ITEM
DS
F
NO
DS
F
SUM
DS
F
C
CSECT
.
L
3,EOFFS
AR
3,11
USING
E,3
ST
9,SUM
.
.
EOFFS DC
Q(E)
.
.
FREEMAIN
Releases the acquired virtual storage
Address should be on a double word boundary

Syntax
66 / 118
Name FREEMAIN
R,LV=lv,A=addr
R
Register form
lv
Length value
A
Virtual storage address
Example
FREEMAIN
R,LV=4096,A=(1)
Note: More details on FREEMAIN are available in the chapter VIRTUAL STORAGE
MANAGEMENT
Example of a program that dynamically acquires its working storage and initialises it with
constants from static read only storage.
FIRST
FIRST
FIRST
LOADERR
WSCONST
CSECT
AMODE 31
RMODE ANY
STM
14,12,12(13)
BALR 12,0
USING *,12
LR
2,1
GETMAIN R,LV=LEN,LOC=BELOW
ST
13,4(0,1)
USING WS,13
LR
13,1
LR
1,2
MVC
WS+72(LEN-72),WSCONST+72
BAL
2,INIT
LOAD EP=ADD
LTR
15,15
BNZ
LOADERR
LR
15,0
LA
1,PARM
BASSM 14,15
WTO 'BACK'
L
5,RES
CVD
5,DW
UNPK MSG+2(16),DW
OI
MSG+17,X'F0'
WTO
'RESULT IS'
LA
4,MSG
WTO
TEXT=(4)
LR
2,13
L
13,SAVE+4
FREEMAIN R,LV=LEN,A=(2)
LM
14,12,12(13)
LA
15,0
BR
14
L
13,SAVE+4
LM
14,12,12(13)
LA
15,16
BR
14
DS
0F
DS
18F
LEN
INIT
WS
SAVE
A
B
RES
PARM
MSG
DW
ADD
SAVE
DC
DC
DS
DS
DS
DS
DC
DS
DS
EQU
DS
LA
ST
LA
ST
LA
ST
BR
DSECT
DS
DS
DS
DS
DS
DS
DS
DS
DS
DS
END
CSECT
STM
BALR
USING
ST
LA
LR
WTO
LR
LM
L
A
ST
WTO
L
LM
LA
BSM
DS
END
F'100'
F'200'
F
F
F
F
AL2(16)
CL16
D
*-WSCONST
0H
3,A
3,PARM
3,B
3,PARM+4
3,RES
3,PARM+8
2
18F
F
F
F
F
F
F
AL2
CL16
D
14,12,12(13)
12,0
*,12
13,SAVE+4
13,SAVE
2,1
'IN ADD'
1,2
2,4,0(1)
5,0(0,2)
5,0(0,3)
5,0(0,4)
'EXITING ADD'
13,SAVE+4
14,12,12(13)
15,0
0,14
18F
67 / 118
68 / 118
Program Management
LOAD
Brings the load module into virtual storage
Module contains program or table
Placed above or below line
Returns
Authorisation code
Length of the module
Entry point to the module
AMODE of the module
Control is not passed to the module
Used in dynamic subroutine call
Modules can be shared

Name LOAD EP=entry name
On return to caller the registers contain the following
0
Entry point address of requested load module. The high order bit reflects the load modules
AMODE (1 for 31 bit AMODE, else 0 for 24 bit AMODE).
If AMODE is any then the bit reflects callers AMODE.
15
Zero if no error, else reason code
Example
LOAD
LTR
BNZ
LR
BSSM
EP=MYPROG
15,15
ERROR
15,0
stick to using register 15 for entry point
14,15
BSSM takes care of switch of AMODE if reqd.
An important point to note is that if the module has already been loaded into the callers address
space because of a earlier request ( Possibly from some asynchronous exit routine) then control
is given to the existing copy of the module. Since we branch to the entry point directly, we can
have a problem if the module is in use and it is not re-entrant or is only serially reusable. For this
reason XCTL or LINK is preferred as the control is passed via system which checks for this
possible source of error.
DELETE
Remove a module from virtual storage
Entry name same as used in load macro
Task termination removes the module

Name DELETE
EP=entry name
Register 15 is zero on successful completion.
CALL
Name CALL
entry-name | (n),(parm1,parm2,.),VL
Notes
Control returns only after called program returns. Hence register 15 reflects return code of called program
If entry name is used, the called program gets link edited into the main program (caller) at linking time
XCTL
To transfer control to another module
Module loaded if not in virtual storage
Handles the addressing mode
69 / 118
Control does not return back

name
XCTL
(reg1,reg2), EP=entry name, PARAM=(parm1,parm2,),VL=1,

MF=(E, user area | (n))
Notes:- The reg1,reg2 indicates the registers that are to be restored from save area before the
called routine gets control . Usually coded (2,12). MF=(E,User area). User area points to an area
where the parameter list can be generated .Since the transfer is through the system, the system
takes care of the AMODE switch if required. The system also takes care of re-entrancy of the
module transferred to. Control does not return back to caller in any case.
Example:
ADDRDATA
LINK
XCTL
.
.
DC
DC
(2,12),EP=MYPROG,MF=(E,ADDRDATA)
A(PARM1)
A(PARM2)
To pass control to an entry point

Module loaded if not in virtual storage
Handles the addressing mode
Parameter list could be passed
Control returns back
Error handling could be specified
Name
LINK
EP=entry name,
PARAM=(parm1,parm2,..),VL=1,
ERRET=errroutine
Called routine gets control with the following values in the register
1
address of parameter list
15 Entry address of called program
If the link was unsuccessful the error routine gets control with the following
1
Abend Code that would have been issued if the caller had not provided error exit
2-12 unchanged
15 Address of the error exit
14 used as work register by system
Example
LINK
PARM1
PARM2
ERROR
.
.
DS
DS
EP=MYPROG,PARAM=(parm1,parm2),
ERRET=ERROR
F
F
Process Management
ABEND
Name ABEND
compcode,REASON=,DUMP,STEP
compcode
REASON
value 0 to 4095.Register notation (2) to (12) permitted

This code is passed to subsequent user exits if specified. 32 bit hexadecimal
value or 31 bit decimal number
70 / 118
DUMP
Requests a dump of virtual storage assigned to task. Needs //SYSABEND,
//SYSDUMP or //SYSUDUMP DD statement to be present in the JCL for the job step.
STEP Requests all tasks associated with this Job step of which this task is a part to abend
ATTACH
To create a new task
New task is the subtask
Parameter list could be passed
ECB can be provided
Limit priority same as that of the creating task
Dispatching priority same as that of the creating task
Use DETACH macro to remove the sub task
Returns TCB address in reg 1

Name ATTACH
EP=entry name,
PARAM=(parm1,parm2,),
VL=1,
ECB=ecb addr,
EXTR=Address of end of task routine
Registers on entry to subtask are
0
Used as work area by system
1
Used by macro to point to parameter list
2-12 Used as work regs by System
13 Should point to a 18F save area in callers module
14 Return address. Bit 0 is 0 if subtask gets control in 24 bit mode else 1 if subtask
gets control in 31 bit mode
15 Entry point address of subtask
Registers on return to caller after issue of ATTACH
1
address of TCB of subtask
15 A return code of non zero means subtask could not be attached
Load Libraries searched are
Job pack area
Requesting tasks task library and all unique task libraries of parent tasks
Step library
Job library
Link Pack area
Link Library
In simplest form usage can be :
ATTACH
EP=PROG1,ECB=ECB1
ECB1
DS
F
Notes:
This macro creates a separate thread of execution in callers address space
Within the Address space this subtask will compete for processor resources
1) There is a despatching priority for address space
2) At a lower level there is a despatching priority for the subtasks
The attaching task has to wait for subtasks to end before terminating else it will abend when
attempting to terminate
The attaching task has to wait on the ECB which is posted by the system when the subtask
ends
The attaching task then issues a DETACH macro.
71 / 118
EXTR exit routine gets control with the following register values
0
used as a work register by the system
1
Address of TCB of subtask. Needed for issuing DETACH macro
2-12 Work registers
13 18F save area provided by system
14 return address
15 entry point of exit routine
DETACH
Removes a subtask
If issued before task completion, terminate the task
Should be issued if ECB or ETXR is used in ATTACH
Removing a task removes all its dependent tasks also
If ECB or ETXR is used, and the parent task does not issue DETACH, then the
parent task will abend
Name DETACH
tcb address | (n)
Operand can be in register notation in which case regs 1 thru 12 may be used.
The TCB address should have been previously obtained by EXTR exit routine
Example
ATTACH
LTR
BNZ
ST
.
.
TCB1
DC
ENDOFTSK
DETACH
BR
WAIT
EP=PROG1,EXTR=ENDOFTSK
15,15
ERROR
1,TCB1 save address of TCB for later use
F'0'
(1)
14
Wait for completion of events

Initialise the ECB before calling
A list of ECBs can be specified for waiting on any number of events
Example of MAIN creating two subtasks TASK1 and TASK2
FIRST
CSECT
STM
14,12,12(13)
BALR 12,0
USING *,12
ST
13,SAVE+4
LA
13,SAVE
WTO
'MAIN1 STARTING'
ATTACH EP=TASK1,ECB=ECB1
LTR
15,15
BNZ
ERROR1
ST
1,TCB1
ATTACH EP=TASK2,ECB=ECB2
ERROR1
ERROR2
SAVE
ECB1
ECB2
TCB1
TCB2
TASK1
LOOP
SAVE
TASK2
LOOP
72 / 118
LTR
15,15
BNZ
ERROR2
ST
1,TCB2
WTO
'MAIN1 ENTERING WAIT FOR TASK1 COMPLETION'
WAIT ECB=ECB1
WTO
'MAIN1 ENTERING WAIT FOR TASK2 COMPLETION'
WAIT ECB=ECB2
LA
4,TCB1
DETACH (4)
LA
4,TCB2
DETACH (4)
L
13,SAVE+4
L
13,SAVE+4
L
13,SAVE+4
DS
18F
DC
F'0'
DC
F'0'
DS
F
DS
F
END
CSECT
STM
BALR
USING
ST
LA
LA
WTO
BCT
L
LM
SR
BR
DS
END
CSECT
STM
BALR
USING
ST
LA
LA
WTO
BCT
L
LM
14,12,12(13)
12,0
*,12
13,SAVE+4
13,SAVE
5,50
'TASK1 REPORTING'
5,LOOP
13,SAVE+4
14,12,12(13)
15,15
14
18F
14,12,12(13)
12,0
*,12
13,SAVE+4
13,SAVE
5,50
'TASK2 REPORTING'
5,LOOP
13,SAVE+4
14,12,12(13)
SR
BR
DS
END
SAVE
73 / 118
15,15
14
18F
RETURN
Name RETURN
(reg1,reg2),T,RC=retcode
restores reg1 to reg2 from save area pointed by R13
T sets a flag in the save area in the called program for dump analysis if required
Maximum value for return code is 4095 which is set in R15
(see example of implementation under MACROS and conditional assembly)
SAVE
Name SAVE
(reg1,reg2)
Saves reg1 thru reg2 in save area pointed to by R13
(see example of implementation under MACROS and conditional assembly)
REENTERABILITY
For load modules which may be shared amongst more than one concurrent task, re-entrancy is
important. Most macros (in standard form) generate an inline parameter list of data areas
which are used for passing as well as receiving information from the macro call. Obviously inline
parameter list makes the load module non re-entrant and at best serially re-entrant.
For this reason to make a load module re-entrant, do not define data areas in the program which
will be part of the load module. Instead at run time (using GETMAIN or STORAGE OBTAIN) to
dynamically acquire storage. A typical example of this would be to acquire the 18 full word save
area dynamically. Where the acquired area needs to be accessed by field you can use a DSECT
to format the block of storage.
As for MACROS IBM provides, apart from standard form which develops inline parameter lists,
LIST and EXECUTE (MF=L or MF=E) form of the macro exist. The list form does not generate
any executable code. Instead it generates only a parameter list. At run time you acquire storage
equivalent in size to this list and copy the list to this area. This way each thread of execution will
have it's own discrete parameter area. At run time use the execute for of the macro (which can
also be used to change some of the parameters generated earlier) with a pointer to the
parameter list built up in virtual storage.
The list form of the macro is signalled to the assembler by the parameter MF=L
The execute form is signalled to the assembler by using the parameter MF=E
Example
.
.
LA
3,MACNAME load address of the list generated
LA
5,NSIADDR
load address of end of list
SR
5,3
GPR5 will now have length of list
BAL
14,MOVERTN go to rtn to move list
DEQ ,MF=(E,(1))
GPR1 points to parm list, execute form
.
.
processing here
.
BR
14
* acquire storage sufficient to hold the list
MOVERTN
GETMAIN
R,LV=(5)
LR
4,1
address of area in gpr4
MOVEINST
MACNAME
NSIADDR
NAME1
NAME2
BCTR
EX
BR
MVC
DEQ
EQU
DC
DC
5,0
subtract 1 from gpr5
5,MOVEINST
14
0(0,4),0(3)
change the length field and copy the list
(NAME1,NAME2,8,SYSTEM),RET=HAVE,MF=L
*
CL8'MAJOR'
CL8'MINOR'
Example using WTO
FIRST
SAVE
MV
MSG
LMSG
CSECT
STM
14,12,12(13)
BALR 12,0
USING *,12
ST
13,SAVE+4
GETMAIN R,LV=LMSG
LR
2,1
LA
3,MSG
LA
4,LMSG
BCTR 4,0
EX
4,MV
WTO
,MF=(E,(2))
LA
13,SAVE
L
13,SAVE+4
LM
14,12,12(13)
SR
15,15
BR
14
DS
18F
MVC
0(0,2),0(3)
WTO
'THIS IS THE MESSAGE',MF=L
EQU
*-MSG
END
Re-entrancy and writable storage
FIRST
74 / 118
CSECT
STM
14,12,12(13)
BALR 12,0
USING *,12
LR
2,1
GETMAIN R,LV=WSLENGTH,LOC=BELOW
USING WS,1
ST
13,SAVE+4
LA
13,SAVE
DROP 1
LR
13,1
LR
1,2
USING WS,13
WTO
'ASM1 REPORTING'
MVC
MSG+2(6),=C'ABCDEF'
LA
6,6
STH
6,MSG
LA
6,MSG
WTO
TEXT=(6)
LA
15,4
LR
2,13
L
13,SAVE+4
FREEMAIN R,LV=WSLENGTH,A=(2)
L
14,12(0,13)
LM
0,12,20(13)
BR
14
WS
DSECT
SAVE
DS
18F
MSG
DS
AL2
DS
CL100
WSLENGTH EQU
*-WS
END
75 / 118
76 / 118
ACCESSING VSAM DATA SETS USING ASSEMBLER LANGUAGE

Macros
Name ACB
back
AM=VSAM,
BUFND=,
BUFNI=,
BUFSP=,
DDNAME=,
MACRF=([ADR],[,CNV][,KEY][,DIR][,SEQ][,SKP][,IN][,OUT] )
EXLST=,
PASSWD=,
NOTES:
AM
BUFND
BUFNI
BUFSP
:
:
:
:
DDNAME
EXLST
MACRF
:
:
:
PASSWD
Always code VSAM for access to VSAM data sets

Number of data buffers, default=2,override possible through JCL
Number of Index buffers, default=1,override possible through JCL
Size of area for Index and Data Buffers. Defaults to specification
in catalogue
Connects a DD statement in run time JCL with this ACB
Address of EXLST macro
ADR
Access by RBA
CNV
Access by Control Interval
KEY
Access by Record Key
DIR
Direct Processing
SEQ
Sequential Processing
SKP
Skip Sequential Processing
IN
Input only
OUT
Input / Output
Address(label) of an area which contains password for the Data
set
Note: This macro generates a control block and should therefore be placed in Data area of your
program
Name
EXLST
[AM=VSAM]
[,EODAD=(address[,A|N][,L] )]
[,JRNAD=(address[,A|N][,L] )]
[,LERAD=(address[,A|N][,L] )]
[,SYNAD=(address[,A|N][,L] )]
EODAD
JRNAD
LERAD
SYNAD
A
N
L
Is the exit routine for end of file

exit routine for journal file updates/deletions/insertions
Logical error exit
Physical error exit
Routine is active
Routine is inactive
Routine is to be dynamically loaded when required
Notes
Name
NOTES :
ACB
RPL
ACB=,
AREA=,
AREALEN=,
RECLEN=,
ARG=,
KEYLEN=,
OPTCD=,
NXTRPL=
:
Address of ACB macro (label)
AM
AREA
AREALEN
RECLEN
:
ARG
KEYLEN
NXTRPL
OPTCD
77 / 118
:
Always code VSAM (used for documentation purposes only)
:
In move mode address of work area for record (label of data area)
:
In locate mode is used by VSAM to set address of record in VSAM
buffer
:
Length of work area. In locate mode will be at least 4.(Full word)
:
For a PUT request is length of record for variable length record
For a GET request is updated by VSAM to indicate length of record
read
:
Label of Argument Field (Key | RBA) field used with GET,PUT,
:
POINT
:
Used to specify key length if Generic key is used (OPTCD=GEN)
:
address of next RPL in chain if chained RPL'S are used.
:
( [ADR|CNV|KEY],[DIR|SEQ|SKP],[FWD|BWD],[ARD|LRD],
:
[NSP|NUP|IPD],[LOC|MVE],[ASY|SYN],[KEQ|KGE],
:
[FKS|GEN])
:
:
ADR Access by RBA
:
CNV Access by control interval
:
KEY
Access by record key
:
:
DIR
Direct processing
:
SEQ Sequential Processing
:
SKP
Skip sequential processing
:
:
FWD Forward Sequential processing
:
BWD Backward Sequential processing
:
:
:
ARD
:
:
:
:
:
NSP
:
:
LOC
MOV
:
:
:
:
:
ASY
:
:
FKS
GEN
full key search

generic search. KEYLEN must be specified
:
:
KEQ
KGE
search key equal

search key greater than or equal.
LRD
NUP
UPD
SYN
Start sequential processing forward or backward with the

record identified by the ARG field
For Backward processing start from the last record in the
file
No updating(for Direct processing VSAM is positioned at
the next record in the file).
No updating, VSAM is not positioned for subsequent
processing
Retain position for Updating
Locate mode I/O(record is processed in VSAM Buffers)
Move mode I/O(records are processed in programs data
area)
Asynchronous operation. Program can continue with
other processing. Later uses CHECK macro to wait on
completion
synchronous operation. Program waits until operation is
complete
You can code only one option from each group

The options must be consistent with one another and with ACB parameters
The first two groups correspond to the MACRF parameter in the ACB macro
The third group specifies direction of processing
78 / 118
The fourth group specifies whether processing is to start with last record in file or record
identified by the ARG field
The fifth group specifies whether the record is being read with intention to update. If not which
record is to be read next.
The last group specifies whether the MOVE or LOCATE mode of I/O is to be used.
This macro generates a control block and should therefore be placed in Data area of your
program
OPEN Address of ACB Macro
CLOSE Address of ACB Macro
GET
RPL=Label of RPL macro | (register)
retrieve a record
PUT
RPL=Label of RPL macro | (register) write a record
POINT RPL=Label of RPL macro | (register) position for subsequent access
ERASE RPL=Label of RPL macro | (register) Delete a record
Note : These MACROS generate executable code and should therefore be in the Instruction area of
the Program
MACROS FOR CONTROL BLOCK MANIPULATION.
SHOWCB
This
TESTCB
This
MODCB
This
GENCB
This
Name SHOWCB
Notes:
ACB|EXLST|RPL
AREA
LENGTH
FIELDS
macros is fetch control block fields

macro is used to test control block fields
macro used to modify control block fields
macro is used to dynamically generate a control block at run time
ACB|EXLST|RPL=,
AM=VSAM,
only for documentation purpose
AREA=,
LENGTH=,
FIELDS=(keyword[,keyword])
: Address (label) of specified Macro

: Area into which VSAM will put the contents of field
specified
: Length of Data area specified under AREA. Each field of the ACB|
EXLST|RPL macro fields are 4 bytes long except : DDNAME which is
8 bytes
: Can be most of any field specified in the ACB|EXLST|RPL macro;
FOR RPL
: ACB,AREA,AREALEN,FDBK,KEYLEN,RECLEN
: RBA,NXTRPL all one full word of data
FOR EXLST
: EODAD,JRNAD,LERAD,SYNAD
FOR ACB
: ACBLEN length of ACB
Can be attributes of an open file as below

AVSPAC number of bytes of available space
BUFNO Number of buffers in use for this file
CINV
Size of Control Interval
FS
Percent of Free control intervals
KEYLEN Length of key field
LRECL Maximum record length
NCIS
Number of Control Interval Splits
NDELR Number of deleted records from file
NEXT
NINSR
NLOGR
NRETR
NUPDR
RKP
79 / 118
Number of Extents allocated to file

Number of records inserted in file
Number of records in file
Number of records retrieved from file
Number of records updated in file
Position of record key relative to start of record
Name TESTCB
ACB|EXLST|RPL=,
AM=VSAM,
ERET=,
keyword=,
OBJECT=
ACB|EXLST|RPL
ERET
keyword
OBJECT
: Address(label) of any of the control block macros

: Address of error handler to be executed if test cannot be executed
: Any field of the ACB,EXLST,RPL,GENCB macro;
The length of any ACB,EXLST,RPL macro using the keywords
ACBLEN,EXLLEN,RPLLEN
: DATA or INDEX
Example
TESTCB
RPL1
RPL=RPL1,FDBK=8
BE
DUPKEY
.
.
.
RPL
.
Notes: Some common

8
12
16
68
92
104
VSAM FDBK codes are

Duplicate key
Record out of sequence
No record found
Access requested does not match access specified
A put for update without a corresponding get for update
Invalid or conflicting RPL options
Name MODCB
ACB|EXLST|RPL=,
AM=VSAM,
Operand keyword= new value
Example:
RPL1
MODCB
.
.
.
RPL
.
RPL=RPL1,OPTCD=(DIR)
FRAMEWORK OF ASSEMBLER PROGRAMS TO ACCESS VSAM FILES

Keyed Direct Deletion
DELETE
LIST
ACB
RPL
MACRF=(KEY,DIR,OUT)
ACB=DELETE,AREA=WORK,AREALEN=50, X
ARG=KEYFIELD,OPTCD=(KEY,DIR,SYN,UPD, X
LOOP
ERROR
WORK
KEYFIELD
80 / 118
MVE,FKS,KEQ)
.
.
MVC KEYFIELD,source
GET
RPL=LIST
LTR
15,15
BNZ
ERROR
.
.
B
LOOP if you do not want to delete this record
ERASE RPL=LIST
LTR
15,15
BNZ
ERROR
..
DS
CL50
DS
CL5
Note that when you GET a record with UPD in the OPTCD option of the RPL vsam maintains
position after the get anticipating either an ERASE or PUT (update). Instead if you issue a GET it
goes ahead with the GET and position for the previous record is lost.
Example
Keyed Sequential retrieval (Forward)
INPUT
RETRVE
ACB
RPL
LOOP
GET
LTR
BNZ
.
.
B
ERROR
IN
.
DS
MACRF=(KEY,SEQ,IN)
ACB=INPUT,AREA=IN,AREALEN=100,
OPTCD=(KEY,SEQ,SYN,NUP,MVE)
RPL=RETRVE
15,15
ERROR
process the record

LOOP
error handler
CL100
Example
Keyed sequential retrieval (backward)
INPUT
RETRVE
EXLST1
LOOP
EOD
ERROR
ACB
RPL
DDNAME=INPUT,EXLST=EXLST1
OPTCD=(KEY,SEQ,LRD,BWD)
EXLST EODAD=EOD
POINT RPL=RETRVE
LTR
15,15
BNZ
ERROR
GET
RPL=RETRVE
LTR
15,15
BNZ
ERROR
.
.
process the record here
B
LOOP
EQU *
.
.
come here for end of file
.
IN
.
.
DS
81 / 118
come here for any error

CL100
Example
Skip Sequential retrieval ksds variable length records
LOOP
ERROR
CHECK0
RCDADDR
SRCHKEY
RCDLEN
GENCBBLK=ACB,DDNAME=INPUT,MACRF=(KEY,SKP,IN)
LTR
15,15
BNZ
ERROR
LR
2,1
GENCB
BLK=RPL,ACB=(2),AREA=RCDADDR,
X
AREALEN=4,
ARG=SRCHKEY,
OPTCD=(KEY,SKP,SYN,NUP,KGE,FKS,LOC)
LTR
15,15
BNZ
CHECK0
LR
3,1
.
MVC
SRCHKEY,source
GET
RPL=(3)
LTR
15,15
BNZ
ERROR
SHOWCB
AREA=RCDLEN,FIELDS=RECLEN,LENGTH=4,
RPL=(3)
LTR
15,15
BNZ
CHECK0
.
B
LOOP
.
.
DS
F
DS
CL8
DS
F
X
X
Example
Keyed Direct Retrieval in LOCATE mode(KSDS, RRDS)
INPUT
RETRVE
LOOP
ACB
RPL
.
.
MVC
GET
LTR
BNZ
.
.
B
ERROR
IN
KEYAREA
.
DS
DS
MACRF=(KEY,DIR,IN)
ACB=INPUT,AREA=IN,AREALEN=4,OPTCD=(KEY,
DIR,SYN,NUP,KEQ,GEN,LOC),ARG=KEYAREA,
KEYLEN=5
X
X
KEYAREA,source
RPL=RETRVE
15,15
ERROR
Address of record is now in IN
LOOP
..
CL4
CL5
Where VSAM puts the address of the record in the I/O buffer
82 / 118
Notes: In LOCATE mode (LOC) there is no transfer of the record from the VSAM buffer to the
data area in your program. Instead VSAM supplies your program the address of the record in the
VSAM (Control Interval) buffer.
When Generic (GEN) is specified also specify KEYLEN=, and condition like KEQ. VSAM
positions at first record which meets the condition. To continue in the sequence
Change to sequential mode and issue GET(s).
Or use GET with KGE using the key of the current record
If the data set is a RRDS the ARG field the search argument is a relative record number
Example
Switch from Direct to Sequential retrieval
INPUT
ACB
MACRF=(KEY,DIR,SEQ,IN)
RETRVE
RPL
X
OPTCD=(KEY,DIR,SYN,NSP,KEQ,GEN,MVE), X
ARG=KEYAREA,KEYLEN=8
.
.
LOOP
MVC
KEYAREA,source
LOOP1
GET
RPL=RETRVE
direct get
LTR
15,15
BNZ
ERROR
.
SHOWCB
RPL=RETRVE,AREA=FDBAREA,FIELDS=FDBK
LTR
15,15
CLI
ERRCD,8
If 8 means duplicate records
BE
SEQ
B
LOOP
SEQ
MODCB
RPL=RETRVE,OPTCD=SEQ
*
*
switched to sequential mode
*
LTR
15,15
BNZ
ERROR
SEQGET
GET
RPL=RETRVE
LTR
15,15
BNZ
ERROR
.
SHOWCB
RPL=RETRVE,AREA=FDBAREA,FIELDS=FDBK
LTR
15,15
BNZ
ERROR
CLI
ERRCD,8
*
check to see if still need sequential mode
BE
SEQGET
*
if not switch back to direct mode
*
DIR
MODCB
RPL=RETRVE,OPTCD=DIR
LTR
15,15
BNZ
ERROR
B
LOOP
ERROR
..
IN
DS
CL100
KEYAREA
DS
CL8
FDBAREA
DS
0F
DS
1C
TYPECD
DS
1C
CMPCD
ERRCD
DS
DS
83 / 118
1C
1C
Example
Position with POINT macro
BLOCK
ACB
DDNAME=IO
POSITION
RPL ACB=BLOCK,AREA=WORK,AREALEN=50,
ARG=SRCHKEY,OPTCD=(KEY,SEQ,SYN,KEQ,FKS)
LOOP
MVC SRCHKEY,source
POINT RPL=POSITION
LTR
15,15
BNZ
ERROR
LOOP1
GET
RPL=POSITION
LTR
15,15,
BNZ
ERROR
.
process record
.
B
LOOP1
continue in sequential mode
ERROR
.
SRCHKEY
DS
CL5
WORK
DS
CL50
Example
Keyed Sequential insertion KSDS variable length
BLOCK
ACB
DDNAME=OUTPUT,MACRF=(KEY,SEQ,OUT)
LIST
RPL
ACB=BLOCK,AREA=BUILDRCD,AREALEN=250,
OPTCD=(KEY,SEQ,SYN,NUP,MVE)
LOOP
L
2,source-length
MODCB
RPL=LIST,RECLEN=(2)
*
*
alter record length field
*
LTR
15,15
BNZ
ERROR
PUT
RPL=LIST
LTR
15,15
BNZ
ERROR
B
LOOP
ERROR
.
BUILDRCD
DS
CL250
Example
Skip Sequential insertion for KSDS variable length record
OUTPUT
RPL1
*
*
*
LOOP
ERROR
ACB
RPL
MACRF=(KEY,SKP,OUT)
ACB=OUTPUT,AREALEN=80,
OPTCD=(KEY,SKP,SYN,NUP,MVE),
AREA=WORK
set up record in WORK
PUT
LTR
BNZ
.
B
RPL=RPL1
15,15
ERROR
set up next record
LOOP
..
X
X
WORK
DS
84 / 118
80C
Note:In skip sequential insertion you do not need to have a ARG field with key value. However
records have to be in sequence.
Example
Keyed direct insertion
OUTPUT
ACB
RPL1
RPL
*
*
*
LOOP
*
ERROR
WORK
MACRF=(KEY,DIR,OUT)
ACB=OUTPUT,AREALEN=80,
OPTCD=(KEY,DIR,SYN,NUP,MVE),
AREA=WORK
X
X
set up record in WORK

PUT
RPL=RPL1
LTR
15,15
BNZ
ERROR
set up next record
B
LOOP
..
DS
80C
Note VSAM extracts the keyfield from the record area.

Example
Keyed Direct Update
INPUT
ACB
UPDTE
RPL
*
*
*
LOOP
*
*
*
STORE
ERROR
IN
KEYAREA
RLGTH
NACRF=(KEY,DIR,OUT)
OPTCD=(KEY,DIR,SYN,UPD,KEQ,FKS,MVE),
ARG=KEYAREA,KEYLEN=5
X
X
set up search argument

GET
LTR
BNZ
SHOWCB
LTR
BNZ
RPL=UPDTE
15,15
ERROR
RPL=UPDTE,AREA=RLNGTH,FIELDS=RECLEN,
15,15
ERROR
update the record

does the new record have a different length
BE
STORE
If not go to PUT
L
5,length
set R5 for new length
MODCB
RPL=UPDTE,RECLEN=(5)
LTR
15,15
BNZ
ERROR
PUT
RPL=UPDTE
LTR
15,15
BNZ
ERROR
B
LOOP
..
DS
CL120
DS
CL5
DS
F
85 / 118
FULL EXAMPLE 1
SEQUENTIAL READ.
PGMNAM
START
0
BEGIN
SAVE
(14,12)
BALR
3,0
USING
*,3
ST
13,SAVE+4
LA
13,SAVE
OPEN
(ACB1)
LTR
15,15
set CC based on value in register 15
BNZ
OPENERR
and test for open error
.
.
LOOP
GET
RPL=RPL1
LTR
15,15
set CC based on value in register 15
BNZ
READERR
and test for read error
.
Process record here
.
B
LOOP
CLOSE
(ACB1)
L
13,SAVE+4
RETURN
(14,12)
ACB1
ACB
AM=VSAM,MACRF=IN
RPL1
RPL
ACB=ACB1,AREA=REC1,AREALEN=80,RECLEN=80
REC1
DS
CL80
SAVE
DS
18F
END
BEGIN
FULL EXAMPLE 2 DIRECT RETRIEVAL FOR UPDATE.
EXAMPLE
START
0
BEGIN
SAVE
(14,12)
BALR
3,0
USING
*,3
ST
13,SAVE+4
LA
13,SAVE
OPEN
(ACB1)
LTR
15,15
BNZ
DUMP
no point continuing if file will not open
LOOP
MVC
ITEMKEY,
Set up record key
GET
RPL=RPL1
now fetch record
LTR
15,15
BNZ
ERROR
if error check what error
.
.
modify record as desired
.
PUT
RPL=RPL1
LTR
15,15
BNZ
DUMP
at this stage any error is unexpected
.
.
B
LOOP
CLOSE
(ACB1)
LTR
15,15
BNZ
DUMP
error closing files is serious
L
13,SAVE+4
RETURN
(14,12)
ERROR
TESTCB
RPL=RPL1,FDBK=16 any error other than no
DUMP
REC1
ITEMKEY
SAVE
ACB1
RPL1
BE
ABEND
DS
DS
DS
ACB
RPL
86 / 118
LOOP
record found is serious
1000,DUMP
CL80
CL6
18F
AM=VSAM,MACRF=(DIR,OUT)
ACB=ACB1,AREA=REC1,AREALEN=80,RECLEN=80, X
ARG=ITEMKEY,OPTCD=(DIR,UPD)
87 / 118
LINKAGE CONVENTIONS / 31 BIT ADDRESSING
back
LINKAGE CONVENTIONS
Another program can be invoked through BALR, BASR, BASSM or LINK, XCTL and CALL
macros
A primary mode program is one which operates in primary Address Space Control mode or
primary ASC for short. In this mode access of machine instructions is only in the primary
address space. All your application programs run in this mode. System programs, like the
DB2 subsystem, etc can switch to Address Space modes.
The called program needs to save the registers when it receives control and restore them
when returning. For this the caller provides a 18 Full word save area pointed to by R13.
When caller provides a 18F save area the area is used as below
Word Usage
0
Used by language products
1
Address of previous ( caller) save area
2
Address of next save area
3
GPR14
4
GPR15
5-17
GPR0-12
Example of using the caller provided save area
Calling program linkage
L
15,=A(PGM)
BALR 14,15
Called program linkage
PGM
CSECT
PGM
AMODE
PGM
RMODE
STM
LR
USING
GETMAIN
ST
ST
LR
.
.
.
LR
L
FREEMAIN
SR
L
LM
BR
END
31
ANY
14,12,12(13)
12,15
PGM,12
RU,LV=72
13,4(,1)
1,8(,13)
13,1
save callers registers in callers save area

set up base register
obtain save area
and store callers R13 point in it
store this programs save area in callers save area
set R13 to point to this save programs area
2,13
Set R1 to the address of this programs save area
13,4(,13)
set R13 to point to callers save area
RU,A=(2),LV=72 release this programs save area
15,15
Zero R15
14,12(0,13)
Restore R14 of caller
2,12,28(13)
Restore R2 to R12 of caller
14
Return
Primary mode program which uses Linkage stack must do the following
On entry: Save callers registers 14 thru 12 in the save area pointed to by R13 + 12 bytes Offset.
Establish a GPR as a base register.
Establish a base area of 18 Full words of its own.
Save callers R13 into our own save area + 4.
88 / 118
Set GPR 13 to point to its own save area

Set our save area address into callers save area + 8 (optional).
On exit
Place parameter information that may be returned to caller in R1, R0
Load R13 with callers save area address and restore R0-R12,R14
Load R15 with return code
Issue the BR R14 instruction.
Passing Parameters
If the calling program is in primary mode, the parameter list should be in primary address space
Use R1 to point to a parameter list which is an array of 32 bit addresses which point to parameters.
The last element of the array should have bit 0 set to 1 to indicate it is the last element.
In Primary Mode
GPR1
A(PARM1)
A(PARM2)
A(PARM3)
2 BYTE LENGTH
PARM FIELD -----------
2 BYTE LENGTH
PARM FIELD-------------
A(PARMN)
Example if control is passed to another program in same mode.
PARMLIST
DCBADDRS
ANSWERAD
NEXTADDR
GOOUT
RETURN
ARE
L
CNOP
BAL
DS
DC
DC
DC
DC
BALR
.
.
DC
15,NEXTADDR
0,4
1,GOOUT
0A
A(INDCB)
A(OUTDCB)
A(AREA+X'80000000)
V(NEXTPGM)
14,15
12F'0'
Addressing
AMODE is the mode in which a program expects to receive control. AMODE = 31 means that the
program expects to receive control in 31 bit mode (bit 32 of PSW on) and any addresses are
passed as 32 bit values with bit 0 on to represent 31 bit addressing mode. AMODE = 24 means
that the program expects to receive control in 24 bit addressing mode. In this case the high order
8 bits are not reckoned for computing the effective address. The mode of operation affects
operation of some machine instructions like
BAL, BALR, LA
In the case of BAL and BALR, in 24 bit mode the link register (first operand) which contains the
return address in low order 24 bits, has the high order 8 bits set to the ILC (Instruction length
code, CC (Condition code) and Program mask. When in 31 bit addressing mode the link register
89 / 118
has bit 0 set to 1 and rest of the 31 bits represent the address. In the case of LA, in 24 bit mode
the high order 8 bits are cleared and low order 24 bits are set to represent a 24 bit address. In 31
bit mode, bit 0 is set to 0 and rest of the bits represent a 31 bit address.
RMODE of a program indicate where it can be loaded by the system for execution. A RMODE of
any indicates it can be loaded either above or below what is known as the 16MB line or simply
the line. A RMODE of 24 indicates that it is to be loaded only below the line.
AMODE and RMODE can be set in the assembler source as below:
MAIN
MAIN
MAIN
CSECT
AMODE
RMODE
31
24
AMODE can be 24 / 31 / any.Default=24

RMODE can be 24 or any.Default=24.
Note that the attributes are propagated by the assembler, Linkage editor to the Directory entry for
the load module in the PDS.
The following instructions are used for linkage: BAL
Branch and Link
BAL
Branch and Link Register
BAS
Branch and Save
BASR
Branch and Save register
BSM
Branch and Set mode
BASSM
Branch and save and set mode
BAS and BASR perform as BAL and BALR when in 31 bit mode
BSM provides an unconditional branch to the address in operand 2, saves the current
AMODE in the high order bit of the Link register (operand 1) and sets the AMODE to agree
with the high order bit in the to address.
BASSM does all that BSM does and in addition the link register contains the return
address.
If we need to transfer control without a change of addressing mode use the following
combinations
Transfer
Return
BAL/BALR
BR
BAS/BASR
BR
If we need to change the AMODE as well use BASSM
Example
TEST
TEST
TEST
EPA
CSECT
AMODE
RMODE
.
.
L
BASSM
.
.
EXTRN
DC
.
.
END
24
24
15,EPA
14,15
Obtain transfer address

switch AMODE and branch
EP1
A(X'80000000+EP1) set high order bit to 1 to switch AMODE
EP1
EP1
EP1
CSECT
AMODE
RMODE
.
.
SLR
BSM
END
90 / 118
31
ANY
15,15
0,14
set return code to 0

return and switch to callers AMODE
31 Bit addressing
A 370/XA or a 370/ESA processor can operate in 24 or 31 bit mode (Bimodal operation).
The following kinds of programs must operate below the 16MB line
Programs with AMODE 24
Programs with AMODE any
Programs that use system services that require their callers to be in 24 bit mode
Programs that use system services that require their caller to have RMODE 24
Programs that must be addressable by 24 bit callers
Rules and conventions for 31 bit operation
Addresses are treated as 31 bit values
Any data passed by a program in 31 bit mode to a program in 24 bit mode must lie below the
16MB line
The A mode bit affect the way some H/W instructions work (BAL,BALR,LA,LRA)
A program must return control in the same mode in which it gained control
A program expects a 24 bit address from a 24 bit mode program and 31 bit addresses from a
31 bit mode program
A program must validate the high order byte of any address passed by a 24 bit mode program
before using it as an address in 31 bit mode.
CALL, BALR
Calling module
amode 24
rmode 24
Called module
amode 24
rmode 24
LINK, XCTL, ATTACH

Calling module
amode 24
rmode 24
Called module
amode 31
rmode 24
At Execution time only the following combinations are valid

AMODE 24, RMODE 24
AMODE 31,RMODE 24
AMODE 31,RMODE any
AMODE/RMODE can be controlled and set at following levels
In the assembler source

MAIN
CSECT
MAIN
AMODE
31
MAIN
RMODE
24
In the EXEC statement invoking the linkage editor
91 / 118
//LKED EXEC PGM=HEWL,PARM='AMODE=31,RMODE=24'

Linkage editor control statement
MODE AMODE(31),RMODE(24)
The Linkage editor creates indicators in the load module from inputs from Object Decks and
Load modules input to it
It indicates the attributes in the PDS member to reflect PARM and LKED control
statements.
System obtains the AMODE and RMODE information from the PDS entry.
MVS support for AMODE and RMODE
MVS obtains storage for the module as indicated in RMODE
ATTACH,LINK,XCTL gives control as per the AMODE

LOAD brings in a module into storage as per it's RMODE and sets bit 0 in R0 to indicate
the AMODE
CALL passes control in the AMODE of its caller
Programs in 24 bit mode can switch mode to access data above 16MB line as follows
Example
USER
CSECT
USER
AMODE
24
USER
RMODE
24
L
15,ACTLB
L
1,LABEL1
BSM
0,1
LABEL1
DC
A(LABEL2+X'80000000)
LABEL2
DS
0H
L
2,4,(,15)
LA
1,LABEL3
BSM
0,1
LABEL3
DS
0H
.
.
END
92 / 118
AMODE 31
OK
OK
AMODE 31
OK
16 MB LINE
OK
AMODE 31
AMODE 31
AMODE 31
16 MB line
AMODE 31
definitely a problem
possible problem
AMODE 24
AMODE 24
possible problem
AMODE 31
93 / 118
ABOVE CSECT
ABOVE AMODE 31
ABOVE RMODE ANY .
16MB LINE
.
.
BSM 0,14
BELOW CSECT
BELOW AMODE 24
BELOW RMODE 24
LOAD EP=ABOVE
ST 0,EPABOVE
L 15,EPABOVE
BASSM 14,15
The above method can be used for dynamic loading and branching to a module with a different
AMODE.
The following example indicates how to make a static call where the called module has a
different AMODE.
Example
RTN1
CSECT
EXTRN
RTN2AD
EXTRN
RTN3AD
.
.
L
15,=A(RTN2AD)
L
15,0(,15)
BASSM
14,15
.
.
L
15,=A(RTN3AD)
L
15,0(,15)
BASSM
14,15
.
.
END
RTN2
RTN2
RTN2AD
RTN3
RTN3
RTN3AD
CSECT
AMODE
ENTRY
.
BSM
DC
CSECT
AMODE
ENTRY
.
BSM
DC
24
RTN2AD
0,14
A(RTN2)
31
RTN3AD
0,14
A(X'80000000+RTN3)
94 / 118
Example of 31 bit program with static storage above 16 MB line. This program does not
work with ADD as ADD operates in 24 bit mode.
FIRST
FIRST
FIRST
LOADERR
SAVE
B
A
RES
PARMS
MSG
DW
CSECT
AMODE
RMODE
STM
BALR
USING
ST
LA
LOAD
LTR
BNZ
LR
LA
BASSM
L
CVD
UNPK
OI
WTO
LA
WTO
L
LM
LA
BR
L
LM
LA
BR
DS
DC
DC
DS
DC
DC
DC
DC
DS
DS
END
31
ANY
14,12,12(13)
12,0
*,12
13,SAVE+4
13,SAVE
EP=ADD
15,15
LOADERR
15,0
1,PARMS
14,15
5,RES
5,DW
MSG+2(16),DW
MSG+17,X'F0'
'RESULT IS'
4,MSG
TEXT=(4)
13,SAVE+4
14,12,12(13)
15,0
14
13,SAVE+4
14,12,12(13)
15,16
14
18F
F'200'
F'100'
F
A(A)
A(B)
A(X'80000000'+RES)
AL2(16)
CL16
D
Example of 31 bit program with dynamically acquired storage below the line. This
program works fine with ADD although ADD operates in 24 bit mode.
FIRST
FIRST
FIRST
CSECT
AMODE 31
RMODE ANY
STM
14,12,12(13)
BALR 12,0
USING *,12
LOADERR
INIT
WS
SAVE
A
B
RES
PARMS
LR
2,1
GETMAIN R,LV=LEN,LOC=BELOW
ST
13,4(0,1)
USING WS,13
LR
13,1
LR
1,2
BAL
2,INIT
LOAD EP=ADD
LTR
15,15
BNZ
LOADERR
LR
15,0
LA
1,PARMS
BASSM 14,15
WTO 'BACK'
L
5,RES
CVD
5,DW
UNPK MSG+2(16),DW
OI
MSG+17,X'F0'
WTO
'RESULT IS'
LA
4,MSG
WTO
TEXT=(4)
LR
2,13
L
13,SAVE+4
FREEMAIN R,LV=LEN,A=(2)
LM
14,12,12(13)
LA
15,0
BR
14
L
13,SAVE+4
LM
14,12,12(13)
LA
15,16
BR
14
LA
3,100
ST
3,A
LA
3,200
ST
3,B
LA
3,A
ST
3,PARMS
LA
3,B
ST
3,PARMS+4
LA
3,RES
ST
3,PARMS+8
LA
3,16
STH
3,MSG
BR
2
DSECT
DS
18F
DS
F
DS
F
DS
F
DS
F
DS
F
95 / 118
MSG
DW
LEN
DS
DS
DS
DS
EQU
END
F
AL2
CL16
D
*-WS
By default ADD operates in 24 / 24 mode
ADD
SAVE
CSECT
STM
USING
ST
LA
LR
DROP
USING
LR
WTO
LR
LM
L
A
ST
WTO
L
LM
LA
BSM
DS
END
14,12,12(13)
ADD,15
13,SAVE+4
13,SAVE
12,15
15
ADD,12
2,1
'IN ADD'
1,2
2,4,0(1)
5,0(0,2)
5,0(0,3)
5,0(0,4)
'EXITING ADD'
13,SAVE+4
14,12,12(13)
15,0
0,14
18F
96 / 118
97 / 118
ASSEMBLER COURSE LAB EXERCISES

The following exercises do not present any complex assembler programming effort. Rather they serve to
reinforce basic and fundamental concepts. The instructions you may need to use may not be more than
about twenty or so. Before you start you need to have the quick reference card, Assembler services
reference and assembler services guide handy. The principles of operation which explain all
operation codes in detail is available online (Windows network) in case you need it. Most operation codes
you use would have been explained in the class handouts and that should be adequate. You may also
need to have access to MVS codes in case your program abends. Good luck and happy programming !.
Setup the work environment
Note:The data set space parameters are given on a rough basis only. In case you get into a data set full
condition, you may have to create a larger, new data set and copy the members across.
1)Create a PDS for your assembler source as below
Lrecl
80
Blksize
800
Recfm
FB
DSN
userid.asmclass.asm
Unit
SYSDA or allow SMS to default
Primary alloc
2 trk
Sec alloc
2trk
Dir
5 block
Unit of allocation
trk
2)Create a PDS for your assembler JCL as below
Lrecl
80
Blksize
800
Recfm
FB
DSN
userid.asmclass.cntl
Unit
Primary alloc
2 trk
Sec alloc
1trk
Dir
5 block
Unit of allocation
trk
3)Creat a PDS for your assembler object files as below
Lrecl
80
Blksize
800
Recfm
FB
DSN
userid.asmclass.obj
Unit
Primary alloc
2 trk
Sec alloc
1trk
Dir
5 block
Unit of allocation
trk
4)Creat a PDS for your assembler loadlib as below
Lrecl
23200
Blksize
0
Recfm
U
DSN
userid.asmclass.loadlib
Unit
Primary alloc
2 trk
Sec alloc
2trk
Dir
10 block
98 / 118
Unit of allocatin trk

5)Creat a PDS for your assembler user macros as below
Lrecl
80
Blksize
800
Recfm
FB
DSN
userid.asmclass.maclib
Unit
Primary alloc
2 trk
Sec alloc
1trk
Dir
5 block
Unit of allocatin trk
6)Browse the member ASMACL in the SYS1.PROCLIB . This is the procedure to assemble and link your
assembler programs.You should be able to understand every line of the prcedure as well as the
assembler and linker options. You may have to access IBM manuals for the assembler and linker
options. Understand what statements need to be overridden to achieve the following:Program source from
userid.asmclass.asm
Program Loadmodule into
userid.asmclass.loadlib
Object code for subprograms into
userid.asmclass.obj
Object code for subprograms from
userid.asmclass.obj
User macros from
userid.asmclass.maclib
Change assembler and linker parms (if appropriate) when invoking the Procedure.
99 / 118
EXERCISES
1)Write a simple assembler program which does nothing other than return to check out the operation of the
JCL and submitting jobs to batch. Make sure that you understand the process including using the SDSF
facility.
2)Write a program which can detect and copy the value passed through the PARM field in the exec
statement and output it via SYSOUT
3)Write an assembler program which converts a 26 byte character field from lower case to upper case.
Verify the correct operation of the program through a SNAP dump before and after the operation.
4)Write an assembler program to convert a binary value in a full word storage field to a displayable value
in another storage field. Verify correct operation through SNAP dump
5)a)Write a user macro (store it in userid.asmclass.maclib) which accepts a binary full word field in a GPR
(operand one) and converts it to a displayable value in a memory field (operand two)
b)Use the program logic debugged and working from previous example. You will also have to make JCL
modifications to include your maclib
c)Write your own macro to implement saving and restoring registers on entry and exit into your program.
6)Write an assembler program to open and read a QSAM PS file and output it via SYSOUT
7)Create a VSAM KSDS data set and load the data set using an assembler program which reads input
from a QSAM PS file and loads it in sequential mode.
8)Run an IDCAMS job stream to ensure that the data set has been loaded (use PRINT option )
9)Insert records in the data set using DIRECT mode and input from another QSAM file where records
which may be in any order
10)Try out other modes of VSAM access like DIRECT get, SEQ get with an EODAD routine defined
through EXLST macro. Use SHOWCB macro to test VSAM feedback code after each operation. Use
dynamic storage allocation (Getmain / Storage macro) to acquire storage for data buffers in your
program.
11)Write a main program which calls a subprogram in the same file with three storage Fullword integers as
parameters. The subprogram must add the two integers and return the sum in the third fullword. Output
the result via sysout. Note that you have to convert the binary form to displayable form using the CVD
and UNPACK instructions.
12)Write an assembler sub program which can be called using CALL macro. The main program and the
subprogram should share the same DCB for SYSOUT data. Main and sub programs should announce
their entry and exit thru messages on SYSOUT. Note that main and sub programs are having separate
source files and need separate compilation.
Hint:You will need to have modified ASMACL to create the Object code for the subprogram which is to
be in userid.asmclass.obj.
13)Write an assembler program to do the same function as in exercise (17) above but using a LOAD
macro.
14)Write a main program which creates a subtask with the ATTACH macro. The main program and the
subprogram must share the same DCB for the SYSOUT dataset. The main and subprogram must
announce their entry and exit. The main program must wait for the attached task to complete before
ending.
100 / 118
*******************************************************************************
* USE THIS PROGRAM TO CHECK OUT YOUR JCL AND BATCH JOB SUBMISSION*
* BEFORE YOU START THE EXERCISES
*
*******************************************************************************
BEGIN CSECT
SAVE
(14,12)
BALR
12,0
USING
*,12
ST
13,SAVE+4
L
13,SAVE+4
RETURN
(14,12),,RC=0
SAVE
DS
18F
END
BEGIN
101 / 118
********************************************************************************
* EXAMPLE OF LOADING AND EXECUTING A PROGRAM AT RUN TIME
*
********************************************************************************
BEGIN
*
*
ERROR1
LOADERR
OUTBUFF
MSG1
MSG2
SAVE DS
FILE2
CSECT
SAVE
BALR
USING
ST
LA
(14,12)
3,0
*,3
13,SAVE+4
13,SAVE
00010000
00030000
00040000
00050000
00060000
00070000
OPEN
LTR
BNZ
(FILE2,OUTPUT)
15,15
ERROR1
00081005
00082005
00083015
MVC
PUT
OUTBUFF(L'MSG1),MSG1
FILE2,OUTBUFF
00084018
00090218
LOAD
LTR
BNZ
LR
BALR
EP=SUB1
15,15
LOADERR
15,0
14,15
00090319
00090419
00090519
00090619
00090719
MVC
00090820
PUT
FILE2,OUTBUFF
00090918
L
13,SAVE+4
00146009
RETURN
(4,12),,RC=0
00147009
L
13,SAVE+4
00148015
RETURN
(14,12),,RC=4
00149015
L
13,SAVE+4
00150019
RETURN
(14,12),,RC=8
00151019
DC
CL80' '
00160018
DC
C'INVOKING SUB1'
00161018
DC
C'EXITING MAIN1'
00162018
18F
00170000
DCB
DSORG=PS,RECFM=F,BLKSIZE=132,LRECL=132,
X 00200001
MACRF=PM,DDNAME=OUTFILE,DEVD=PR
00210005
END
BEGIN
00220001
102 / 118
*******************************************************************************
* SUB1
*
*******************************************************************************
SUB1
CSECT
00010019
SAVE
(14,12)
00030000
BALR
3,0
00040000
USING
*,3
00050000
ST
13,SAVE+4
00060000
LA
13,SAVE
00070000
OPEN
(FILE2,OUTPUT)
00081005
LTR
15,15
00082005
BNZ
ERROR1
00083015
L
2,=F'5'
00084015
LOOP
PUT
FILE2,OUTBUFF
00090215
BCT
2,LOOP
00110015
CLOSE
(FILE2)
00120018
L
13,SAVE+4
00146009
RETURN
(14,12),,RC=0
00147009
ERROR1
L
13,SAVE+4
00148015
RETURN
(14,12),,RC=4
00149015
OUTBUFF
DC
C'THIS IS SUB 1 LOOPING'
00160015
DC
CL(80-L'OUTBUFF)' '
00161017
SAVE DS
18F
00170000
FILE2
DCB
DSORG=PS,RECFM=F,BLKSIZE=132,
X
LRECL=132,MACRF=PM,DDNAME=SUBFILE, X
DEVD=PR
00210018
END
00220019
103 / 118
*******************************************************************************
* EXAMPLE OF USAGE OF A CALL MACRO
*
*******************************************************************************
BEGIN
CSECT
00010000
SAVE
(14,12)
00030000
BALR
3,0
00040000
USING
*,3
00050000
ST
13,SAVE+4
00060000
LA
13,SAVE
00070000
OPEN
(FILE2,OUTPUT)
00081005
LTR
15,15
00082005
BNZ
ERROR1
00083015
MVC
00084018
PUT
FILE2,OUTBUFF
00090218
CALL
SUB2,(FILE2)
00090322
MVC
00090820
PUT
FILE2,OUTBUFF
00090918
L
13,SAVE+4
00146009
RETURN
(14,12),,RC=0
00147009
ERROR1
L
13,SAVE+4
00148015
RETURN
(14,12),,RC=4
00149015
LOADERR
L
13,SAVE+4
00150019
RETURN
(14,12),,RC=8
00151019
OUTBUFF
DC
CL80' '
00160018
MSG1
DC
C'INVOKING SUB1'
00161018
MSG2
DC
C'EXITING MAIN1'
00162018
SAVE
DS
18F
00170000
FILE2
DCB
DSORG=PS,RECFM=F,BLKSIZE=132,LRECL=132,
X00200001
00210005
END
BEGIN
00220001
104 / 118
*******************************************************************************
* SUB2
*
*******************************************************************************
SUB2
CSECT
00010021
SAVE
(14,12)
00030000
BALR
3,0
00040000
USING
*,3
00050000
ST
13,SAVE+4
00060000
LA
13,SAVE
00070000
L
4,0(1)
00080022
L
2,=F'5'
00084015
LOOP
PUT
(4),OUTBUFF
00090222
BCT
2,LOOP
00110015
L
13,SAVE+4
00146009
RETURN
(14,12),,RC=0
00147009
OUTBUFF
DC
00160015
DC
CL(80-L'OUTBUFF)' '
00161017
SAVE
DS
18F
00170000
END
00220019
105 / 118
*******************************************************************************
* EXAMPLE OF USAGE OF ATTACH A SUBTASK USING ATTACH MACRO
*
*******************************************************************************
BEGIN
CSECT
00010000
SAVE
(14,12)
00030000
BALR
3,0
00040000
USING
*,3
00050000
ST
13,SAVE+4
00060000
LA
13,SAVE
00070000
SYSSTATE
ASCENV=P
00080026
OPEN
(FILE2,OUTPUT)
00081005
LTR
15,15
00082005
BNZ
ERROR1
00083015
MVC
00084018
PUT
FILE2,OUTBUFF
00090218
ATTACHX
EP=SUB3,ETXR=ETXSUB3,PARAM=FILE2,
X
SZERO=YES
00090328
LTR
15,15
00090419
BNZ
ATTCHERR
00090521
WAIT
1,ECB=ECBSUB3
00090722
MVC
00091020
PUT
FILE2,OUTBUFF
00092018
L
13,SAVE+4
00146009
00146125
ETXSUB3
ST
1,TCBADDR
00146232
DETACH
TCBADDR
00146332
POST
ECBSUB3
00146425
BR
14
00146525
ERROR1
L
13,SAVE+4
00148015
RETURN
(14,12),,RC=4
00149015
ATTCHERR
L
13,SAVE+4
00150021
RETURN
(14,12),,RC=8
00151019
TCBADDR
DC
A(0)
00151132
ECBSUB3
DC
F'0'
00152021
OUTBUFF
DC
CL80' '
00160018
MSG1
DC
C'INVOKING SUB3'
00161021
MSG2
DC
C'EXITING MAIN3'
00162021
SAVE
DS
18F
00170000
FILE2
DCB DSORG=PS,RECFM=F,BLKSIZE=132,LRECL=132,
X00200001
00210005
END
BEGIN
00220001
*********************************************************************
* SUB3
*
*********************************************************************
SUB3
CSECT
SAVE
(14,12)
BALR
3,0
USING
*,3
ST
13,SAVE+4
LA
13,SAVE
L
4,0(1)
L
2,=F'20'
LOOP
PUT
(4),OUTBUFF
BCT
2,LOOP
L
13,SAVE+4
RETURN
(14,12),,RC=0
OUTBUFF
DC
DC
CL(80-L'OUTBUFF)' '
SAVE
DS
18F
END
106 / 118
00010023
00030000
00040000
00050000
00060000
00070000
00080022
00084023
00090222
00110015
00146009
00147009
00160023
00161017
00170000
00220019
107 / 118
***********************************************************************
* EXAMPLE OF INVOKING ANOTHER PROGRAM AT RUN TIME USING A*
* LINK MACRO
*
***********************************************************************
BEGIN
CSECT
00010000
SAVE
(14,12)
00030000
BALR
3,0
00040000
USING
*,3
00050000
ST
13,SAVE+4
00060000
LA
13,SAVE
00070000
OPEN
(FILE2,OUTPUT)
00081005
LTR
15,15
00082005
BNZ
ERROR1
00083015
MVC
00084018
PUT
FILE2,OUTBUFF
00090218
LINK
EP=SUB4,PARAM=FILE2
00090335
LTR
15,15
00090419
BNZ
LINKERR
00090535
MVC
00094028
PUT
FILE2,OUTBUFF
00095028
L
13,SAVE+4
00146009
RETURN
(14,12),,RC=0
00146125
ERROR1
L
13,SAVE+4
00148015
RETURN
(14,12),,RC=4
00149015
LINKERR
L
13,SAVE+4
00150035
RETURN
(14,12),,RC=8
00151019
OUTBUFF
DC
CL80' '
00160018
MSG1
DC
C'INVOKING SUB4'
00161029
MSG3
DC
C'EXITING MAIN4'
00162034
SAVE
DS
18F
00170000
FILE2
DCB DSORG=PS,RECFM=F,BLKSIZE=132,LRECL=132,
X00200001
00210005
END
BEGIN
00220001
108 / 118
***********************************************************************
* SUB4
*
***********************************************************************
SUB4
CSECT
00010024
SAVE
(14,12)
00030000
BALR
3,0
00040000
USING
*,3
00050000
ST
13,SAVE+4
00060000
LA
13,SAVE
00070000
L
4,0(1)
00080022
L
2,=F'2'
00084025
LOOP
PUT
(4),OUTBUFF
00090222
BCT
2,LOOP
00110015
L
13,SAVE+4
00146009
RETURN
(14,12),,RC=0
00147009
OUTBUFF
DC
00160026
DC
CL(80-L'OUTBUFF)' '
00161017
SAVE
DS
18F
00170000
END
00220019
109 / 118
************************************************************************
* EXAMPLE OF OBTAINING A SNAP DUMP
*
************************************************************************
BEGIN
CSECT
00010000
SAVE
(14,12)
00030000
BALR
3,0
00040000
USING
*,3
00050000
ST
13,SAVE+4
00060000
LA
13,SAVE
00070000
TPUT
MSG,L'MSG
00071013
OPEN
(FILE1,INPUT)
00080005
LTR
15,15
00080105
BNZ
ERROR1
00080205
OPEN
(FILE2,OUTPUT)
00081005
LTR
15,15
00082005
BNZ
ERROR2
00083005
OPEN
(SNAPDCB,OUTPUT)
00084014
LTR
15,15
00085014
BNZ
ERROR3
00086014
LOOP
GET
FILE1,INBUFF
00090002
MVC
OUTBUFF,INBUFF
00090108
PUT
FILE2,OUTBUFF
00090208
B
LOOP
00110000
ERROR1
L
13,SAVE+4
00141005
RETURN
(14,12),,RC=1
00142005
ERROR2
L
13,SAVE+4
00143005
RETURN
(14,12),,RC=2
00144005
ERROR3
L
13,SAVE+4
00144114
RETURN
(14,12),,RC=3
00144214
EOFRTN
CLOSE
(FILE1,,FILE2)
00145009
SNAP
DCB=SNAPDCB,ID=1,PDATA=(REGS,SA),
X
STORAGE=(BEGIN,LAST)
00145214
CLOSE
SNAPDCB
00145314
L
13,SAVE+4
00146009
RETURN
(14,12),,RC=0
00147009
INBUFF
DS
CL80
00150012
OUTBUFF
DS
CL80
00160012
DC
52C' '
00161012
SAVE
DS
18F
00170000
MSG
DC
CL15'ENTERING PGM'
00171013
FILE1
DCB
DSORG=PS,RECFM=FB,BLKSIZE=800,
X
LRECL=80,MACRF=GM,DDNAME=INFILE,
X
EODAD=EOFRTN
00190009
FILE2
DCB
X
LRECL=132,MACRF=PM,DDNAME=OUTFILE,
X
DEVD=PR
00210005
SNAPDCB
DCB
DSORG=PS,RECFM=VBA,BLKSIZE=882,
X
LRECL=125,MACRF=W,DDNAME=SNAPDMP
00210214
LAST
EQU
*
00211014
END
BEGIN
00220001
110 / 118
********************************************************************
* EXAMPLE OF LOADING VSAM KSDS SEQUENTIALLY
*
********************************************************************
BEGIN
CSECT
00010000
SAVE
(14,12)
00030000
BALR
3,0
00040000
USING
*,3
00050000
ST
13,SAVE+4
00060000
LA
13,SAVE
00070000
OPEN
(FILE1,INPUT)
00080005
LTR
15,15
00080105
BNZ
ERROR1
00080205
OPEN
(VSAMACB)
00081015
LTR
15,15
00082005
BNZ
ERROR2
00083005
LOOP
GET
FILE1,INBUFF
00090002
MVC
OUTBUFF,INBUFF
00090108
PUT
RPL=VSAMRPL
00090215
B
LOOP
00110000
ERROR1
L
13,SAVE+4
00141005
RETURN
(14,12),,RC=1
00142005
ERROR2
L
13,SAVE+4
00143005
RETURN
(14,12),,RC=2
00144005
EOFRTN
CLOSE
(FILE1,,VSAMACB)
00145016
L
13,SAVE+4
00146009
RETURN
(14,12),,RC=0
00147009
INBUFF
DS
CL80
00150012
OUTBUFF
DS
CL80
00160012
SAVE
DS
18F
00170000
FILE1
DCB
X
LRECL=80, MACRF=GM,DDNAME=INFILE, X
EODAD=EOFRTN
00190009
VSAMACB
ACB
AM=VSAM,DDNAME=OUTFILE,
X
MACRF=(KEY,SEQ,OUT)
00200015
VSAMRPL
RPL
AM=VSAM,ACB=VSAMACB,AREA=OUTBUFF,X
AREALEN=80,ARG=VSAMKEY,KEYLEN=4,
X
OPTCD=(KEY,SEQ),RECLEN=80
00210115
VSAMKEY
DS
F
00210215
END
BEGIN
00220001
111 / 118
************************************************************************
* EXAMPLE OF DIRECT UPDATE OF A VSAM KSDS USING A QSAM FILE *
* INPUT
*
************************************************************************
BEGIN
CSECT
00010000
SAVE
(14,12)
00030000
BALR
3,0
00040000
USING
*,3
00050000
ST
13,SAVE+4
00060000
LA
13,SAVE
00070000
OPEN
(FILE1,INPUT)
00080005
LTR
15,15
00080105
BNZ
ERROR1
00080205
OPEN
(VSAMACB)
00081015
LTR
15,15
00082005
BNZ
ERROR2
00083005
LOOP
GET
FILE1,INBUFF
00090002
MVC
OUTBUFF,INBUFF
00090108
MVC
VSAMKEY,OUTKEY
00090217
PUT
RPL=VSAMRPL
00090315
B
LOOP
00110000
ERROR1
L
13,SAVE+4
00141005
RETURN
(14,12),,RC=1
00142005
ERROR2
L
13,SAVE+4
00143005
RETURN
(14,12),,RC=2
00144005
EOFRTN
CLOSE
(FILE1,,VSAMACB)
00145016
L
13,SAVE+4
00146009
RETURN
(14,12),,RC=0
00147009
INBUFF
DS
CL80
00150012
OUTBUFF
DS
0CL80
00160017
OUTKEY
DS
CL4
00161017
DS
CL76
00162017
SAVE
DS
18F
00170000
FILE1
DCB
X
X
EODAD=EOFRTN
00190009
VSAMACB
ACB
AM=VSAM,DDNAME=OUTFILE,
X
MACRF=(KEY,DIR,OUT)
00200017
VSAMRPL
RPL
AM=VSAM,ACB=VSAMACB,
X
AREA=OUTBUFF,AREALEN=80,
X
ARG=VSAMKEY,KEYLEN=4,
X
OPTCD=(KEY,DIR),RECLEN=80
00210117
VSAMKEY
DS
F
00210215
END
BEGIN
00220001
112 / 118
********************************************************************
* EXAMPLE OF READING VSAM KSDS SEQUENTIALLY
*
********************************************************************
BEGIN
CSECT
00010000
SAVE
(14,12)
00030000
BALR
3,0
00040000
USING
*,3
00050000
ST
13,SAVE+4
00060000
LA
13,SAVE
00070000
OPEN
(VSAMACB)
00080018
LTR
15,15
00080105
BNZ
ERROR1
00080205
OPEN
(FILE1,OUTPUT)
00081018
LTR
15,15
00082005
BNZ
ERROR2
00083005
LOOP
GET
RPL=VSAMRPL
00090018
SHOWCB
RPL=VSAMRPL,AREA=RETCODE,LENGTH=4, X
FIELDS=FDBK
00090120
L
4,RETCODE
00090220
LTR
4,4
00090320
BNZ
ERROR3
00090420
MVC
OUTBUFF,INBUFF
00090508
PUT
FILE1,OUTBUFF
00090619
B
LOOP
00110000
ERROR1
L
13,SAVE+4
00141005
RETURN
(14,12),,RC=1
00142005
ERROR2
L
13,SAVE+4
00143005
RETURN
(14,12),,RC=2
00144005
ERROR3
L
13,SAVE+4
00144120
RETURN
(14,12),,RC=3
00144220
EOFRTN
CLOSE
(FILE1,,VSAMACB)
00145016
L
13,SAVE+4
00146009
RETURN
(14,12),,RC=0
00147009
LIST
EXLST
AM=VSAM,EODAD=EOFRTN
00148019
INBUFF
DS
CL80
00150012
OUTBUFF
DS
CL80
00160018
DS
CL52
00161018
SAVE
DS
18F
00170000
RETCODE
DS
F
00171020
FILE1
DCB
X
LRECL=132,MACRF=PM,DDNAME=OUTFILE, X
DEVD=PR
00190018
VSAMACB
ACB
AM=VSAM,DDNAME=INFILE,
X
MACRF=(KEY,SEQ,IN),EXLST=LIST
00201019
VSAMRPL
RPL
AM=VSAM,ACB=VSAMACB,AREA=INBUFF, X
X
OPTCD=(KEY,SEQ),RECLEN=80
00210118
VSAMKEY
DS
F
00210215
END
BEGIN
00220001
113 / 118
********************************************************************
* EXAMPLE OF READING VSAM KSDS DIRECTLY BY KEY
*
********************************************************************
BEGIN
CSECT
00010000
SAVE
(14,12)
00030000
BALR
3,0
00040000
USING
*,3
00050000
ST
13,SAVE+4
00060000
LA
13,SAVE
00070000
OPEN
(VSAMACB)
00080018
LTR
15,15
00080105
BNZ
ERROR1
00080205
OPEN
(FILE1,OUTPUT)
00081018
LTR
15,15
00082005
BNZ
ERROR2
00083005
FIRST
MVC
VSAMKEY,=C'0008'
00084021
GET
RPL=VSAMRPL
00090021
SHOWCB
FIELDS=FDBK
00090120
L
4,RETCODE
00090220
LTR
4,4
00090320
BNZ
ERROR3
00090420
MVC
OUTBUFF,INBUFF
00090508
PUT
FILE1,OUTBUFF
00090619
SECOND
MVC
VSAMKEY,=C'0010'
00090721
GET
RPL=VSAMRPL
00090821
SHOWCB
FIELDS=FDBK
00090921
L
4,RETCODE
00091021
LTR
4,4
00092021
BNZ
ERROR3
00093021
MVC
OUTBUFF,INBUFF
00094021
PUT
FILE1,OUTBUFF
00095021
THIRD
MVC
VSAMKEY,=C'0001'
00096021
GET
RPL=VSAMRPL
00097021
SHOWCB
FIELDS=FDBK
00098021
L
4,RETCODE
00099021
LTR
4,4
00100021
BNZ
ERROR3
00101021
MVC
OUTBUFF,INBUFF
00102021
PUT
FILE1,OUTBUFF
00103021
FOURTH
MVC
VSAMKEY,=C'0050'
00103122
GET
RPL=VSAMRPL
00103222
SHOWCB
FIELDS=FDBK
00103322
L
4,RETCODE
00103422
LTR
4,4
00103522
BNZ
ERROR3
00103622
MVC
OUTBUFF,INBUFF
00103722
PUT
FILE1,OUTBUFF
00103822
B
ENDRTN
00104021
ERROR1
L
13,SAVE+4
00141005
RETURN
(14,12),,RC=1
00142005
ERROR2
L
13,SAVE+4
00143005
RETURN
(14,12),,RC=2
00144005
ERROR3
CLOSE
(FILE1,,VSAMACB)
00144121
L
13,SAVE+4
00144221
SAVE
RETCODE
FILE1
RETURN
CLOSE
L
RETURN
DS
DS
DS
DS
DS
DCB
VSAMACB
ACB
VSAMRPL
RPL
VSAMKEY
DS
END
ENDRTN
INBUFF
OUTBUFF
114 / 118
(14,12),,RC=3
00144320
(FILE1,,VSAMACB)
00145021
13,SAVE+4
00146009
(14,12),,RC=0
00147009
CL80
00150012
CL80
00160018
CL52
00161018
18F
00170000
F
00171020
X
DEVD=PR
00190018
AM=VSAM,DDNAME=INFILE,
X
MACRF=(KEY,DIR,IN)
00200021
AM=VSAM,ACB=VSAMACB,AREA=INBUFF, X
X
OPTCD=(KEY,DIR),RECLEN=80
00210121
F
00210215
BEGIN
00220001
115 / 118
************************************************************************
* EXAMPLE OF DYNAMIC ALLOCATION AND USE OF DATA AREAS
*
************************************************************************
BEGIN
CSECT
00010000
SAVE
(14,12)
00030000
BALR
3,0
00040000
USING
*,3
00050000
ST
13,SAVE+4
00060000
LA
13,SAVE
00070000
GETMAIN
R,LV=NOFBYTES,LOC=BELOW
00071015
LTR
15,15
00072015
BNZ
GETMERR
00073015
LR
4,1
00074015
USING
BUFFS,4
00075015
OPEN
(FILE1,INPUT)
00080005
LTR
15,15
00080105
BNZ
ERROR1
00080205
OPEN
(FILE2,OUTPUT)
00081005
LTR
15,15
00082005
BNZ
ERROR2
00083005
LOOP
GET
FILE1,INBUFF
00090002
MVC
OUTBUFF,INBUFF
00090108
PUT
FILE2,OUTBUFF
00090208
B
LOOP
00110000
ERROR1
FREEMAIN
R,LV=NOFBYTES,A=(4)
00120015
L
13,SAVE+4
00141015
RETURN
(14,12),,RC=1
00142005
ERROR2
FREEMAIN
R,LV=NOFBYTES,A=(4)
00142115
L
13,SAVE+4
00143015
RETURN
(14,12),,RC=2
00144005
GETMERR
L
13,SAVE+4
00144315
RETURN
(14,12),,RC=4
00144415
EOFRTN
CLOSE
(FILE1,,FILE2)
00145009
FREEMAIN
R,LV=NOFBYTES,A=(4)
00145115
L
13,SAVE+4
00146009
RETURN
(14,12),,RC=0
00147009
FILE1
DCB
X
X
EODAD=EOFRTN
00190009
FILE2
DCB
X
DEVD=PR
00210005
SAVE
DS
18F
00210315
*
00211115
BUFFS
DSECT
00211215
INBUFF
DS
CL80
00212015
OUTBUFF
DS
CL80
00213015
DS
CL52
00214015
*
00216015
NOFBYTES
EQU
*-INBUFF
00217015
END
BEGIN
00220001
116 / 118
ASMACL PROCEDURE TO COMPILE AND LINK YOUR ASSEMBLER PROGRAM

//*
//* ASMACL PROCEDURE PROVIDED BY IBM IN SYS1.PROCLIB
//* THIS PROCEDURE RUNS THE HIGH LEVEL ASSEMBLER, LINK-EDITS THE
//* NEWLY ASSEMBLED PROGRAM
//*
//ASMACL
PROC
//C
EXEC
PGM=ASMA90
//SYSLIB
DD
DSN=SYS1.MACLIB,DISP=SHR
//SYSUT1
DD
//
DCB=BUFNO=1
//SYSPRINT
DD
SYSOUT=*
//SYSLIN
DD
DSN=&&OBJ,SPACE=(3040,(40,40),,,ROUND),UNIT=VIO,
//
DISP=(MOD,PASS),DCB=(BLKSIZE=3040,LRECL=80,RECFM=FBS,BUFNO=1)
//L
EXEC
PGM=HEWL,PARM='MAP,LET,LIST,NACL',COND=(8,LT,C)
//SYSLIN
DD
DSN=&&OBJ,DISP=(OLD,DELETE)
//
DD
DDNAME=SYSIN
//SYSLMOD
DD
DISP=(,PASS),UNIT=SYSDA,SPACE=(CYL,(1,1,1)),
//
DSN=&&GOSET(GO)
//SYSUT1
DD
//
DCB=BUFNO=1
//SYSPRINT
DD
SYSOUT=*
INVOCATION OF THE PROCEDURE
//HCLUSR1
JOB
MSGCLASS=A,NOTIFY=HCLUSR
//*
//* If you want copy the proc into your USERID.ASMCLASS.CNTL and edit it to make many
//* changes
//* if you do this you need to add the JCLLIB statement below
//*
JCLLIB
ORDER=(HCLUSR.ASMCLASS.CNTL)
//*
//MYSTEP
EXEC
PROC=ASMACL
//C.SYSIN
DD
DSN=HCLUSR.ASMCLASS.ASM(memn),DISP=SHR
//*
//* use the JCL statement below if you want to compile,link and also place the object code
in your
//* object library
//* C.SYSLIN DD DSN=HCLUSR.ASMCLASS.OBJ(SUB4),DISP=OLD
//*
//L.SYSLMOD DD
DSN=HCLUSR.ASMCLASS.LOADLIB(SAMP9),DISP=OLD
//L.SYSLIB
DD
DSN=HCLUSR.ASMCLASS.OBJ,DISP=SHR
//*
//* use the JCL statement below if you want to compile, link and also place the object code
in your //* object library
//* L.SYSLIN DD DSN=HCLUSR.ASMCLASS.OBJ(SUB4),DISP=SHR
//
SAMPLE RUN JCL - 1

//HCLUSR1
JOB
//JOBLIB
DD
//MYSTEP
EXEC
//INFILE
DD
//SNAPDMP
DD
//OUTFILE
DD
//SUBFILE
DD
//
DSN=HCLUSR.ASMCLASS.LOADLIB,DISP=SHR
PGM=SAMP9
DSN=HCLUSR.ASMCLASS.DATA,DISP=SHR
SYSOUT=*
SYSOUT=*
SYSOUT=*
SAMPLE RUN JCL - 2

//HCLUSR1
JOB
//JOBLIB
DD
//MYSTEP
EXEC
//INFILE
DD
//OUTFILE
DD
//
DSN=HCLUSR.ASMCLASS.LOADLIB,DISP=SHR
PGM=PROG3
DSN=HCLUSR.ASMCLASS.DATA,DISP=SHR
DSN=HCLUSR.ASMCLASS.KSDS.CLUSTER,DISP=SHR
SAMPLE RUN JCL - 3

//HCLUSR1 JOB MSGCLASS=A,NOTIFY=HCLUSR
//JOBLIB DD DSN=HCLUSR.ASMCLASS.LOADLIB,DISP=SHR
//MYSTEP EXEC PGM=PROG4
//INFILE DD DSN=HCLUSR.ASMCLASS.DATA1,DISP=SHR
//OUTFILE DD DSN=HCLUSR.ASMCLASS.KSDS.CLUSTER,DISP=SHR
//
SAMPLE RUN JCL - 4
//HCLUSR1 JOB MSGCLASS=A,NOTIFY=HCLUSR
//JOBLIB DD DSN=HCLUSR.ASMCLASS.LOADLIB,DISP=SHR
//MYSTEP EXEC PGM=PROG5
//OUTFILE DD SYSOUT=*
//INFILE DD DSN=HCLUSR.ASMCLASS.KSDS.CLUSTER,DISP=SHR
//
117 / 118
SAMPLE JCL FOR DEFINING A KSDS VSAM CLUSTER

//HCLUSR1
JOB
//MYSTEP
EXEC
PGM=IDCAMS
//SYSPRINT
DD
SYSOUT=*
//SYSIN
DD
*
DEFINE CLUSTER
(NAME(HCLUSR.ASMCLASS.KSDS.CLUSTER)
TRACKS(1 1)
RECORDSIZE(80 80)
KEYS(4 0)
INDEXED
)
DATA
(NAME(HCLUSR.ASMCLASS.KSDS.DATA)
CISZ(4096)
)
INDEX
(NAME(HCLUSR.ASMCLASS.KSDS.INDEX))
/*
//
SAMPLE JCL TO DEFINE VSAM LINEAR DATA SET
//HCLUSR1
JOB
//MYSTEP
EXEC PGM=IDCAMS
//SYSPRINT
DD
SYSOUT=*
//SYSIN
DD
*
DEFINE CLUSTER
(NAME(HCLUSR.ASMCLASS.LINEAR.DATA) TRACKS(1 1)
LINEAR
)
/*
//
SAMPLE JCL TO PRINT CONTENTS OF VSAM CLUSTER
//HCLUSR1
JOB
//MYSTEP
EXEC PGM=IDCAMS
//SYSPRINT
DD
SYSOUT=*
//SYSIN
DD
*
PRINT INDATASET(HCLUSR.ASMCLASS.KSDS.CLUSTER) CHAR
/*
//
118 / 118

IBM Assembler Mannual

Transféré par

Informations du document

Description originale:

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

IBM Assembler Mannual

Transféré par

Droits d'auteur :

Formats disponibles

IBM 370 ASSEMBLY LANGUAGE

IBM 370 ASSEMBLY

IBM 370 ASSEMBLY LANGUAGE

IBM 370 ASSEMBLY LANGUAGE

Lowest-level of programming on a system

Advantages over high-level language

Use of mnemonic operation codes helps remembering the instructions

IBM 370 ASSEMBLY LANGUAGE

IBM-370 MACHINE ARCHITECTURE

Main storage Addressed by 24 bits or 31 bits

Fixed point Arithmetic,

Floating point Arithmetic,

Program Status Word (PSW) 64 bits wide

General Purpose Registers (GPRs)

Floating Point Registers (FPRs)

Control Registers (CRs) 0-15 each 32 bits wide

Access Registers (AR'S) 0-15

Contains the Condition Code (two bits)

Address of the next instruction to be executed.

PSW Key field

numbered 0-15 and 32 bits wide

Used as accumulators in Fixed point arithmetic

Used as base and index registers in computing the effective address

Numbered 0-15 each 32 bits wide

Used to point to address / data space

Used for floating point operations

Numbered 0,2,4,6 each 64 bits wide

Can contain short or long operand

Control registers each of 32 bits are available

Used by the IBM control program

Data processing and I/O processing are concurrent

Consists of Channel subsystem, Control Unit and I/O unit

IBM 370 ASSEMBLY LANGUAGE

ASSEMBLY STATEMENT FORMAT

Fixed Format. Can be changed only through ICTL Assembler Directive

IBM 370 ASSEMBLY LANGUAGE

Two, four, or six bytes in length

Should begin on a half-word boundary

Operation code specifies the function of the instruction

Operand designation follows the operation code

Entities that are involved in operations defined by operation code

Operands can be either implicit or explicit

Four types of operands

Identified by R field in the instruction

Specifies either GPR or FPR

Operand access is faster

Contained with in the instruction itself

IBM 370 ASSEMBLY LANGUAGE

Eight bit value

Address is not specified explicitly

Program can be relocated

If Register 0 is used as a base or index register its contents are ignored

BALR instruction is used to load base register

If symbols are used assembler resolves it to base displacement form

Effective address = (base register) + (Index Register) + 12 bit displacement

Size of storage operand is implied by the instruction for some instructions

For some instructions Length field(s) is/are embedded in the instruction

Storage operands can be specified in implicit form as a re-locatable expression

Storage operands can be specified in the Explicit form

Absolute addresses are also assembled in base displacement form.

IBM 370 ASSEMBLY LANGUAGE

SECOND HALF WORD