coff_example.c

// I tried not doing anything too non-portable so it should be possible to run
// this on Mac or Linux... probably... even then, you can't use the obj files there
//
// once you have the obj file you should be able to do:
//     link YOUROBJ.obj /defaultlib:libcmt
//                      ^^^^^^^^^^^^^^^^^^
//                      linking against crt
#define _CRT_SECURE_NO_WARNINGS
#include <stdint.h>
#include <stdlib.h>
#include <stdio.h>
#include <time.h>

#define STB_DS_IMPLEMENTATION
#include "stb_ds.h"
#define DynArray(T) T*

// IMAGE_SCN_CNT_CODE | IMAGE_SCN_MEM_EXECUTE | IMAGE_SCN_MEM_READ | IMAGE_SCN_ALIGN_16BYTES
#define COFF_CHARACTERISTICS_TEXT 0x60500020u
// IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_WRITE | IMAGE_SCN_MEM_READ
#define COFF_CHARACTERISTICS_DATA 0xC0000040u
// IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ
#define COFF_CHARACTERISTICS_RODATA 0x40000040u
// IMAGE_SCN_CNT_UNINITIALIZED_DATA | IMAGE_SCN_MEM_WRITE | IMAGE_SCN_MEM_READ | IMAGE_SCN_ALIGN_16BYTES
#define COFF_CHARACTERISTICS_BSS 0xC0500080u
// IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_ALIGN_8BYTES | IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_DISCARDABLE
#define COFF_CHARACTERISTICS_CV 0x42100040u

#define IMAGE_SYM_CLASS_EXTERNAL      0x0002
#define IMAGE_SYM_CLASS_STATIC        0x0003
#define IMAGE_SYM_CLASS_LABEL         0x0006
#define IMAGE_SYM_CLASS_FILE          0x0067

#define IMAGE_FILE_LINE_NUMS_STRIPPED 0x0004

#define IMAGE_REL_AMD64_ADDR64        0x0001
#define IMAGE_REL_AMD64_ADDR32        0x0002
#define IMAGE_REL_AMD64_ADDR32NB      0x0003
#define IMAGE_REL_AMD64_REL32         0x0004
#define IMAGE_REL_AMD64_SECTION       0x000A
#define IMAGE_REL_AMD64_SECREL        0x000B

#define MD5_HASHBYTES 16

typedef struct COFF_SectionHeader {
    char name[8];
    union {
        uint32_t physical_address;
        uint32_t virtual_size;
    } misc;
    uint32_t  virtual_address;
    uint32_t  raw_data_size;
    uint32_t  raw_data_pos;
    uint32_t  pointer_to_reloc;
    uint32_t  pointer_to_lineno;
    uint16_t  num_reloc;
    uint16_t  num_lineno;
    uint32_t  characteristics;
} COFF_SectionHeader;
static_assert(sizeof(COFF_SectionHeader) == 40, "COFF Section header size != 40 bytes");

typedef struct COFF_FileHeader {
    uint16_t machine;
    uint16_t num_sections;
    uint32_t timestamp;
    uint32_t symbol_table;
    uint32_t symbol_count;
    uint16_t optional_header_size;
    uint16_t characteristics;
} COFF_FileHeader;
static_assert(sizeof(COFF_FileHeader) == 20, "COFF File header size != 20 bytes");

// NOTE: Symbols, relocations, and line numbers are 2 byte packed
#pragma pack(push,2)
typedef struct COFF_ImageReloc {
    union {
        uint32_t VirtualAddress;
        uint32_t RelocCount;
    };
    uint32_t SymbolTableIndex;
    uint16_t Type;
} COFF_ImageReloc;
static_assert(sizeof(COFF_ImageReloc) == 10, "COFF Image Relocation size != 10 bytes");

typedef struct COFF_Symbol {
    union {
        uint8_t short_name[8];
        uint32_t long_name[2];
    };
    uint32_t value;
    int16_t section_number;
    uint16_t type;
    uint8_t storage_class;
    uint8_t aux_symbols_count;
} COFF_Symbol;
static_assert(sizeof(COFF_Symbol) == 18, "COFF Symbol size != 18 bytes");

typedef struct COFF_AuxSectionSymbol {
    uint32_t length;         // section length
    uint16_t reloc_count;    // number of relocation entries
    uint16_t lineno_count;   // number of line numbers
    uint32_t checksum;       // checksum for communal
    int16_t number;          // section number to associate with
    uint8_t selection;       // communal selection type
    uint8_t reserved;
    int16_t high_bits;       // high bits of the section number
} COFF_AuxSectionSymbol;
static_assert(sizeof(COFF_AuxSectionSymbol) == 18, "COFF Aux Section Symbol size != 18 bytes");
#pragma pack(pop)

enum {
    COFF_MACHINE_AMD64 = 0x8664,  // AMD64 (K8)
    COFF_MACHINE_ARM64 = 0xAA64,  // ARM64 Little-Endian
};

typedef int SymbolTableIndex;

