Дополнительные байты в конце файла DOS .COM, скомпилированного с помощью GCC

Поскольку вы используете собственный компилятор, а не кросс-компилятор i686 (или i386), вы можете получить достаточно дополнительной информации. Это скорее зависит от конфигурации компилятора. Я бы рекомендовал сделать следующее, чтобы удалить нежелательную генерацию кода и разделы:

• Используйте опцию GCC -fno-asynchronous-unwind-tables, чтобы удалить любые .eh_frame разделы. В данном случае это причина нежелательных данных, добавленных в конце вашей DOS-программы COM.
• Используйте опцию GCC -static для сборки без перемещений, чтобы избежать любой формы динамического связывания.
• Попросите GCC передать параметр --build-id=none компоновщику с помощью -Wl, чтобы избежать ненужного создания каких-либо .note.gnu.build-id разделов.
• Измените скрипт компоновщика, чтобы ОТМЕНИТЬ любые .comment разделы.

Ваша команда сборки может выглядеть так:

gcc -fno-pie -static -Os -nostdlib -fno-asynchronous-unwind-tables -ffreestanding \
-m16 -march=i386 -Wl,--build-id=none,--nmagic,--script=simple_dos.ld simple_dos.c \
-o simple_dos.com

Я бы изменил ваш скрипт компоновщика, чтобы он выглядел так:

OUTPUT_FORMAT(binary)
SECTIONS
{
    . = 0x0100;
    .text :
    {
        *(.text*);
    }
    .data :
    {
        *(.data);
        *(.rodata*);
        *(.bss);
        *(COMMON)
    }
    _heap = ALIGN(4);

    /DISCARD/ : { *(.comment); }
}

Помимо добавления директивы /DISCARD/ для удаления любых .comment разделов, я также добавляю *(COMMON) рядом с .bss. Оба являются разделами BSS. Я также переместил их после разделов данных, так как они не будут занимать место в файле .COM, если появятся после других разделов. Я также изменил *(.rodata); на *(.rodata*); и *(.text); на *(.text*);, потому что GCC может генерировать имена разделов, которые начинаются с .rodata и .text, но имеют разные суффиксы.

Встроенная сборка

Не связано с проблемой, о которой вы спрашивали, но важно. В этой встроенной сборке:

__asm__(
    "mov $0x09, %%ah;"
    "int $0x21;"
    : // no output
    : "d"(str)
    : "ah"
);

Целое 21ч/AH=9ч также забивает АЛ. Вы должны использовать ax как клоббер.

Поскольку вы передаете адрес массива через регистр, вы также захотите добавить memory clobber, чтобы компилятор реализовал весь массив в памяти до того, как ваша встроенная сборка будет испущена. Ограничение "d"(str) только сообщает компилятору, что вы будете использовать указатель в качестве входных данных, а не то, на что указывает указатель.

Скорее всего, если вы скомпилировали с оптимизацией в -O3, вы, вероятно, обнаружите, что в следующей версии программы даже нет вашей строки "Hello world$" из-за этой ошибки:

__asm__(
        ".code16gcc;"
        "call dosmain;"
        "mov $0x4C, %AH;"
        "int $0x21;"
);

void print(char *str)
{
        __asm__(
                "mov $0x09, %%ah;"
                "int $0x21;"
                : // no output
                : "d"(str)
                : "ax");
}

void dosmain()
{
        char hello[] = "Hello world$";
        print(hello);
}

Сгенерированный код для dosmain выделил место в стеке для строки, но никогда не помещал строку в стек перед печатью строки:

00000100 <print-0xc>:
 100:   66 e8 12 00 00 00       calll  118 <dosmain>
 106:   b4 4c                   mov    $0x4c,%ah
 108:   cd 21                   int    $0x21
 10a:   66 90                   xchg   %eax,%eax

0000010c <print>:
 10c:   67 66 8b 54 24 04       mov    0x4(%esp),%edx
 112:   b4 09                   mov    $0x9,%ah
 114:   cd 21                   int    $0x21
 116:   66 c3                   retl

