/*****************************   omf.h   *************************************
* Author:        Agner Fog
* Date created:  2007-01-29
* Last modified: 2007-01-29
* Project:       objconv
* Module:        omf.h
* Description:
* Header file for definition of data structures and constants in OMF object 
* file format. Also defines class COMFFileBuilder.
*
* Copyright 2006-2008 GNU General Public License http://www.gnu.org/licenses
******************************************************************************
*
* An OMF file consists of a chain of records which all have the same basic
* structure: 
* 1. One byte describing the type of record
* 2. A 16-bit word indicating the length of the rest of the record
* 3. Data of variable types and sizes (max 1024 bytes)
* 4. One byte for checksum. Some systems just set this byte to 0
*
* The OMF format is designed for compactness. All integers of type "index"
* are represented by one byte if no bigger than 127, or by two bytes if
* 128 or more. The most significant bit of the first byte indicates whether
* there are one or two bytes. Integers indicating a segment offset are 16
* bits if the type byte is even, or 32 bits if the type byte is odd.
* Some fields can be left out if they are zero or repeated. The precense
* or absense of a particular field may depend on certain bits in the preceding
* fields. The records cannot be defined as C++ structures because a field
* with variable size or a field that can be absent makes the position of the
* subsequent fields variable.
*
* For these reasons, you will not find any structures defining OMF records
* in this header file. Only the bitfields that are used are defined here. 
* Instead, I have defined the member functions of SOMFRecordPointer for 
* reading fields of various types occurring in OMF records, and the member
* functions of COMFFileBuilder for writing these fields. The structure of 
* an OMF record is simply defined by calling these functions in the right 
* order.
*
* The size of the data field is limited to 1024 bytes because records of type
* FIXUPP have only 10 bits for indexing into the data field of a preceding
* record of type LEDATA or LIDATA. Most tools (but not all!) limit the size
* of all types of records to 1024 bytes of data, although this limitation
* is technically necessary only for LEDATA and LIDATA records. A segment 
* bigger than one kilobyte must be split into several LEDATA records. Each
* LEDATA record is followed by a FIXUPP record if it has relocations.
*
* Symbol names and other text strings are stored with one byte indicating the
* length of the string followed by an ASCII string without terminating zero.
* Consequently, the length of all symbol names is limited to 255 characters.
*
*****************************************************************************/

#ifndef OMF_H
#define OMF_H

//********************** Record types **********************

#define OMF_THEADR   0x80  // Translator Header Record
#define OMF_LHEADR   0x82  // Library Module Header Record
#define OMF_COMENT   0x88  // Comment Record (Including all comment class extensions)
#define OMF_MODEND   0x8A  // (0x8B) Module End Record
#define OMF_EXTDEF   0x8C  // External Names Definition Record
#define OMF_PUBDEF   0x90  // (0x91) Public Names Definition Record
#define OMF_LINNUM   0x94  // (0x95) Line Numbers Record
#define OMF_LNAMES   0x96  // List of Names Record
#define OMF_SEGDEF   0x98  // (0x99) Segment Definition Record
#define OMF_GRPDEF   0x9A  // Group Definition Record
#define OMF_FIXUPP   0x9C  // (0x9D) Fixup Record
#define OMF_LEDATA   0xA0  // (0xA1) Logical Enumerated Data Record
#define OMF_LIDATA   0xA2  // (0xA3) Logical Iterated Data Record
#define OMF_COMDEF   0xB0  // Communal Names Definition Record
#define OMF_BAKPAT   0xB2  // (0xB3) Backpatch Record
#define OMF_LEXTDEF  0xB4  // Local External Names Definition Record
#define OMF_LPUBDEF  0xB6  // (0xB7) Local Public Names Definition Record
#define OMF_LCOMDEF  0xB8  // Local Communal Names Definition Record
#define OMF_CEXTDEF  0xBC  // COMDAT External Names Definition Record
#define OMF_COMDAT   0xC2  // (0xC3) Initialized Communal Data Record
#define OMF_LINSYM   0xC4  // (0xC5) Symbol Line Numbers Record
#define OMF_ALIAS    0xC6  // Alias Definition Record
#define OMF_NBKPAT   0xC8  // (0xC9) Named Backpatch Record
#define OMF_LLNAMES  0xCA  // Local Logical Names Definition Record
#define OMF_VERNUM   0xCC  // OMF Version Number Record
#define OMF_VENDEXT  0xCE  // Vendor-specific OMF Extension Record
#define OMF_LIBHEAD  0xF0  // Library Header Record
#define OMF_LIBEND   0xF1  // Library End Record
#define OMF_LIBEXT   0xF2  // Library extended dictionary


