Лекция: hello world на x86-64
Программирование под 64-битную версию Windows мало чем отличается от традиционного, только все операнды и адреса по умолчанию 64-разярные, а параметры API-функций передаются через регистры, а не через стек. Первые четыре аргумента всех API-функций передаются в регистрах RCX, RDX, R8 и R9 (регистры перечислены в порядке следования аргументов, крайний левый аргумент помещается в RCX). Остальные параметры кладутся на стек. Все это называется x86-64 fast calling conversion (соглашение о быстрой передаче параметров для x86-64), подробное описание которой можно найти в статье «The history of calling conventions, part 5 amd64» (http://blogs.msdn.com/oldnewthing/archive/2004/01/14/58579.aspx). Так же нелишне заглянуть на страничку бесплатного компилятора Free PASCAL и поднять документацию по способам вызова API: www.freepascal.org/wiki/index.php/Win64/AMD64_API.
В частности, вызов функции с пятью аргументами API_func(1,2,3,4,5) выглядит так:
mov dword ptr [rsp+20h], 5; кладем на стек пятый слева аргумент
mov r9d, 4; передаем четвертый слева аргумент
mov r8d, 3; передаем третий слева аргумент
mov edx, 2; передаем второй слева аргумент
mov ecx, 1; передаем первый слева аргумент
call API_func
Листинг 8 пример вызова API-функции с пятью параметрами по соглашению x86-64
Смещение пятого аргумента относительно верхушки стека требует пояснений. Почему оно равно 20h? Ведь адрес возврата занимает только 8 байт. Какая су… сущность съела все остальные? Оказывается, они «резервируются» для первых четырех аргументов, переданных через регистры. «Зарезервированные» ячейки содержат неинициализированный мусор и по-буржуйски называются «spill», что переводится как «затычка» или «потеря».
Вот минимум знаний, необходимых для выживания в мире 64-битной Windows при программировании на ассемблере. Остается разобрать самую малость. Как эти самые 64-бита заполучить?! Для перевода FASM'а в x86-64 режим достаточно указать директиву «use64» и дальше шпрехать как обычно.
Ниже идет пример простейшей x86-64 программы, которая не делает ничего, только возвращает в регистре RAX значение «ноль».
; сообщаем FASM'у, что мы хотим программировать на x86-64
Use64
xor r9,r9; обнуляем регистр r9
mov rax,r9; пересылаем в rax,r9 (можно сразу mov rax,0, но неинтересно)
ret; выходим туда откуда пришли
Листинг 9 простейшая 64-битная программа
Никаких дополнительных аргументов командной строки указывать не надо, просто сказать «fasm file-name.asm» и все! Через несколько секунд образуется файл file-name.bin, который в hex-представлении выглядит следующим образом:
4D 31 C9 xor r9, r9
4C 89 C8 mov rax, r9
C3 retn
Листинг 10 дизассемблерный листинг простейшей 64-битной программы
Формально, это типичный com-файл, вот только запустить его не удастся (во всяком случае, ни одна популярная ось его не «съест») и необходимо замутить законченный ELF или PE, в заголовке которого будет явно прописана нужна разрядность.
Начиная с версии 1.64 ассемблер FASM поддерживает специальную директиву «format PE64», автоматически формирующую 64-разрядный PE-файл (директиву «use64» в этом случае указывать уже не нужно), а в каталоге EXAMPLES можно найти готовый пример PE64DEMO в котором показано как ее использовать на практике.
Ниже приведен пример x86-64 программы «hello, world» с комментариями:
; пример 64-битного PE файла
; для его выполнения необходимо иметь Windows XP 64-bit edition
; указываем формат
format PE64 GUI
; указываем точку входа
entry start
; создать кодовую секцию с атрибутами на чтение и исполнение
section '.code' code readable executable
start:
mov r9d,0; uType == MB_OK (кнопка по умолчанию)
; аргументы по соглашению x86-64
; передаются через регистры, не через стек!
; префикс d задает регистр размером в слово,
; можно использовать и mov r9,0, но тогда
; машинный код будет на байт длиннее
lea r8,[_caption]; lpCaption передаем смещение
; команда lea занимает всего 7 байт,
; а mov reg, offset — целых 11, так что
; lea намного более предпочтительна
lea rdx,[_message]; lpText передаем смещение выводимой строки
mov rcx,0; hWnd передам дескриптор окна-владельца
; (можно так же использовать xor rcx,rcx
; что на три байта короче)
call [MessageBox]; вызываем функцию MessageBox
mov ecx,eax; заносим в ecx результат возврата
; (Функция ExitProcess ожидает 32-битный параметр
; можно использовать и mov rcx,rax, но это будет
; на байт длиннее)
call [ExitProcess]; вызываем функцию ExitProcess
; создать секцию данных с атрибутами на чтение и запись
; (вообще-то в данном случае атрибут на запись необязателен,
; поскольку мы ничего не пишем, а только читаем)
section '.data' data readable writeable
_caption db 'PENUMBRA is awesome!',0; ASCIIZ-строка заголовка окна
_message db 'Hello World!',0; ASCIIZ-строка выводимая на экран
; создать секцию импорта с атрибутами на чтение и запись
; (здесь атрибут на запись обязателен, поскольку при загрузке PE-Файла
; в секцию импорта; будут записываться фактические адреса API-функций)
section '.idata' import data readable writeable
dd 0,0,0,RVA kernel_name,RVA kernel_table
dd 0,0,0,RVA user_name,RVA user_table
dd 0,0,0,0,0; завершаем список двумя 64-разряными нулеми!!!
kernel_table:
ExitProcess dq RVA _ExitProcess
dq 0; завершаем список 64-разряным нулем!!!
user_table:
MessageBox dq RVA _MessageBoxA
dq 0
kernel_name db 'KERNEL32.DLL',0
user_name db 'USER32.DLL',0
_ExitProcess dw 0
db 'ExitProcess',0
_MessageBoxA dw 0
db 'MessageBoxA',0
Листинг 11 64-битное приложение «hello, world» под Windows на FASM'е
Рисунок 8 64-битный файл — первый полет
Ассемблируем файл (fasm PE64DEMO.ASM) и запустим образовавшийся EXE на выполнение. Под 32-разрядной Windows он, естественно, не запустится и она скажет «мяу»:
Рисунок 9 реакция 32-битной Windows на попытку запуска 64-битного PE-файла
Вдоволь наигравшись нашем первым x86-64 файлом, загрузим его в дизассемблер (например, в IDA Pro 4.7. Она хоть и материться, предлагая использовать специальную 64-битную версию, но при нажатии на «yes» все конкретно дизассемблирует, во всяком случае до тех пор пока не столкнется с подлинным 64-битным адресом или операндом, с которым произойдет обрезание, в частности mov r9,1234567890h дизассемблируется как mov r9, 34567890h, так что переход на 64-битную версию IDA все же очень желателен, тем более, что начиная с IDA 4.9 она входит в базовую поставку). Посмотрим, что у него внутри?
А внутри у него вот что:
.code:0000000000401000 41 B9 00 00 00 00 mov r9d, 0
.code:0000000000401006 4C 8D 05 F3 0F 00 00 lea r8, aPENUMBRA
.code:000000000040100D 48 8D 15 03 10 00 00 lea rdx, aHelloWorld; «Hello World!»
.code:0000000000401014 48 C7 C1 00 00 00 00 mov rcx, 0
.code:000000000040101B FF 15 2B 20 00 00 call cs:MessageBoxA
.code:0000000000401021 89 C1 mov ecx, eax
.code:0000000000401023 FF 15 13 20 00 00 call cs:ExitProcess
Листинг 12 дизассемблерный листинг 64-битного приложения «hello, world!»
Что ж… довольно громоздко, объемно и концептуально. Для сравнения, дизассемблированный листинг аналогичного 32-разрядного файла приведен ниже. Старый x86 код в 1,6 раз короче! А ведь это только демонстрационная программа из нескольких строк! На полновесных приложениях разрыв будет только нарастать! Так что не стоит злоупотреблять 64-разрядным кодом без необходимости. Его следует использовать только там, где 64-битная арифметика и 8 дополнительных регистров действительно дают ощутимый выигрыш. Например, в математических задачах или программах для вскрытия паролей.
Рисунок 10 дизассемблирование 64-битного PE-файла 32-битной версий IDA Pro
code:00401000 6A 00 push 0
code:00401002 68 00 20 40 00 push offset aPENUMBRA
code:00401007 68 17 20 40 00 push offset aHelloWorld
code:0040100C 6A 00 push 0
code:0040100E FF 15 44 30 40 00 call ds:MessageBoxA
code:00401014 6A 00 push 0
code:00401016 FF 15 3C 30 40 00 call ds:ExitProcess
Листинг 13 дизассемблерный листинг 32-битного приложения «hello, world!»
В качестве заключительно упражнения перепишем наше приложение в стиле MASM, поклонников которого нужно не бить, а уважать (как ни крути, а все-таки патриарх). Никаких радикальных отличий не наблюдается:
; объявляем внешние API-функции, которые мы будем вызывать
extrn MessageBoxA: PROC
extrn ExitProcess: PROC
; секция данных с атрибутами по умолчанию (чтение и запись)
.data
mytit db 'PENUMBRA is awesome!', 0
mymsg db 'Hello World!', 0
; секция кода с атрибутами по умолчанию (чтение и исполнение)
.code
Main:
mov r9d, 0; uType = MB_OK
lea r8, mytit; LPCSTR lpCaption
lea rdx, mymsg; LPCSTR lpText
mov rcx, 0; hWnd = HWND_DESKTOP
call MessageBoxA
mov ecx, eax; uExitCode = MessageBox(...)
call ExitProcess
End Main
Листинг 14 64-битное приложение «hello, world» под Windows на MASM'е
Ассемблирование и линковка проходит так: «ml64 XXX.asm /link /subsystem:windows /defaultlib:kernel32.lib /defaultlib:user32.lib /entry:main» в результате чего образуется готовый к употреблению exe-файл с румяной поджаренной корочкой нашего ЦП (FASM ассемблирует намного быстрее).
Примеры более сложных программ легко найти в сети. Как показывает практика, запросы типа «x86-64 [AMD64] assembler example» катастрофически неэффективны и гораздо лучше использовать «mov rax» (без кавычек) или вроде того.
заключение
Вот мы и познакомились с архитектурой x86-64! Здесь действительно есть место где развернутся и чему поучиться! Насколько эти знания окажутся востребованы на практике — так сразу и не скажешь. У AMD есть хорошие шансы пошатнуть рынок, но ведь и Intel не дремлет, активно продвигая собственные 64-разрядные платформы, известные под общем именем IA64, но о них как ни будь в другой раз…