eld Manual
Table Of Contents
- eld Manual
- Legal Notices
- Contents
- What’s New in This Manual
- Manual Information
- New and Changed Information
- About This Manual
- Notation Conventions
- 1 Introduction to eld
- 2 eld Input and Output
- 3 Binding of References
- Overview
- Presetting Loadfiles
- To Preset or Not to Preset, and Creation of the LIC
- Handling Unresolved References
- Using User Libraries
- Creating Import Libraries
- Ignoring Optional Libraries
- Merging Symbols Found in Input Linkfiles
- Accepting Multiply-Defined Symbols
- Using the -cross_dll_cleanup option
- Specifying Which Symbols to Export, and Creating the Export Digest
- Public Libraries and DLLs
- The Public Library Registry
- 4 Other eld Processing
- Adjusting Loadfiles: The -alf Option
- Additional rules about -alf
- The -set and -change Options
- eld Functionality for 64-Bit
- Checking the C++ Language Dialect
- Renaming Symbols
- Creating Linker-Defined Symbols
- Updating Or Stripping DWARF Symbol Table Information
- Modifying the Data Sections that Contain Stack Unwinding Information
- Creating the MCB
- Processing of Floating Point Versions and Data Models
- Specification of the Main Entry Point
- Specifying Runtime Search Path Information for DLLs
- Merging Source RTDUs
- 5 Summary of Linker Options
- 6 Output Listings and Error Handling
- A TNS/E Native Object Files
- Glossary
- Index
Introduction to eld
eld Manual—527255-009
1-4
Native Object Files
There are four types of TNS/E object file:
Collectively, programs and DLLs are called loadfiles. Loadfiles and import libraries are
built by the linker.
The main distinctions occur between linkfiles and loadfiles. There is little difference
between a program and a DLL as far as the file format is concerned, and an import
library is a subset of what is in a DLL.
A loadfile may refer by name to symbols that exist in other loadfiles in the same
process. Such references are resolved when the loadfiles are brought into memory by
the runtime loader (rld) or by the C/C++ runtime procedure named dlopen(). When
the loadfile was originally built by the linker it is also possible that the linker tried to
resolve such references. A loadfile whose references have been resolved by the linker
is said to be preset.
A process can also use one user library. A user library is a DLL. Nothing within a user
library distinguishes it from other DLLs, and a DLL that serves as the user library for
one program can also be used like any other DLL by other programs. The only
difference between the user library and other DLLs is in the way the program identifies
the user library that it uses. For a DLL to be used as a user library at runtime its
filename must be in the Guardian name space.
An import library can take the place of a DLL at link time. One use of import libraries is
to save space. Another use is for security, when it is necessary for the linker to read
the header information but it is not desirable for others to be able to see the code.
Import libraries are further categorized as complete or incomplete. The difference is
that an incomplete import library need not contain the correct addresses for symbols. A
complete import library can be used by the linker when presetting a loadfile. The linker
can use an incomplete import library to check for unresolved references, but not to
preset.
DLLs and import libraries can also be used at compile time by the COBOL compiler to
find out information about procedure call interfaces.
Type of Object File Description
Linkfile Object files that are produced by a compiler or by the
assembler that can be given as input to the linker. It is also
possible for the linker to produce a linkfile as output when
run with the -r option.
Program This is the main program. There is one program in every
process.
DLL This is a dynamic-link library. It is an object file that is not a
program but can also be part of a process. A process can
contain any number of DLLs. DLLs are also used by the
linker when building other programs or DLLs.
Import Library This is a file that contains just part of a DLL that is needed
at link time to build other DLLs or programs.