SteelFrame — Compiling & Building Programs

How to compile, link and deploy every program type this engine runs — and the common combinations (CICS + BMS + DB2, COBOL + HLASM, IDMS + ADS, …). Every proc, step name, DD name and PARM on this page is quoted from the procs and jobs actually installed on the system; nothing here is invented. ← back to the manuals directory

Where the build JCL lives. The cataloged procedures are in SYS1.PROCLIB (IGYWCL, ASMACL, SAS and its site aliases). SYS2.COMPJCL holds one ready-to-submit job per language/environment — COBOL, ASM, BMSMAP, COBOLDB2, COBOLCIC, CICSDB2, LINKONLY — each of which compiles a seeded sample as-is; edit the SYSIN/GOPGM lines to build your own source. (The ISPF Primary Option Menu advertises the same list.) A // JCLLIB ORDER=(…) card searches your own proclibs ahead of SYS1.PROCLIB.

0. Quick reference: which proc for what 1. COBOL (batch) — IGYWCL 2. HLASM — ASMACL, and COBOL + HLASM mixed 3. BMS mapsets — BMSMAP / DFHBMSCP 4. CICS COBOL — COBOLCIC 5. DB2 COBOL — COBOLDB2, bind, DBRMs 6. CICS + BMS + DB2 — CICSDB2 7. COBOL + VSAM 8. PL/I — IBMZPLI + IEWL 9. SAS — the SAS proc and its site aliases 10. Easytrieve — EZTPA00 (and EZT + DB2) 11. Natural + ADABAS — NATBAT, STOW/CATALOG 12. IDMS DML COBOL — IDMSDMLC, and ADS — ADSOBCOM 13. Link-edit only — LINKONLY / IEWL 14. Building through Endevor (generate processors) 15. Others & honest limits

0. Quick reference — which proc for what

You are building	Use	Compiler / engine steps	Output goes to
Plain batch COBOL	`SYS2.COMPJCL(COBOL)` → proc `IGYWCL`	`IGYCRCTL` → `IEWL`	`&PROGLIB(&GOPGM)`, default `IBMUSER.LOADLIB`
COBOL + VSAM	same `COBOL` job / `IGYWCL`	VSAM is a run-time DD, not a compile option	load lib; cluster defined by IDCAMS
CICS COBOL (+ BMS, VSAM)	`SYS2.COMPJCL(COBOLCIC)`	CICS translator inside `IGYCRCTL` (`PARM=CICS` or auto) → `IEWL`	load lib + CSD `PROGRAM` definition
Batch COBOL + DB2	`SYS2.COMPJCL(COBOLDB2)`	DB2 precompiler (DSNH) inside `IGYCRCTL` (`PARM=SQL` or auto) → `IEWL`	load lib; bind against subsystem `DSN1`
CICS + BMS + DB2 COBOL	`SYS2.COMPJCL(CICSDB2)`	`DFHBMSCP` map step, then translator + precompiler both inside `IGYCRCTL`	copylib (symbolic map) + load lib
BMS mapset alone	`SYS2.COMPJCL(BMSMAP)`	`DFHBMSCP`	physical map (CICS) + `SYSPUNCH` copybook
HLASM (standalone or COBOL sub)	`SYS2.COMPJCL(ASM)` → proc `ASMACL`	`ASMA90` (writes the module directly)	`&PROGLIB(&GOPGM)`
PL/I	raw two-step JCL (no cataloged proc)	`IBMZPLI` → `IEWL`	`SYSLMOD` load lib
SAS	proc `SAS` (aliases `SAS606 SAS609 EDSAS609 EDMXGSAS`)	`SASHOST` — interpreted, no link step	`SASLOG`/`SASLIST`
Easytrieve	`PGM=EZTPA00` directly	interpreted — no compile or link	report on `SYSPRINT`
Natural (+ ADABAS)	`PGM=NATBAT`	`STOW`/`CATALOG` cards on `CMSYNIN`	Natural library (not an MVS load lib)
IDMS DML COBOL	`IDMSDMLC` → `IGYWCL`	precompile → compile+link → run	load lib
ADS dialogs / processes	`PGM=ADSOBCOM`, run with `ADSBATCH`	deck compile; dialogs stored by the ADS engine	ADS dialog store
Relink an existing object	`SYS2.COMPJCL(LINKONLY)`	`IEWL` `PARM='LIST,MAP'`	`SYSLMOD`

1. COBOL (batch) — the IGYWCL proc