00000118 <dosmain>:
 118:   66 83 ec 10             sub    $0x10,%esp
 11c:   67 66 8d 54 24 03       lea    0x3(%esp),%edx
 122:   b4 09                   mov    $0x9,%ah
 124:   cd 21                   int    $0x21
 126:   66 83 c4 10             add    $0x10,%esp
 12a:   66 c3                   retl

Если вы измените встроенную сборку, включив в нее "memory" клобер, например:

void print(char *str)
{
        __asm__(
                "mov $0x09, %%ah;"
                "int $0x21;"
                : // no output
                : "d"(str)
                : "ax", "memory");
}

Сгенерированный код может выглядеть как аналогичный:

00000100 <print-0xc>:
 100:   66 e8 12 00 00 00       calll  118 <dosmain>
 106:   b4 4c                   mov    $0x4c,%ah
 108:   cd 21                   int    $0x21
 10a:   66 90                   xchg   %eax,%eax

0000010c <print>:
 10c:   67 66 8b 54 24 04       mov    0x4(%esp),%edx
 112:   b4 09                   mov    $0x9,%ah
 114:   cd 21                   int    $0x21
 116:   66 c3                   retl

00000118 <dosmain>:
 118:   66 57                   push   %edi
 11a:   66 56                   push   %esi
 11c:   66 83 ec 10             sub    $0x10,%esp
 120:   67 66 8d 7c 24 03       lea    0x3(%esp),%edi
 126:   66 be 48 01 00 00       mov    $0x148,%esi
 12c:   66 b9 0d 00 00 00       mov    $0xd,%ecx
 132:   f3 a4                   rep movsb %ds:(%si),%es:(%di)
 134:   67 66 8d 54 24 03       lea    0x3(%esp),%edx
 13a:   b4 09                   mov    $0x9,%ah
 13c:   cd 21                   int    $0x21
 13e:   66 83 c4 10             add    $0x10,%esp
 142:   66 5e                   pop    %esi
 144:   66 5f                   pop    %edi
 146:   66 c3                   retl

Disassembly of section .rodata.str1.1:

00000148 <_heap-0x10>:
 148:   48                      dec    %ax
 149:   65 6c                   gs insb (%dx),%es:(%di)
 14b:   6c                      insb   (%dx),%es:(%di)
 14c:   6f                      outsw  %ds:(%si),(%dx)
 14d:   20 77 6f                and    %dh,0x6f(%bx)
 150:   72 6c                   jb     1be <_heap+0x66>
 152:   64 24 00                fs and $0x0,%al

Альтернативная версия встроенной сборки, которая передает подфункцию 9 через ограничение a с использованием переменной и помечает ее как ввод/вывод с помощью + (поскольку возвращаемое значение AX затирается), может быть выполнена следующим образом:

void print(char *str)
{
    unsigned short int write_fun = (0x09<<8) | 0x00;
    __asm__ __volatile__ (
        "int $0x21;"
        : "+a"(write_fun)
        : "d"(str)
        : "memory"
    );
}

Рекомендация: не используйте GCC для генерации 16-битного кода. Встроенная сборка — трудно понять правильно, и вы, вероятно, будете использовать ее изрядное количество для подпрограмм низкого уровня. В качестве альтернативы вы можете посмотреть на Меньший C, Компилятор C Брюса или Опенватком С. Все они могут генерировать DOS COM-программы.

Дополнительные данные, вероятно, представляют собой информацию раскрутки DWARF. Вы можете запретить GCC генерировать его с помощью опции -fno-asynchronous-unwind-tables.

Вы также можете сделать так, чтобы компоновщик GNU отбросил информацию о раскрутке, добавив следующее в директиву SECTIONS вашего скрипта компоновщика:

/DISCARD/ : 
{
     *(.eh_frame)
}

Также обратите внимание, что сгенерированный COM-файл будет на один байт больше, чем вы ожидаете, из-за нулевого байта в конце строки.