ассемблер invoke что это

Ассемблер invoke что это

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

1. Метка с двоеточием после имени определяет адрес следующей за меткой команды.

2. Директива LABEL позволяет определить явно тип метки. Значение же определенной таким образом метки равно адресу команды или данных, стоящих далее. Например,
LABEL L1 DWORD.

3. Выражение ИМЯ PROC определяет метку, переход на которую обычно происходит по команде CALL. Блок кода, начинающийся с такой метки, называют процедурой. Впрочем, переход на такую метку можно осуществлять и с помощью JMP, как, впрочем, и команду CALL можно использовать для перехода на обычную метку. В этом, несомненно, состоит сила и гибкость ассемблера.

6. Метка «$» всегда определяет текущий адрес.

7. В MASM метки, стоящие в процедуре, автоматически считаются локальными и, следовательно, имена меток в процедурах могут дублироваться. В TASM все метки по умолчанию считаются глобальными. Чтобы сделать метки, стоящие в процедуре локальными, они должны иметь префикс @@, а в начале программы следует указать директиву LOCALS (см. предыдущую главу).

1. Директива STRUC позволяет объединить несколько разнородных данных в одно целое. Эти данные называются полями. Вначале при помощи STRUC определяется шаблон структуры, затем с помощью директивы можно определить любое количество структур. Рассмотрим пример:

Доступ к полям структуры осуществляется посредством точки: COMP1.RE.

2. Объединение. Объединение определяется при помощи ключевого слова UNION. От структуры объединение отличается только тем, что все поля располагаются в структуре с нулевым смещением, т.е. накладываются друг на друга.

1. Условное ассемблирование дает возможность при трансляции обходить тот или иной участок программы. Существует три вида условного ассемблирования.
Условие считается не выполненным, если выражение принимает значение 0 и выполненным, если выражение отлично от нуля.

2. Ассемблеры MASM и TASM поддерживают также несколько условных специальных директив, назовем некоторые из них.

б) Операторы IF1 и IF2 проверяют первый и второй проход при ассемблировании.

Условное ассемблирование понадобится нам в конце главы для написания программы, транслируемой как в MASM, так и TASM.

1. Повторение, заданное опеделенное число раз. Используется макродиректива REPT. Например:
Будет сгенерировано 100 директив DB 10. С этой директивой удобно использовать оператор «=», который позволяет изменять значение переменной многократно, т.е. использовать выражение типа А = А + 5.

2. Директива IRP.
Блок будет вызываться столько раз, сколько параметров в списке. Например:
Приведет к генерации следующих строк:

Пример:
Данный фрагмент эквивалентен следующей последовательности:

Общий вид макроопределения. Определив блок один раз, можно использовать его в программе многократно. Причем в зависимости от значений параметров заменяемый участок может иметь разные значения. Если заданный участок предполагается многократно использовать, например в цикле, макроопределение имеет несомненные преимущества перед процедурой, т.к. несколько убыстряет выполнение кода. Пример: Данное макроопределение приводит к обмену содержимым между параметрами.

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

Некоторые другие директивы транслятора ассемблера

1. Кроме объявлений с использованием директив PUBLIC и EXTERN, возможно объявление при помощи директивы GLOBAL, которая действует, как PUBLIC и EXTERN одновременно.

38 В операционной системе MS DOS это было существенно.

1. Условные конструкции.

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

На Рис. 2.6.1 представлена программа, транслируемая и в MASM, и TASM. Программа весьма проста, но рассмотрения ее вполне достаточно для создания более сложных подобных совместимых программ.

Источник

Ассемблер invoke что это

1. Метка с двоеточием после имени определяет адрес следующей за меткой команды.

6. Метка «$» всегда определяет текущий адрес.

Доступ к полям структуры осуществляется посредством точки: COMP1.RE.

2. Ассемблеры MASM и TASM поддерживают также несколько условных специальных директив, назовем некоторые из них.