/********************** Relocation types **********************/

#define OMF_Fixup_8bit         0  // 8 bit or low byte of 16 bits
#define OMF_Fixup_16bit        1  // 16 bit offset
#define OMF_Fixup_Segment      2  // 16 bit segment selector
#define OMF_Fixup_Far          3  // 16 bit offset + 16 big segment
#define OMF_Fixup_Hi8bit       4  // High 8 bits of 16 bit offset
#define OMF_Fixup_16bitLoader  5  // 16 bit, loader resolved
#define OMF_Fixup_Pharlab48    6  // 32 bit offset + 16 bit segment, Pharlab only
#define OMF_Fixup_32bit        9  // 32 bit offset
#define OMF_Fixup_Farword     11  // 32 bit offset + 16 bit segment
#define OMF_Fixup_32bitLoader 13  // 32 bit, loader resolved

// Define fixed indexes in LNAMES for default group and class names
#define OMF_LNAME_FLAT         1  // Default group name 
#define OMF_LNAME_CODE         2  // Default class for code
#define OMF_LNAME_DATA         3  // Default class for data
#define OMF_LNAME_BSS          4  // Default class for uninitialized data
#define OMF_LNAME_CONST        5  // Default class for constant data
#define OMF_LNAME_LAST         5  // Last default name. Nondefault names start at OMF_LNAME_LAST + 1
                                  // Class name STACK not used


// Define bitfield structures used in OMF records

union OMF_SAttrib { // Structure of attributes in SEGDEF record
   uint8 b;                            // Byte
   struct {
      uint8 P:1,                       // 0: 16 bit, 1: 32 bit
            B:1,                       // Big
            C:3,                       // Combination (private, public, stack, common)
            A:3;                       // Alignment
   } u;
};

union OMF_SLocat { // Structure of first two bytes of FIXUP subrecord swapped = Locat field
   uint8 bytes[2];                     // First two bytes swapped
   struct {
      uint16 Offset:10,                // Offset into LEDATA (or LIDATA)
             Location:4,               // Relocation method
             M:1,                      // 0 = self-relative, 1 = direct
             one:1;                    // 1 = FIXUP subrecord, 0 = THREAD subrecord
   } s;
};

union OMF_SFixData { // Structure of FixData field in FIXUP subrecord of FIXUPP record
   uint8 b;                            // Byte
   struct {
      uint8  Target:2,                 // Target method (T=0) or target thread number (T=1)
             P:1,                      // 0 = target displacement field present, 1 = displacement is zero
             T:1,                      // 0 = target field present, 1 = target defined by thread
             Frame:3,                  // Frame method (F=0) or frame thread (F=1)
             F:1;                      // 0 = target frame field present, 1 = frame defined by thread
   } s;
};

union OMF_STrdDat { // Structure of Thread Data field in THREAD subrecord of FIXUPP record
   uint8 b;                            // Byte
   struct {
      uint8  Thread:2,                 // Thread number
             Method:3,                 // Method (T0 - T3, F0 - F6)
             Unused:1,                 // 0
             D:1,                      // 0 = Target thread, 1 = Frame thread
             Zero:1;                   // 1 = FIXUP subrecord, 0 = THREAD subrecord
   } s;
};


// Structure of OMF record pointer
struct SOMFRecordPointer {
public:
   uint8  Type;            // Record type
   uint8  Type2;           // Record type, made even
   uint16 Unused;          // Align
   uint32 FileOffset;      // Position in file
   uint32 FileEnd;         // End of file = file size
   uint32 Index;           // Offset to current byte while parsing from start of record
   uint32 End;             // Offset to checksum byte from start of record
   int8 * buffer;          // Pointer to file buffer
   uint8  GetByte();       // Read next byte from buffer
   uint16 GetWord();       // Read next 16 bit word from buffer
   uint32 GetDword();      // Read next 32 bit dword from buffer
   uint32 GetIndex();      // Read byte or word, depending on sign of first byte
   uint32 GetNumeric();    // Read word or dword, depending on record type even or odd
   uint32 GetLength();     // Read 1, 2, 3 or 4 bytes, depending on value of first byte
   char * GetString();     // Read string and return as ASCIIZ string
   void   Start(int8 * Buffer, uint32 FileOffset, uint32 FileEnd); // Start scanning through records
   uint8  GetNext(uint32 align = 0);// Get next record
   uint32 InterpretLIDATABlock(); // Interpret Data block in LIDATA record recursively
   uint32 UnpackLIDATABlock(int8 * destination, uint32 MaxSize); // Unpack Data block in LIDATA record recursively and store data at destination
};


