Как портировать немного 16-битного кода доса в линукс?

Какие варианты?

Переписать заново.

http://www.dosemu.org/

а он прерывания дёргает?

а что за код-то? Неужели написать заново не быстрее будет?

Переписать заново.

Это я и хотел сделать, пока не зааааался распутывать граф вызовов

http://stackoverflow.com/questions/15597155/porting-16-bit-dos-x86-assembly-t...

а он прерывания дёргает?

Дергает, но в принципе, это дерганье можно вырезать. Вот с таймерами не очень ясно, оно свой обработчик вешает, но думаю вырезать реально и это

Может быть проще и дешевле нанять того кто сможет распутать и переписать.И только в случае совсем отчаянья пытаться погружаться в такую дикую безну некрофилии.

Если это тонкий намек на портирование под синтаксис AT&T, то вас следует посадить за пропаганду самоубийств

Ответ прочти.

Скорее всего, это может помочь http://www.codon.org.uk/~mjg59/libx86/

что эта программа хоть делает, если не хочешь запускать ее из dosemu?

Если это намек на прерывания, то как я выше написал, вырезать их можно, нужный кусок кода, который я пытаюсь вытащить, работает сам по себе

Не томи душу, скажи хоть что там за секретный супер оптимизированный инновационный функционал?

DosBox

Самая большая проблема в модели памяти. Если все значения сегментов константные, то можно, в принципе, руками все инструкции, в которых сегменты упоминаются, поправить. А если неконстантные, то будет геморрой.

Второй путь не выглядит чем-то сверхестественным, первый тоже вполне реален. Но лучше найми профессионала.

IDA генерит граф, местами помечает красным «я тут не смогла», HexRays говорит что 16-битный код не умеет, REC валится на этапе анализа, DCC не очень понятно как использовать.
Какие варианты?

Можно еще не просто смотреть на дизасм и гадать что оно делает, а запустить это дело под отладчиком в эмуляторе и проследить работу. И по ходу помечать нужные места. Когда станет понятна логика проще будет восстановить код.

Правильнее, конечно, отреверсить логику, но если сильно ломает, проще, думаю, идти по первому пути. Можно попробовать реверсить по кускам, патча оригинальный бинарь уже понятым и переписанным кодом.

берешь питон и питонишь на нем необходимый функционал старой проги. Профит

Я за первый вариант. Над мелкими оптимизациями вроде соединения двух обращений к массиву в один корпеть смысла нет, компилятор с этим справится. В эмуляции всех регистров тоже страшного ничего нет, union помогает. С флагами нужно повозиться всего один раз, тем более для 16-битного кода на 32-битной машине можно даже проверять их напрямую, не выдумывая хитрых формул.

что мешает закодить с goto

Немного в сторону но может пригодится.

Где-то полгодика назад я загорелся такой идеей - перенести пошаговую стратегию MAX (DOS игра) из бинарников на язык C++ в Linux. Связано это было с тем, что мало того что в DOSBOX игра время от времени тормозила, так где-то после 10 ходов она ещё и вылетала. Видимо программисты-разработчики игры не все ошибки в игре исправили :)

В связи с чем и написал программку, которая «запускает» и дизассембилирует её в C подобный код, стараясь корректно разбить код на функции. Получая приблизительно такой код:

FUNC_INFO_V4(0x10076884, 0x78942246fba1d8bc, 0x20, {0x68, 0x28, 0, ... /* бинарный код функции */ })
{
	FUNC_START_V2(0x10076884, 0x20);
	II(0x10076884, 0x5)   pushd(0x28);                          /* push dword 0x28 */
	II(0x10076889, 0x5)   calld(check_available_stack_size, 0xef4c4); /* call 0x10165d52 */
	II(0x1007688e, 0x1)   pushd(ebx);                           /* push ebx */
	II(0x1007688f, 0x1)   pushd(ecx);                           /* push ecx */
	II(0x10076890, 0x1)   pushd(edx);                           /* push edx */
	II(0x10076891, 0x1)   pushd(esi);                           /* push esi */
	II(0x10076892, 0x1)   pushd(edi);                           /* push edi */
	II(0x10076893, 0x1)   pushd(ebp);                           /* push ebp */
	II(0x10076894, 0x2)   mov(ebp, esp);                        /* mov ebp, esp */
	II(0x10076896, 0x6)   sub(esp, 0xc);                        /* sub esp, 0xc */
	II(0x1007689c, 0x3)   mov(memd_a32(ss, ebp - 0x4), eax);    /* mov [ebp-0x4], eax */
	II(0x1007689f, 0x3)   mov(eax, memd_a32(ss, ebp - 0x4));    /* mov eax, [ebp-0x4] */
	II(0x100768a2, 0x3)   cmp(memd_a32(ds, eax), 0);            /* cmp dword [eax], 0x0 */
	II(0x100768a5, 0x2)   jzd(0x100768b0, 0x9);                 /* jz 0x100768b0 */
	II(0x100768a7, 0x7)   mov(memd_a32(ss, ebp - 0x8), 0);      /* mov dword [ebp-0x8], 0x0 */
	II(0x100768ae, 0x2)   jmpd(0x100768c9, 0x19);               /* jmp 0x100768c9 */
l_0x100768b0:
	II(0x100768b0, 0x5)   mov(ecx, 0xae);                       /* mov ecx, 0xae */
	II(0x100768b5, 0x5)   mov(ebx, 0x101a0018);                 /* mov ebx, 0x101a0018 */ /* "smartptr.h" */
	II(0x100768ba, 0x5)   mov(edx, 0x101a0023);                 /* mov edx, 0x101a0023 */ /* "ptr != 0" */
	II(0x100768bf, 0x2)   xor_(eax, eax);                       /* xor eax, eax */
	II(0x100768c1, 0x5)   calld(assert_, 0xef4cc);              /* call 0x10165d92 */
	II(0x100768c6, 0x3)   mov(memd_a32(ss, ebp - 0x8), eax);    /* mov [ebp-0x8], eax */
l_0x100768c9:
	II(0x100768c9, 0x3)   mov(eax, memd_a32(ss, ebp - 0x4));    /* mov eax, [ebp-0x4] */
	II(0x100768cc, 0x2)   mov(eax, memd_a32(ds, eax));          /* mov eax, [eax] */
	II(0x100768ce, 0x3)   mov(memd_a32(ss, ebp - 0xc), eax);    /* mov [ebp-0xc], eax */
	II(0x100768d1, 0x3)   mov(eax, memd_a32(ss, ebp - 0xc));    /* mov eax, [ebp-0xc] */
	II(0x100768d4, 0x2)   mov(esp, ebp);                        /* mov esp, ebp */
	II(0x100768d6, 0x1)   popd(ebp);                            /* pop ebp */
	II(0x100768d7, 0x1)   popd(edi);                            /* pop edi */
	II(0x100768d8, 0x1)   popd(esi);                            /* pop esi */
	II(0x100768d9, 0x1)   popd(edx);                            /* pop edx */
	II(0x100768da, 0x1)   popd(ecx);                            /* pop ecx */
	II(0x100768db, 0x1)   popd(ebx);                            /* pop ebx */
	II(0x100768dc, 0x1)   retd();                               /* ret  */
}

В общем то в таком виде я и получил более менее работающий код. Где-то 500000 строчек. Тратить время на полноценный графический интерфейс желания у меня не было (на данном этапе это не удобно), т.ч. она запускается в режиме автоматического боя компьютер против компьютера и сохраняет сами картинки игры в png файлы.

Следующий логический шаг перенос всего этого непосредственно в C++ - в процессе.

Да и к чему я это всё пишу - уверен, смогу ваш код портировать под Linux, опыт то получен. Но не бесплатно.

Ах да, и ещё. Сам код я могу дать бесплатно, у меня в общем то и так было желание распространять его на правах «общественно достояния». Но т.к. проект до ума ещё не доведён и пока что жёстко заточен под эту игру, я его пока никуда не выкладывал. И думаю самостоятельно (без меня) его будет использовать проблематично.

Скажите, а вы бы заплатили за реверсинг-портирование игры? Вот и я бы не стал, я это делаю ради фана игр, а не коммерческой выгоды. В худшем случае, я просто ничего не сделаю.

В принципе, генератор огромных портянок из goto уже написан, граф вызовов известен, проблема в том, что надо реализовать все команды. Причем надо тщательно разбирать, где у нас word, а где byte, придумать какой-то свой слой работы с сегментами памяти, а вот этого я не умею. По первости кажется что inc можно реализовать 1 строчкой var++, а на самом деле писанины куда больше

Я не знаю как этот функционал устроен, иначе бы я написал это на нормальном языке сразу, даже питон бы не понадобился