Additional Processing

Basic processing by the linkage editcr produces a single load module from the data that i t reads from its primary input, but i t has several other facilities that you can call upon by using linkage editcr control statements. The use of those statements of particular relevance tc a PL/I program is described below. All the linkage editor control staterrents are fully described in the linkage editor and loader publication.

FORMAT OF CONTROL S1ATEMENTS

A linkage editor control staterrent is an aO-byte record that contains two fields.

The operation field specifies the operation required of the linkage editcr; i t rrust be preceded and followed by at least one blank character. The operand field names the control sections, data sets, or mcdules that are to be processed, and i t may

contain symbols to indicate the manner of processing; the field consists of one or more parameters separated by commas. Some control statements may have multiple operand fields separated by commas.

The position of a control statement in the linkage editor input depends on its function.

In the following descriptions of the control statements, items within l:rackets

[] are optional.

MODULE NAME

A load module must have a name so that the linkage editor and the operating system can identify it. A name comprises up to eight characters, the first of which must be alphabetic.

You can name a load module in cne of two ways:

1. If you are producing a single load module from a single link-edit job step, i t is sufficient to include its name as a member name in the DSNAME parameter of the DD statement with the name SYSLMOD.

2. If you are producing two or more load modules from a single link-edit job step, you will need to use the NAME statement. (The optimizing compiler can supply the NAME statements when you use batch compilation as described in Chapter 4.)

The format of the NAME statement is:

NAME name [ (R) ]

Iwhere "name" is any name of up to eight characters; the first character must be alphabetic. The NAME statement serves the following functions:

• It identifies a load module. The name specified will be given to the load module. "(R)", if present, specifies that the load module is to replace an

existing load module of the sarre name in 'the data set defined by the DD statement with the name SYSLMOD.

• I t acts as a delimiter between input for different load modules in one link-edit step.

'rhe NAME statement must appear in the primary input to the linkage editor (the standard data set defined by the DD

statement SYSLIN); if i t appears elsewhere,

the linkage editor ignores it. The

statement must follow innediately after the last object module that will form part of the load module i t names (or after the INCLUDE control statement that specifies the last object module).

Alternative Names

You can use the ALIAS statement to give a load module an alternative narre; a lead module can have as many as sixteen aliases in addition to the name given to i t in a DD statement with the name SYSLMOD, or by a NAME statement.

The format of the ALIAS statement is:

ALIAS name

where "name" is any name of up to eight characters; the first character wust be alphabetic. You can include more than one name in an ALIAS statewent, se~arating the naJlles by commas" for example:

ALIAS FEE,FIE,FOE,FUM

An ALIAS statement can be placed before, between, or after object medules and

control statements that are being processed to form a load module, but i t nust ~recede

the NAME statement that specifies the primary name of the load module.

To execute a load module, you can include an alias instead of the primary name in the PGM parameter of an EXEC statement.

Aliases can be used for external entry points in a PL/I procedure. Hence a CALL statement or a function reference to any of the external entry names will cause the linkage editor to include the module containing the alias entry names without the need to use the INCLUDE statenent for this module.

ADDITIONAL INPUT SOURCES

The linkage editor can ^acce~tinput from sources other than the primary input defined in the DD statement with the name SYSLIN. For example" automatic library call enables the linkage editor to include modules from a data set (a library) defined by the DD statement with the name SYSLIB.

You can name these additional input sources by means of the INCLUDE statement, and you can direct the automatic library call mechanism to alternative libraries by means

58 OS PL/I Optimizing Compiler: Programmer's Guide

of the LIBRARY statement.

INCLUDE statement

The INCLUDE statement causes the linkage editor to process the module or modules

indicated. After the included modules have been processed, the linkage editor

continues with the next item in the prirrary input. If an included sequential data set also contains an INCLUDE statement, that statement is processed as if it were the last item in the data set, as shown in Figure 5-10.

r---,

Primary Input Sequential Data Set Data Set

end

INCLUDE end

INCLUDE not

processed

Library Member

end end end

L---J

Figure 5-10. Processing of additional data sources

The format of the INCLUDE statement is:

INCLUDE ddname[(membername)]

where "ddname" is the name of a DD