// Class for building OMF files
class COMFFileBuilder : public CFileBuffer {
public:
   COMFFileBuilder();                  // Constructor
   void StartRecord(uint8 type);       // Start building new record
   void EndRecord();                   // Finish building current record
   void PutByte(uint8);                // Put byte into buffer
   void PutWord(uint16);               // Put 16 bit word into buffer
   void PutDword(uint32);              // Put 32 bit dword into buffer
   void PutIndex(uint32);              // Put byte or word into buffer (word if > 127)
   void PutNumeric(uint32);            // Put word or dword into buffer, depending on type being even or odd
   void PutString(const char *);       // Put ASCII string into buffer, preceded by size
   void PutBinary(void *, uint32);     // Put binary data of any length
   uint32 GetSize();                   // Get size of data added so far to current record
protected:
   uint8  Type;                        // Record type
   uint32 Index;                       // Index to current offset
   uint32 RecordStart;                 // Index to start of current record
};


// Structure for temporary segment list used while building OMF file
struct SOMFSegmentList {
public:
   uint32 NewNumber;                   // Segment index in new file
   uint32 OldName;                     // Segment name in old file as index into NameBuffer
   uint32 NewName;                     // Segment name in new file as index into NameBuffer
   uint32 NewNameI;                    // Segment name in new file as index into LNAMES record. Zero for subsequent entries with same segment name
   SCOFF_SectionHeader * psechdr;      // Pointer to old section header
   uint32 Align;                       // Alignment = 2^Align
   uint32 Class;                       // Class in new file
   uint32 Offset;                      // Offset of section in old file to first section with same name
   uint32 Size;                        // Size of section. First record has combined size of all sections with same name
   uint32 SegmentSize;                 // Size of segment = combined size of all sections with same name. Stored only in first section of segment
};


// Structure for temporary symbol list used while building OMF file
struct SOMFSymbolList {
public:
   uint32 Scope;                       // 0 = local, 1 = public, 2 = external
   uint32 NewIndex;                    // PUBDEF index if Scope = 1, EXTDEF index if scope = 2
   uint32 Segment;                     // New segment index
   uint32 Offset;                      // Offset relative to segment = first section with same name
   uint32 Name;                        // Symbol name in new file as index into NameBuffer
};


// Structure for temporary relocation (fixup) list used while building OMF file
struct SOMFRelocation {
public:
   uint32 Section;                     // Section number in old file
   uint32 SourceOffset;                // Offset of source relative to section
   int32  Mode;                        // 0 = EIP-relative, 1 = direct, -1 = unsupported
   uint32 Scope;                       // 0 = local, 2 = external
   uint32 TargetSegment;               // Segment index or EXTDEF index of target in new file 
   uint32 TargetOffset;                // Offset relative to segment in new file of target
   int operator < (SOMFRelocation const & x) const {// operator < for sorting by CSList::Sort()
      return Section < x.Section || (Section == x.Section && SourceOffset < x.SourceOffset);
   }
};

// Structure for assigning names to unnamed local symbols while converting OMF file
struct SOMFLocalSymbol {
   uint32 Offset;                      // Offset into segment
   uint32 Segment;                     // Segment number in old file
   uint32 Name;                        // Assigned name as index into new string table
   uint32 NewSymtabIndex;              // Index into new symbol table
   // Operator < needed for sorting table of SOMFLocalSymbol:
   int operator < (const SOMFLocalSymbol & b) const {
      return Segment < b.Segment || (Segment == b.Segment && Offset < b.Offset);
   }
};

// Structure for interpreted SEGDEF record used during disassembly
struct SOMFSegment {
   uint32 NameO;                       // Segment name, as offset into NameBuffer
   uint32 Offset;                      // Segment address
   uint32 Size;                        // Segment size
   uint32 Align;                       // Alignment = 1 << Align
   uint32 Type;                        // Segment type (as defined in disasm.h)
   uint32 WordSize;                    // 16 or 32 bits
   uint32 BufOffset;                   // Offset of raw data into SegmentData buffer
   uint32 NameIndex;                   // Name index, used for COMDAT segment only
};

#endif // #ifndef OMF_H