SYS1.PROCLIB(IGYWCL) is the compile-and-link proc every COBOL build on this system goes through. It is, verbatim:

//IGYWCL PROC PARM=,PROGLIB='IBMUSER.LOADLIB',GOPGM=GO
//*-------------------------------------------------------------------
//* COMPILE AND LINK A COBOL PROGRAM (ZOSWEB)
//*   //STEP1 EXEC IGYWCL,GOPGM=MYPROG
//*   //COBOL.SYSIN DD DSN=IBMUSER.SOURCE(MYPROG),DISP=SHR
//*-------------------------------------------------------------------
//COBOL   EXEC PGM=IGYCRCTL,PARM='&PARM'
//SYSPRINT DD SYSOUT=*
//SYSLIN   DD DSN=&&LOADSET,DISP=(MOD,PASS),RECFM=U
//SYSLIB   DD DSN=SYS2.COBOL.COPYLIB,DISP=SHR
//LKED    EXEC PGM=IEWL,COND=(8,LT,COBOL)
//SYSPRINT DD SYSOUT=*
//SYSLIN   DD DSN=&&LOADSET,DISP=(OLD,DELETE)
//SYSLMOD  DD DSN=&PROGLIB(&GOPGM),DISP=SHR

The ready-to-submit job SYS2.COMPJCL(COBOL) invokes it like this (edit GOPGM= and the SYSIN member for your own program):

//CL       EXEC IGYWCL,GOPGM=HELLO
//COBOL.SYSIN DD DSN=IBMUSER.SOURCE(HELLO),DISP=SHR
//COBOL.SYSLIB DD DSN=IBMUSER.COPYLIB,DISP=SHR
//             DD DSN=SYS2.COBOL.COPYLIB,DISP=SHR

Copybooks come from the COBOL.SYSLIB concatenation (COPY members). Override it, as above, to put your own copylib first.
Output is the load module &PROGLIB(&GOPGM) — by default IBMUSER.LOADLIB(GO). Set GOPGM= to your program name.
Run it with //RUN EXEC PGM=yourpgm and //STEPLIB DD DSN=IBMUSER.LOADLIB,DISP=SHR.
The link step is skipped when the compile RC is above 8 (COND=(8,LT,COBOL)).

2. HLASM — ASMACL, and COBOL + HLASM mixed

SYS1.PROCLIB(ASMACL), verbatim — note the assembler writes the load module directly to SYSLMOD (one step, no separate link):

//ASMACL PROC PROGLIB='IBMUSER.LOADLIB',GOPGM=GO
//*-------------------------------------------------------------------
//* ASSEMBLE AND LINK A HLASM PROGRAM (ZOSWEB)
//*-------------------------------------------------------------------
//ASM     EXEC PGM=ASMA90
//SYSPRINT DD SYSOUT=*
//SYSLIB   DD DSN=SYS1.MACLIB,DISP=SHR
//SYSLMOD  DD DSN=&PROGLIB(&GOPGM),DISP=SHR

The ready-to-submit job is SYS2.COMPJCL(ASM):

//CL       EXEC ASMACL,GOPGM=SUMRPT
//ASM.SYSIN DD DSN=IBMUSER.SOURCE(SUMRPT),DISP=SHR

COBOL calling an HLASM subroutine (mixed build)

Build each half with its own proc, into the same load library:

//ASM      EXEC ASMACL,GOPGM=MYSUB          <-- assembler subroutine
//ASM.SYSIN DD DSN=IBMUSER.SOURCE(MYSUB),DISP=SHR
//CL       EXEC IGYWCL,GOPGM=MYMAIN         <-- COBOL main
//COBOL.SYSIN DD DSN=IBMUSER.SOURCE(MYMAIN),DISP=SHR
//RUN      EXEC PGM=MYMAIN
//STEPLIB  DD DSN=IBMUSER.LOADLIB,DISP=SHR

At run time the COBOL CALL 'MYSUB' is resolved dynamically against the STEPLIB/JOBLIB concatenation, exactly like a real dynamic CALL: the loadable name is the load-module member name (BLDL semantics), never the internal CSECT name. The assembler module then executes on the S/390 interpreter, bridged into the COBOL run.

Honest limit: a true static bind of a COBOL object and an assembler object into one physical load module is not how this engine links them. If your IEWL SYSLIN carries an INCLUDE of a language-interface module, the linkage editor reports it as IEW2308I … INCLUDED (LANGUAGE INTERFACE — RESOLVED BY THE RUNTIME BRIDGE) and the call still resolves dynamically at run time. Keep both members in the STEPLIB concatenation and the behaviour is the same as a statically-bound module.