б) Операторы IF1 и IF2 проверяют первый и второй проход при ассемблировании.

Пример:
Данный фрагмент эквивалентен следующей последовательности:

Некоторые другие директивы транслятора ассемблера

38 В операционной системе MS DOS это было существенно.

1. Условные конструкции.

Источник

Консольное приложение на ассемблере

Как вы знаете, большинство упомянутых системных утилит мигрировали к нам из ранних версий операционной системы Windows, куда они, в свою очередь, заимствовались как из той же MSDOS (фактически предка Windows), так и из сторонних операционных систем. Соответственно, в старых ОС, до определенного времени, интерфейс взаимодействия с пользователем (командная строка) ограничивался текстовым режимом, по этой причине и разрабатывались утилиты исключительно под него. Казалось бы, при переходе операционных систем к графическому режиму, стоило бы переписывать и системные утилиты под новые реалии? Тем не менее это не имело ни малейшего смысла, поскольку системные утилиты представляют собой обособленную группу программ, предназначенных для работы в командных сценариях, своеобразных программах, которые используют простые языки описания действий, в которых вывод одной программы может поступать на вход другой. То есть вся работа зачастую ведется с минимальным выводом статусных сообщений, либо и вовсе без какого-либо визуального оповещения пользователя. Очевидно, что использование графического интерфейса тут явно не к месту (избыточно). Описанная выше так называемая «преемственность» консольных утилит имеет под собой ряд весомых причин:

Помимо класса консольных утилит, в практике разработчика часто возникают задачи, в которых разворачивать оконный графический интерфейс соразмерно напрасной трате своего и процессорного времени. В подобного рода задачах вполне достаточным условием является использование текстового (для вывода диагностических сообщений) или вовсе неинтерактивного (вывод данных в файл) режимов. Действительно, зачем пытаться изображать графический интерфейс там, где он явно излишен или вовсе не обязателен, не проще ли в таких задачах от него отказаться вовсе? Поэтому, сегодня мы акцентируем внимание на особенностях языка Ассемблера (FASM) при написании консольного приложения на ассемблере под Windows, и темой данной статьи будет создание серии простейших консольных приложений, демонстрирующих основные алгоритмы взаимодействия с консолью. Разработанные шаблоны (в примерах) могут быть в дальнейшем использованы в качестве базовых в различного рода проектах.
Итак, в словосочетании консольное приложение на ассемблере присутствует ключевое слово «консоль», на которое стоит обратить особое внимание, поскольку именно оно даст нам понимание основных принципов работы. Скорее всего, люди уже знакомые с компьютером в общем и операционными системами в частности, знают что это такое, хотя могут понимать это в широком, так сказать, смысле этого слова: механизм для ввода информации с клавиатуры и вывода ее на экран. Поэтому, не лишним будет дать серию расширенных определений:

что является базой для:

что, в свою очередь, формирует понятие:

Различия оконного и консольного приложений

Консольные приложения являются одним из типов исполняемых образов (приложений) Windows, наряду с типовыми оконными (GUI), библиотеками (DLL), драйверами (native) и некоторыми другими. По сути это полноценные приложениями, имеющие ряд специфических отличий:

Следует ли из всего вышеперечисленного, что все функциональные методы консольного приложения «заключены» внутри набора текстовых функций и им лишь и ограничиваются? Отнюдь, основная идея заключается в том, что отличие оконного приложения от консольного чисто условное, поскольку консольное приложение сохраняет возможность вызывать GUI-функции (то есть функции, работающие уже с графическими примитивами) программного интерфейса Win32, все зависит лишь от набора подключаемых библиотек. Да, в простейшем случае текстовый интерфейс использует интерфейс командной строки, тем не менее многие приложения могут создавать более дружественный пользователю интерфейс при помощи интерактивных элементов, тем самым приближаясь по удобству к полноценному оконному (графическому).