statement that defines either a sequential data set or a library that contains the modules and control statements to be processed. If the DD statement defines a library, replace "membername" with the names of the modules to be processed, separated by commas. You can specify more than one ddname, each of which may be followed by any number of member names in a

single INCLUDE statement. For example:

INCLUDE D1(MEM1,MEM2),D2(MODA,MODB) specifies the inclusion of the merrbers MEM1 and MEM2 from the library defined by the DO statement with the name D1, and the members MODA and MODB from the library defined by the DD statement with the name D2.

LIBRARY Statement

The basic function of the LIERARY statement is to name call libraries in additicn to those named in the DD statem€~t SYSLIB.

The format of the LIBRARY staterrent is:

LIBRARY ddname(membername) where "ddname" is the narre cf a rr

statement that defines the additional call library, and "rr.embernarre" is the narre of the module to be examined by the automatic call mechanism. More than cr,e rrcdule can be specified; separate the module names with corrmas.

OVERLAY STRUCTURES

A load module constructed as an overlay structure can be executed in an area of main storage that is net large encugh to contain the entire module at one time. The linkage editor divides the load module into segments that can be loaded and executed in turn. To construct an overlay structure, you must use linkage editor control

statements to specify the relationship between the segments. One segment, termed the root segment must remain in main

storage throughout the execution of the prcgram.

In an overlay environment the addressing of a static external structure element, array, or string may be incorrect if used in a data-directed I/O statenent cr CHECR staterr.ent. This error will arise if the control section containing the syrrbcl table of the identifier, and the corresponding static internal contrcl secticn are not in the same overlay segment. This is because the symbol table contains the address of a locator that is in sta~ic internal storage.

The difficulty can be avoided by ensuring that the procedure in the root segment contains a reference tc the identifier in a data-directed I/O or CHECR context. The statement containing the ider,tifier need not be executed; its presence ensures that the symbol table for the identifier

addresses the locator in the static internal control section of the rcot segment.

I

The descriptor for a controlled external laggregate with fixed extents is stored in Ithe static internal control section of the I procedure that allocates i t . 'Ihis prevents Ireferences to the external variable being Imade in other procedures that overlay the Isegrr.ent in which i t was allocated. A Icontrolled external variable must be lallocated in one of two ways:

r---,

IA: PROC OPTICNS (MAIN) ; I

I I

I CALL Bi I

I I

I CALL F i I

I I

I

END Ai

I

L---J r---,

IB: PROC; I

I I

I CALL C; I

I I

I

END B;

I

L---J r---,

IC: PROC; I

I I

I CALL Di I

Procedure A

r---,

I I I

I I

^Prccedure^B

I

Procedure F

I CALL E; I

I I

I

END C i

I

L---_J

I I I

r---,

Procedure C

I I

ID: PROC: I

I

I I r---,

I I I

I

END D:

I I I

L---J

I Prccedure D I Procedure E

I I

r---, ^I ^I

IE: PROC: I

I I

I

END E i

I

~---________ ._J

r---,

IF: PROC; I

I I

I

END F:

I

L---__

Figure 5-11. OVerlay structure and its tree 1. The variable can be allocated in the

root phase. A convenient technique to use would be to have a subroutine, containing the ALLOCATE state~ent,

which could be called from any segment.

2. The variable can be allocated with adjustable extents, so that the descriptor will be copied into the controlled storage area when

allocation takes place. Note that this method uses more storage.

Design of the Overlay ^Struct~~~

Before Freparing the linkage editor control stateroents, you must design the overlay structure for your program. A tree is a graphic representation of an overlay

structure that shows which segrrents cccupy rrain stcrage at different times. The

design cf trees is discussed in the linkage editor and loader putlication~ but for the purposes of this chapter, Figure 5-11 contains a simple example. The program corrprises six procedures: A, B, C, D, E~

60 OS PL/I Optimizing Compiler: Prograrrmer's Guide

//OPI'5#12 //S'IEPl //PLI.SYSIN

JOB

EXEC PLIXCLG, PARM.LKED='OVLY' DD

*

(insert here source statements for procedu re A)

* PROCESS;

(insert here source statements for procedure B)

