IBM Mainframe Forum

willy jensen wrote:Unfortunately there is no 'zOS Assembler for beginners' nor a free self-study as already mentioned. There are still some people offering courses, but not for free. And neither will I. So I suggest that you try to find a mentor in your organization.
This small sample only demonstrates one method for starting and ending a program, plus a bit of I/O thrown in. By the way, this is a assemble-link-go, so the module is not stored permanently.
But there is of course much more to assembler than that. First you must decide in which environment the program will run.
Search the internet for 'ibm assembler language tutorial' and similar and see what pops up.

Select all

//ASMMINI  JOB (WJ),'small asm pgm',CLASS=A,MSGCLASS=T,COND=(0,LT)
//*                                                                
//   EXEC HLASMCLG,PARM.C='TERM',PARM.L='RMODE(24),AMODE(31)'      
//C.SYSLIB  DD DISP=SHR,DSN=SYS1.MACLIB                            
//          DD DISP=SHR,DSN=SYS1.MODGEN                            
//C.SYSTERM DD SYSOUT=*                                            
//C.SYSIN   DD *                                                  
*PROCESS COMPAT(NOCASE,MACROCASE)                                  
         sysstate archlvl=2                                        
*                                                                  
* equate registers                                                
*                                                                  
r0       equ   0                                                  
r1       equ   1                                                  
r2       equ   2                                                  
r3       equ   3                                                  
r4       equ   4                                                  
r5       equ   5                                                  
r6       equ   6                                                  
r7       equ   7                                                  
r8       equ   8                                                  
r9       equ   9                                                  
r10      equ   10                                                  
r11      equ   11                                                  
r12      equ   12                                                  
r13      equ   13                                                  
r14      equ   14                                                  
r15      equ   15                                                  
*                                                                  
* Macro for clearing area                                          
*                                                                  
         Macro                                                    
         CLEAR &area                                              
         mvi   &area,c' '              clear                      
         mvc   &area+1(l'&area-1),&area    target                  
         Mend                                                      
*                                                                  
* Program prolog                                                  
*                                                                  
         using ASMMINI,r12                                        
ASMMINI  amode 31                                                  
ASMMINI  rmode any                                                
ASMMINI  csect                                                    
         save  (14,12)                                            
         larl  r12,ASMMINI                                        
         sam31                                                    
* get dynamic storage                                              
         getmain R,lv=workln                                      
         lr    r10,r1                                              
         using work,r10                                            
* chain saveareas re linkage conventions                          
         la    r14,sa1                                            
         st    r13,4(,r14)                                        
         st    r14,8(,r13)                                        
         lr    r13,r14                                                  
*                                                                      
* open files                                                            
*                                                                      
         Open  (infile,(input))                                        
         Open  (prtfile,(output))                                      
*                                                                      
         clear prtrec                                                  
         mvc   prtrec(20),=cl20'*Starting program'                      
         put   prtfile,prtrec                                          
*                                                                      
* read and list                                                        
*                                                                      
Readit   equ   *                                                        
         get   infile,inrec                                            
         clear prtrec                                                  
         mvc   prtrec,inrec                                            
         put   prtfile,prtrec                                          
         j     readit                                                  
Readend  equ   *                                                        
         clear prtrec                                                  
         mvc   prtrec(25),=cl25'*End of file reached'                  
         put   prtfile,prtrec                                          
* remove the asterix in the next statement to get a S0C1 abend          
*        dc    h'0'                                                    
         clear prtrec                                                  
         mvc   prtrec(15),=cl25'*End of program'                        
         put   prtfile,prtrec                                          
*                                                                      
* close files                                                          
*                                                                      
         close  infile                                                  
         close  prtfile                                                
*                                                                      
* Program epilog                                                        
*                                                                      
         l     r13,4(,r13)         unchain savearea                    
* release dynamic storage                                              
         Freemain R,lv=workln,a=(10)                                    
*        wto 'freemain done'                                            
* set rc and get back                                                  
         xr    r15,r15                                                  
         l     r14,12(,r13)                                            
         return (2,12)                                                  
*                                                                      
* static work area                                                      
*                                                                      
blank    dc    cl150' '                                                
         print nogen                                                    
infile   dcb   ddname=INDATA,dsorg=ps,macrf=gm,recfm=fb,eodad=readend  
prtfile  dcb   ddname=SYSPRINT,                                        c
               dsorg=ps,macrf=pm,recfm=fb,lrecl=l'prtrec,blksize=0      
         print gen                                                      
         ltorg                                                          
*                                                                      
* dynamic work area      
*                        
work     Dsect          
sa1      ds    18f      
         ds    0d        
inrec    ds    cl200    
prtrec   ds    cl133    
         ds    0d        
workln   equ   *-work    
                         
         End            
//G.SYSPRINT DD SYSOUT=*
//G.INDATA   DD *        
kilroy                  
 was                    
  here                  

I think Macro's are designed to generate Assembler code?

I am not sure why, perhaps it makes creating Assembler programs faster and more dynamic?

enrico-sorichetti wrote:NO, it it just a way to encapsulate repetitive STANDARD sequence of instructions
certainly if You do not have to code by hand the sequence of instruction for open,close, ... add as many as You want
writing an assembler program will take less time
faster execution and more dynamic are not taken into account

These users thanked the author steve-myers for the post:

deucalion0 (Wed Jun 08, 2016 5:20 pm)

steve-myers wrote:Here is an extremely simplified example of linkage -

Select all

//A       EXEC HLASMCLG
//C.DUMP   DD  DISP=(MOD,DELETE),UNIT=SYSALLDA,SPACE=(TRK,0),
//             DSN=&SYSUID..LINKAGE.DUMP
//C.LPT    DD  DISP=(MOD,DELETE),UNIT=SYSALLDA,SPACE=(TRK,0),
//             DSN=&SYSUID..LINKAGE.LPT
//C.SYSIN  DD  *
MAIN     CSECT
         USING *,12
         SAVE  (14,12),,*
         LR    12,15
         LA    15,MAINSAVE
         ST    13,4(,15)
         ST    15,8(,13)
         LR    13,15
         L     15,=A(SUBR1)
         CALL  (15)
         L     13,4(,13)
         RETURN (14,12),T,RC=(15)
MAINSAVE DC    9D'0'
         LTORG ,
SUBR1    CSECT
         USING *,12
         SAVE  (14,12),,*
         LR    12,15
         LA    15,SBR1SAVE
         ST    13,4(,15)
         ST    15,8(,13)
         LR    13,15
         L     15,=V(SUBR2)
         CALL  (15)
         L     13,4(,13)
         RETURN (14,12),T,RC=(15)
SBR1SAVE DC    9D'0'
         LTORG ,
SUBR2    CSECT
         USING *,12
         SAVE  (14,12),,*
         LR    12,15
         LA    15,SBR2SAVE
         ST    13,4(,15)
         ST    15,8(,13)
         LR    13,15
         DC    H'0'
         L     13,4(,13)
         SR    15,15
         RETURN (14,12),T,RC=(15)
SBR2SAVE DC    9D'0'
         END   MAIN
//G.SYSUDUMP DD DISP=(,CATLG),UNIT=SYSDA,SPACE=(TRK,(50,5),RLSE),
//             DSN=&SYSUID..LINKAGE.DUMP
//CONVERT EXEC PGM=CNVTM,COND=ONLY
//STEPLIB  DD  DISP=(SHR,PASS),DSN=&SYSUID..LOAD
//SYSPRINT DD  SYSOUT=*
//SYSUT1   DD  DISP=(OLD,DELETE),DSN=&SYSUID..LINKAGE.DUMP
//SYSUT2   DD  DISP=(,CATLG),UNIT=SYSDA,SPACE=(TRK,(50,5),RLSE),
//             DSN=&SYSUID..LINKAGE.LPT

MAIN calls SUBR1 which calls SUBR2. SUBR2 has been "zapped" to abnormally terminate. The program in the CONVERT step fixes a data set with control characters - the dump - so it is a little more friendly on a work station.

The dump program prints a nice little summary at the start -

Select all

COMPLETION CODE      SYSTEM = 0C1      REASON CODE = 00000001

  PSW AT ENTRY TO ABEND   078D0000  00007FA0  ILC  02  INTC  0001

PSW LOAD MODULE             ADDRESS = 00007E70  OFFSET = 00000130
NAME=GO

Sometimes the summary is useful, especially with S0Cx ABENDs. Dump was not always so accommodating! We used to have to do some hexadecimal arithmetic -

7FA0 (the address in the PSW) - 7E70 (which dump was kind enough to extract) = 130

Now the 7E70 is the entry point of the load module, which for our example is the start of the load module. This is not always the case!

No summary? What do we do?

Now we have to dig into the main part of the dump.

First, find the TCB. Most of the time we don't really look at the TCB, but we have to find it.

After the TCB in the dump is a series of control blocks called Request Blocks, or the short cut RBs. MVS creates an RB in response to system assisted linkage. We're usually only interested in PRBs and SVRBs. Finding the "correct" RB is a bit of an art. Start with the ABEND code 0C1. This means we need to find an RB with interrupt code 1.

Select all

PRB: 009F9090
          -0020  XSB...... 7FFFDDF0  FLAGS2... 00        RTPSW1... 078D0000  00007FA0            RTPSW2... 00020001
          -000C            7F646000  FLAGS1... 00000000  WLIC..... 00020001
          +0000  RSV...... 00000000  00000000            SZSTAB... 00110082  CDE...... 009FC488
          +0010  OPSW..... 078D0000  00007FA0            SQE...... 00000000  LINK..... 009CCC48

The interrupt code is the last two bytes of WLIC.

After the RB that caused the error we usually see two SVRBs. The first SVRB is for ABEND itself. The second SVRB is for "SNAP," the program that actually prints the dump. The ABEND SVRB is very important. The "registers" listed with the failing PRB have nothing to do with the PRB. The registers at the time of the ABEND are in the ABEND SVRB -

Select all

SVRB: 009FD660
          -0020  XSB...... 7FFEF8C8  FLAGS2... 00        RTPSW1... 00000000  00000000            RTPSW2... 00000000
          -000C            00000000  FLAGS1... 22000000  WLIC..... 00020033
          +0000  RSV...... 00000000  00000000            SZSTAB... 001ED022  CDE...... 00000000
          +0010  OPSW..... 070C1000  8582EA12            Q........ 00000000  LINK..... 009F9090
          +0020  GPR0-3... FD000008  00006FF8  00000040  009D09D4
          +0030  GPR4-7... 009D09B0  009FD098  009BDFE0  FD000000
          +0040  GPR8-11.. 009F91C8  009CD9C8  00000000  009FD098
          +0050  GPR12-15. 00007F80  00007FB8  40007F1C  00007FB8

Why? They're there so they can be restored when a normal SVC function ends.

Now how we convert the load module offset to an offset in a CSECT? We start with the module map, either from the Binder or IMBLIST -

Select all

CLASS
OFFSET  NAME                TYPE    LENGTH

     0  MAIN               CSECT        84

    88  SUBR1              CSECT        84

   110  SUBR2              CSECT        80

We easily see offset 130 is in SUBR2, at offset 20. Hex arithmetic again -

130 - 110 = 20

That's enough to get you started.

Every error is different; the steps to find the request block are basically the same, though they differ based on the ABEND. Most ABENDs in an SVC do not really represent an error in IBM code. They really represent an issue with the caller of the SVC, so you backup to the RB that called the failing SVC.

• There are very few load modules linked in the “scatter” format any more AND
• Load modules in the “scatter” format can only load below the line, and most load modules are linked RMODE ANY and normally load above the line AND
• Storage is rarely, if ever, so fragmented that it is necessary to “scatter” load a load module.