Иначе говоря, программы с текстовым интерфейсом могут имитировать оконный интерфейс. Поэтому можно сделать следующее обобщение: консольные приложения имеют возможность полноценно взаимодействовать с функциями Win32 API наравне с типовым оконным GUI-приложением, ведь в процессе написания исходного кода автор имеет возможность импортировать (подключать) любые функции любых доступных коду библиотек, каковые он сочтет нужными.

Объекты консольного приложения

Выводить текст на консоль, осуществлять ввод символов, а так же совершать любые иные действия с консолью можно лишь ассоциировав с ней некие системные сущности (объекты), посредством которых можно обеспечивать обмен данными. Каждая консоль состоит из следующих основных объектов:

Стандартные потоки (дескрипторы консоли)

На программном уровне для ввода/вывода информации консольные приложения используют три основных стандартных устройства ввода-вывода:

Наименование	Назначение
Стандартный ввод ( stdin )	Поток данных, идущих в программу.
Стандартный вывод ( stdout )	Поток данных, идущих из программы.
Стандартная ошибка ( stderr )	Поток сообщений об ошибках, идущих из программы.

Для кода любого консольного приложения стандартные потоки доступны через дескрипторы и используют последние для того, чтобы обратиться к стандартному вводу (буферу ввода данных) и стандартному выводу (экранным буферам) собственной консоли. Хотя этими потоками консольное приложение не ограничено, никто не запрещает ему открывать любые файлы, использовать сетевые соединения и совершать иные действия, доступные в выполняющей их среде.

Традиционно, со стандартным вводом ассоциирована клавиатура, а со стандартным выводом/ошибкой ассоциирован монитор (экран), таким образом вывод печатных символов в STDOUT и STDERR приводит к появлению этих символов на устройстве вывода и к получению их пользователем. В дополнение, потоки могут быть переопределены (перенаправлены) и на другие логические устройства (файл, ввод/вывод другой программы и прочее). Поэтому определение консольного приложения может быть расширено:

Буфер ввода

Каждое консольное приложение имеет буфер вводимых данных:

В момент, когда окно консольного приложения имеет фокус клавиатуры (является активным), консоль оформляет каждое событие ввода (типа нажатия/отпускания клавиши, перемещение указателя мыши или щелчка кнопки мыши) в качестве данных, которые помещаются в буфер вводимых данных консоли. Что такое эти самые данные? Запись данных о вводе ― структура Windows, содержащая в себе информацию о деталях события: тип, источник (клавиатура, мышь, размеры окна, фокус, меню) и прочих. Структура имеет внутренний тип INPUT_RECORD и представляет собой следующее:

Источник

Программирование на Ассемблере для начинающих с примерами программ

Многие считают, что Assembler – уже устаревший и нигде не используемый язык, однако в основном это молодые люди, которые не занимаются профессионально системным программированием. Разработка ПО, конечно, хорошо, но в отличие от высокоуровневых языков программирования, Ассемблер научит глубоко понимать работу компьютера, оптимизировать работку с аппаратными ресурсами, а также программировать любую технику, тем самым развиваясь в направлении машинного обучения. Для понимания этого древнего ЯП, для начала стоит попрактиковаться с простыми программами, которые лучше всего объясняют функционал Ассемблера.

IDE для Assembler

Первый вопрос: в какой среде разработки программировать на Ассемблере? Ответ однозначный – MASM32. Это стандартная программа, которую используют для данного ЯП. Скачать её можно на официальном сайте masm32.com в виде архива, который нужно будет распаковать и после запустить инсталлятор install.exe. Как альтернативу можно использовать FASM, однако для него код будет значительно отличаться.

Перед работой главное не забыть дописать в системную переменную PATH строчку:

Программа «Hello world» на ассемблере

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

Для начала запускаем редактор qeditor.exe в папке с установленной MASM32, и в нём пишем код программы. После сохраняем его в виде файла с расширением «.asm», и билдим программу с помощью пункта меню «Project» → «Build all». Если в коде нет ошибок, программа успешно скомпилируется, и на выходе мы получим готовый exe-файл, который покажет окно Windows с надписью «Hello world».

