Dec 132017
 
VERY detailed info on LX file headers (WATCOM & OS/2).
File LXEXE.ZIP from The Programmer’s Corner in
Category C Source Code
VERY detailed info on LX file headers (WATCOM & OS/2).
File Name File Size Zip Size Zip Type
LXEXE.DOC 77007 16790 deflated

Download File LXEXE.ZIP Here

Contents of the LXEXE.DOC file



LX - Linear eXecutable Module Format Description

June 3, 1992



Figure 1. 32-bit Linear EXE File Layout

00h +------------------+ <--+
| DOS 2 Compatible | |
| EXE Header | |
1Ch +------------------+ |
| unused | |
+------------------+ |
24h | OEM Identifier | |
26h | OEM Info | |
| | |-- DOS 2.0 Section
3Ch | Offset to | | (Discarded)
| Linear EXE | |
| Header | |
40h +------------------+ |
| DOS 2.0 Stub | |
| Program & | |
| Reloc. Table | |
+------------------+ <--+
| |
xxh +------------------+ <--+
| Executable | |
| Info | |
+------------------+ |
| Module | |
| Info | |
+------------------+ |-- Linear Executable
| Loader Section | | Module Header
| Info | | (Resident)
+------------------+ |
| Table Offset | |
| Info | |
+------------------+ <--+
| Object Table | |
+------------------+ |
| Object Page Table| |
+------------------+ |
| Resource Table | |
+------------------+ |
| Resident Name | |
| Table | |
+------------------+ |-- Loader Section
| Entry Table | | (Resident)
+------------------+ |
| Module Format | |
| Directives Table | |
| (Optional) | |
+------------------+ |
| Resident | |
| Directives Data | |
| (Optional) | |
| | |
| (Verify Record) | |
+------------------+ |
| Per-Page | |
| Checksum | |
+------------------+ <--+
| Fixup Page Table | |
+------------------+ |
| Fixup Record | |
| Table | |
+------------------+ |-- Fixup Section
| Import Module | | (Optionally Resident)
| Name Table | |
+------------------+ |
| Import Procedure | |
| Name Table | |
+------------------+ <--+
| Preload Pages | |
+------------------+ |
| Demand Load | |
| Pages | |
+------------------+ |

| Iterated Pages | |
+------------------+ |
| Non-Resident | |-- (Non-Resident)
| Name Table | |
+------------------+ |
| Non-Resident | |
| Directives Data | |
| (Optional) | |
| | |
| (To be Defined) | |
+------------------+ <--+
| Debug Info | |-- (Not used by Loader)
+------------------+ <--+



Figure 2. 32-bit Linear EXE Header

+-----+-----+-----+-----+-----+-----+-----+-----+
00h | "L" "X" |B-ORD|W-ORD| FORMAT LEVEL |
+-----+-----+-----+-----+-----+-----+-----+-----+
08h | CPU TYPE | OS TYPE | MODULE VERSION |
+-----+-----+-----+-----+-----+-----+-----+-----+
10h | MODULE FLAGS | MODULE # OF PAGES |
+-----+-----+-----+-----+-----+-----+-----+-----+
18h | EIP OBJECT # | EIP |
+-----+-----+-----+-----+-----+-----+-----+-----+
20h | ESP OBJECT # | ESP |
+-----+-----+-----+-----+-----+-----+-----+-----+
28h | PAGE SIZE | PAGE OFFSET SHIFT |
+-----+-----+-----+-----+-----+-----+-----+-----+
30h | FIXUP SECTION SIZE | FIXUP SECTION CHECKSUM|
+-----+-----+-----+-----+-----+-----+-----+-----+
38h | LOADER SECTION SIZE |LOADER SECTION CHECKSUM|
+-----+-----+-----+-----+-----+-----+-----+-----+
40h | OBJECT TABLE OFF | # OBJECTS IN MODULE |
+-----+-----+-----+-----+-----+-----+-----+-----+
48h | OBJECT PAGE TABLE OFF | OBJECT ITER PAGES OFF |
+-----+-----+-----+-----+-----+-----+-----+-----+
50h | RESOURCE TABLE OFFSET |#RESOURCE TABLE ENTRIES|
+-----+-----+-----+-----+-----+-----+-----+-----+
58h | RESIDENT NAME TBL OFF | ENTRY TABLE OFFSET |
+-----+-----+-----+-----+-----+-----+-----+-----+
60h | MODULE DIRECTIVES OFF | # MODULE DIRECTIVES |
+-----+-----+-----+-----+-----+-----+-----+-----+
68h | FIXUP PAGE TABLE OFF |FIXUP RECORD TABLE OFF |
+-----+-----+-----+-----+-----+-----+-----+-----+
70h | IMPORT MODULE TBL OFF | # IMPORT MOD ENTRIES |
+-----+-----+-----+-----+-----+-----+-----+-----+
78h | IMPORT PROC TBL OFF | PER-PAGE CHECKSUM OFF |
+-----+-----+-----+-----+-----+-----+-----+-----+
80h | DATA PAGES OFFSET | #PRELOAD PAGES |
+-----+-----+-----+-----+-----+-----+-----+-----+
88h | NON-RES NAME TBL OFF | NON-RES NAME TBL LEN |
+-----+-----+-----+-----+-----+-----+-----+-----+
90h | NON-RES NAME TBL CKSM | AUTO DS OBJECT # |
+-----+-----+-----+-----+-----+-----+-----+-----+
98h | DEBUG INFO OFF | DEBUG INFO LEN |

+-----+-----+-----+-----+-----+-----+-----+-----+
A0h | #INSTANCE PRELOAD | #INSTANCE DEMAND |
+-----+-----+-----+-----+-----+-----+-----+-----+
A8h | HEAPSIZE |
+-----+-----+-----+-----+

Note: The OBJECT ITER PAGES OFF must either be 0 or set to the
same value as DATA PAGES OFFSET in OS/2 2.0. Ie., iterated pages are
required to be in the same section of the file as regular pages.

Note: Table offsets in the Linear EXE Header may be set to
zero to indicate that the table does not exist in the EXE
file and it's size is zero.

"L" "X" = DW Signature word.
The signature word is used by the loader to identify
the EXE file as a valid 32-bit Linear Executable
Module Format. "L" is low order byte. "X" is high
order byte.

B-ORD = DB Byte Ordering.
This byte specifies the byte ordering for the linear
EXE format. The values are:

00H - Little Endian Byte Ordering.
01H - Big Endian Byte Ordering.

W-ORD = DB Word Ordering.
This byte specifies the Word ordering for the linear
EXE format. The values are:

00H - Little Endian Word Ordering.
01H - Big Endian Word Ordering.

Format Level = DD Linear EXE Format Level.
The Linear EXE Format Level is set to 0 for the
initial version of the 32-bit linear EXE format.
Each incompatible change to the linear EXE format
must increment this value. This allows the system
to recognized future EXE file versions so that an
appropriate error message may be displayed if an
attempt is made to load them.