3. BMS mapsets — BMSMAP / DFHBMSCP

SYS2.COMPJCL(BMSMAP) assembles a BMS mapset. One step, PGM=DFHBMSCP, produces both map forms: the physical map (loaded by CICS at SEND MAP time) and the symbolic map copybook, punched to SYSPUNCH for your COBOL COPY:

//BMS      EXEC PGM=DFHBMSCP
//SYSPRINT DD SYSOUT=*
//SYSIN    DD DSN=IBMUSER.SOURCE(ACCTSET),DISP=SHR
//SYSPUNCH DD DSN=IBMUSER.COPYLIB(ACCTSET),DISP=SHR

Build the mapset before compiling any CICS program that COPYs its symbolic map — the COBOLCIC job says exactly this in its own comments. The copybook lands in IBMUSER.COPYLIB, which is first in the COBOL.SYSLIB concatenation of the CICS compile jobs.

4. CICS COBOL — COBOLCIC (COBOL + CICS + BMS, VSAM)

SYS2.COMPJCL(COBOLCIC), verbatim comments included — the CICS command-language translator runs inside IGYCRCTL:

//*-------------------------------------------------------------------
//* CICS COBOL: THE CICS TRANSLATOR (DFHECP1$) RUNS INSIDE IGYCRCTL
//* AUTOMATICALLY WHEN EXEC CICS IS PRESENT (OR PARM=CICS).
//* BUILD THE BMS MAPSET FIRST (MEMBER BMSMAP) SO THE SYMBOLIC MAP
//* COPYBOOK EXISTS IN IBMUSER.COPYLIB
//*-------------------------------------------------------------------
//CL       EXEC IGYWCL,GOPGM=ACCTPGM,PARM=CICS
//COBOL.SYSIN DD DSN=IBMUSER.SOURCE(ACCTPGM),DISP=SHR
//COBOL.SYSLIB DD DSN=IBMUSER.COPYLIB,DISP=SHR
//             DD DSN=SYS2.COBOL.COPYLIB,DISP=SHR

So COBOL + CICS + BMS is a two-job flow: BMSMAP first, then COBOLCIC. COBOL + CICS + BMS + VSAM is the same build — VSAM files are a CICS FILE definition and run-time resource, not a compile option (see §7).

Deploying into the region

CICS loads a program from the library named on its PROGRAM definition, falling back to IBMUSER.LOADLIB then SYS2.LINKLIB. Define the program and transaction in the CSD (CEDA) and install the group.
After a recompile, CEMT SET PROGRAM(name) NEWCOPY (or PHASEIN) is accepted; this engine reloads the load module per task, so the new copy is picked up immediately.

5. DB2 COBOL — COBOLDB2, bind, DBRMs

SYS2.COMPJCL(COBOLDB2), verbatim comments included — there is no separate precompile step to run:

//*-------------------------------------------------------------------
//* COBOL + EMBEDDED SQL: THE DB2 PRECOMPILER (DSNH) RUNS INSIDE
//* IGYCRCTL AUTOMATICALLY WHEN EXEC SQL IS PRESENT (OR PARM=SQL);
//* THE BIND IS PERFORMED AT LINK TIME AGAINST SUBSYSTEM DSN1
//*-------------------------------------------------------------------
//CL       EXEC IGYWCL,GOPGM=EMPRPT,PARM=SQL
//COBOL.SYSIN DD DSN=IBMUSER.SOURCE(EMPRPT),DISP=SHR
//COBOL.SYSLIB DD DSN=IBMUSER.COPYLIB,DISP=SHR
//             DD DSN=SYS2.COBOL.COPYLIB,DISP=SHR

The compile listing carries the real precompiler message, DSNH740I DB2 PRECOMPILER: n SQL STATEMENTS PROCESSED; host-variable and syntax errors surface as DSNH304E/DSNH104E in the same listing.
BIND: DSN under batch TSO (PGM=IKJEFT01) supports BIND PLAN / BIND PACKAGE / REBIND / FREE, maintaining a real bind repository (SYSIBM.SYSPLAN, SYSPACKAGE, SYSPACKLIST, SYSDBRM).

Honest limit: no physical DBRM member is punched to a DBRM library — the precompiler rewrites the SQL in place and the bind repository records the catalog rows. There is also no standalone DSNH cataloged procedure; PARM=SQL on IGYWCL is the supported shape.