Сложение двух чисел на assembler

В этом случае мы смотрим, равна ли сумма чисел нулю, или же нет. Если да, то на экране появляется соответствующее сообщение об этом, и, если же нет – появляется иное уведомление.

Здесь мы используем так называемые метки и специальные команды с их использованием (jz, jmp, test). Разберём подробнее:

Программа суммы чисел на ассемблере

Примитивная программа, которая показывает процесс суммирования двух переменных:

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

Получение значения из командной строки на ассемблере

Одно из важных основных действий в программировании – это получить данные из консоли для их дальнейшей обработки. В данном случае мы их получаем из командной строки и выводим в окне Windows:

Также можно воспользоваться альтернативным методом:

Здесь используется invoke – специальный макрос, с помощью которого упрощается код программы. Во время компиляции макрос-команды преобразовываются в команды Ассемблера. Так или иначе, мы пользуемся стеком – примитивным способом хранения данных, но в тоже время очень удобным. По соглашению stdcall, во всех WinAPI-функциях переменные передаются через стек, только в обратном порядке, и помещаются в соответствующий регистр eax.

Циклы в ассемблере

Для создания цикла используется команда repeat. Далее с помощью inc увеличивается значение переменной на 1, независимо от того, находится она в оперативной памяти, или же в самом процессоре. Для того, чтобы прервать работу цикла, используется директива «.BREAK». Она может как останавливать цикл, так и продолжать его действие после «паузы». Также можно прервать выполнение кода программы и проверить условие repeat и while с помощью директивы «.CONTINUE».

Сумма элементов массива на assembler

Здесь мы суммируем значения переменных в массиве, используя цикл «for»:

С помощью команды jne выполняется переход по метке, основываясь на результате сравнения переменных. Если он отрицательный – происходит переход, а если операнды не равняются друг другу, переход не осуществляется.

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

Источник

Win32Asm Tutorial

66 03 C2 (в шестнадцатеричной системе)

Почему я должен использовать ассемблер?

Собственно Assembler
Что: MASM (из пакета MASM32)
Где: www.pbq.com.au/home/hutch/masm.htm
Не когда, а Зачем: собственно он и формирует объектный (понятный процу) код из того
бреда, что ввёл программер 🙂

Редактор ресурсов
Что: Borland Resource Workshop
Где: www.crackstore.com
Зачем: Редактор ресурсов используется для создания ресурсов
(изображения, диалоги, bimap’ы, менюшки).

Текстовый редактор
Что: Notepad 🙂 можно и Ultraedit
Где: www.ultraedit.com
Зачем: 😉

Установка утиля
Без комментариев 😉

ОПКОДЫ

Проги на ассемблере пишутся в основном опкодами (кодами операций)
вроде следующего:
ADD

Этой инструкцией мы складываем два числа из регистров:
ADD eax, edx

Имеющиеся размеры регистров: 8 бит, 16 бит, 32 бит (и более на
современных процах).
В 16-битной программе, можно юзать только 16-бит и 8-бит регистры.
В 32-битной проге все остальные.
Некоторые регистры являются частью других регистров; например, если EAX содержит EA7823BBh, то можно сказать что:

EAX = EA 78 23 BB (32 бит)
AX = 23 BB (младшие 16 бит)
AH = 23 (старшие 8 бит из АХ)
AL = BB (младшие 8 бит из AХ)

Пример использования регистров (пока не обращай внимание на опкоды):

mov cl, ah ;перемещает ah в cl
sub cl, 10 ;вычитает 10 (дес.) из cl и результат заносит в cl
mov al, cl ;перемещает cl обратно в al

Общего назначения:
32-битные(16/8 для их частей):
eax (ax/ah/al) Аккумулятор
ebx (bx/bh/bl) Базовый
ecx (cx/ch/cl) Счётчик
edx (dx/dh/dl) Данные

