 
           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. 
