Mercury13

У нас маленькие регистры и много памяти. То есть полный адрес задаётся регистровой парой, а не одним регистром. Можно сделать линейную адресацию, а можно сегментную. Объясню логику за сегментами.
1. У нас линейная адресация, и надо по какой-то причине прибавить единицу к адресу. Если нижний адрес переполнится, надо переносить эту единицу в верхний — то есть делать длинный сумматор, увеличивать регистровый файл, постоянно работать с парами регистров и эту пару никак нельзя заменить одним — машина по сути превращается в костыльную 32-битную.
2. Линейная адресация сильно усложняет загрузчики — им приходится обрабатывать так называемые relocations. Задан базовый адрес, и если загрузка случилась по другому. к определённым точкам в памяти надо прибавить разницу. В сегментной адресации этих relocations куда меньше: они задаются по сегментам, а не по точкам. (А в x64 для избавления от relocations ОЧЕНЬ МНОГО команд используют адресацию «от IP».)
3. Совместимость с Intel 8080. Он тогда широко применялся, и IBM пошла на хитрость: после небольшой переделки проги под 8080 работали и на их ПК. Сейчас COM — странная технология Windows, а раньше COM — это было расширение маленьких исполняемых файлов в один сегмент длиной.

Итак, на стеке лежит локальный объект, и так совпало, что его адрес совпадает с регистром esp. Стек на x86 растёт вниз, так что такое бывает.
Для этого объекта мы вызываем функцию с соглашением вызова cdecl thiscall и одним dword-параметром, предположительно указателем. Функция возвращает указатель/ссылку на объект — видимо для «текучего интерфейса».

Как я понял, вы подставным DLL или подобной дрянью хотите вызвать эту функцию, верно? Тогда в DLL пишем примерно такое.

#include <iostream>

class X
{
public:
    // Наделай полей — непонятно, какой нужен размер объекта, но минимум 7 dword
    uint32_t field0 = 0, field4 = 0, field8 = 0, fieldC = 0,
           field10 = 0, field14 = 0, field18 = 0;
    // Просто тестовая функция, тебе не нужна
    X& doSmth(void* param);
};


// Просто тестовая функция, тебе не нужна
X& X::doSmth(void* param)
{
    std::cout << "My address is " << this << std::endl;
    std::cout << "My param is " << param << std::endl;
    return *this;
}

// Известно, что параметр — указатель/ссылка, но какого типа — неизвестно.
// Пусть будет void*.
using PFunc = X& (X::*)(void*);

int main()
{    
    PFunc func = &X::doSmth;  // Тебе надо reinterpret_cast<PFunc>(0x471440)
    X x;
    auto param = reinterpret_cast<void*>(0x5678);  // Или придумай, чему должен равняться этот param
    (x.*func)(param);
    return 0;
}

Я не знаю, что такое month — но, по всей видимости, этот макрос надо вызывать invoke atoi, month.

Потому что [month] — это разыменование. А нам адрес нужен.

Так возвращает ноль или вылетает, я не понял? Если случился вылет, в eax может быть что угодно.

С lea edi, [month] всё верно — lea не разыменовывает, а грузит адрес. Хотя ассемблер, по идее, должен выдать обычный mov edi, month.

Зависит от того, чем линкуете.
Если вызываете напрямую ld — --kill-at.
Если gcc — то -Wl,--kill-at вроде.

У меня нет линукса, чтобы проверить, но, кажется, программа в корне неверна. Вы используете 32-битное соглашение вызова на 64-битной машине.
https://www.informatik.htw-dresden.de/~beck/ASM/sy...
https://blog.rchapman.org/posts/Linux_System_Call_...

Откуда 32-битный вызов на x64 — дайте пруфлинк, может, в вашем линуксе так и есть.

Регистры — это маленькие и очень быстрые ячейки памяти, встроенные в процессор. Их ограниченное количество, и у них конкретные чётко зафиксированные названия.

Часто для работы с данными малых разрядностей и совместимости с ранним кодом процессор даёт доступ и к половинкам регистров. Так, нижняя половина регистра rax — eax, нижняя четверть — ax, половины ax (соответственно восьмушки rax) называются al и ah. Сами понимаете: когда процессор был 16 бит, регистр назывался ax = al + ah. Сделали 32 бита — стал eax. Сделали 64 бита — стал rax.

Для вызова системных функций Linux используется такое соглашение вызова. Все функции висят на прерывании 0x80, rax — название функции, остальные параметры рассовываются по регистрам.

Насчёт int, char, double. Знаковость (signed/unsigned) определяется инструкциями ассемблера (например, ja = jump if above для unsigned, jg = jump if greater для signed). Длина — задействованным куском регистра (rax = long long, eax = int/long, ax = short, al = char). С дробными числами работает отдельный блок процессора, т.н. сопроцессор, со своими регистрами (в первых x86 он был отдельной микросхемой, существовавшей не во всех компьютерах, отсюда название).

Вы компилируете функцию в двоичный код и на месте же вызываете. Так что есть вопросы.
1. Функции обеспечили правильное соглашение вызова?
Мне что-то кажется, что при подобной ручной компиляции проще работать с соглашением PASCAL или STDCALL — ну, шут его знает.
2. VirtualProtect работает с целыми страницами. Так что на куске памяти из сегмента данных (ну или из стека, полного кода не вижу) она в лучшем случае откажет, в худшем ничего не сделает. Проверьте, была ли ошибка.
3. Первый параметр должен быть source, а не &source.

Можно после запуска нажать Alt-F5, чтобы увидеть, что программа вывела.
Есть там эта кнопка в меню — пункт не помню, а кнопку помню.
UPD. Команда называется «User screen».

Хотелось бы уточнить.
1. Размеры делимого и делителя.
2. Знаковые или беззнаковые?
3. Нужен ли остаток?
4. Делим на константу или на что-то заранее неизвестное?

Вот для примера 16-битное беззнаковое делить на произвольное 8-битное беззнаковое, как я понял, без остатка.
www.avr-asm-tutorial.net/avr_en/calc/DIV8E.html

А вот так работает деление на константу (в данном случае на 6).
stackoverflow.com/questions/34136339/how-does-divi...

Это к Sony или StarForce. И те, и другие делали заSHITу и прокалывались на подобном.