Несмотря на то, что эти регистры имеют имена (пошло
с очень
старых процов) их можно использовать для любых целей.

Сегментные регистры:
В программировании под Виндозой малополезны, но всё равно, вот они:
CS сегмент кода
DS сегмент
SS сегмент стека
ES дополнительный сегмент
FS (тока 286+) общего назначения
GS (тока 386+) общего назначения

Регистры указатели:
о это кул регистры: содержат всё, что угодно, как и общего назначения,
а ещё используются некоторыми командами при работе с памятью
(scasb, stosb и др.):

esi (si) Индекс источника
edi (di) Индекс получателя
eip (ip) указатель инструкции

EIP (IP в старых процах) указывает на текущую исполняемую инструкцию

Стековые регистры:
esp (sp) Указатель стека (указывает на вершину стека)
ebp (bp) Базовый указатель

Регистр флагов :
Содержит в каждом бите признаки выполнения каждой операции
(переполнение, знак результата, признак переноса и др.)

Можно также считать параметр из памяти:
как может выглядеть (побайтно) часть памяти программы :

смещение
34 35 36 37 38 39 3A 3B 3C 3D 3E 3F 40 41 42
данные
0D 0A 50 32 44 57 25 7A 5E 72 EF 7D FF AD C7

итак нам надо считать данные (размером 4 байта) из 3A-ой ячейки:

mov eax, dword (размер того, что надо
переслать) ptr [0000003Ah] (адрес памяти (смещение))

Можно писать и сами числа (не забывая о размере регистров):

mov edx, 5006 ;запишет число 5006 (дес.) в edx

Как делать простые вычисления или опкоды ADD, SUB, MUL, DIV.

формат: опкод получатель, источник

Пример:
sub ecx,4h ;ecx=ecx-4h

пр.: источник команды div нельзя задавать непосредственно числом

Битовые операции (выполняются для каждого бита числа отдельно)

mov ax, 3406
mov dx, 13EAh
xor ax, dx
not ax

SHL что_сдвигаем, на_сколько_бит_сдвигаем ;побитно сдвиг влево
(младшие->старшие)
SHR что_сдвигаем, на_сколько_бит_сдвигаем ;побитно сдвиг вправо
(старшие->младшие)

mov al, 01011011b ; (двоичное)
shr al, 3

SAL что_сдвигаем, на_сколько_бит_сдвигаем ;сдвиг влево
SAR что_сдвигаем, на_сколько_бит_сдвигаем ;сдвиг вправо

записывают самый старший (знаковый) бит на место в(ы)двигаемого бита.
Пример:

;al = 10100110
sar al, 3
;al = 11110100
sar al, 2
;al = 11111101

;bl = 00100110
sar bl, 3
;bl = 00000010

Вращение (циклический сдвиг)
rol что_вращаем, на_сколько_бит; вращаем влево
ror что_вращаем, на_сколько_бит; вращаем влево
rcl что_вращаем, на_сколько_бит; вращаем через carry влево
rcr что_вращаем, на_сколько_бит; вращаем через carry вправо

Принцип: ror (вращение вправо)

Bit7 Bit6 Bit5 Bit4 Bit3 Bit2 Bit1 Bit0
1 0 0* 1
1 0 1 1
1 0 0 1
1 0 1 1

RCL и ROR работают аналогично, но последний в(ы)двигаемый бит у RCL
будет в флаге carry.

;eax = 237h
;ecx = 978h
xchg eax, ecx
;eax = 978h
;ecx = 237h

Описания разделов в программе:

.code ; начало сегмента, содержащего код
.data ; начало сегмента, содержащего данные
.data? ; начало сегмента, содержащего неинициализированные данные
.const ; начало сегмента, содержащего константы

Простая прога для демонстрации написания разделов:

.code ;секция кода
mov eax, Number1 ;простые операции 😉
mov ecx, offset Number2
add ax, word ptr [ecx+4]
mov Value, eax