CPU Type = DW Module CPU Type.
This field specifies the type of CPU required by
this module to run. The values are:

01H - 80286 or upwardly compatible CPU is
required to execute this module.
02H - 80386 or upwardly compatible CPU is
required to execute this module.
03H - 80486 or upwardly compatible CPU is
required to execute this module.

OS Type = DW Module OS Type.
This field specifies the type of Operating system
required to run this module. The currently defined
values are:

00H - Unknown (any "new-format" OS)
01H - OS/2 (default)
02H - Windows
03H - DOS 4.x
04H - Windows 386

MODULE VERSION = DD Version of the linear EXE module.
This is useful for differentiating between revisions
of dynamic linked modules. This value is specified
at link time by the user.

MODULE FLAGS = DD Flag bits for the module.
The module flag bits have the following definitions.

00000001h = Reserved for system use.
00000002h = Reserved for system use.
00000004h = Per-Process Library Initialization.
The setting of this bit requires the EIP
Object # and EIP fields to have valid
values. If the EIP Object # and EIP fields
are valid and this bit is NOT set, then
Global Library Initialization is assumed.
Setting this bit for an EXE file is invalid.

00000008h = Reserved for system use.
00000010h = Internal fixups for the module have
been applied.
The setting of this bit in a Linear
Executable Module indicates that each object
of the module has a preferred load address
specified in the Object Table Reloc Base
Addr. If the module's objects can not be
loaded at these preferred addresses, then
the relocation records that have been
retained in the file data will be applied.

00000020h = External fixups for the module have
been applied.
00000040h = Reserved for system use.
00000080h = Reserved for system use.
00000100h = Incompatible with PM windowing.
00000200h = Compatible with PM windowing.
00000300h = Uses PM windowing API.
00000400h = Reserved for system use.
00000800h = Reserved for system use.
00001000h = Reserved for system use.
00002000h = Module is not loadable.
When the 'Module is not loadable' flag is
set, it indicates that either errors were
detected at link time or that the module is
being incrementally linked and therefore
can't be loaded.

00004000h = Reserved for system use.
00038000h = Module type mask.
00000000h = Program module.
A module can not contain dynamic links to
other modules that have the 'program module'
type.

00008000h = Library module.
00018000h = Protected Memory Library module.
00020000h = Physical Device Driver module.
00028000h = Virtual Device Driver module.
40000000h = Per-process Library Termination.
The setting of this bit requires the EIP
Object # and EIP fields to have valid
values. If the EIP Object # and EIP fields
are valid and this bit is NOT set, then
Global Library Termination is assumed.
Setting this bit for an EXE file is invalid.

MODULE # PAGES = DD Number of pages in module.

This field specifies the number of pages physically
contained in this module. In other words, pages
containing either enumerated or iterated data, or
zero-fill pages that have relocations, not invalid
or zero-fill pages implied by the Virtual Size in
the Object Table being larger than the number of
pages actually in the linear EXE file. These pages
are contained in the 'preload pages', 'demand load
pages' and 'iterated data pages' sections of the
linear EXE module. This is used to determine the
size of the page information tables in the linear
EXE module.

EIP OBJECT # = DD The Object number to which the Entry
Address is relative.
This specifies the object to which the Entry Address
is relative. This must be a nonzero value for a
program module to be correctly loaded. A zero value
for a library module indicates that no library entry
routine exists. If this value is zero, then both
the Per-process Library Initialization bit and the
Per-process Library Termination bit must be clear in
the module flags, or else the loader will fail to
load the module. Further, if the Per-process
Library Termination bit is set, then the object to
which this field refers must be a 32-bit object
(i.e., the Big/Default bit must be set in the object
flags; see below).

EIP = DD Entry Address of module.
The Entry Address is the starting address for
program modules and the library initialization and
Library termination address for library modules.

ESP OBJECT # = DD The Object number to which the ESP is
relative.
This specifies the object to which the starting ESP
is relative. This must be a nonzero value for a
program module to be correctly loaded. This field
is ignored for a library module.

ESP = DD Starting stack address of module.
The ESP defines the starting stack pointer address
for program modules. A zero value in this field
indicates that the stack pointer is to be
initialized to the highest address/offset in the
object. This field is ignored for a library module.

PAGE SIZE = DD The size of one page for this system.
This field specifies the page size used by the
linear EXE format and the system. For the initial
version of this linear EXE format the page size is
4Kbytes. (The 4K page size is specified by a value
of 4096 in this field.)

PAGE OFFSET SHIFT = DD The shift left bits for page
offsets.
This field gives the number of bit positions to
shift left when interpreting the Object Page Table
entries' page offset field. This determines the
alignment of the page information in the file. For
example, a value of 4 in this field would align all
pages in the Data Pages and Iterated Pages sections
on 16 byte (paragraph) boundaries. A Page Offset
Shift of 9 would align all pages on a 512 byte (disk
sector) basis. The default value for this field is
12 (decimal), which give a 4096 byte alignment. All
other offsets are byte aligned.

FIXUP SECTION SIZE = DD Total size of the fixup
information in bytes.
This includes the following 4 tables:

- Fixup Page Table
- Fixup Record Table
- Import Module name Table
- Import Procedure Name Table

FIXUP SECTION CHECKSUM = DD Checksum for fixup
information.
This is a cryptographic checksum covering all of the
fixup information. The checksum for the fixup
information is kept separate because the fixup data
is not always loaded into main memory with the
'loader section'. If the checksum feature is not
implemented, then the linker will set these fields
to zero.

LOADER SECTION SIZE = DD Size of memory resident
tables.
This is the total size in bytes of the tables
required to be memory resident for the module, while
the module is in use. This total size includes all
tables from the Object Table down to and including
the Per-Page Checksum Table.

LOADER SECTION CHECKSUM = DD Checksum for loader
section.
This is a cryptographic checksum covering all of the
loader section information. If the checksum feature
is not implemented, then the linker will set these
fields to zero.

OBJECT TABLE OFF = DD Object Table offset.
This offset is relative to the beginning of the
linear EXE header.

# OBJECTS IN MODULE = DD Object Table Count.
This defines the number of entries in Object Table.

OBJECT PAGE TABLE OFFSET = DD Object Page Table offset
This offset is relative to the beginning of the
linear EXE header.

OBJECT ITER PAGES OFF = DD Object Iterated Pages
offset.
This offset is relative to the beginning of the EXE
file.

RESOURCE TABLE OFF = DD Resource Table offset.
This offset is relative to the beginning of the
linear EXE header.

# RESOURCE TABLE ENTRIES = DD Number of entries in
Resource Table.

RESIDENT NAME TBL OFF = DD Resident Name Table offset.
This offset is relative to the beginning of the
linear EXE header.

ENTRY TBL OFF = DD Entry Table offset.
This offset is relative to the beginning of the
linear EXE header.