* PROCESS;

(insert here source statements for procedure C)

* PROCESS;

(insert here source statements for procedure D)

* PROCESS;

(insert here source statements for procedure E)

* PROCESS;

(insert here source statements for precedure F)

//LKED~SYSIN DD * OVERLAY X

INSERT ******Bl,******C1 OVERLAY Y

INSERT ******D1 OVERLAY Y INSERT ******E1 OVERLAY X INSERT ******F1

Figure 5-12. Creating and executing the overlay structure of Figure 5-11

and F. Procedure B calls procedure C which, in turn, calls procedures D and E.

(Only procedure A requires the optien MAIN. )

The main procedure (A) must be in main storage throughout the execution ef the prcqram. Since the execution of procedure B \,ii..ll be completed before procedure F is called, the two procedures can occupy the same storage: this is depicted by the lines representing the two procedures in Figure

51-11 starting from the common point (node) X. Procedure B must remain in sterage while procedures C, D, and E are executed, but procedures D and E can occupy the same

storage~ ~hus the lines representing procedures D and E start from the node X.

The degree of segmentation that can be achieved can be clearly seen fren the figure. Since procedure A must al~ays be present, i t must be included in the root segnent. Procedures F, D and E can

usefully be placed in individual segrrents, as can procedures Band C be placed

together; there is nething tc be gained by separating procedures Band C, since they must be present together at sene tine during execution.

Control Statements

Two linkage editor control statements, OVERLAY and INSERT, centrel the

relationship of the segments in the overlay structure. The OVERLAY statenent specifies the start of a segment and the INSERT

statement specifies the pesitiens ef contrel sections in a segment. You must include the attribute OVLY in the FARM parameter of the EXEC statement that invokes the linkage editer, ctherwise the linkage editor will ignore the control statements.

The format of the OVERLAY statenent is:

OVERLAY symtol

where "symbol" is the nede at which the segnent starts (for example, X in Figure

5-11). You rr.ust specify the start cf every segrrent, except the root segment, in an OVERLAY statereent.

The format of the INSER'I staterrent is:

INSERT control-section-name

~here "control-sectien-narre" is the name ef the centrol section (that is, the

derivative of the precedure r.arre that is found in the linkage editor map) that is to be placed in the segrrent. ~cre thar: one contrel section can te specified, separate the names with conmas. 'Ihe INSERT

statements that name the control sections in the root segrrent rrust precede the first OVERLAY statement.

creating an Overlay Structure

The nest efficient method of defining an overlay structure, and the sinplest for a PI/I pregram, is to group all the OVERLAY and INSERT staterrents tegether and place them in the linkage editor input (SYSLIN)

after the object modules that for~r the program. The linkage editor initially places all these ob ject mod ules in the root segment, and then moves those control

sections that are referred to in INSERT statements into other segments.

'rhis method has the advantage that you single overlay structure.)

The use of the IBM-supplied cataloged procedure PLIXCLG to create and execute the overlay structure of Figure 5-11, is shown in Figure 5-12.

An alternative approach instead of 'batched compilation is to compile the

procedures independently and store them as object modules in a private library. You

All other control sections established by the compi ler, and all the PL/I library exclusive calls (calls between segments that do not lie in the same path). For example, in Figure 5-11, procedures in the segment containing D could call procedures in the segments containing A, B, C, and 0,

However, certain library subroutines may not. be required by all segments, in which case you can move them into a lower

segment. To do this, compile the

procedures using the compiler option ESD,

and exarrine the resulting external symbol dictionary. For example, i f in Figure 5-11 a library subroutine is called only by the segment containing E, you can rreve i t into that segment by placing an INSERT

statement, specifying the subreutin.e name, immediately after the statement INSERT

******E1. particular, the static external centrol section for SYSFRINT must always be placed

in the root segrrent.

I When using the COUNT cpticn, ensure that lall procedures for which count information lis required have their static internal Icontrol sections in the root segment, or Ithe count information will be rendered I invalid.

LINK EDITING FETCHABLE LeAD MODULES The PL/I FETCH and RELEASEstaterrents

permit the dynamic loading of separate load modules which can be subsequently invoked from the PL/I object program.