дополню:
.data?
ManyBytes1 db 5000 dup (?)

.data
ManyBytes2 db 5000 dup (0)

(5000 dup значит: 5000 повторов. Те. Val1 db 4,4,4,4,4,4,4 аналогично
Val1 db 7 dup (4); знак ‘?’ значит, что число не определено)

Позволяют программе перейти в заданный участок кода.

loc1:
mov eax,ebx
jmp loc1 ;зацикливаем участок

Просто приведу пример кода:

аналог на BASIC:
IF (edx-ecx)=2 THEN
EAX = 1
ELSE
EAX = 0
END IF

Содержит признаки выполненной операции

SF (Знак) Ставится если результат вычисления отрицателен.

CF (Признак переноса) Флаг переноса содержит старший бит результата если был перенос из старшего разряда.

OF (Переполнение) Указывает на переполнение при вычислениях, что
происходит когда результат «не влезает» в получатель.

Список условных переходов.

«Jump if above» значит:
cmp x, y
JMP если x больше(above) y

Опкод Расшифровка Условия

Выполняет логическую И над числами и по результату (не помещая его в
получатель) ставит флаг ZF:

формат: CALL Метка(или адрес)
RET

..код..
call 0455659 ;переход на адрес 0455659 подпрограммы
add esp,8 ;сюда перейдём после выхода из подпрограммы
..другой код..

код по адресу 455659:
add eax, 500
mul eax, edx
ret ;возврат из подпрограммы

Используя стек, в подпрограмму можно также передавать параметры :

push 0 ;запишем параметры в стек
push eax
call FunctionName
add esp,8 ;удалим параметры из стека (аналогично 2м POP’ам)

внутри подпрограммы в этом случае их можно считать так:

Зная всё предыдущее сделаем, свою первую прогу на Ассемблере
сразу под Винду:

;first.asm
;возможный вариант заголовка в 32-битной программе
.486
.model flat, stdcall
option casemap:none

;библиотеки импорта
includelib \masm32\lib\kernel32.lib
includelib \masm32\lib\user32.lib

;файлы с описаниями внешних макросов и функций
include \masm32\include\kernel32.inc
include \masm32\include\user32.inc
include \masm32\include\windows.inc

invoke MessageBox, NULL, ADDR MsgText, ADDR MsgTitle, MB_OK or
MB_ICONINFORMATION
invoke ExitProcess, NULL ;выходим из проги

Итак с примером разобрались, запустили и порадовались, теперь перейдём к созданию окна. Это требует дополнительно создания класса этого окна, введения цикла обработки сообщений Винды (так она информирует окно о каком-либо событии типа клика мышью, вызова меню, нажатия батона на клаве), а так же оконной процедуры.

Here we go:
;second.asm
.486
.model flat, stdcall
option casemap:none

;библиотек и импортов теперь больше
includelib \masm32\lib\kernel32.lib
includelib \masm32\lib\user32.lib
includelib \masm32\lib\gdi32.lib

include \masm32\include\windows.inc
include \masm32\include\kernel32.inc
include \masm32\include\user32.inc
include \masm32\include\gdi32.inc

.data
ClassName db «FirstWindowClass»,0
AppName db «NewF@#inWindow»,0

.code
start:
;берём идентификатор текущего модуля
invoke GetModuleHandle, NULL
mov hInstance, eax
;запусаем приложение
invoke WinMain, hInstance, NULL, NULL, SW_SHOWNORMAL
;выходим
invoke ExitProcess, NULL

;главная процедура (!) в проге, её и вызываем при запуске
WinMain proc hInst:HINSTANCE,hPrevInst: HINSTANCE,CmdLine:LPSTR,CmdShow:DWORD
LOCAL wc:WNDCLASSEX
LOCAL hwnd:DWORD
LOCAL msg:MSG

;выведем его на экран и перерисуем
invoke ShowWindow, hwnd,SW_SHOWNORMAL
invoke UpdateWindow, hwnd

Источник