MODULE DIRECTIVES OFF = DD Module Format Directives
Table offset.
This offset is relative to the beginning of the
linear EXE header.

# MODULE DIRECTIVES = DD Number of Module Format
Directives in the Table.
This field specifies the number of entries in the
Module Format Directives Table.

FIXUP PAGE TABLE OFF = DD Fixup Page Table offset.
This offset is relative to the beginning of the
linear EXE header.

FIXUP RECORD TABLE OFF = DD Fixup Record Table Offset
This offset is relative to the beginning of the
linear EXE header.

IMPORT MODULE TBL OFF = DD Import Module Name Table
offset.
This offset is relative to the beginning of the
linear EXE header.

# IMPORT MOD ENTRIES = DD The number of entries in the
Import Module Name Table.

IMPORT PROC TBL OFF = DD Import Procedure Name Table
offset.
This offset is relative to the beginning of the
linear EXE header.

PER-PAGE CHECKSUM OFF = DD Per-Page Checksum Table
offset.
This offset is relative to the beginning of the
linear EXE header.

DATA PAGES OFFSET = DD Data Pages Offset.
This offset is relative to the beginning of the EXE
file.

# PRELOAD PAGES = DD Number of Preload pages for this
module. Note that OS/2 2.0 does not respect the preload
of pages as specified in the executable file for performance
reasons.

NON-RES NAME TBL OFF = DD Non-Resident Name Table
offset.
This offset is relative to the beginning of the EXE
file.

NON-RES NAME TBL LEN = DD Number of bytes in the
Non-resident name table.

NON-RES NAME TBL CKSM = DD Non-Resident Name Table
Checksum.
This is a cryptographic checksum of the Non-Resident
Name Table.

AUTO DS OBJECT # = DD The Auto Data Segment Object
number.
This is the object number for the Auto Data Segment
used by 16-bit modules. This field is supported for
16-bit compatibility only and is not used by 32-bit
modules.

DEBUG INFO OFF = DD Debug Information offset.
This offset is relative to the beginning of the
linear EXE header.

DEBUG INFO LEN = DD Debug Information length.
The length of the debug information in bytes.

# INSTANCE PRELOAD = DD Instance pages in preload
section.
The number of instance data pages found in the
preload section.

# INSTANCE DEMAND = DD Instance pages in demand
section.
The number of instance data pages found in the
demand section.

HEAPSIZE = DD Heap size added to the Auto DS Object.
The heap size is the number of bytes added to the
Auto Data Segment by the loader. This field is
supported for 16-bit compatibility only and is not
used by 32-bit modules.





Program (EXE) startup registers and Library entry registers


Program startup registers are defined as follows.

EIP = Starting program entry address.

ESP = Top of stack address.

CS = Code selector for base of linear address space.

DS = ES = SS = Data selector for base of linear
address space.

FS = Data selector of base of Thread Information
Block (TIB).

GS = 0.

EAX = EBX = 0.

ECX = EDX = 0.

ESI = EDI = 0.

EBP = 0.

[ESP+0] = Return address to routine which calls
DosExit(1,EAX).

[ESP+4] = Module handle for program module.

[ESP+8] = Reserved.

[ESP+12] = Environment data object address.

[ESP+16] = Command line linear address in
environment data object.


Library initialization registers are defined as follows.

EIP = Library entry address.

ESP = User program stack.

CS = Code selector for base of linear address space.

DS = ES = SS = Data selector for base of linear
address space.

Note that a 32-bit Protected Memory Library module
will be given a GDT selector in the DS and ES
registers (PROTDS) that addresses the full linear
address space available to a application. This
selector should be saved by the initialization
routine. Non-Protected Memory Library modules will
receive a selector (FLATDS) that addresses the same
amount of linear address space as an application's
.EXE can.

FS = Data selector of base of Thread Information
Block (TIB).

GS = 0.

EAX = EBX = 0.

ECX = EDX = 0.

ESI = EDI = 0.

EBP = 0.

[ESP+0] = Return address to system, (EAX) = return
code.

[ESP+4] = Module handle for library module.

[ESP+8] = 0 (Initialization)

Note that a 32-bit library may specify that its entry
address is in a 16-bit code object. In this case, the
entry registers are the same as for entry to a library
using the Segmented EXE format. These are documented
elsewhere. This means that a 16-bit library may be
relinked to take advantage of the benefits of the Linear
EXE format (notably, efficient paging).


Library termination registers are defined as follows.

EIP = Library entry address.

ESP = User program stack.

CS = Code selector for base of linear address space.

DS = ES = SS = Data selector for base of linear
address space.

FS = Data selector of base of Thread Information
Block (TIB).

GS = 0.

EAX = EBX = 0.

ECX = EDX = 0.


ESI = EDI = 0.

EBP = 0.

[ESP+0] = Return address to system.

[ESP+4] = Module handle for library module.

[ESP+8] = 1 (Termination)

Note that Library termination is not allowed for
libraries with 16-bit entries.





Object Table


The number of entries in the Object Table is given by the #
Objects in Module field in the linear EXE header. Entries
in the Object Table are numbered starting from one.

Each Object Table entry has the following format:

+-----+-----+-----+-----+-----+-----+-----+-----+
00h | VIRTUAL SIZE | RELOC BASE ADDR |
+-----+-----+-----+-----+-----+-----+-----+-----+
08h | OBJECT FLAGS | PAGE TABLE INDEX |
+-----+-----+-----+-----+-----+-----+-----+-----+
10h | # PAGE TABLE ENTRIES | RESERVED |
+-----+-----+-----+-----+-----+-----+-----+-----+

VIRTUAL SIZE = DD Virtual memory size.
This is the size of the object that will be
allocated when the object is loaded. The object's
virtual size (rounded up to the page size value)
must be greater than or equal to the total size of
the pages in the EXE file for the object. This
memory size must also be large enough to contain all
of the iterated data and uninitialized data in the
EXE file.

RELOC BASE ADDR = DD Relocation Base Address.
The relocation base address the object is currently
relocated to. If the internal relocation fixups for
the module have been removed, this is the address
the object will be allocated at by the loader.

OBJECT FLAGS = DW Flag bits for the object.
The object flag bits have the following definitions.

0001h = Readable Object.
0002h = Writable Object.
0004h = Executable Object.
The readable, writable and executable flags
provide support for all possible
protections. In systems where all of these
protections are not supported, the loader
will be responsible for making the
appropriate protection match for the system.

0008h = Resource Object.
0010h = Discardable Object.
0020h = Object is Shared.
0040h = Object has Preload Pages.
0080h = Object has Invalid Pages.
0100h = Object has Zero Filled Pages.
0200h = Object is Resident (valid for VDDs, PDDs
only).
0300h = Object is Resident & Contiguous (VDDs,
PDDs only).
0400h = Object is Resident & 'long-lockable'
(VDDs, PDDs only).
0800h = Reserved for system use.
1000h = 16:16 Alias Required (80x86 Specific).
2000h = Big/Default Bit Setting (80x86
Specific).
The 'big/default' bit , for data segments,
controls the setting of the Big bit in the
segment descriptor. (The Big bit, or B-bit,
determines whether ESP or SP is used as the
stack pointer.) For code segments, this bit
controls the setting of the Default bit in
the segment descriptor. (The Default bit,
or D-bit, determines whether the default
word size is 32-bits or 16-bits. It also
affects the interpretation of the
instruction stream.)