6. CICS + BMS + DB2 — the CICSDB2 job

SYS2.COMPJCL(CICSDB2) is the full combination in one job: a DFHBMSCP map step followed by the compile-and-link, with both the CICS translator and the DB2 precompiler auto-detected inside IGYCRCTL:

//*-------------------------------------------------------------------
//* CICS + DB2 COBOL: BOTH THE CICS TRANSLATOR AND THE DB2
//* PRECOMPILER RUN INSIDE IGYCRCTL (EXEC CICS / EXEC SQL DETECTED).
//*-------------------------------------------------------------------
//BMS      EXEC PGM=DFHBMSCP
//SYSPRINT DD SYSOUT=*
//SYSIN    DD DSN=IBMUSER.SOURCE(ORDSET),DISP=SHR
//SYSPUNCH DD DSN=IBMUSER.COPYLIB(ORDSET),DISP=SHR
//CL       EXEC IGYWCL,GOPGM=ORDINQ
//COBOL.SYSIN DD DSN=IBMUSER.SOURCE(ORDINQ),DISP=SHR
//COBOL.SYSLIB DD DSN=IBMUSER.COPYLIB,DISP=SHR
//             DD DSN=SYS2.COBOL.COPYLIB,DISP=SHR

Combination → proc map

Combination	Job / proc	Steps that run
COBOL only	`COMPJCL(COBOL)` → `IGYWCL`	`IGYCRCTL` → `IEWL`
COBOL + VSAM	`COMPJCL(COBOL)`	same; VSAM is run-time
COBOL + DB2	`COMPJCL(COBOLDB2)`	precompiler-in-compiler → `IEWL`; bind vs `DSN1`
COBOL + CICS (+ BMS, VSAM)	`COMPJCL(BMSMAP)` then `COMPJCL(COBOLCIC)`	`DFHBMSCP`; translator-in-compiler → `IEWL`
COBOL + CICS + BMS + DB2	`COMPJCL(CICSDB2)`	`DFHBMSCP` + translator + precompiler → `IEWL`

On a classic shop you would see an explicit DFHECP1$ translate step, a DSNHPC precompile step, then IGYCRCTL and IEWL as four separate steps of a DFHYITVL/DSNHICOB-style proc. Here the translator and precompiler are integrated into IGYCRCTL (the way current compilers integrate them with CICS/SQL compiler options) — the source you write and the diagnostics you read are the same.

7. COBOL + VSAM

There is nothing VSAM-specific in the compile: build with COMPJCL(COBOL)/IGYWCL exactly as in §1. VSAM enters at three other points:

Define the cluster with IDCAMS before first use: //DEF EXEC PGM=IDCAMS with a DEFINE CLUSTER (NAME(…) INDEXED KEYS(…) RECORDSIZE(…)…) deck on SYSIN.
Batch: the program's SELECT … ASSIGN TO ddname ORGANIZATION INDEXED is satisfied by a plain //ddname DD DSN=your.cluster,DISP=SHR.
CICS: the file is a CSD FILE definition; the program never names the dataset, only the CICS file.

Make the copybook record length, the cluster RECORDSIZE, and (for CICS) the LENGTH() you pass agree — length mismatches are the classic cause of silent zero-record runs.

8. PL/I — IBMZPLI + IEWL

The PL/I compiler is PGM=IBMZPLI (Enterprise-PL/I-compatible front end). There is no cataloged PL/I proc in SYS1.PROCLIB or member in SYS2.COMPJCL; the operational shape is the classic two-step compile + link, exactly as the system's own test decks submit it:

//CMP      EXEC PGM=IBMZPLI,PARM='LIST'
//SYSPRINT DD SYSOUT=*
//SYSIN    DD DISP=SHR,DSN=IBMUSER.SOURCE(MYPLI)
//SYSLIN   DD DISP=OLD,DSN=IBMUSER.OBJLIB(MYPLI)
//LNK      EXEC PGM=IEWL,REGION=0M
//SYSPRINT DD SYSOUT=*
//SYSLMOD  DD DISP=SHR,DSN=IBMUSER.LOADLIB
//INOBJ    DD DISP=SHR,DSN=IBMUSER.OBJLIB
//SYSLIN   DD *
    INCLUDE INOBJ(MYPLI)
    NAME MYPLI(R)
//RUN      EXEC PGM=MYPLI
//STEPLIB  DD DISP=SHR,DSN=IBMUSER.LOADLIB

