Saltar al contenido
Entender conceptos

Principiante11 min de lectura

Del fuente a la ejecución: compilar, linkeditar y ejecutar

Entre el fuente que editas y el programa que corre hay dos pasos que casi nadie te explica. Aquí ves qué entra y qué sale de cada uno, el JCL que los hace y el tropiezo clásico de "compilé y sigue corriendo lo viejo".

Al terminar sabrás

  • Qué son el módulo objeto y el program object, y por qué no basta con compilar.
  • Qué DD usa el compilador y cómo encuentra los copys.
  • Qué hace el binder al linkeditar, qué DD usa y por qué deja la salida en un PDSE.
  • Cómo leer un COND, y qué revisar cuando compilaste y sigue corriendo el programa viejo.

Antes de empezar

En El mapa del mainframe dejamos a CALCNOM1 en dos lugares: su fuente en NOMINA.FUENTES y el programa que el job de ejecución busca en NOMINA.PRUEBAS.LOADLIB. Esta guía es lo que pasa en medio. Los términos (dataset, miembro, ddname, step) están en el glosario del mapa; aquí los usamos sin volver a explicarlos.

Tres pasos, tres cosas que cambian de mano

En una PC “compilar” suele ser un solo botón. Aquí son dos pasos antes de ejecutar, y cada uno recibe una cosa y entrega otra:

  1. Compilar. Entra el fuente, el texto COBOL. Sale el módulo objeto: código máquina, pero incompleto. Tiene huecos donde el programa llama a cosas que no están en él.
  2. Linkeditar. Entra el módulo objeto. El binder le rellena los huecos con las rutinas de Language Environment (LE) y, si las hay, con otros programas, y entrega el program object: el ejecutable completo, guardado como miembro en la librería de loads.
  3. Ejecutar. El job de ejecución nombra el miembro con PGM= y la librería con STEPLIB.

Por eso no basta con compilar: un módulo objeto no corre. Hasta que el binder no lo convierte en program object y lo deja en la librería, el job de ejecución sigue encontrando el miembro de antes.

Compilar: IGYCRCTL y sus DD

El compilador de Enterprise COBOL es el programa IGYCRCTL, y se ejecuta como cualquier otro: con un EXEC y los DD que necesita. Este es el step de compilación de CALCNOM1, armado con la estructura del procedimiento IGYWCL que entrega IBM:

//NOMINA02 JOB (CUENTA),'COMPILA CALCNOM1',CLASS=A,MSGCLASS=X
//COMPILA  EXEC PGM=IGYCRCTL,REGION=0M
//STEPLIB  DD DSN=IGY.V6R4M0.SIGYCOMP,DISP=SHR
//         DD DSN=CEE.SCEERUN,DISP=SHR
//         DD DSN=CEE.SCEERUN2,DISP=SHR
//SYSIN    DD DSN=NOMINA.FUENTES(CALCNOM1),DISP=SHR
//SYSLIB   DD DSN=NOMINA.COPYS,DISP=SHR
//SYSPRINT DD SYSOUT=*
//SYSLIN   DD DSN=&&OBJETO,DISP=(MOD,PASS),UNIT=SYSALLDA,
//            SPACE=(CYL,(1,1))
//SYSUT1   DD UNIT=SYSALLDA,SPACE=(CYL,(1,1))
//SYSUT2   DD UNIT=SYSALLDA,SPACE=(CYL,(1,1))
//SYSUT3   DD UNIT=SYSALLDA,SPACE=(CYL,(1,1))
//SYSUT4   DD UNIT=SYSALLDA,SPACE=(CYL,(1,1))
//SYSUT5   DD UNIT=SYSALLDA,SPACE=(CYL,(1,1))
//SYSUT6   DD UNIT=SYSALLDA,SPACE=(CYL,(1,1))
//SYSUT7   DD UNIT=SYSALLDA,SPACE=(CYL,(1,1))
//SYSUT8   DD UNIT=SYSALLDA,SPACE=(CYL,(1,1))
//SYSUT9   DD UNIT=SYSALLDA,SPACE=(CYL,(1,1))
//SYSUT10  DD UNIT=SYSALLDA,SPACE=(CYL,(1,1))
//SYSUT11  DD UNIT=SYSALLDA,SPACE=(CYL,(1,1))
//SYSUT12  DD UNIT=SYSALLDA,SPACE=(CYL,(1,1))
//SYSUT13  DD UNIT=SYSALLDA,SPACE=(CYL,(1,1))
//SYSUT14  DD UNIT=SYSALLDA,SPACE=(CYL,(1,1))
//SYSUT15  DD UNIT=SYSALLDA,SPACE=(CYL,(1,1))
//SYSMDECK DD UNIT=SYSALLDA,SPACE=(CYL,(1,1))