typedef struct {
    const char* name;
    uint32_t characteristics;

    uint32_t relocation_pos;
    DynArray(COFF_ImageReloc) relocations;

    uint32_t raw_data_pos;
    uint32_t raw_data_size;
    const uint8_t* raw_data;
} Section;

typedef struct {
    const char* name;

    uint32_t value;
    uint32_t section_num;

    uint32_t storage_class;
} Symbol;

static DynArray(Symbol)  symbols;
static DynArray(Section) section_headers;

static void add_reloc(Section* s, const COFF_ImageReloc rel) {
    arrput(s->relocations, rel);
}

static void add_symbol(const Symbol sym) {
    arrput(symbols, sym);
}

// this small .text has some simple relocations to compile an extended
// hello world program
static SymbolTableIndex generate_text_section(int rdata_section_num, int normal_symbol_base) {
    static const uint8_t contents[] = {
        0x48, 0x8D, 0x0D, 0x05, 0x00, 0x00, 0x00, // lea rcx, [.rdata + 5]
        0xBA, 0x2A, 0x00, 0x00, 0x00,             // mov rdx, 42
        0xE9, 0x00, 0x00, 0x00, 0x00,             // jmp printf
    };

    Section s = {
        .name = ".text",
        .characteristics = COFF_CHARACTERISTICS_TEXT,

        .raw_data = contents,
        .raw_data_size = sizeof(contents)
    };

    // Apply a relocation to the Hello string
    add_reloc(&s, (COFF_ImageReloc){
            .Type             = IMAGE_REL_AMD64_REL32,
            .SymbolTableIndex = rdata_section_num,

            // This refers to the spot within the text section that
            // the relocation will happen to, relocations add onto
            // the value that's already there
            .VirtualAddress   = 3
        });

    add_reloc(&s, (COFF_ImageReloc){
            .Type             = IMAGE_REL_AMD64_REL32,

            // we're referring to the printf external symbol
            .SymbolTableIndex = normal_symbol_base+1,

            // this is the CALL instruction's rip relative address
            .VirtualAddress   = 13
        });

    arrput(section_headers, s);

    // it's zero based and there's two symbols per section
    SymbolTableIndex text_section = (arrlen(section_headers)-1)*2;
    // there's a distinction between symbol table indices and
    // section numbers, i explain the section headers in the symbol
    // output code at the bottom
    int text_section_num = arrlen(section_headers);

    // this is symbol normal_symbol_base+0
    add_symbol((Symbol) {
            .name = "main",

            // the value means the byte offset at which the
            // function is found in the text section
            .value = 0,
            .section_num = text_section_num,

            // the external storage means it's visible beyond this TU
            .storage_class  = IMAGE_SYM_CLASS_EXTERNAL
        });

    // this is symbol normal_symbol_base+1
    add_symbol((Symbol) {
            .name = "printf",

            // this symbol is importing something that's defined
            // elsewhere, section_number = 0 means it's not bound
            // to any section here
            .value = 0,
            .section_num = 0,

            // the external storage means it's visible beyond this TU
            .storage_class  = IMAGE_SYM_CLASS_EXTERNAL
        });

    return text_section;
}

static SymbolTableIndex generate_rdata_section() {
    // we put some extra bytes at the start so we can show
    // what relocations look like offseted a bit
    static const uint8_t contents[] = "_x_x_Hello, Agent %d!";

    Section s = {
        .name = ".rdata",
        .characteristics = COFF_CHARACTERISTICS_RODATA,

        .raw_data = contents,
        .raw_data_size = sizeof(contents)
    };
    arrput(section_headers, s);

    // it's zero based and there's two symbols per section
    return (arrlen(section_headers)-1)*2;
}