4000h = Object is conforming for code (80x86
Specific).
8000h = Object I/O privilege level (80x86
Specific).
Only used for 16:16 Alias Objects.

PAGE TABLE INDEX = DD Object Page Table Index.
This specifies the number of the first object page
table entry for this object. The object page table
specifies where in the EXE file a page can be found
for a given object and specifies per-page
attributes.

The object table entries are ordered by logical page
in the object table. In other words the object
table entries are sorted based on the object page
table index value.

# PAGE TABLE ENTRIES = DD # of object page table
entries for this object.
Any logical pages at the end of an object that do
not have an entry in the object page table
associated with them are handled as zero filled or
invalid pages by the loader.

When the last logical pages of an object are not
specified with an object page table entry, they are
treated as either zero filled pages or invalid pages

based on the last entry in the object page table for
that object. If the last entry was neither a zero
filled or invalid page, then the additional pages
are treated as zero filled pages.

RESERVED = DD Reserved for future use. Must be set to
zero.



Object Page Table


The Object page table provides information about a logical
page in an object. A logical page may be an enumerated
page, a pseudo page or an iterated page. The structure of
the object page table in conjunction with the structure of
the object table allows for efficient access of a page when
a page fault occurs, while still allowing the physical page
data to be located in the preload page, demand load page or
iterated data page sections in the linear EXE module. The
logical page entries in the Object Page Table are numbered
starting from one. The Object Page Table is parallel to the
Fixup Page Table as they are both indexed by the logical
page number.

Each Object Page Table entry has the following format:

63 32 31 16 15 0
+-----+-----+-----+-----+-----+-----+-----+-----+
00h | PAGE DATA OFFSET | DATA SIZE | FLAGS |
+-----+-----+-----+-----+-----+-----+-----+-----+

PAGE DATA OFFSET = DD Offset to the page data in the
EXE file.
This field, when bit shifted left by the PAGE OFFSET
SHIFT from the module header, specifies the offset
from the beginning of the Preload Page section of
the physical page data in the EXE file that
corresponds to this logical page entry. The page
data may reside in the Preload Pages, Demand Load
Pages or the Iterated Data Pages sections.

If the FLAGS field specifies that this is a
zero-Filled page then the PAGE DATA OFFSET field
will contain a 0.

If the logical page is specified as an iterated data
page, as indicated by the FLAGS field, then this
field specifies the offset into the Iterated Data
Pages section.

The logical page number (Object Page Table index),
is used to index the Fixup Page Table to find any
fixups associated with the logical page.


DATA SIZE = DW Number of bytes of data for this page.
This field specifies the actual number of bytes that
represent the page in the file. If the PAGE SIZE
field from the module header is greater than the
value of this field and the FLAGS field indicates a
Legal Physical Page, the remaining bytes are to be
filled with zeros. If the FLAGS field indicates an
Iterated Data Page, the iterated data records will
completely fill out the remainder.


FLAGS = DW Attributes specifying characteristics of
this logical page.
The bit definitions for this word field follow,

00h = Legal Physical Page in the module (Offset
from Preload Page Section).
01h = Iterated Data Page (Offset from Iterated
Data Pages Section).
02h = Invalid Page (zero).
03h = Zero Filled Page (zero).
04h = Range of Pages.




Resource Table


The resource table is an array of resource table entries.
Each resource table entry contains a type ID and name ID.
These entries are used to locate resource objects contained
in the Object table. The number of entries in the resource
table is defined by the Resource Table Count located in the
linear EXE header. More than one resource may be contained
within a single object. Resource table entries are in a
sorted order, (ascending, by Resource Name ID within the
Resource Type ID). This allows the DosGetResource API
function to use a binary search when looking up a resource
in a 32-bit module instead of the linear search being used
in the current 16-bit module.

Each resource entry has the following format:

+-----+-----+-----+-----+
00h | TYPE ID | NAME ID |
+-----+-----+-----+-----+
04h | RESOURCE SIZE |
+-----+-----+-----+-----+-----+-----+
08h | OBJECT | OFFSET |
+-----+-----+-----+-----+-----+-----+


TYPE ID = DW Resource type ID.
The type of resources are:

BTMP = Bitmap
EMSG = Error message string
FONT = Fonts

NAME ID = DW An ID used as a name for the resource when
referred to.

RESOURCE SIZE = DD The number of bytes the resource
consists of.

OBJECT = DW The number of the object which contains the
resource.

OFFSET = DD The offset within the specified object
where the resource begins.





Resident or Non-resident Name Table Entry


The resident and non-resident name tables define the ASCII
names and ordinal numbers for exported entries in the
module. In addition the first entry in the resident name
table contains the module name. These tables are used to
translate a procedure name string into an ordinal number by
searching for a matching name string. The ordinal number is
used to locate the entry point information in the entry
table.

The resident name table is kept resident in system memory
while the module is loaded. It is intended to contain the
exported entry point names that are frequently dynamicaly
linked to by name. Non-resident names are not kept in
memory and are read from the EXE file when a dynamic link
reference is made. Exported entry point names that are
infrequently dynamicaly linked to by name or are commonly
referenced by ordinal number should be placed in the
non-resident name table. The trade off made for references
by name is performance vs memory usage.

Import references by name require these tables to be
searched to obtain the entry point ordinal number. Import
references by ordinal number provide the fastest lookup
since the search of these tables is not required.

The strings are CASE SENSITIVE and are NOT NULL TERMINATED.

Each name table entry has the following format:

+-----+-----+-----+-----+ +-----+-----+-----+
00h | LEN | ASCII STRING . . . | ORDINAL # |
+-----+-----+-----+-----+ +-----+-----+-----+


LEN = DB String Length.
This defines the length of the string in bytes. A
zero length indicates there are no more entries in
table. The length of each ascii name string is
limited to 127 characters.

The high bit in the LEN field (bit 7) is defined as
an Overload bit. This bit signifies that additional
information is contained in the linear EXE module
and will be used in the future for parameter type
checking.

ASCII STRING = DB ASCII String.
This is a variable length string with it's length
defined in bytes by the LEN field. The string is
case case sensitive and is not null terminated.

ORDINAL # = DW Ordinal number.
The ordinal number in an ordered index into the
entry table for this entry point.





Entry Table


The entry table contains object and offset information that
is used to resolve fixup references to the entry points
within this module. Not all entry points in the entry table
will be exported, some entry points will only be used within
the module. An ordinal number is used to index into the
entry table. The entry table entries are numbered starting
from one.