Los cuatro DD que importan:

  • SYSIN: el fuente. Un miembro de la librería de fuentes, o el código pegado en el mismo JCL con DD *.
  • SYSLIB: las librerías de copys. Aquí se cierra lo que el mapa dejó pendiente: cada vez que el compilador encuentra un COPY, busca el miembro en las librerías del SYSLIB, en el orden en que estén concatenadas. Si tu proyecto tiene copys propios y copys comunes, van dos DD seguidos, el segundo sin nombre. Un copy que no está en ninguna da el mensaje de arranque y la cascada que se explica en Los errores de compilación más comunes.
  • SYSPRINT: el listado. El de Cómo leer un listado de compilación, con SYSOUT=* para verlo en el spool.
  • SYSLIN: el módulo objeto. La salida que le interesa al siguiente step. &&OBJETO es un dataset temporal: existe solo durante el job, y DISP=(MOD,PASS) se lo pasa al step de linkedit.

Los demás están porque el compilador los exige: el STEPLIB es la librería del compilador más las de LE que necesita para correr; SYSUT1 a SYSUT15 son datasets de trabajo temporales; y SYSMDECK recibe el fuente con los copys ya expandidos, o sirve de trabajo si no pides la opción MDECK. Los nombres IGY.V6R4M0.SIGYCOMP, CEE.SCEERUN y CEE.SCEERUN2 son los que trae la documentación por omisión; cada instalación puede tener otros.

Linkeditar: el binder y sus DD

El binder es el programa IEWBLINK (el nombre viejo, linkage editor, sigue vivo en el verbo “linkeditar”). Toma el módulo objeto y resuelve sus referencias externas: cada nombre que el programa usa y no define.

Para CALCNOM1 son las rutinas de Language Environment que el compilador invoca por él: lo que no genera como código dentro del programa, como abrir y leer archivos o hacer DISPLAY, lo pide a LE. La aritmética, en cambio, sí la genera el compilador dentro del programa. Por eso el S0C7 de Me tronó en ejecución cae en un offset de CALCNOM1, es decir, en una posición del código del propio programa.

Si CALCNOM1 tuviera CALL a otros programas, también serían referencias externas. El binder busca cada nombre en las librerías del SYSLIB, pega lo que encuentra y deja el resultado como un solo miembro. Un CALL puede resolverse aquí, al linkeditar, o en ejecución: es la diferencia entre CALL estático y dinámico.

Lo que el binder pega de LE no es la librería completa. IBM separa dos cosas: en SCEELKED y SCEELKEX están las rutinas residentes, las que se linkeditan con tu programa (entre ellas las de inicio y fin de la ejecución), y en SCEERUN y SCEERUN2 están las rutinas de ejecución, las que el programa carga cuando corre. Por eso LE aparece dos veces en el recorrido: en el SYSLIB del binder y en el STEPLIB del job de ejecución.

//LINKEDIT EXEC PGM=IEWBLINK,COND=(8,LT,COMPILA),REGION=0M
//SYSLIB   DD DSN=CEE.SCEELKEX,DISP=SHR
//         DD DSN=CEE.SCEELKED,DISP=SHR
//SYSLIN   DD DSN=&&OBJETO,DISP=(OLD,DELETE)
//SYSLMOD  DD DSN=NOMINA.PRUEBAS.LOADLIB(CALCNOM1),DISP=SHR
//SYSPRINT DD SYSOUT=*
//SYSUT1   DD UNIT=SYSALLDA,SPACE=(CYL,(1,1))
  • SYSLIN: la entrada. El mismo &&OBJETO que dejó el compilador. DISP=(OLD,DELETE) lo borra al terminar: ya no hace falta.
  • SYSLIB: de dónde saca lo que falta. Las librerías de LE con las rutinas que el programa necesita. Si CALCNOM1 llamara a subprogramas tuyos, su librería iría concatenada aquí.
  • SYSLMOD: la salida. El miembro CALCNOM1 de la librería de loads. Esta librería tiene que ser un PDSE: desde Enterprise COBOL 5 el binder produce un program object, y los program objects solo se guardan en PDSE (o en archivos de z/OS UNIX, que aquí no usamos). Con un PDS el linkedit no sirve para programas de Enterprise COBOL 5 o posterior: IBM documenta que un módulo con varias clases de texto, como los que genera este compilador, no cabe en el formato viejo, y el binder lo guarda marcado con error o no lo guarda.
  • SYSPRINT: el reporte del binder. Trae los módulos que incluyó, el mapa del programa y los avisos. Se lee menos que el listado del compilador, pero cuando el linkedit falla, aquí está el porqué.