int main(int argc, char** argv) {
    if (argc < 2) {
        printf("Expected output path for .obj file\n");
        return 1;
    }

    FILE* file = fopen(argv[1], "wb");
    if (!file) {
        printf("Could not open '%s' for writing\n", argv[1]);
        return 1;
    }

    // Assemble some machine code and data
    int normal_symbol_base = 4;

    int rdata_section_num = generate_rdata_section();
    int text_section_num  = generate_text_section(rdata_section_num, normal_symbol_base);

    // Convert our abstraction over COFF into file contents
    size_t section_count = arrlen(section_headers);

    // normal symbols like functions and imports start right after our section symbols
    // i dont think this is necessarily a rule more like a convention
    assert(section_count * 2 == normal_symbol_base);

    // The file header is at the start and just gives some basic
    // data on where the important tables are
    COFF_FileHeader header = {
        .num_sections = section_count,
        .timestamp = time(NULL),

        // in this example the machine code is x64 but you can find the
        // table for these values online at:
        .machine = COFF_MACHINE_AMD64,

        // there's 2 symbols per section (the auxillary symbol counts)
        .symbol_count = (2 * section_count) + arrlen(symbols),

        // we fill in this value later on
        .symbol_table = 0,
        .characteristics = IMAGE_FILE_LINE_NUMS_STRIPPED
    };

    // layout
    uint32_t string_table_pos;
    {
        size_t pos = sizeof(COFF_FileHeader) + (section_count * sizeof(COFF_SectionHeader));

        // raw data
        for (size_t i = 0; i < section_count; i++) {
            section_headers[i].raw_data_pos = pos;
            pos += section_headers[i].raw_data_size;
        }

        // relocations
        for (size_t i = 0; i < section_count; i++) {
            // if there's no relocations you can just leave the relocation
            // pos as 0, it doesn't matter
            section_headers[i].relocation_pos = pos;
            pos += arrlen(section_headers[i].relocations) * sizeof(COFF_ImageReloc);
        }

        // we'll place the symbol table at the end, directly after the symbol
        // table is the string table which is where longer symbol names will
        // be placed
        header.symbol_table = pos;
        string_table_pos = pos + (header.symbol_count * sizeof(COFF_Symbol));
    }

    // write the COFF headers
    fwrite(&header, sizeof(header), 1, file);
    for (size_t i = 0; i < section_count; i++) {
        COFF_SectionHeader sec = {
            .characteristics  = section_headers[i].characteristics,
            .raw_data_size    = section_headers[i].raw_data_size,
            .raw_data_pos     = section_headers[i].raw_data_pos,

            .num_reloc        = arrlen(section_headers[i].relocations),
            .pointer_to_reloc = section_headers[i].relocation_pos
        };

        // We just truncate the longer section names here, doesn't
        // matter here since all the names are small like .text
        assert(strlen(section_headers[i].name) < 8);
        strncpy(sec.name, section_headers[i].name, 8);
        sec.name[8 - 1] = 0;

        fwrite(&sec, sizeof(sec), 1, file);
    }

    // write out raw data
    for (size_t i = 0; i < section_count; i++) {
        assert(ftell(file) == section_headers[i].raw_data_pos);
        fwrite(section_headers[i].raw_data, section_headers[i].raw_data_size, 1, file);
    }

    // relocations
    for (size_t i = 0; i < section_count; i++) {
        assert(ftell(file) == section_headers[i].relocation_pos);
        fwrite(section_headers[i].relocations, arrlen(section_headers[i].relocations), sizeof(COFF_ImageReloc), file);
    }

    assert(ftell(file) == header.symbol_table);
    for (size_t i = 0; i < section_count; i++) {
        // section number 0 is kinda a NULL section so we skip it when
        // labeling our sections, relocations and symbols use this number
        // to refer to the sections so we wanna be consistent
        int section_number = i+1;

        COFF_Symbol sym = {
            .section_number = section_number,

            // section symbols have static storage because
            // every separate translation unit will have their
            // own separate copy
            .storage_class  = IMAGE_SYM_CLASS_STATIC,

            // auxillary symbols just add on to the data these symbols
            // tell us, in this case since it's a section we wanna add
            // extra data that says how many relocations and how big
            // the section itself is
            .aux_symbols_count = 1
        };

        // Same thing as before, we dont care that it truncates, we'll assert
        // but beyond that it shouldn't actually matter
        assert(strlen(section_headers[i].name) < 8);
        strncpy((char*) sym.short_name, section_headers[i].name, 8);
        sym.short_name[8 - 1] = 0;

        fwrite(&sym, sizeof(sym), 1, file);

        // Write the auxillary section symbol
        COFF_AuxSectionSymbol aux = {
            .length = section_headers[i].raw_data_size,
            .reloc_count = arrlen(section_headers[i].relocations),

            // for odd reasons the section number is duplicated in
            // the symbol and the aux
            .number = section_number
        };
        fwrite(&aux, sizeof(aux), 1, file);
    }

    // this is where our normal looking symbols go, imports,
    // functions, globals. symbols here can be longer than 8
    // characters which means that we use the long name format
    // and place the actual string into the string table
    uint32_t string_table_mark = 4;
    DynArray(char*) string_table = NULL;

    size_t symbol_count = arrlen(symbols);
    for (size_t i = 0; i < symbol_count; i++) {
        COFF_Symbol sym = {
            .value          = symbols[i].value,
            .section_number = symbols[i].section_num,
            .storage_class  = symbols[i].storage_class
        };

        const char* name = symbols[i].name;
        size_t name_len = strlen(name);

        if (name_len >= 8) {
            sym.long_name[0] = 0;                 // this value is 0 for the long names
            sym.long_name[1] = string_table_mark; // and this is the position in the string table

            // allocate some space in the string table
            arrput(string_table, (char*) name);
            string_table_mark += name_len + 1;
        } else {
            memcpy(sym.short_name, name, name_len + 1);
        }

        fwrite(&sym, sizeof(sym), 1, file);
    }

    // String table
    // First 4 bytes are the size of the string table, then
    // it's all just null terminated strings
    assert(ftell(file) == string_table_pos);
    fwrite(&string_table_mark, sizeof(string_table_mark), 1, file);

    size_t string_table_count = arrlen(string_table);
    for (size_t i = 0; i < string_table_count; i++) {
        size_t len = strlen(string_table[i]) + 1;
        fwrite(string_table[i], len, 1, file);
    }

    fclose(file);
    return 0;
}