Fetchable (or dynamically-loaded) modules should be link-edited inte a load module library which is subsequently made available for the job step by rreans ef a JOBLIB or STEPLIB DO statement.

The step which link-edits a fetchable load module into a library requires the following linkage editor control

statements:

• An ENTRY statement to define the entry-point into the PL/I program.

62 OS PL/I Optimizing Compiler: Programmer's Guide

Control

Multitasking programs that use the WAIT statement

Programs that use the

COMPLETION builtin function or pseudovariable

Multitasking programs that use the COMPLETION built-in

function or pseudovariable.

Programs that use the PRIORITY pseudovariable

Multitasking programs that use the PRIORITY pseudovariable.

Programs compiled with the FLOW

//LKED.SYSLMOD DD DSN=PRVLIB, ••.

//LKED.SYSLIN DD DDNAME=SYSIN

/ / DD DSN=&&LOADSET,DISP=COLD,DELETE) //LKED.SYSIN CD

*

the invoking procedure.

COBOl or FORTRAN modules cannot be Optimizing and Checkout Corr:Filers When a program is to consist of PL/I modules compiled by the optirrizing and

checkout compilers, the following points should be considered before link-editing the modules into a single load module:

• The modules compiled by the optirrizing compiler should be link-edited tc form a load module.

• The linkage editor option NCAL rrust be specified for this link-editing

operation. initialization routine for a program compiled by the optiroizing ccrot:iler will not be included in the final load module and that the initialization routine for a program compiled by the checkout compiler is used ~hen the prograrr: is executed.

Both the space occupied by the final load module and its speed of execution are affected by the SYSLIB data set specified for use by the linkage editor. Two data sets, SYS1.PLICMIX and SYS1.PLIBASE are available. Use SYS1.PLICMIX to obtain a

smaller load module at the expense of execution time; use SYSl. PLIBASE ·to save execution time at the expense of space.

Loader

The loader is an operating system processing program that produces and executes load modules. It always stores the load modules directly in main storage where they are execut ed immediately.

The input to the loader can include single object modules or load modules, several object modules or load modules, or a mixture of both. The output from the

1~1der always comprises an executable program that is loaded into main storage from where i t will be executed.

Unlike the linkage editor you cannot use any control statements with the loader. If any linkage editor control statements are used, they will be ignored, and their presence in the input stream will not be treated as an error. Your job will

continue to be processed, a message will be generated and, if you have included a DD statement with the name SYSLOUT, this message and the name of the contrel

statement will be printed on your listing.

The loader compensates for the absence of the facilities provided by control

statements by allowing the concatenation of both object and load modules in the data set defined by the DD statement with the name SYSLIN, and by allowing an entry point to be specified by means of the EP option, as described in "Optional Facilities,"

later in this chapter.

LOADER PROCESSING

A PL/I program cannot be executed until the appropriate PL/I library subroutines have been included. All library subroutines are included during loading. In basic

processing, as shown in Figure 5-15, the loader accepts data from its primary input source, a dat a set defined by the DD

statement with the name SYSLIN. For a PL/I program, this data is the object module produced by the compiler. The loader uses the external symbol dictionary in this object module to determine whether the module includes any external references for which there are no corresponding external

s~nbols in the module: i t attempts to resolve such references by a method termed automatic library call as described in

"Linkage Editor processing," earlier in

this chapter.

The loader locates the surroutines in which the external symbcls aIe defined (if such surroutines exist) and includes them

in the load module. If all external

references are resolved satisfactorily the load module is executed.

The loader will always search the link-pack area before searching the PL/!

resident library, as shown ir. Figure 5-16.

The link-pack area is an area of main storage in which frequently used lcad modules are stored permanently. If there is more than one copy of an cbject rrcdule in the data set defined ry the DD statement with the name SYSLIN, the lcader will load the first and ignore the rest.

Main storaqe Requirements

The minimum main storage requirements for the loader are shown in Figure 5-17.

This amounts to at least 17K bytes for the loader and its associated routines and data areas plus the rr.ain stcIage required for the program that is to re executed. If the loader program and the data rranagement access routines were stored in the

Dans le document OS PL/I (Page 70-77)