SYSUT1 es su dataset de trabajo. Y CEE.SCEELKEX y CEE.SCEELKED son, de nuevo, los nombres por omisión de la documentación; tu instalación puede usar otros.

Ejecutar: PGM= y STEPLIB

El job de ejecución es el del mapa, visto ahora desde el otro lado:

//PASO01   EXEC PGM=CALCNOM1
//STEPLIB  DD DSN=NOMINA.PRUEBAS.LOADLIB,DISP=SHR

PGM=CALCNOM1 es el miembro que el binder dejó en SYSLMOD, y STEPLIB es la misma librería. El sistema busca el programa en el STEPLIB y, si no lo encuentra, en las librerías del sistema; si no está en ninguna, el step termina con un S806 antes de ejecutar nada.

Un programa COBOL siempre necesita LE al correr: las rutinas de ejecución de SCEERUN y SCEERUN2 tienen que estar en el orden de búsqueda del sistema, sea en el STEPLIB o en la lista de enlace del sistema (LNKLST). En casi todas las instalaciones ya están en la lista del sistema y el STEPLIB solo lleva tu librería; si no, van concatenadas después de la tuya, como en el procedimiento IGYWCLG de IBM.

El recorrido completo

De arriba hacia abajo, con el DD que conecta cada paso:

NOMINA.FUENTES(CALCNOM1)        NOMINA.COPYS
fuente                          copys
        |                             |
        |  SYSIN                      |  SYSLIB
        v                             |
COMPILA: IGYCRCTL  <------------------+
        |
        |  SYSLIN          SYSPRINT -> listado de compilación
        v
&&OBJETO
módulo objeto, temporal
        |                        CEE.SCEELKEX, CEE.SCEELKED
        |  SYSLIN                rutinas de LE
        v                             |
LINKEDIT: IEWBLINK  <-----------------+  SYSLIB
        |
        |  SYSLMOD         SYSPRINT -> reporte del binder
        v
NOMINA.PRUEBAS.LOADLIB(CALCNOM1)
program object, en un PDSE
        |
        |  STEPLIB y PGM=CALCNOM1
        v
job de ejecución (el del mapa)

En prosa: el fuente entra por SYSIN y los copys por SYSLIB; el compilador deja el listado en SYSPRINT y el módulo objeto en SYSLIN. Ese módulo entra al binder por su propio SYSLIN, el binder completa lo que falta desde su SYSLIB y deja el program object en SYSLMOD, que es el miembro de la librería de loads. El job de ejecución lo encuentra por STEPLIB y PGM=.

Casi nunca vas a escribir este JCL a mano. IBM entrega procedimientos catalogados que ya lo traen: IGYWC compila, IGYWCL compila y linkedita, IGYWCLG compila, linkedita y ejecuta. Tu instalación suele tener el suyo, con sus librerías y sus opciones, o una herramienta que lo lanza por ti. Lo que cambia es quién escribe el JCL; los pasos y los DD son estos.

Return codes y el COND

Cada step deja su return code. El del compilador es la severidad más alta de sus mensajes (0, 4, 8, 12 o 16, como se explica en Cómo leer un listado de compilación). El del binder va igual: 0 limpio, 4 con avisos, 8 terminó con errores, 12 un error severo no lo dejó terminar y 16 se detuvo de inmediato. Con 8, revisa su reporte antes de ejecutar.

Un step puede decidir si corre según el return code de uno anterior, con el parámetro COND del EXEC. Se lee al revés de lo que uno espera: el step se salta si la condición es cierta. En el ejemplo, COND=(8,LT,COMPILA) se lee “salta este step si 8 es menor que el return code de COMPILA”. Con números:

Return code de COMPILA ¿8 es menor que él? LINKEDIT
0 o 4 No Corre.
8 No Corre.
12 o 16 Sí Se salta.

Es la práctica común, no una regla: IBM la usa en IGYWCL, y en IGYWCLG el step que ejecuta el programa lleva además COND=(4,LT,LKED), es decir, no corre si el binder devolvió más de 4. Cada instalación ajusta estos valores; hay quien linkedita solo con 0 o 4. Léelo en el JCL de tu equipo antes de suponer.

“Compilé y sigue corriendo lo viejo”

Es el tropiezo clásico del primer mes: cambias el fuente, compilas, ejecutas, y el programa se comporta como antes. Tres causas, de la más común a la menos:

  1. El linkedit no corrió. La compilación terminó con 12 y el COND saltó el step. El miembro de la librería de loads sigue siendo el de la vez pasada. Cómo comprobarlo: en la salida del job, compara el return code de COMPILA con el COND del LINKEDIT; si la condición se cumplió, el step no corrió: en lugar de su return code verás el mensaje IEF202I con el texto STEP WAS NOT RUN BECAUSE OF CONDITION CODES.
  2. SYSLMOD y STEPLIB apuntan a librerías distintas. El linkedit dejó el load en una y el job de ejecución lo busca en otra. Tiene dos orígenes típicos: compilaste con un procedimiento que escribe en una librería que no es la de tu ambiente, o copiaste el JCL de ejecución de otro ambiente y el STEPLIB se quedó con la librería de ese. Cómo comprobarlo: pon los dos JCL uno junto al otro y compara los nombres letra por letra.
  3. El STEPLIB tiene varias librerías concatenadas. El sistema las recorre en el orden de los DD y se queda con el primer miembro que encuentre con ese nombre. Si tu CALCNOM1 está en la segunda librería y hay otro CALCNOM1 en la primera, corre el de la primera. Cómo comprobarlo: busca el miembro en cada librería del STEPLIB, en orden.

Ojo con esto: antes de buscar el error en tu código, confirma que lo que corrió es lo que compilaste. Un DISPLAY nuevo al inicio del programa, con la fecha del cambio, te lo dice en el SYSOUT sin abrir ninguna librería.

Qué puede fallar en cada paso, y si hay SQL

Paso Cómo se ve A dónde ir
Compilación Return code 8 o más y mensajes al final del SYSPRINT. Cómo leer un listado de compilación y Los errores de compilación más comunes.
Linkedit Return code 8 en LINKEDIT (4 si se linkeditó con NCAL); en su SYSPRINT, el mensaje IEW2456E con el nombre del símbolo que no encontró. Revisa el SYSLIB del binder y el nombre del CALL. Con 8, el binder marca el módulo como no ejecutable, salvo que se linkedite con LET; en ese caso el CALL puede acabar en un S0C1.
Ejecución Abend (el sistema detuvo el programa a media ejecución) o return code alto en el job de ejecución. Me tronó en ejecución; si es un S806, vuelve a la sección anterior.

Si el programa tiene EXEC SQL, hay pasos adicionales que esta guía solo nombra: el SQL se procesa antes de compilar (con el precompilador de Db2) o durante la compilación (con el coprocesador, opción SQL), y del lado de Db2 hace falta un bind, el paso que registra en Db2 el SQL del programa, antes de ejecutar. Tu instalación ya tiene el procedimiento para esto; cuando te toque, pregunta cuál es.

Resumen

  • Compilar produce un módulo objeto; linkeditar lo convierte en program object; ejecutar lo busca por STEPLIB y PGM=. Sin el segundo paso, corre el programa de antes.
  • Compilador: SYSIN el fuente, SYSLIB los copys en orden de búsqueda, SYSPRINT el listado, SYSLIN el módulo objeto.
  • Binder: SYSLIN la entrada, SYSLIB las rutinas de LE y tus subprogramas, SYSLMOD el miembro en la librería de loads, que es un PDSE.
  • COND=(8,LT,COMPILA): el linkedit se salta si 8 es menor que el return code de la compilación. Práctica común; cada instalación tiene la suya.
  • Si cambiaste el fuente y corre lo viejo: linkedit saltado, SYSLMOD y STEPLIB en librerías distintas, o una librería concatenada antes que la tuya.
  • Los términos están en el glosario del mapa.