%INCLUDE members resolve from the SYSLIB DD concatenation (or a named DD: %INCLUDE ddname(member)).
IEWL merges multiple PL/I objects into one load module — INCLUDE several members and the units are bound with the OPTIONS(MAIN) procedure as the entry point; NAME mod(R) names the module.
Under Endevor the same pipeline is packaged as the GPLI generate processor (§14).

9. SAS — the SAS proc and its site aliases

SYS1.PROCLIB(SAS), verbatim — SAS is interpreted by the SASHOST engine, so there is no link-edit and no load module:

//SAS     PROC OPTIONS=,WORK='4M'
//*-------------------------------------------------------------------
//* SAS BATCH (ZOSWEB clean-room SAS language engine)
//*   //STEP1 EXEC SAS,OPTIONS='NODATE NOSOURCE'
//*   //SYSIN DD * ... the SAS program ...
//*-------------------------------------------------------------------
//SAS     EXEC PGM=SASHOST,PARM='&OPTIONS',REGION=0M
//SASLOG  DD SYSOUT=*
//SASLIST DD SYSOUT=*
//SASHELP  DD DUMMY
//SASAUTOS DD DUMMY
//CONFIG   DD DUMMY

The same proc is seeded under the shop-style names real corpus decks invoke — SAS609, EDSAS609, SAS606, EDMXGSAS — so those jobs run with only DSN substitutions. Add your own //SYSIN DD * program and any libref DDs; the log arrives on SASLOG, procedure output on SASLIST.

10. Easytrieve — EZTPA00 (and EZT + DB2)

Easytrieve is interpreted by PGM=EZTPA00 — there is no compile, no link, and nothing lands in a load library. The whole build is the run JCL:

//EZ       EXEC PGM=EZTPA00,REGION=8M
//INF      DD DISP=SHR,DSN=your.input.file      <-- one DD per FILE stmt
//SYSPRINT DD SYSOUT=*
//SYSIN    DD DSN=your.ezt.srclib(MYEZT),DISP=SHR

Each FILE ddname in the library section is satisfied by a same-named DD. The report is rendered to SYSPRINT.

EZT + DB2

Embedded SQL is supported in the same job shape — no precompile: SQL files with automatic cursor management, SQL INCLUDE field generation from the DB2 catalog, and native SQL with :host variables all execute directly against the engine's DB2 (each statement its own committed unit of work — SQL ROLLBACK warns loudly about that documented deviation).

11. Natural + ADABAS — NATBAT, STOW / CATALOG / SAVE

Natural programs are not built with JCL procs at all: the batch nucleus PGM=NATBAT (alias NATURAL) reads commands and inline source from CMSYNIN, writes its listing to CMPRINT, and compiles into a Natural library, not an MVS load library. The install job for a real estate looks like this:

//NACTINST JOB (ACT),'INSTALL',CLASS=A,MSGCLASS=X
//STEP1   EXEC PGM=NATBAT
//CMPRINT DD SYSOUT=*
//CMSYNIN DD *
LOGON ACTLIB
<program source>
STOW NACTPV
<next program source>
STOW NACTRES
FIN

STOW name compiles and saves both the source and the cataloged object — a syntax error fails the install instead of surfacing at run time. CATALOG compiles and stores the object only (source not saved); SAVE stores source only; CATALL re-catalogs a whole library.
Run with EXECUTE name (cataloged object) or RUN (source area) cards; batch INPUT data comes from CMOBJIN when assigned, else the next CMSYNIN lines. End the session with FIN.
ADABAS access needs no extra build step: define the DDMs (also via CMSYNIN decks, DDM … END-DDM) before STOWing programs that reference them.
Natural Security (PGM=NATSEC) can protect libraries; a denied LOGON stops the deck.

12. IDMS DML COBOL — IDMSDMLC, and ADS — ADSOBCOM / ADSBATCH

COBOL with navigational DML is a three-step flow — precompile, compile+link, run — the shape every IDMS estate on this system uses:

//PRE     EXEC PGM=IDMSDMLC              <-- precompile
//SYSLST  DD SYSOUT=*                        (listing: NO ERRORS)
//SYSPCH  DD DSN=IDMS.SRC.MYPGM,DISP=(NEW,CATLG),
//           SPACE=(TRK,(2,2)),LRECL=80,RECFM=FB
//SYSIPT  DD *
   ... DML COBOL source ...
