Assembler Programming : .COM and .EXE Program Structures

There are two basic forms of executable programs in MS-DOS: the .COM format and the .EXE format. High level languages hide these differences from the programmer and (except for languages like C where the "memory model" selection can affect the format) generate code in only one format (normally the .EXE format). When programming in low level assembler, however, these differences have a major impact on the source code that needs to be written; it therefore becomes critical to understand the differences between these two forms.

The Program Segment Prefix (PSP)

- Predecessor of MS-DOS: in order to provide for the availability of an application software base, MS-DOS was designed to enable the execution of CP/M programs with little or no modifications.
- CP/M based on the 8008 processor with a 16-bit addressable memory.
- The first 100(hex.)/256(dec.) bytes of memory formed a "resident" portion of the Operating System; application programs started in memory at address 100(hex.)
- Standard application program termination was by "jumping" to address 0, the beginning of the Operating System.
- 100(hex) / 256(dec) bytes
- INT 20h - at offset addresses 0 and 1; an MS-DOS service call to terminate the current (.COM-style) program
- formatted data area - offsets 2 to 7F; includes, for example, a formatted version of up to 2 file paths that were entered on the same line as the command used to run the program
- length of "command tail" - offset 80h - number of characters typed on the same line as the command used to run this program, following the actual command.
- command tail - ASCII codes of actual characters typed after the command used to run this program (terminated with a "carriage return" code); this makes argument values (typically file paths) available to programs during execution.
- DS and ES segment registers initially point to a PSP for every program run under MS-DOS.

.COM-Style Programs

- All segment registers initialized to point to PSP when program is initially dispatched
- Note that this causes a warning message when "linking" your "assembler" mnemonic programs with the standard LINK program (to be discussed later); since the standard LINK program assumes that you should have a separate segment for the stack (as a minimum).
- IP set to 0100h for initial dispatch
- .COM-style programs must have their initial instructions at this location
- Note that the system supplied PSP takes up the first 100h bytes, so that no portion of the program may precede this address.
- An ORG 100h pseudo-mnemonic instruction is required to force the initial instructions to be treated as occurring at offset 100h
- stack is constructed backwards (towards the program code and data) starting from the last even address within the (single) program segment.
- if the program and data are quite large (within the 64K-byte segment), problems may occur is the stack fills up overtop of instructions or data
- .COM programs must be loaded to run within the first Megabyte of memory.
- .COM program addresses are not "memory range" checked and .COM programs can access and modify any (RAM) portion of the first Megabyte of memory (including the Operating System and its tables.

MASM Source for .COM-Style Programs

Reserved words are displayed in capital letters in the following "code skeleton".
Semicolons (;) make the beginning of comments.

; sample.asm
; author: j.e.snaird
; date written: 3 november 1997
; function: demonstration of .com code skeleton
program SEGMENT
        ASSUME CS:program,DS:program
        ORG    100h
start:         ;instruction mnemonics start here
        INT    20h ;program termination
                   ;alternately MOV AH,00 then INT 21h
                   ;or MOV AH,4Ch, MOV AL,00, INT 21h
                   ;The INT 20h version is only valid for .COM programs
;---typically some data items would then be defined
a_number DW    ?   ;uninitialized word
a_char   DB    ?   ;uninitialized byte
message  DB    "life in the fast lane.$"  ;initialized string of bytes
program  ENDS
         END   start

Each segment (in the case of a .COM-style program there is only one) begins with a SEGMENT statement and ends with an ENDS statement; both statements must have the same label.
We must tell the Assembler that it is safe to "assume" that when the program starts execution, both the CS and DS segment registers will point to this segment.
In order to allow space for the PSP within this segment area, the first instruction must be assembled to be loaded at (an "origin" of) 100h.
The first instruction must be labelled; this label must appear as a referncec on the very last statement of the program, the END statement.
Labels on instructions must end with a colon (:); labels on declarations, for example data declarations (DB and DW) or segment declarations (SEGMENT) must not end with a colon. Label references never end in a colon.

.EXE-Style Programs

- DS and ES registers initially point to the PSP. Program code is required to modify their contents to point to program data segments (after any command tail processing has been done).
- CS initially points to the first segment containing instructions within the program code.
- SS initially points to the first "stack" segment within the program code. At least one segment should be identified (with the STACK option) as being a data area for the stack.
- Execution normally starts with the IP set to 0000, at the first instruction of the (first) code segment. However, the actual offset is determined by a label reference on the END statement which marks the end of the source program.
- The SP register is set to the length of the supplied "stack" segment.
- In rare cases, there may be several "stack" segments. In such cases, all segments with the STACK option are combined into a single stack and the SP is set to the total length of this combined segment.

MASM Source for .EXE-Style Programs

Typical Code "Skeleton"

; exepgm.asm
; author: j.e.snaird
; date written: 3 november 1997
; purpose: demonstrate sample .exe source code structure

dseg   SEGMENT
some_val  DW 0
another   DB "A"
two_lines DB "3 blind pigs",0Dh,0Ah,"See how they run",0Dh,0Ah,"$"
dseg    ENDS

cseg    SEGMENT
        ASSUME CS:cseg
begin:  MOV    AX,SEGMENT dseg ;reset DS to point to data segment
        MOV    DS,AX
        ASSUME DS:dseg   ;now safe for program to assume DS points here
        ;-----
        ;-- other code --
        MOV    AH,4Ch    ;terminate with return code option value
        MOV    AL,00h    ;return code of zero
        INT    21h
cseg    ENDS

sseg    SEGMENT STACK
        DW   256 DUP (?) ;256 copies ("duplicates") of uninitialized word
                         ;  for use as "stack"
                         ;this should be adequate if program does not make
                         ;  explicit use of the stack
        ENDS

        END   begin

Assembler Programming : .COM and .EXE Program Structures

The Program Segment Prefix (PSP)

CP/M Operating System Compatibility

PSP structure

PSP access

.COM-Style Programs

Single 64K-byte Segment

Execution Always Begins At Offset 100h

Stack Pointer Initialized to FFFEh

Real Mode Execution Only

MASM Source for .COM-Style Programs

.EXE-Style Programs

Multiple Segments

Initial Execution Offset

Initial Stack Pointer

MASM Source for .EXE-Style Programs

Typical Code "Skeleton"