The list of entries are compressed into 'bundles', where
possible. The entries within each bundle are all the same
size. A bundle starts with a count field which indicates
the number of entries in the bundle. The count is followed
by a type field which identifies the bundle format. This
provides both a means for saving space as well as a
mechanism for extending the bundle types.

The type field allows the definition of 256 bundle types.
The following bundle types will initially be defined:

Unused Entry.
16-bit Entry.
286 Call Gate Entry.
32-bit Entry.
Forwarder Entry.

The bundled entry table has the following format:

+-----+-----+-----+-----+-----+
00h | CNT |TYPE | BUNDLE INFO . . .
+-----+-----+-----+-----+-----+


CNT = DB Number of entries.
This is the number of entries in this bundle.

A zero value for the number of entries identifies
the end of the entry table. There is no further
bundle information when the number of entries is
zero. In other words the entry table is terminated
by a single zero byte.

TYPE = DB Bundle type.
This defines the bundle type which determines the
contents of the BUNDLE INFO.

The follow types are defined:

00h = Unused Entry.
01h = 16-bit Entry.
02h = 286 Call Gate Entry.
03h = 32-bit Entry.
04h = Forwarder Entry.
80h = Parameter Typing Information Present.
This bit signifies that additional
information is contained in the linear
EXE module and will be used in the
future for parameter type checking.


The following is the format for each bundle type:

+-----+-----+
00h | CNT |TYPE |
+-----+-----+

CNT = DB Number of entries.
This is the number of unused entries to skip.

TYPE = DB 0 (Unused Entry)

+-----+-----+-----+-----+
00h | CNT |TYPE | OBJECT |
+-----+-----+-----+-----+
04h |FLAGS| OFFSET |
+-----+-----+-----+
07h | ... | . . . |
+ + + +


CNT = DB Number of entries.
This is the number of 16-bit entries in this
bundle. The flags and offset value are repeated
this number of times.

TYPE = DB 1 (16-bit Entry)

OBJECT = DW Object number.
This is the object number for the entries in
this bundle.

FLAGS = DB Entry flags.
These are the flags for this entry point.
They have the following definition.

01h = Exported entry flag.
F8h = Parameter word count mask.

OFFSET = DW Offset in object.
This is the offset in the object for the
entry point defined at this ordinal number.


+-----+-----+-----+-----+
00h | CNT |TYPE | OBJECT |
+-----+-----+-----+-----+-----+
04h |FLAGS| OFFSET | CALLGATE |
+-----+-----+-----+-----+-----+
09h | ... | . . . | . . . |
+ + + + + +


CNT = DB Number of entries.
This is the number of 286 call gate entries in
this bundle. The flags, callgate, and offset
value are repeated this number of times.

TYPE = DB 2 (286 Call Gate Entry)
The 286 Call Gate Entry Point type is needed by
the loader only if ring 2 segments are to be
supported. 286 Call Gate entries contain 2
extra bytes which are used by the loader to
store an LDT callgate selector value.

OBJECT = DW Object number.
This is the object number for the entries in
this bundle.

FLAGS = DB Entry flags.
These are the flags for this entry point. They
have the following definition.

01h = Exported entry flag.
F8h = Parameter word count mask.

OFFSET = DW Offset in object.
This is the offset in the object for the entry
point defined at this ordinal number.

CALLGATE = DW Callgate selector.
The callgate selector is a reserved field used
by the loader to store a call gate selector
value for references to ring 2 entry points.
When a ring 3 reference to a ring 2 entry point
is made, the callgate selector with a zero
offset is place in the relocation fixup address.
The segment number and offset in segment is
placed in the LDT callgate.


+-----+-----+-----+-----+
00h | CNT |TYPE | OBJECT |
+-----+-----+-----+-----+-----+
04h |FLAGS| OFFSET |
+-----+-----+-----+-----+-----+
09h | ... | . . . |
+ + + + + +

CNT = DB Number of entries.
This is the number of 32-bit entries in this
bundle. The flags and offset value are repeated
this number of times.

TYPE = DB 3 (32-bit Entry)
The 32-bit Entry type will only be defined by
the linker when the offset in the object can not
be specified by a 16-bit offset.

OBJECT = DW Object number.
This is the object number for the entries in
this bundle.

FLAGS = DB Entry flags.
These are the flags for this entry point. They
have the following definition.

01h = Exported entry flag.
F8h = Parameter dword count mask.

OFFSET = DD Offset in object.
This is the offset in the object for the entry
point defined at this ordinal number.

+-----+-----+-----+-----+
00h | CNT |TYPE | RESERVED |
+-----+-----+-----+-----+-----+-----+-----+
04h |FLAGS| MOD ORD# | OFFSET / ORDNUM |
+-----+-----+-----+-----+-----+-----+-----+
09h | ... | ... | ... |
+ + + + + + + +

CNT = DB Number of entries.
This is the number of forwarder entries in this
bundle. The FLAGS, MOD ORD#, and OFFSET/ORDNUM
values are repeated this number of times.

TYPE = DB 4 (Forwarder Entry)

RESERVED = DW 0
This field is reserved for future use.

FLAGS = DB Forwarder flags.
These are the flags for this entry point. They
have the following definition.

01h = Import by ordinal.
F7h = Reserved for future use; should be zero.

MOD ORD# = DW Module Ordinal Number
This is the index into the Import Module Name Table
for this forwarder.

OFFSET / ORDNUM = DD Procedure Name Offset or Import
Ordinal Number
If the FLAGS field indicates import by ordinal, then
this field is the ordinal number into the Entry
Table of the target module, otherwise this field is
the offset into the Procedure Names Table of the
target module.

A Forwarder entry (type = 4) is an entry point whose value
is an imported reference. When a load time fixup occurs
whose target is a forwarder, the loader obtains the address
imported by the forwarder and uses that imported address to
resolve the fixup.

A forwarder may refer to an entry point in another module
which is itself a forwarder, so there can be a chain of
forwarders. The loader will traverse the chain until it
finds a non-forwarded entry point which terminates the chain
, and use this to resolve the original fixup. Circular
chains are detected by the loader and result in a load time
error. A maximum of 1024 forwarders is allowed in a chain;
more than this results in a load time error.

Forwarders are useful for merging and recombining API calls
into different sets of libraries, while maintaining
compatibility with applications. For example, if one wanted
to combine MONCALLS, MOUCALLS, and VIOCALLS into a single
libraries, one could provide entry points for the three
libraries that are forwarders pointing to the common
implementation.



Module Format Directives Table


The Module Format Directives Table is an optional table that
allows additional options to be specified. It also allows
for the extension of the linear EXE format by allowing
additional tables of information to be added to the linear
EXE module without affecting the format of the linear EXE
header. Likewise, module format directives provide a place
in the linear EXE module for 'temporary tables' of
information, such as incremental linking information and
statistic information gathered on the module. When there
are no module format directives for a linear EXE module, the
fields in the linear EXE header referencing the module
format directives table are zero.

