How Old Is OMF?

The Object Module Format (OMF), used by most DOS development tools, and eventually displaced by COFF/ELF in the 32-bit world, is quite old. It is a somewhat strange format because of its age, and it is quite complex, both because it was designed for the segmented 8086 architecture and because it evolved over many years.

The LINK.EXE linker supplied with DOS 1.0 (1981) used OMF as the input format and Microsoft’s development tools (MASM, Pascal, etc.) produced it. Just about all major 16-bit 8086 compilers use OMF by default. OMF must be at least as old as DOS then.

Wikipedia claims that OMF “was originally developed by Intel in 1981” and bases the claim on the fact that Intel published an 8086 OMF specification in 1981. Anyone actually reading that specification will wonder why a specification supposedly developed in 1981 and published that year is already at version 4.0.

The answer is of course that OMF is several years older than that and was likely developed closer to the mid-1970s than to 1981.

First of all, OMF was clearly not developed for the 8086; it was developed for the 8080/85 first, and adapted for the 8086. That is why the 8080 OMF records have numbers starting with zero and 8086 records have numbers starting with 80h. In 1981, an 8080/85 version of the OMF specification was released alongside the 8086 one.

It is probably true that OMF was not publicly documented before 1981 because until then, only Intel’s development tools used it. In other words, there was not much point in understanding the details of the file format when only Intel’s own tools produced and consumed it.

Except when there was: OMF was not used just for object files that only exist at an intermediate stage of the development process. It was also used for relocated “absolute” object modules meant to be burned into a PROM and so on.

For example this Intel document from 1977 describes the “8080 Absolute Object File Format” which is obviously a subset of OMF. The document number is 9800183B, suggesting that it’s not the first revision of the document. This document shows that OMF is not only older than 1981 but also older than the 8086 (1978). On page 4, the document explicitly mentions that the same format is also used for relocatable modules and tools working with absolute code must reject such modules.

None of this is news for readers of this blog. The use of OMF by Intel’s late 1970s tools was mentioned before. It can be shown that Intel’s pre-1980 development tools produce OMF files that can be understood by much newer tools without any real trouble.

Pinning down exactly how old OMF is may unfortunately be impossible. Not enough tools and documentation have survived. For actual surviving tools it is easy to verify whether they produce OMF (like ASM86 V2.0) or not, but dating the tools is problematic because ISIS-II (the most likely host OS for those tools) had no timestamps on disk files. ASM86 V2.0 is most likely from 1979, given that it includes 1979 copyright messages but not 1980 ones. Which conclusively proves that not only is OMF older than 1981 but so is 8086-specific OMF. It should be safe to assume that the missing ASM86 V1.0 (likely from 1978) also used OMF.

Even where old Intel tool documentation survived, it is often not clear whether the tools produced OMF object files or not, since the format was effectively internal to those tools and therefore Intel wasn’t particularly motivated to document it.

Chances are that OMF was used with the initial batch of Intel development tools for the 8085, which was likely released in 1976. So far, we have the aforementioned 1977 document clearly showing OMF usage; OMF is very likely a year or two older than that, having been conceived at some point within the first ten years of Intel’s history.

This entry was posted in Development, Intel, Microsoft, PC history, x86. Bookmark the permalink.

8 Responses to How Old Is OMF?

  1. Viktor Ostashevskyi says:

    here is an interesting stament here about origins of OMF:

    A good friend of mine, Bruce, got the job of developing the Object
    Module Format (OMF) for the 8080, and the upcoming 8086. This piece of
    work would live on for years, since MS-DOS used it with little or no
    modifications as the EXE format. It was a good piece of work and it was
    updated in 1985 to support the 80386 32-bit flat address mode. It
    probably was updated again when the 64-bit architecture came along, but
    I wasn’t in the loop at the time.

    It looks like OMF was created for ISIS-II

  2. Michal Necasek says:

    There is one obvious inaccuracy — OMF is certainly not used as the DOS executable format, and never was. But the linker shipped with DOS (LINK.EXE) always used OMF modules as input. OMF was (to the best of my knowledge) never extended to support the 64-bit AMD64 architecture, although it’s not fundamentally impossible. For 16-bit x86 development there never really was anything better than OMF because OMF was designed explicitly for the 8086 architecture and can express everything an x86 assembler or compiler needs.

    Anyway thanks for finding the write-up. It’s not 100% clear in answering the question when OMF was developed, but it must have been before 1977 (when the author left Intel). If the anecdote about cigarette smoking and floppies can be taken literally when it says “this is 1975”, and it is quite possible given the chronology, then OMF was indeed developed around 1975.

  3. Viktor Ostashevskyi says:

    Sure, there are some inaccuracies. But we can get two interesting pieces of information from that interview.

    First one is about the author – Bruce (Schafer?).

    Second once is that OMF for 8086 wasn’t created as upgrade for existing OMF for 8080, but rather both format were created simultaneously in order to be similar and cover both CPUs.

  4. Michal Necasek says:

    The 8080/85 and 8086 parts of OMF are independent enough that they could have been designed together or not. It is clear that 8080 OMF was out in the field before the 8086 was released, although that doesn’t really prove either way whether 8086 OMF was an add-on or designed from the start.

    If you’re right and the Bruce who developed OMF was Bruce Schafer then we have another data point here. The article reprint on page 140 in the PDF says that “Schafer joined Intel in 1976”. Since we know that OMF was out there in 1977, it would mean OMF had to be developed in the 1976-1977 time frame, roughly Winter 1976/77. Actually Bruce Schafer’s Facebook page (not hard to find) says he joined Intel in July 1976, obviously right after graduating from college.

    I suppose now the question is if that’s the right Bruce; the move to Oregon would match, though Intel had thousands of employees in 1976 and there must have been more than a few Bruces. Then again the software development group seems to have been quite small.

  5. Michal Necasek says:

    By the way, wrong Bruce (checked with Bruce Schafer). Trying to track down the right one.

  6. Michal Necasek says:

    So what I found out so far was that the 8086 variant of OMF (aka OMF-86) was in fact added later, and it was done by a team different from the people who created the original OMF-80 design.

  7. vbdasc says:

    > It is probably true that OMF was not publicly documented before 1981 because until then, only Intel’s development tools used it.

    I’m curious then, what was the object module format used by Microsoft’s, DR’s and maybe others’ linkers for the 8080/8085/Z80?

  8. Michal Necasek says:

    DRI and Microsoft used a different format for relocatable object modules:

Leave a Reply

Your email address will not be published. Required fields are marked *

This site uses Akismet to reduce spam. Learn how your comment data is processed.