//CL      EXEC IGYWCL,GOPGM=MYPGM,COND=(0,NE)   <-- compile+link
//COBOL.SYSIN DD DSN=IDMS.SRC.MYPGM,DISP=SHR
//RUN     EXEC PGM=MYPGM,COND=(0,NE)            <-- run, local mode
//STEPLIB DD DSN=IBMUSER.LOADLIB,DISP=SHR
//SYSOUT  DD SYSOUT=*

IDMSDMLC reads DML COBOL from SYSIPT, punches pure COBOL to SYSPCH with every DML verb commented out and expanded into CALL 'IDMS' against the generated SUBSCHEMA-CTRL block, and generates the record copybooks. The listing must end NO ERRORS.
Schemas/subschemas are defined beforehand with PGM=IDMSDDDL decks; IDMSRPTS and IDMSBCF are the reporting/command utilities.
PROTOCOL. MODE IS BATCH. (manual status checking with IDMS-STATUS) is the supported protocol; AUTOSTATUS is not generated — an honest, documented limit.

ADS dialogs and processes

//COMP    EXEC PGM=ADSOBCOM               <-- compile the deck
//SYSLST  DD SYSOUT=*
//SYSIPT  DD *
ADD PROCESS NAME IS <name>. ... END PROCESS.
ADD DIALOG NAME IS <name>. ...
//DRIVE   EXEC PGM=ADSBATCH               <-- drive the dialogs
//ADSOUT  DD SYSOUT=*
//ADSIN   DD *
   ... simulated terminal input, one response per line ...

ADSOBCOM compiles process/dialog decks (source on SYSIPT or SYSIN, listing on SYSLST); ADSBATCH (alias ADSORUN1) drives dialogs with input on ADSIN and output on ADSOUT. Dialogs live in the ADS store, not an MVS load library. Any record field a dialog moves must be in the dialog's subschema, not merely the schema.

13. Link-edit only — LINKONLY / IEWL

SYS2.COMPJCL(LINKONLY) relinks an existing object into a load library:

//LKED    EXEC PGM=IEWL,PARM='LIST,MAP'
//SYSPRINT DD SYSOUT=*
//SYSLIN   DD DSN=IBMUSER.OBJLIB(GO),DISP=SHR
//SYSLMOD  DD DSN=IBMUSER.LOADLIB(GO),DISP=SHR

IEWL (aliases HEWL, IEWBLINK) also accepts instream SYSLIN control cards — INCLUDE ddname(member,…), NAME module(R), ENTRY — and links COBOL objects, PL/I objects (merging multiple compile units), assembled ASMA90 images, and IMS DBDGEN/PSBGEN control blocks by pass-through.

14. Building through Endevor (generate processors)

If the source is under Endevor (NDVRC1 SCL), a GENERATE ELEMENT runs the stage's generate processor, which packages the same pipelines against the stage libraries: GCOBOL (COBOL → IGYCRCTL+IEWL into NDVR.&C1ENVMNT..S&C1STGNUM..LOADLIB), GASM (ASMA90), GPLI (IBMZPLI+IEWL), GIMSCOB, and GDBD/GPSB (IMS DBDGEN/PSBGEN). Easytrieve elements (type EZT) are stored as source — interpreted by EZTPA00 at run time, nothing to generate into a loadlib.

15. Others & honest limits

REXX / CLIST: interpreted, nothing to compile. Batch REXX runs under PGM=IRXJCL,PARM='exec args'; both run interactively from SYS1.SYSEXEC / SYSPROC.
IMS: DBDGEN/PSBGEN control blocks are generated by the DFSF10.PROCLIB gen procs (or Endevor GDBD/GPSB) and linked by IEWL pass-through; IMS application COBOL/PL/I compiles with the ordinary IGYWCL/IBMZPLI flows.
No standalone translate/precompile procs: there is no separate DFHECP1$, DSNH/DSNHPC or DFHYITVL-style multi-step proc to invoke — translation and SQL precompilation are integrated into IGYCRCTL and selected by PARM=CICS/PARM=SQL or auto-detected from EXEC CICS/EXEC SQL in the source.
No physical DBRMs: BIND maintains the catalog's bind repository, but no DBRM member is punched to a library (§5).
COBOL↔HLASM static bind: resolved by the runtime bridge, not a true single-module static link (§2).
Easytrieve, SAS, Natural, ADS: nothing ever lands in an MVS load library for these — EZT and SAS are interpreted per run; Natural objects live in Natural libraries; ADS dialogs live in the ADS store.
Anything not listed on this page has no build path on this engine — ask before assuming a proc exists.