Each Module Format Directive Table entry has the following
format:

+-----+-----+-----+-----+-----+-----+----+----+
00h | DIRECT # | DATA LEN | DATA OFFSET |
+-----+-----+-----+-----+-----+-----+----+----+

DIRECT # = DW Directive number.
The directive number specifies the type of directive
defined. This can be used to determine the format
of the information in the directive data. The
following directive numbers have been defined:

8000h = Resident Flag Mask.
Directive numbers with this bit set indicate
that the directive data is in the resident
area and will be kept resident in memory
when the module is loaded.

8001h = Verify Record Directive. (Verify record
is a resident table.)
0002h = Language Information Directive. (This is
a non-resident table.)
0003h = Co-Processor Required Support Table.
0004h = Thread State Initialization Directive.

Additional directives can be added as needed in the
future, as long as they do not overlap previously
defined directive numbers.

DATA LEN = DW Directive data length.
This specifies the length in byte of the directive
data for this directive number.

DIRECTIVE OFFSET = DD Directive data offset.
This is the offset to the directive data for this
directive number. It is relative to beginning of
linear EXE header for a resident table, and relative
to the beginning of the EXE file for non-resident
tables.





Verify Record Directive Table


The Verify Record Directive Table is an optional table. It
maintains a record of the pages in the EXE file that have
been fixed up and written back to the original linear EXE
module, along with the module dependencies used to perform
these fixups. This table provides an efficient means for
verifying the virtual addresses required for the fixed up
pages when the module is loaded.

Each Verify Record entry has the following format:

+-----+-----+
00h |# OF ENTRY |
+-----+-----+-----+-----+-----+-----+
02h | MOD ORD # | VERSION | MOD # OBJ |
+-----+-----+-----+-----+-----+-----+
08h | OBJECT # | BASE ADDR | VIRTUAL |
+-----+-----+-----+-----+-----+-----+
0Eh | . . . | . . . | . . . |
+ + + + + + +

# OF ENTRY = DW Number of module dependencies.
This field specifies how many entries there are in
the verify record directive table. This is equal to
the number of modules referenced by this module.

MOD ORD # = DW Ordinal index into the Import Module
Name Table.
This value is an ordered index in to the Import
Module Name Table for the referenced module.

VERSION = DW Module Version.

This is the version of the referenced module that
the fixups were originally performed. This is used
to insure the same version of the referenced module
is loaded that was fixed up in this module and
therefore the fixups are still correct. This
requires the version number in a module to be
incremented anytime the entry point offsets change.

MOD # OBJ = DW Module # of Object Entries.
This field is used to identify the number of object
verify entries that follow for the referenced
module.

OBJECT # = DW Object # in Module.
This field specifies the object number in the
referenced module that is being verified.

BASE ADDR = DW Object load base address.
This is the address that the object was loaded at
when the fixups were performed.

VIRTUAL = DW Object virtual address size.
This field specifies the total amount of virtual
memory required for this object.





Per-Page Checksum


The Per-Page Checksum table provides space for a
cryptographic checksum for each physical page in the EXE
file.

The checksum table is arranged such that the first entry in
the table corresponds to the first logical page of code/data
in the EXE file (usually a preload page) and the last entry
corresponds to the last logical page in the EXE file
(usually a iterated data page).

+-----+-----+-----+-----+
Logical Page #1 | CHECKSUM |
+-----+-----+-----+-----+
Logical Page #2 | CHECKSUM |
+-----+-----+-----+-----+
. . .

+-----+-----+-----+-----+
Logical Page #n | CHECKSUM |
+-----+-----+-----+-----+


CHECKSUM = DD Cryptographic checksum.





Fixup Page Table


The Fixup Page Table provides a simple mapping of a logical
page number to an offset into the Fixup Record Table for
that page.

This table is parallel to the Object Page Table, except that
there is one additional entry in this table to indicate the
end of the Fixup Record Table.

The format of each entry is:

+-----+-----+-----+-----+
Logical Page #1 | OFFSET FOR PAGE #1 |
+-----+-----+-----+-----+
Logical Page #2 | OFFSET FOR PAGE #2 |
+-----+-----+-----+-----+
. . .
+-----+-----+-----+-----+
Logical Page #n | OFFSET FOR PAGE #n |
+-----+-----+-----+-----+
|OFF TO END OF FIXUP REC| This is equal to:
+-----+-----+-----+-----+ Offset for page #n + Size
of fixups for page #n


OFFSET FOR PAGE # = DD Offset for fixup record for this
page.
This field specifies the offset, from the beginning
of the fixup record table, to the first fixup record
for this page.

OFF TO END OF FIXUP REC = DD Offset to the end of the
fixup records.
This field specifies the offset following the last
fixup record in the fixup record table. This is the
last entry in the fixup page table.

The fixup records are kept in order by logical page
in the fixup record table. This allows the end of
each page's fixup records is defined by the offset
for the next logical page's fixup records. This
last entry provides support of this mechanism for
the last page in the fixup page table.





Fixup Record Table


The Fixup Record Table contains entries for all fixups in
the linear EXE module. The fixup records for a logical page
are grouped together and kept in sorted order by logical
page number. The fixups for each page are further sorted
such that all external fixups and internal selector/pointer
fixups come before internal non-selector/non-pointer fixups.
This allows the loader to ignore internal fixups if the
loader is able to load all objects at the addresses
specified in the object table.

Each relocation record has the following format:

+-----+-----+-----+-----+
00h | SRC |FLAGS|SRCOFF/CNT*|
+-----+-----+-----+-----+-----+-----+
03h/04h | TARGET DATA * |
+-----+-----+-----+-----+-----+-----+
| SRCOFF1 @ | . . . | SRCOFFn @ |
+-----+-----+---- ----+-----+-----+

* These fields are variable size.
@ These fields are optional.


SRC = DB Source type.
The source type specifies the size and type of the
fixup to be performed on the fixup source. The
source type is defined as follows:

0Fh = Source mask.
00h = Byte fixup (8-bits).
01h = (undefined).
02h = 16-bit Selector fixup (16-bits).
03h = 16:16 Pointer fixup (32-bits).
04h = (undefined).
05h = 16-bit Offset fixup (16-bits).
06h = 16:32 Pointer fixup (48-bits).
07h = 32-bit Offset fixup (32-bits).
08h = 32-bit Self-relative offset fixup
(32-bits).
10h = Fixup to Alias Flag.
When the 'Fixup to Alias' Flag is set, the
source fixup refers to the 16:16 alias for
the object. This is only valid for source
types of 2, 3, and 6. For fixups such as
this, the linker and loader will be required
to perform additional checks such as
ensuring that the target offset for this
fixup is less than 64K.

20h = Source List Flag.

When the 'Source List' Flag is set, the
SRCOFF field is compressed to a byte and
contains the number of source offsets, and a
list of source offsets follows the end of
fixup record (after the optional additive
value).

FLAGS = DB Target Flags.
The target flags specify how the target information
is interpreted. The target flags are defined as
follows:

03h = Fixup target type mask.
00h = Internal reference.
01h = Imported reference by ordinal.
02h = Imported reference by name.
03h = Internal reference via entry table.
04h = Additive Fixup Flag.
When set, an additive value trails the fixup
record (before the optional source offset
list).

08h = Reserved. Must be zero.
10h = 32-bit Target Offset Flag.
When set, the target offset is 32-bits,
otherwise it is 16-bits.

20h = 32-bit Additive Fixup Flag.
When set, the additive value is 32-bits,
otherwise it is 16-bits.


40h = 16-bit Object Number/Module Ordinal Flag.
When set, the object number or module
ordinal number is 16-bits, otherwise it is
8-bits.

80h = 8-bit Ordinal Flag.
When set, the ordinal number is 8-bits,
otherwise it is 16-bits.

SRCOFF = DW/CNT = DB Source offset or source offset
list count.
This field contains either an offset or a count
depending on the Source List Flag. If the Source
List Flag is set, a list of source offsets follows
the additive field and this field contains the count
of the entries in the source offset list.
Otherwise, this is the single source offset for the
fixup. Source offsets are relative to the beginning
of the page where the fixup is to be made.

Note that for fixups that cross page boundaries, a
separate fixup record is specified for each page.
An offset is still used for the 2nd page but it now
becomes a negative offset since the fixup originated
on the preceding page. (For example, if only the
last one byte of a 32-bit address is on the page to
be fixed up, then the offset would have a value of
-3.)

TARGET DATA = Target data for fixup.
The format of the TARGET DATA is dependent upon
target flags.

SRCOFF1 - SRCOFFn = DW[] Source offset list.
This list is present if the Source List Flag is set
in the Target Flags field. The number of entries in
the source offset list is defined in the SRCOFF/CNT
field. The source offsets are relative to the
beginning of the page where the fixups are to be
made.

+-----+-----+-----+-----+
00h | SRC |FLAGS|SRCOFF/CNT*|
+-----+-----+-----+-----+-----+-----+
03h/04h | OBJECT * | TRGOFF * @ |
+-----+-----+-----+-----+-----+-----+
| SRCOFF1 @ | . . . | SRCOFFn @ |
+-----+-----+---- ----+-----+-----+

* These fields are variable size.
@ These fields are optional.


OBJECT = D[B|W] Target object number.
This field is an index into the current module's
Object Table to specify the target Object. It
is a Byte value when the '16-bit Object
Number/Module Ordinal Flag' bit in the target
flags field is clear and a Word value when the
bit is set.


TRGOFF = D[W|D] Target offset.
This field is an offset into the specified
target Object. It is not present when the
Source Type specifies a 16-bit Selector fixup.
It is a Word value when the '32-bit Target
Offset Flag' bit in the target flags field is
clear and a Dword value when the bit is set.

+-----+-----+-----+-----+
00h | SRC |FLAGS|SRCOFF/CNT*|
+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
03h/04h | MOD ORD# *| PROCEDURE NAME OFFSET*| ADDITIVE * @ |
+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
| SRCOFF1 @ | . . . | SRCOFFn @ |
+-----+-----+---- ----+-----+-----+

* These fields are variable size.
@ These fields are optional.


MOD ORD # = D[B|W] Ordinal index into the Import
Module Name Table.
This value is an ordered index in to the Import
Module Name Table for the module containing the
procedure entry point. It is a Byte value when
the '16-bit Object Number/Module Ordinal' Flag
bit in the target flags field is clear and a
Word value when the bit is set. The loader
creates a table of pointers with each pointer in
the table corresponds to the modules named in
the Import Module Name Table. This value is
used by the loader to index into this table
created by the loader to locate the referenced
module.

PROCEDURE NAME OFFSET = D[W|D] Offset into the
Import Procedure Name Table.
This field is an offset into the Import
Procedure Name Table. It is a Word value when
the '32-bit Target Offset Flag' bit in the
target flags field is clear and a Dword value
when the bit is set.

ADDITIVE = D[W|D] Additive fixup value.
This field exists in the fixup record only when
the 'Additive Fixup Flag' bit in the target
flags field is set. When the 'Additive Fixup
Flag' is clear the fixup record does not contain
this field and is immediately followed by the
next fixup record (or by the source offset list
for this fixup record).

This value is added to the address derived from
the target entry point. This field is a Word
value when the '32-bit Additive Flag' bit in the
target flags field is clear and a Dword value
when the bit is set.

+-----+-----+-----+-----+
00h | SRC |FLAGS|SRCOFF/CNT*|
+-----+-----+-----+-----+-----+-----+-----+-----+
03h/04h | MOD ORD# *|IMPORT ORD*| ADDITIVE * @ |
+-----+-----+-----+-----+-----+-----+-----+-----+
| SRCOFF1 @ | . . . | SRCOFFn @ |
+-----+-----+---- ----+-----+-----+

* These fields are variable size.
@ These fields are optional.


MOD ORD # = D[B|W] Ordinal index into the Import
Module Name Table.
This value is an ordered index in to the Import
Module Name Table for the module containing the
procedure entry point. It is a Byte value when
the '16-bit Object Number/Module Ordinal' Flag
bit in the target flags field is clear and a
Word value when the bit is set. The loader
creates a table of pointers with each pointer in
the table corresponds to the modules named in
the Import Module Name Table. This value is
used by the loader to index into this table
created by the loader to locate the referenced
module.

IMPORT ORD = D[B|W|D] Imported ordinal number.
This is the imported procedure's ordinal number.
It is a Byte value when the '8-bit Ordinal' bit
in the target flags field is set. Otherwise it
is a Word value when the '32-bit Target Offset
Flag' bit in the target flags field is clear and
a Dword value when the bit is set.

ADDITIVE = D[W|D] Additive fixup value.
This field exists in the fixup record only when
the 'Additive Fixup Flag' bit in the target
flags field is set. When the 'Additive Fixup
Flag' is clear the fixup record does not contain
this field and is immediately followed by the
next fixup record (or by the source offset list
for this fixup record).

This value is added to the address derived from
the target entry point. This field is a Word
value when the '32-bit Additive Flag' bit in the
target flags field is clear and a Dword value
when the bit is set.

+-----+-----+-----+-----+
00h | SRC |FLAGS|SRCOFF/CNT*|
+-----+-----+-----+-----+-----+-----+
03h/04h | ORD # * | ADDITIVE * @ |
+-----+-----+-----+-----+-----+-----+
| SRCOFF1 @ | . . . | SRCOFFn @ |
+-----+-----+---- ----+-----+-----+

* These fields are variable size.
@ These fields are optional.

ENTRY # = D[B|W] Ordinal index into the Entry
Table.
This field is an index into the current module's
Entry Table to specify the target Object and
offset. It is a Byte value when the '16-bit
Object Number/Module Ordinal' Flag bit in the
target flags field is clear and a Word value
when the bit is set.

ADDITIVE = D[W|D] Additive fixup value.
This field exists in the fixup record only when
the 'Additive Fixup Flag' bit in the target
flags field is set. When the 'Additive Fixup
Flag' is clear the fixup record does not contain
this field and is immediately followed by the
next fixup record (or by the source offset list
for this fixup record).

This value is added to the address derived from
the target entry point. This field is a Word
value when the '32-bit Additive Flag' bit in the
target flags field is clear and a Dword value
when the bit is set.





Import Module Name Table


The import module name table defines the module name strings
imported through dynamic link references. These strings are
referenced through the imported relocation fixups.

To determine the length of the import module name table
subtract the import module name table offset from the import
procedure name table offset. These values are located in
the linear EXE header. The end of the import module name
table is not terminated by a special character, it is
followed directly by the import procedure name table.

The strings are CASE SENSITIVE and NOT NULL TERMINATED.

Each name table entry has the following format:

+-----+-----+-----+-----+ +-----+
00h | LEN | ASCII STRING . . . |
+-----+-----+-----+-----+ +-----+

LEN = DB String Length.
This defines the length of the string in bytes. The
length of each ascii name string is limited to 127
characters.

ASCII STRING = DB ASCII String.
This is a variable length string with it's length
defined in bytes by the LEN field. The string is
case sensitive and is not null terminated.





Import Procedure Name Table


The import procedure name table defines the procedure name
strings imported by this module through dynamic link
references. These strings are referenced through the
imported relocation fixups.

To determine the length of the import procedure name table
add the fixup section size to the fixup page table offset,
this computes the offset to the end of the fixup section,
then subtract the import procedure name table offset. These
values are located in the linear EXE header. The import
procedure name table is followed by the data pages section.
Since the data pages section is aligned on a 'page size'
boundary, padded space may exist between the last import
name string and the first page in the data pages section.
If this padded space exists it will be zero filled.

The strings are CASE SENSITIVE and NOT NULL TERMINATED.

Each name table entry has the following format:

+-----+-----+-----+-----+ +-----+
00h | LEN | ASCII STRING . . . |
+-----+-----+-----+-----+ +-----+

LEN = DB String Length.
This defines the length of the string in bytes. The
length of each ascii name string is limited to 127
characters.

The high bit in the LEN field (bit 7) is defined as
an Overload bit. This bit signifies that additional
information is contained in the linear EXE module
and will be used in the future for parameter type
checking.

ASCII STRING = DB ASCII String.
This is a variable length string with it's length
defined in bytes by the LEN field. The string is
case sensitive and is not null terminated.





Preload Pages


The Preload Pages section is an optional section in the
linear EXE module that coalesces a 'preload page set' into a
contiguous section. The preload page set can be defined as
the set of first used pages in the module. The preload page
set can be specified by the application developer or can be
derived by a tool that analyzes the programs memory usage
while it is running. By grouping the preload page set
together, the preload pages can be read from the linear EXE
module with one disk read.

The structure of the preload pages is no different than if
they were demand loaded. They are non-iterated pages.
Their sizes are determined by the Object Page Table entries
that correspond. If the specified size is less than the
PAGE SIZE field given in the linear EXE module header the
remainder of the page is filled with zeros when loaded.

All pages begin on a PAGE OFFSET SHIFT boundary from the
base of the preload page section, as specified in the linear
EXE header. The pages are ordered by logical page number
within this section.

Note: OS/2 2.0 does not respect preload pages. Performance tests
showed that better system performance was obtained by not
respecting the preload request in the executable file.




Demand Load Pages


The Demand Loaded Pages section contains all the
non-iterated pages for a linear EXE module that are not
preloaded. When required, the whole page is loaded into
memory from the module. The characteristics of each of
these pages is specified in the Object Page Table. Every
page begins on a PAGE OFFSET SHIFT boundary aligned offset
from the demand loaded pages base specified in the linear
EXE header. Their sizes are determined by the Object Page
Table entries that correspond. If the specified size is
less than the PAGE SIZE field given in the linear EXE module
header the remainder of the page is filled with zeros when
loaded. The pages are ordered by logical page number within
this section.




Iterated Data Pages


The Iterated Data Pages section contains all the pages for a
linear EXE module that are iterated. When required, the set
of iteration records are loaded into memory from the module
and expanded to reconstitute the page. Every set of
iteration records begins on a PAGE OFFSET SHIFT offset from
the OBJECT ITER PAGES OFF specified in the linear EXE
header. Their sizes are determined by the Object Page Table
entries that correspond. The pages are ordered by logical
page number within this section.

This record structure is used to describe the iterated data
for an object on a per-page basis.

+-----+-----+-----+-----+
00h |#ITERATIONS|DATA LENGTH|
+-----+-----+-----+-----+-----+
04h |DATA BYTES | . . . | ... |
+-----+-----+-----+-----+-----+

Figure 19. Object Iterated Data Record (Iteration Record)

#ITERATIONS = DW Number of iterations.
This specifies the number of times that the data is
replicated.

DATA LENGTH = DW The size of the data pattern in bytes.
This specifies the number of bytes of data of which
the pattern consists. The maximum size is one half
of the PAGE SIZE (given in the module header). If a
pattern exceeds this value then the data page will
not be condensed into iterated data.

DATA = DB * DATA LENGTH The Data pattern to be
replicated.
The next iteration record will immediately follow
the last byte of the pattern. The offset of the
next iteration record is easily calculated from the
offset of this record by adding the DATA LENGTH
field and the sizes of the #ITERATIONS and DATA
LENGTH fields.





Debug Information


The debug information is defined by the debugger and is
not controlled by the linear EXE format or linker. The only
data defined by the linear EXE format relative to the debug
information is it's offset in the EXE file and length in
bytes as defined in the linear EXE header.

To support multiple debuggers the first word of the debug
information is a type field which determines the format of
the debug information.

00h 01h 02h 03h 04h
+-----+-----+-----+-----+-----+-----+-----+-----+
| 'N' | 'B' | '0' | n | DEBUGGER DATA . . . .
+-----+-----+-----+-----+-----+-----+-----+-----+


TYPE = DB DUP 4 Format type.
This defines the type of debugger data that exists
in the remainder of the debug information. The
signature consists of a string of four (4) ASCII
characters: "NB0" followed by the ASCII
representation for 'n'. The values for 'n' are
defined as follows.

These format types are defined.

00h = 32-bit CodeView debugger format.
01h = AIX debugger format.
02h = 16-bit CodeView debugger format.
04h = 32-bit OS/2 PM debugger (IBM) format.

DEBUGGER DATA = Debugger specific data.
The format of the debugger data is defined by the
debugger that is being used.

The values defined for the type field are not
enforced by the system. It is the responsibility
of the linker or debugging tools to follow the
convention for the type field that is defined here.


 December 13, 2017  Add comments

Leave a Reply