Hello world assembler

03.09.202203.09.2022 admin 0 Comments

Hello world assembler

Пишем Hello World на ассемблере под Windows RT с использованием winapi

Однажды, совсем недавно, на планшетах с Windows Microsoft потеряла миллионы долларов. Ну а мы сегодня просто будем писать под них на ассемблере.

Причем у ассемблера в составе Visual Studio 2012 замечана странность: макросы и инструкции обязательно должны содержать перед собой хотя бы один символ табуляции, а вот метки и имена областей памяти наоборот, не должны ничего перед собой содержать(т.е. должны начинаться сразу с начала строки), иначе будут ошибки.

Итак, текст мы набрали, теперь приступим к компиляции. Из меню «Пуск» запускаем:

Microsoft Visual Studio 2012 — Visual Studio Tools — Командная строка VS2012 ARM Cross Tools.

Из открывшегося окна ввода команд переходим в каталог с исходниками, например:

Источник

MS-DOS и TASM 2.0. Часть 3. Первая программа.

Наша первая программа на ассемблере.

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

Ещё мы знаем, что в указанном формате пишутся резидентные программы, драйверы и вирусы.

Резидентная (TSR-программа, от англ. Terminate and Stay Resident) — это программа, которая после запуска передает управление операционной системе, но сама не завершается, а остаётся в оперативной памяти, реагируя на определённые действия пользователя. Например, при нажатии сочетания горячих клавиш делает снимок экрана.

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

Наша первая программа выведет на экран монитора (консоль) надпись «Hello, World!». Итак, как говорил Юрий Алексеевич, поехали!

Создаём исполняемый файл PRG.COM.

Для достижения нашей цели делаем следующее.

Первая строка — запуск транслятора с названием нашего файла с кодом, расположенного в одной директории с транслятором.

Вторая строка — запуск компилятора с параметрами /t /x и название объектного файла — prg.obj, получившегося в результате выполнения первой команды.

Чтобы посмотреть список всех возможных параметров с пояснениями для файлов tasm.exe и tlink.exe необходимо запустить эти программы без параметров. Если вы сделаете это, не выходя из оболочки NC, то, чтобы просмотреть чистое окно DOS нажмите Ctrl+O, чтобы вернуться в NC, нажмите сочетание клавиш повторно.

Батник ASM-EXE.BAT предназначен для создания исполняемого файла формате *.EXE (предусматривает раздельную сегментацию для кода, данных и стека — наиболее распространённый формат исполняемых файлов DOS).

Батник COMPLEX.BAT предназначен для создания исполняемых файлов из двух файлов кода (названия обязательно должны быть prg.asm, prg1.asm).

Наша первая программа на ассемблере прекрасно работает!

TASMED (Tasm Editor) — среда разработки приложений DOS на ассемблере.

Выше мы рассмотрели стандартный подход к программированию на TASM в системе MS-DOS. Указанным алгоритмом создания программ можно пользоваться и далее.

Для более удобной работы с кодом целесообразно применять какую-либо среду разработки. Среда разработки — это громко сказано для времён MS-DOS, правильнее сказать — специфический редактор.

Можете попробывать TASMED в папке D:\UTILS\TASMED\. Программа уже настроена и готова к использованию.

Первая программа на ассемблере в среде разработки TASMED.

Практические советы: группирование проектов, русский язык в MS-DOS.

Для удобства группирования создаваемых программ можно создать отдельную папку (мы создали папку PROJECTS) в которой создавать папки названий проектов, куда копировать соответствующие файлы. Пока у нас — это PRG.ASM, PRG.OBJ, PRG.EXE. Однако, в зависимости от параметров и наших программ их может быть больше (PRG.MAP, PRG.SYM и др.).

В нашем случае, все программы, рассматриваемые в курсе обучения будут группироваться в директории D:\WORK в соответствующих папках. Например, наша первая программа в папке D:\WORK\PRGCOM\ (файлы prg.asm и prg.com). Папку D:\TASM.2_0\PROJECTS\ оставляем пустой для ваших проектов и экспериментов.

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

Конечно вопрос снимается сам собой, если комментарии писать на английском.

В следующей статье мы разберём код нашей первой программы на ассемблере.

Добавить комментарий Отменить ответ

Для отправки комментария вам необходимо авторизоваться.

Источник

Изучаем язык ассемблера на примере TSR программы под MS-DOS. Часть 1

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

Материал рассчитан на новичков в ассемблере, студентов, которым пришлось столкнуться с «динозавром» в виде MS-DOS, и может быть интересен тем, кто хочет немного узнать как функционировали операционные системы на заре своего существования.

Писать мы будем резидентную программу (TSR), которая при завершении возвращает управление оболочке операционной системы, но остается в памяти и продолжает своё существование. В современном мире близкий аналог этого понятия — демон/служба.

Программа будет выполнять следующие функции:

вывод текста вниз экрана по таймеру,

переключение режима отображения шрифта: italic/normal,

запрет на ввод прописных русских букв,

вывод бинарного представления символа.

Предисловие

Материал не претендует на полноту, здесь будут рассматриваться базовые концепции и приемы программирования на языке ассемблера, необходимые для написания программ.

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

Немного оговорок. Далее под ассемблером будет пониматься язык ассемблера, а не программа компилятор. MS-DOS часто будет заменяться на dos/дос.

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

Про MS-DOS. Всех, наверное, пугает это слово в современном мире. Операционная система, которая уже как 20 лет мертва, но не все так однобоко как кажется на первый взгляд. Минусы понятны: изучение технологии, которая уже сгнила и разложилась, не используемая модель памяти. Но что насчет положительных моментов:

Ассемблер он и в Африке ассемблер, основные концепции программирования на нем будут везде одинаковы, да где-то будут расширенные регисты, где-то другой интерфейс по работе с операционной системой.

MS-DOS очень простая операционная система, которая в начале своего существования умещалась в 50 тысяч строк кода, причем ассемблерных (Майкрософт выложила исходники 2-х версий на github). График ее изучения имеет дно, в отличие от современных операционных систем. Аналогией может служить C и C++, последний, наверное, не знает в полной мере со всеми тонкостями ни один человек в мире.

Операционка работает в реальном режиме процессора, то есть в 16-битном. Это означает, что нет виртуальной памяти, адреса сразу преобразуются в физические с использованием сегментной адресаци памяти. Нет защиты процессов друг от друга, можно обратиться по любому адресу, посмотреть, что там лежит, можно делать с осью все, что тебе вздумается, но могут быть последствия ;). Плюс этот режим до сих пор не вымер, при запуске системы процессор начинает работу именно в этом режиме. Так что это не просто знакомство с историей.

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

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

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

Ассемблер актуален в MS-DOS, и это радует, когда работаешь в ней, потому что иных средств разработки программ не так много там. Но в настоящее время ассемблер используется только в виде вставок в языке Си или в микроконтроллерах.

Немного про компилятор. Использоваться будет NASM, хотя логичнее было бы использовать досовские компиляторы TASM, MASM, но они не поддерживают мою рабочую операционную систему Линукс, а разрабатываться хочется все-таки в удобстве, поэтому взят nasm. Он популярный, современный, кроссплатформенный (запускается везде, компилируется подо все, включая дос), более умный — позволяет опускать какие-то вещи в синтаксисе, имеет фичи в виде локальных меток, контекстов, всяких других директив.

Настройка

Для начала нам потребуется эмулятор операционной системы DOS под названием DOSBox. Скачать можно здесь, версия 0.74-3. После установки и запуска вы увидите, что-то похожее на это:

Стартовый экран DOSBox

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

Windows: Z:\> mount c: C:\Users\Username\Desktop\dos

Linux: Z:\> mount c: /home/username/dos

Hello world

Напишем первую программу на ассемблере, которая будет выводить на экран избитую фразу hello world:

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

3-5 строки подготовка для вызова прерывания 21h и непосредственно сам вызов, прерывание мы обсудим в 3-ей части, в нашем случае это попросту вызов функции операционной системы. В строке 3 мы помещаем число 09h (h значит шестнадцатиричное) в регистр ah. 09h — это номер функции.

В строке 5 передаем управление операционной системе с помощью прерывания, по номеру функции дос понимает, что нужно сделать (вывести строку на экран).

Источник

блог alexanius’а

четверг, 12 мая 2016 г.

Пишем «Hello, world» на ассемблере

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

1. Введение

Я буду стараться давать минимум теории, т.к. её рассказывают много где, гораздо более подробно и понятно. Поэтому буду описывать только то, что касается данного примера.
Итак, задача: написать программу, выводящую на экран сообщение «Hello, world». В качестве эталона возьмём программу на C:

int main()
<
const char * msg = «Hello, world\n»;
write(0, msg, 13);
return 0;
>

Здесь специально не использована стандартная библиотека, а применён системный вызов write. Подробнее про него можно прочесть по команде man 2 write.

2. amd64

Теперь попытаемся понять что произошло.

Краткое описание синтаксиса:
На каждой строчке находятся команды (statement). Команда начинается с нуля и более меток, после которых находится ключевой символ, обозначающий тип команды. Всё что начинается с точки `.’ является директивой ассемблера. Всё что начинается с буквы является инструкцией ассемблера и транслируется в машинный код. Комментарии бывают многострочными `/**/’ и однострочными `#’.

После метки _start начинаются непосредственно ассемблерные инструкции. И теперь опять вернёмся к теории.

Данная программа написана под процессор Intel архитектуры amd64 (она же x86_64). Это 64-х битное расширение архитектуры IA-32. Описание самой архитектуры процессора находится в [intel1]. Подробное описание команд процессора находится в [intel2].

.
#define __NR_read 0
#define __NR_write 1
#define __NR_open 2
.
#define __NR_execve 59
#define __NR_exit 60
#define __NR_wait4 61
.

Понятно, что помимо номеров нам нужны ещё аргументы этих вызовов. Их можно найти следующим образом:

Но в целом таблицами, подготовленными хорошими людьми пользоваться удобнее.

Далее нужно выйти из программы. Для этого используется системный вызов exit. Он имеет номер 60 и требует код возврата в качестве первого аргумента. Мы завершаемся с кодом 0, как и положено успешно выполненной программе.

3. Sparc v9

Не устали? Теперь внезапно рассмотрим sparc. Меня эта платформа интересует, т.к. одна из линеек процессоров Эльбрус основана на этой архитектуре. Я тестировался на процессорах TI UltraSparc III+ (Cheetah+) с ОС Gentoo и процессорах Эльбрус R1000 c ОС Эльбрус. Итак, смотрим:

_start:
! Подготавливаем и вызываем write
mov 1, %o0
set hello_str, %o1
mov hello_str_len, %o2
mov 4, %g1
ta 0x10

Инструкция sethi поместит старшие 22 бита hello_str (т.е. её адрес) на регистр %o2. Инструкция or поместит туда младший остаток. Обозначения %hi и %lo нужны для взятия старших и младших битов соответственно. Такие сложности возникают из-за того что инструкция кодируется 32 битами, и просто не может включать в себя 32-х битную константу.

Далее мы кладём значение 4 на глобальный регистр %g1. Можно догадаться что это номер вызова write. Системный возов будет искать номер вызова именно там.

Далее производятся аналогичные действия для вызова exit, думаю их пояснять не нужно.

Спасибо уважаемому Анониму за версию данной программы для SunOS 5.10:

.msg:
.ascii «Hello world!\n»
.msgend:

4. Эльбрус

Как и Sparc, архитектура Эльбруса рассчитана в первую очередь на то что оптимальный код выдаст компилятор. Но в отличает от Sparc, ассемблер Эльбруса вообще не предназначен для людей. Итак, вот наш пример:

$hello_msg:
.ascii «Hello, world\n\000»

.section «.text»
.global _start

! Вызываем write
<
call %ctpr1, wbs = 0x4
>

! Подготавливаем вызов exit
<
sdisp %ctpr2, 0x1
addd, 0 0x0, 0x0, %b[1]
addd, 1 0x0, 0x1, %b[0]
>

! Вызываем exit
<
call %ctpr2, wbs = 0x4
>

Сборка и запуск:

Мы видим что к синтаксису добавились фигурные скобки. Процессоры Эльбрус основаны на VLIW архитектуре, а значит могут исполнять множество статически спланированных команд за такт. Набор таких команд называется широкой командой (ШК) и заключается в фигурные скобки. Остальной синтаксис более или менее идентичен.

Существует программное соглашение, согласно которому для передачи аргументов в вызываемую процедуру мы используем вращающиеся регистры.

Итак теперь переходим к самой программе. Думаю первые несколько строк и так понятны, поэтому рассмотрим сразу первую ШК:

Далее может возникнуть вопрос зачем в команде addd третья d. В мнемониках команд, реализованных для нескольких форматов операндов, последняя буква обозначает используемый формат. В данном случае мы работаем в double формате, т.е. с полноценным 64-х битным регистром.

В третьей ШК мы аналогичным образом подготавливаем переходы для вызова exit, и в четвёртой ШК мы его вызываем.

Послесловие

Вообще я планировал написать эту заметку за неделю-две и перейти на следующий пример. Более того хотел ещё включить описание llvm IR. Но внезапно простенькая заметка про hello world заняла у меня несколько месяцев. Преимущественно из-за Эльбруса. Тут оказалось много нового и непонятного при почти полном отсутствии читабельной документации. И тут хотелось бы сказать огромное спасибо многим моим коллегам, которые терпеливо в течении долгого времени разъясняли мне простейшие вещи.

Источник

Руководство по ассемблеру x86 для начинающих

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

В этой статье мы напишем с нуля калькулятор обратной польской записи (RPN) на чистом ассемблере x86. Когда закончим, то сможем использовать его так:

Весь код для статьи здесь. Он обильно закомментирован и может служить учебным материалом для тех, кто уже знает ассемблер.

Начнём с написания базовой программы Hello world! для проверки настроек среды. Затем перейдём к системным вызовам, стеку вызовов, стековым кадрам и соглашению о вызовах x86. Потом для практики напишем некоторые базовые функции на ассемблере x86 — и начнём писать калькулятор RPN.

Предполагается, что у читателя есть некоторый опыт программирования на C и базовые знания компьютерной архитектуры (например, что такое регистр процессора). Поскольку мы будем использовать Linux, вы также должны уметь использовать командную строку Linux.

Настройка среды

Как уже сказано, мы используем Linux (64- или 32-битный). Приведённый код не работает в Windows или Mac OS X.

Я бы также рекомендовал держать под рукой таблицу ASCII.

Hello, world!

Для проверки среды сохраните следующий код в файле calc.asm :

Комментарии объясняют общую структуру. Список регистров и общих инструкций можете изучить в «Руководстве по ассемблеру x86 университета Вирджинии». При дальнейшем обсуждении системных вызовов это тем более понадобится.

Следующие команды собирают файл ассемблера в объектный файл, а затем компонует исполняемый файл:

После запуска вы должны увидеть:

Makefile

Затем вместо вышеприведённых инструкций просто запускаем make.

Системные вызовы

Системные вызовы Linux указывают ОС выполнить для нас какие-то действия. В этой статье мы используем только два системных вызова: write() для записи строки в файл или поток (в нашем случае это стандартное устройство вывода и стандартная ошибка) и exit() для выхода из программы:

eax	ebx	ecx	edx
Номер системного вызова	arg1	arg2	arg3

Стек вызовов

Стек вызовов — структура данных, в которой хранится информация о каждом обращении к функции. У каждого вызова собственный раздел в стеке — «фрейм». Он хранит некоторую информацию о текущем вызове: локальные переменные этой функции и адрес возврата (куда программа должна перейти после выполнения функции).

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

Соглашение о вызовах для архитектуры x86

В х86 нет встроенного понятия функции как в высокоуровневых языках. Инструкция call — это по сути просто jmp ( goto ) в другой адрес памяти. Чтобы использовать подпрограммы как функции в других языках (которые могут принимать аргументы и возвращать данные обратно), нужно следовать соглашению о вызовах (существует много конвенций, но мы используем CDECL, самое популярное соглашение для x86 среди компиляторов С и программистов на ассемблере). Это также гарантирует, что регистры подпрограммы не перепутаются при вызове другой функции.

Правила вызывающей стороны

Перед вызовом функции вызывающая сторона должна:

Правила вызываемой подпрограммы

Перед вызовом подпрограмма должна:

Стек вызовов после шага 2:

Стек вызовов после шага 4:

На последней диаграмме также можно заметить, что локальные переменные функции всегда начинается на 4 байта выше ebp с адреса ebp-4 (здесь вычитание, потому что мы двигаемся вверх по стеку), а аргументы функции всегда начинается на 8 байт ниже ebp с адреса ebp+8 (сложение, потому что мы двигаемся вниз по стеку). Если следовать правилам из этой конвенции, так будет c переменными и аргументами любой функции.

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

Вход и выход

Написание некоторых основных функций

Здесь понадобится ещё одна функция _strlen для подсчёта длины строки. На C она может выглядеть так:

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

И посмотрим плоды нашей тяжёлой работы, используя эту функцию в полной программе “Hello, world!”.

Хотите верьте, хотите нет, но мы рассмотрели все основные темы, которые нужны для написания базовых программ на ассемблере x86! Теперь у нас есть весь вводный материал и теория, так что полностью сосредоточимся на коде и применим полученные знания для написания нашего калькулятора RPN. Функции будут намного длиннее и даже станут использовать некоторые локальные переменные. Если хотите сразу увидеть готовую программу, вот она.

Создание стека

Теперь можно реализовать функции _push и _pop :

Вывод чисел

На C программа будет выглядеть примерно так:

Теперь вы понимаете, зачем нам эти три функции. Давайте реализуем это на ассемблере:

Теперь у нас есть все необходимые функции, осталось реализовать основную логику в _start — и на этом всё!

Вычисление обратной польской записи

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

Например, если мы хотим вычислить 84/3+6* (это выражение также можно записать в виде 6384/+* ), процесс выглядит следующим образом:

Шаг	Символ	Стек перед	Стек после
1	8	[]	[8]
2	4	[8]	[8, 4]
3	/	[8, 4]	[2]
4	3	[2]	[2, 3]
5	+	[2, 3]	[5]
6	6	[5]	[5, 6]
7	*	[5, 6]	[30]

Если на входе допустимое постфиксное выражение, то в конце вычислений на стеке остаётся лишь один элемент — это и есть ответ, результат вычислений. В нашем случае число равно 30.

В ассемблере нужно реализовать нечто вроде такого кода на C:

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

И мы закончили! Удивите всех своих друзей, если они у вас есть. Надеюсь, теперь вы с большей теплотой отнесётесь к языкам высокого уровня, особенно если вспомнить, что многие старые программы писали полностью или почти полностью на ассемблере, например, оригинальный RollerCoaster Tycoon!

Весь код здесь. Спасибо за чтение! Могу продолжить, если вам интересно.

Дальнейшие действия

Можете попрактиковаться, реализовав несколько дополнительных функций:

Источник

Написать программу, выводящую строку «Hello World» на экран

Написать прогармму выводящую строку «Hello World» на экран

Написать программу на ассемблере, выводящую на экран строку 100 раз
Написать программу на ассемблере, выводящую на экран строку 100 раз.

Составьте программу, выводящую на экран 5 строк «Hello, World!»
Всем доброго времени суток! Есть задание: 1.Составьте программу, выводящую на экран 5 строк.

Программа «Hello World» из книги Крупника А. «Изучаем ассемблер» не выводит строку
Здравствуйте! 🙂 Начал изучать Ассеблер по книге Крупника А. «Изучаем ассемблер». Переписал.

Напишите программу, выводящую на экран «бегущую строку»
Напишите программу, выводящую на экран «бегущую строку» (бегущую строку можно оформить в виде.

Решение

компилировал по разному, даже пытался использовать параметры компиляции из экземпляров которые идут вместе с Tasm 5.0

в туторе написанно что компелировать надо так
tasm32 /m3 /ml program,,;
tlink32 /Tpe /aa program,program,,import32.lib

я даже пытался инклудить всякие билиотеки в самом исходнике, но что-то не выходит (
вот сам исходник

прошу извинить если оффтоп

Надо прилинковать еще IMPORT32.LIB, тогда ошибок не будет:

Спасибо, все работает

правда я прилинковал эту библиотеку
d:\Assembler\TASM5Plus\LIB\imp 32i.lib

Решение

Вложения

	INUSE.ZIP (19.8 Кб, 203 просмотров)
	EGA_CPI.ZIP (9.8 Кб, 70 просмотров)

Решение

l user32 ‘User32.dll’ 0 0
l _user32 0 0’MessageBoxA’0

l kernel32 ‘Kernel32.dll’ 0 0; имя 2 модуля
l _kernel32 0 0’ExitProcess’0
;w 0 0’LoadLibraryA’0

l __user32 ^_user32 0 0 00000000; таблица поиска 1
l __kernel32 ^_kernel32 0 0 00000000; таблица поиска 2

; 1 IAT
l MessageBox
w ^_user32 0000;Смещение таблицы поиска
w 00000000

; 2 IAT
l ExitProcess
w ^__kernel32 0000
;l LoadLibrary 00000000
w 00000000

; таблица импорта:
; 1 модуль
w ^__user32 0000; указатель на 1 таблицу поиска
a 8; 2 пустых поля
w ^user32 0 0; указатель на имя 1 модуля
w ^MessageBox 0000; указатель на 1 IAT

Источник

tomassirio/HelloWorldAsm

Use Git or checkout with SVN using the web URL.

Work fast with our official CLI. Learn more.

Launching GitHub Desktop

If nothing happens, download GitHub Desktop and try again.

Launching GitHub Desktop

If nothing happens, download GitHub Desktop and try again.

Launching Xcode

If nothing happens, download Xcode and try again.

Launching Visual Studio Code

Your codespace will open once ready.

There was a problem preparing your codespace, please try again.

Latest commit

Git stats

Files

Failed to load latest commit information.

README.md

This year I studied computer’s organisation II in College. I’ve been fascinated thus far with how computation is done on an assembler language and I want to share with you a little of my knowledge.

Maybe this will become a series because I’m finding myself really captivated with this subject and I think a lot of people will understand better how programming works with this info.

But first things first

ASM, short for Assembler (or assembly), is not a unique language such as C, Java, Go or whatever, it is instead a program that converts code into machine language. This means there’s assembler languages for the different types of machines. For example: There is assembler for the Intel and AMD processor’ architectures (x86_64) and there’s another for ARM architectures.

This tutorial is going to be oriented toward Intel’s Architecture

🔧 What are we going to use?

For this short program we are going to use NASM and whatever text editor you like. In my case, I’m going to use VS Code since it has some nice plugins.

To install NASM on Debian systems (Ubuntu, PopOs!, Linux Mint, etc..)

I’m only going to show this example in a linux system since the sys calls are different for mac, hence the example won’t work in that system (believe me, this post was intended for mac as well. )

🏗️ Structure of an ASM program

Ok, now we have our assembler and our Text Editor or IDE. What now?

Let’s create a new file and name it helloWorld.asm

Now that we have our empty file. We need to determine how the file is going to be used. In ASM each file has 4 sections. This sections will always exist even if you don’t define them. However, if you need one, you will have to do it.

The 4 sections are:

.data : where we are going to declare our global initialised variables

.rodata : where we are going to declare our global un-itialised constants

.bss : where we are going to declare our global un-initialised variables

.text : where we are going to define our code

Since we don’t want to use any fancy C functions, nor none of those other high level languages functions for the matter, we are going to rely on Syscalls.

Without digging that deep, Syscalls are just calls to the OS. We need to call the 0x80 interruption (on UNIX systems) and pass to that interruption the parameters we want it to handle.

For the function that we are going to use (sys_write) the interruption receives 4 parameters:

RAX, RBX, RCX and RDX are just multi-purpose registers that we are going to use and that I’m going to explain in further chapters of this series. So bare with me for now.

So let’s define the message first and let’s call int 0x80 after that.

A lot of new info here. Let’s go line by line.

This is our new string. It’s declared under the name msg and we initialise it with DB (define byte) the characters that will be displayed and a ‘, 10’ which is going to be our \n character. What I want you to get out of this step is that Each char comprising ‘Hello World!’ takes one byte of memory. So by using DB we are asking the processor for a memory slot that will take 13 bytes (counting the space and \n char).

This one is a little bit tougher. We are declaring a variable call msgSize that is going to step on the right end of Hello World! ($) and will subtract the address were your msg variable began. Thus leaving us with the bytes used for msg

We have our message, let’s display it now!

Again, let’s explain what is happening here

Intel has a very weird way of doing things most of the time. So each line of text will be divided into 4 fragments again

So what we are doing in here is moving the number 4 to our RAX register (because sys_write is our function number 4 on UNIX). We move the number 1 to RBX (representing STDOUT). Then the memory in which msg is defined will be stored on RCX and finally the size on RCX. By calling int 0x80 we are asking the interruption 0x80 to handle all the parameters we threw to it and do what it’s supposed to do.

Our final step is to exit the program. And guess what? that requires another Syscall. In this case, our function will be number 1 (exit) and our parameter will be 0 (because that’s the number we want to return. 0 usually means that the program was executed successfully while 1 means that it wasn’t)

🔗 Assembling and Linking

Let’s save our file as helloWorld.asm and head over to the terminal.

And that’s it for today. You should get a ‘Hello World message on your terminal.

If you want to see the full code, here is the Repository: Hello World!

Источник

Туториал по FASM (Windows x32 API/Win32API), «Hello world!»

Коротко о FASM, ассемблере, WinAPI

Работа с окнами, отрисовка картинок, OpenGL, DirectX, GDI, и все в таком духе.

Взаимодействие с другими процессами.

Работа с консолью Windows

И еще очень много интересных функций.

Зачем нужен ассемблер?

На нем можно сделать все что угодно, от ОС до 3D игр.

Вот плюсы ассемблера:

На нем можно сделать любую программу.

А вот минусы ассемблера:

Долго делать программу. (относительно)

Что нужно для программирования на ассемблере (FASM)?

Это все мероприятие весит всего лишь 8.5MB.

Установка компонентов (если можно так назвать)

Архив FASM-а распаковуем в C:\\FASM\ или любой другой, но потом не забудьте настроить FASMEditor.

Архив FASMEdit-a распаковуем куда-то, в моем случае C:\\FASM Editor 2.0\

Архив OlyDbg распаковуем тоже куда-то, в моем случае C:\\Users\****\Documents\FasmEditorProjects\

Настройка FASM Editor-a

Для этого его нужно запустить.

Сразу вас приветствует FASM Editor соей заставкой.

Жмем на кнопку с названием «. » и выбираем путь к файлам или папкам.

Теперь мы полностью готовы. К началу.

Пишем «Hello world!» на FASM

По началу вас это может напугать, но не боимся и разбираемся.

На самом деле из всей этой каши текста, команд всего 3: на 16, 18, 21 строках. (и то это не команды, а макросы. Мы к командам даже не подобрались)

Все остальное это просто подготовка программы к запуску.

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

Самое интересное то что программа весит 2КБ. (Можно сократить и до 1КБ, но для упрощения и так пойдет)

Разбор: что значат этот весь текст?

Но есть кроме это остальные:

Сразу за командой (для компилятора) format PE Console идет ; это значит комментарий. К сожалению он есть только однострочный.

3 строка: entry start

Говорим windows-у где\в каком месте стартовать. «start» это метка, но о метках чуть позже.

5 строка: include ‘win32a.inc’

Подключает к проекту файл, в данном случае «win32a.inc» он находиться в папке INCLUDE (в папке с FASM). этот файл создает константы и создает макросы для облегчения программирования.

8 строка: section ‘.data’ data readable writeable

Секция данных, то есть программа делиться на секции (части), к этим секциям мы можем дать разрешение, имя.

Флаг «data» (Флаг это бит\байт\аргумент хранившей в себе какую-то информацию) говорит то что эта секция данных.

Флаги «readable writeable» говорят то что эта секция может читаться кем-то и записываться кем-то.

10 строка: hello db ‘hello world!’,0

12 строка: section ‘.code’ code readable writeable executable

Все остальное уже разобрали.

14 строка: start:

Это второй вид меток. Просто эта метка указывает на следующую команду. Обратите внимание на то что в 3 строке мы указали start как метку входа в программу, это она и есть. Может иметь эта метка любое имя, главное не забудьте ваше новое имя метки вписать в entry

15 строка: invoke printf, hello

Это штото на подобие команды, но это и близко не команда ассемблера, а просто макрос.

Например, макро команда invoke делиться на такие команды: (взят в пример команда с 15 строки)

Не переживайте если нечего не поняли.

17 строка: invoke getch

20 строка: invoke ExitProcess, 0

23 строка: section ‘.idata’ data import readable

24-25 строки:

Макро команда «library» загружает DLL библиотеки в виртуальную память (не в ОЗУ, вам ОЗУ не хватит чтоб хранить всю виртуальную память).

Что такое DLL объясню позже.

Дальше есть знак \ это значит что текст на следующей строке нужно подставить в эту строку.

Это нужно потому что у ассемблера 1 строка это 1 команда.

27-28 строка:

Дальше думаю не стоит объяснять, вроде все понятно.

Что такое DLL библиотека?

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

Подводим итог

Источник

Hello World на Ассемблере

После примеров простых программ на Паскале и С++ вы, наверно, не ожидали что я сразу перепрыгну на Ассемблер. Но вот перепрыгнул. И сегодня мы поприветствуем мир на языке ассемблера.

Итак, вот сразу пример, а потом его рассмотрим:

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

С другой стороны, это не так уж и страшно, как иногда думают те, кто никогда не программировал на Ассемблере.

Команда RET выполняет выход из процедуры или из программы. В нашем случае из программы. Таким образом программа завершается и мы возвращаемся в операционную систему.

Ещё несколько слов об объявлении строки:

Ну вот мы и написали свою первую программу на языке ассемблера. Если что-то пропустили, то посмотрите видео:

Источник

FasmWorld Программирование на ассемблере FASM для начинающих и не только

Учебный курс. Часть 6. Hello, world!

Автор: xrnd | Рубрика: Учебный курс | 16-03-2010 | Распечатать запись

В этой части наконец-то напишем долгожданный «Hello, world!». Теперь почти всё должно быть понятно. Для начала необходимо с помощью директивы db объявить строку, содержащую сообщение «Hello, word!». Лучше сделать это в конце программы, за последней командой, иначе процессор может принять строку за код и попытаться её выполнить.

Для вывода строки используется системная функция DOS. Чтобы напечатать строку, нужно поместить 9 в регистр AH, а в регистр DX поместить адрес строки, которая должна заканчиваться символом ‘$’. Обращение к функциям DOS осуществляется с помощью команды int 21h. Вот код программы:

use16 ;Генерировать 16-битный код org 100h ;Программа начинается с адреса 100h mov dx,hello ;В DX адрес строки. mov ah,9 ;Номер функции DOS. int 21h ;Обращение к функции DOS. mov ax,4C00h ;\ int 21h ;/ Завершение программы ;——————————————————- hello db ‘Hello, world!$’

В четвёртой строке FASM подставит адрес строки вместо hello. Не трудно догадаться, что завершение программы — это тоже функция DOS с номером 4Ch. Перед её вызовом в регистр AL помещается код завершения программы (ноль соответствует успешному завершению). Можно объединить эти две операции и сразу поместить в AX значение 4C00h.

В учебном курсе я не буду подробно описывать функции DOS, лишь кратко расскажу о тех функциях, которые мы будем использовать. Если вы захотите узнать больше, в Интернете можно найти подробное описание 🙂

Чтобы увидеть работу программы, надо запустить её из командной строки, иначе она печатает строку и сразу закрывается. Или можно написать простенький bat-файл для запуска:

Результат работы программы:

Если вы запустите программу в отладчике, то просмотреть выводимую строку можно, нажав Alt+F5 или выбрав в меню Turbo Debuger пункт Window->User Screen.

Источник

Assembler. Установка интерпретатора и запуск первой программы через DOSBox

В данной статье разбирается способ установки интерпретатора и запуск файла EXE через DOSBox. Планировалось погрузить читателя в особенности программирования на TASM, но я согласился с комментаторами. Есть много учебников по Ассемблер и нет смысла перепечатывать эти знания вновь. Лично мне в изучении очень помог сайт av-assembler.ru. Рекомендую. В комментариях также вы найдёте много другой литературы по Assembler. А теперь перейдём к основной теме статьи.

Для начала давайте установим наш старенький интерпретатор.
Ссылка

Почему именно vk.com?

Я прекрасно понимаю, что это ещё тот колхоз делиться файлами через обсуждения VK, но кто знает, во что может превратиться эта маленькая группа в будущем.

После распаковки файлов, советую сохранить их в папке Asm на диск C, чтобы иметь меньше расхождений с представленным тут материалом. Если вы разместите директорию в другое место, изменится лишь путь до файлов, когда вы будете использовать команду mount.

Для запуска интерпретатора нам так же потребуется эмулятор DOSBox. Он и оживит все наши компоненты. Скачаем и установим его!
Ссылка

В папке Asm я специально оставил файл code.asm. Именно на нём мы и потренируемся запускать нашу программу. Советую сохранить его копию, ибо там хранится весь код, который в 99% случаев будет присутствовать в каждом вашем проекте.

Итак. Запускаем наш DOSBox и видим следующее:

Для простоты сопоставим имя пути, по которому лежит наша папка Asm. Чтобы это сделать, пропишем следующую команду:

Здесь вместо d: мы можем использовать любую другую букву. Например назвать i или s. А C это наш реальный диск. Мы прописываем путь до наших файлов ассемблера.

Теперь, откроем смонтированный диск:

Прописав команду dir, мы сможем увидеть все файлы, которые там хранятся. Здесь можно заметить и наш файл CODE с расширением ASM, а также дату его создания.

И только теперь мы начинаем запускать наш файл! Бедные программисты 20 века, как они только терпели всё это? Пропишем следующую команду:

После мы увидим следующее сообщение, а наша директория пополнится новым файлом с расширением OBJ.

Теперь пропишем ещё одну команду:

В нашей папке появилась ещё пара файлов – CODE.MAP и CODE.EXE. Последний как раз и есть исполняемый файл нашего кода assembler.

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

Этот старинный интерфейс насквозь пропитан духом ушедшей эпохи старых операционных систем. Тем не менее…

Нажав F7 или fn + F7 вы сможете совершить 1 шаг по коду. Синяя строка начнёт движение вниз, изменяя значения регистров и флагов. Пока это всего лишь шаблон, на котором мы потренировались запускать нашу программу в режиме дебага. Реальное “волшебство” мы увидим лишь с полноценным кодом на asm.

Небольшой пример для запуска

Прога проверяет, было ли передано верное число открывающих и закрывающих скобок:

Давайте ознакомимся с имеющимися разделами.

Code segment – место, где turbo debug отражает все найденные строки кода. Важное замечание – все данные отражаются в TD в виде 16-ричной системы. А значит какая-нибудь ‘12’ это на самом деле 18, а реальное 12 это ‘C’. CS аналогичен разделу “Begin end.” на Pascal или функции main.

Data segment, отражает данные, которые TD обнаружил в d_s. Справа мы видим их символьную (char) интерпретацию. В будущем мы сможем увидеть здесь наш “Hello, world”, интерпретируемый компилятором в числа, по таблице ASCII. Хорошей аналогией DS является раздел VAR, как в Pascal. Для простоты можно сказать, что это одно и тоже.

Stack segment – место хранения данных нашего стека.

Регистры

Все эти ax, bx, cx, si, di, ss, cs и т. д. – это наши регистры, которые используются как переменные для хранения данных. Да, это очень грубое упрощение. Переменные из Pascal и регистры Assembler это не одно и тоже, но надеюсь, такая аналогия даёт более чёткую картину. Здесь мы сможем хранить данные о циклах, арифметических операциях, системных прерываниях и т. д.

Флаги

Все эти c, z, s, o, p и т.д. это и есть наши флаги. В них хранится промежуточная информация о том, например, было ли полученное число чётным, произошло ранее переполнение или нет. Они могут хранить результат побитого сдвига. По опыту, могу сказать, на них обращаешь внимание лишь при отладке программы, а не во время штатного исполнения.

Маленькая шпаргалка для заметок:

mount d: c:\asm – создаём виртуальный диск, где корень –папка asm

tasm code.asm – компилируем исходный код

tlink code.obj – создаём исполняемый файл

td code – запускаем debug

F7 – делаем шаг в программе

Буду ждать комментарии от всех, кому интересен Assembler. Чувствую, я где-то мог накосячить в терминологии или обозначении того или иного элемента. Но статья на Habr отличный повод всё повторить.

Источник

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

Многие считают, что 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 выполняется переход по метке, основываясь на результате сравнения переменных. Если он отрицательный – происходит переход, а если операнды не равняются друг другу, переход не осуществляется.

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

Источник

Учебный курс. Урок 6. Hello, world!

В этой части наконец-то напишем долгожданный «Hello, world!». Теперь почти всё должно быть понятно. Откроем в текстовом редакторе новый файл и сохраним его как hello.asm в директории C:\fasm. Для начала необходимо с помощью директивы db объявить строку, содержащую сообщение «Hello, word!». Лучше сделать это в конце программы, за последней командой, иначе процессор может принять строку за код и попытаться её выполнить.

Чтобы увидеть работу программы, надо дать команду fasm для компиляции исходного кода в файл COM, а затем запустить её из командной строки DOSBox.

Источник

Hello World with NASM Assembler

NASM, or The Netwide Assembler, is an x86 compiler that allows us to turn Assembly code in to machine code object files. Once we have an object file, we can link it and create the final executable. This example is meant for Unix systems or Windows with MinGW toolchain installed. On Debian systems, it can be installed with the nasm package. Put the code below in to hello.asm

Variables are defined the data section and code goes in the text section. We define the hello world string and the length of it. Then, the number that represents the system call for printing is moved into the eax register. That is where the computer will look for the system call number when the system interrupt int 80h is called. To see what other cool things we can do with Linux system calls, check out the chart at the bottom of the page.

Source Code

Compiling and Running

Linux System Calls

In the example above, we move the number 4 in to eax and then call the system interrupt int 80h. We always call the same interrupt, but depending on what values we put in the registers, different things happen. Linux provides a number of system calls besides the one we use, 4, which corresponds to the write call. We write to STDOUT, also knows as file descriptor 1, but we could also write to 2(STDERR) or the file descriptor of a text file on the hard disk or a network socket. STDIN is file descriptor 0, which we would to read from and not write to. Can you figure out what value we would need to put in to eax in order to perform a read? Hint: it is the value for the sys_read system call which you can find in the link below. What else would you need to change in order to read from STDIN? The table below shows what system calls are available as well as what parameters are expected in each register. Registers that have empty values are unused. Check out the Linux System Call Chart.

Источник

Изучаем архитектуру Intel x86-64 при помощи ассемблера (Часть 1 — Hello World на голом железе)

Я давно хотел научиться писать операционную систему или хотя бы попробовать эту задачу на зуб. Почему ОС начинают писать на языке ассемблера? Дело в том, что работа ОС обеспечивается определенными особенностями архитектуры процессора. Это, например, наличие нескольких уровней привилегий (режим ядра, режим пользователя), поддержка виртуальной памяти, поддержка многозадачности. Работа с этими особенностями архитектуры процессора подразумевает использование таких машинных команд и регистров процессора, о которых компиляторы высокоуровневых языков программирования (например C/C++) ничего не знают. Поэтому — ассемблер. В следующей серии заметок я буду писать о своих опытах исследования архитектуры процессоров Intel как то: работа в реальном режиме, переход в защищенный режим, написание загрузчика (bootloader), обработка прерываний, включение механизма виртуальной памяти и пр.

В Интернете я нашел несколько хороших ресурсов по теме:

Кроме того, если вы не знакомы с языком ассемблера для процессоров семейства x86, рекомендую вам книгу Kip Irvine — Assembly Language for x86 Processors, 7th edition — 2014.

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

Программа HelloWorld

Ниже показан исходный код программы HelloWorld на языке ассемблера Flat Assembler (FASM), которая будет стартовать на голом железе в реальном режиме работы x86-совместимого процессора (комментарии пишу на английском — привычка, которая возникла у меня в связи с проблемами с кодировками кириллицы).

; HelloWorld real mode
use16 ; generate 16-bit code
org 7C00h ; the code starts at 0x7C00 memory address

Компиляция исходного кода

Объяснения того, как работает программа — потом, сначала давайте скомпилируем исходный код. Компилировать будем ассемблером Flat Assembler (FASM). Скачиваем с официального сайта архив с дистрибутивом FASM. Внутри архива находится компилятор fasm.exe. Я рекомендовал бы распаковать архив в папку C:\FASM и добавить путь к этой папке в переменную окружения PATH. Далее запускаем командную строку и компилируем исходный код:

HelloWorld.asm — это приведенный выше файл с исходным кодом, HelloWorld.bin — это скомпилированный машинный код.

Создание образа дискеты

Операционная система должна загружаться с какого-то носителя (жесткого диска, CD-ROM, флешки, дискеты и т. д.). Создадим образ загрузочной дискеты с нашим машинным кодом. Виртуальная машина сможет загрузиться с виртуальной дискеты, используя этот образ. Создавать образ дискеты умеет unix’овая утилита под названием dd. Существует версия этой утилиты под Windows. Если вы пользуетесь средой Cygwin, то утилита dd есть в ее составе. Итак, запускаем командную строку:

1-я команда создает образ дискеты floppy.img и заполняет его нулями, 2-я — записывает в самое начало образа нашу программу.

Установка и запуск виртуальной машины Bochs

Type of floppy drive	3.5 1.44M
First floppy image/device	жмем Browse и выбираем ранее созданный нами файл floppy.img
Type of floppy media	1.44M
Write Protection	галка снята
Status	inserted

Жмем кнопку OK. В окне Bochs Start Menu жмем кнопку Start (предварительно можно сохранить сделанные нами настройки в текстовом файле с расширением .bxrc нажав кнопку Save, впоследствии их можно будет загрузить, нажав кнопку Load). Открывается окно, в котором мы видим надпись

Особенности FASM

Прежде всего обратите внимание на документацию Flat Assembler Documentation and Tutorials, которая также поставляется в дистрибутиве FASM в виде файла PDF. Синтаксис FASM имеет особенности, которые отличают его например от MASM, которым мне доводилось пользоваться до сих пор. Особенности касаются обращений к памяти и работы с метками:

Источник

Hello World! in ASM x86_64

Maybe this will become a series because I’m finding myself really captivated with this subject and I think a lot of people will understand better how programming works with this info.

But first things first

❓ What is ASM?

This tutorial is going to be oriented toward Intel’s Architecture

🔧 What are we going to use?

For this short program we are going to use NASM and whatever text editor you like. In my case, I’m going to use VS Code since it has some nice plugins.

To install NASM on Debian systems (Ubuntu, PopOs!, Linux Mint, etc..)

Exit fullscreen mode

I’m only going to show this example in a linux system since the sys calls are different for mac, hence the example won’t work in that system (believe me, this post was intended for mac as well. )

🏗️ Structure of an ASM program

Ok, now we have our assembler and our Text Editor or IDE. What now?

Let’s create a new file and name it helloWorld.asm

The 4 sections are:

.data : where we are going to declare our global initialised variables

.rodata : where we are going to declare our global un-itialised constants

.bss : where we are going to declare our global un-initialised variables

.text : where we are going to define our code

👏 Hands On

Since we don’t want to use any fancy C functions, nor none of those other high level languages functions for the matter, we are going to rely on Syscalls.

Without digging that deep, Syscalls are just calls to the OS. We need to call the 0x80 interruption (on UNIX systems) and pass to that interruption the parameters we want it to handle.

For the function that we are going to use (sys_write) the interruption receives 4 parameters:

RAX, RBX, RCX and RDX are just multi-purpose registers that we are going to use and that I’m going to explain in further chapters of this series. So bare with me for now.

So let’s define the message first and let’s call int 0x80 after that.

A lot of new info here. Let’s go line by line.

Exit fullscreen mode

We have our message, let’s display it now!

Again, let’s explain what is happening here

Exit fullscreen mode

Intel has a very weird way of doing things most of the time. So each line of text will be divided into 4 fragments again

Exit fullscreen mode

🔗 Assembling and Linking

Let’s save our file as helloWorld.asm and head over to the terminal.

Exit fullscreen mode

And that’s it for today. You should get a ‘Hello World message on your terminal.

If you want to see the full code, here is the Repository: Hello World!

Источник

Hello World…Not so easy in Assembly

In this blog post I will walk through a Hello World program in assembly (RISC style Nios II architecture). Although I will not go into detail about what Nios II architecture means, it is important to mention that in order to run the Hello World program, either a computer board or simulator that supports Nios II architecture is required. I recommend using the simulator found here.

Hello World is often the first program new programmers write as it is very simple. I will demonstrate the Hello World program in C, Ruby, JavaScript, and Java to emphasize the simplicity of this program.

Hello World in C

Hello World in Ruby

Hello World in JavaScript

Hello World in Java

Hello World in Assembly

Before I unveil the assembly version of Hello World, I must give you a warning that it is quite long and scary, but I will explain everything to the best of my abilities after. Without further ado, the moment we have all been waiting for, Hello World in assembly:

Yes, I know, it looks very scary. Hopefully, you have not clicked off the blog yet. In Figure 5, lines 1–5 are initializing constants. For example, the first line sets LAST_RAM_WORD to 0x007FFFFC which is a memory location in hexadecimal. Line 8 allows the linker to know where the program starts. In this case, the program starts on line 11. Line 9 lets the assembler know that the memory location of the following line. In Figure 5, line 9 tells the assembler that _start: is at location 0x00000000.

Now, I will explain what is happening in the _start: label, beginning on line 11 in Figure 5. The first line inside of _start:, line 12, moves the value of LAST_RAM_WORD to the stack pointer (sp). That line has essentially initiated sp to contain memory address, 0x007FFFFC. The following line moves ‘\n’ or the next line character into register 2, an internal register on the CPU. Line 14 calls PrintChar. This means that the program will begin executing the code following the PrintChar: label starting on line 20. For simplicity, from now on I will refer to _start:, _end:, PrintChar:, and PrintString: as functions or routines even though they are labels.

The PrintChar: function is in charge of printing a character to the screen. To clarify, this program actually prints the new line character followed by the hello world string. The reason I chose to insert the new line character was to explain the PrintChar: function before explaining the PrintString: function which just calls the PrintChar: function multiple times. To explain this function, I will define word addressable memory. A word can be thought of as a memory unit which can store information. In Nios II architecture, a word is 4 bytes or 32 bits. This PrintChar: function begins by subtracting eight bytes from sp, essentially generating space for two words. Lines 22 and 23 store the current values of registers three and four into the generated spaces. This is important because the CPU contains a limited number of registers that can be used, so storing the value of these registers allows the function to use the registers and restore their values when the function is finished. Line 24 sets the value of register three to 0x10001000, which is the input/output location. Line 25 is a label (pc_loop:). The relevance of this label will become apparent in a moment after defining the next three lines. Line 26 loads the status of the input/output location into register four. Line 27 logically ands the upper bits of the value in register four and WSPACE_MASK (0xFFFF) and then stores the result in register four. The “beq” in line 28 stands for “branch equal to.” Essentially, line 28 causes the program to loop back to the “pc_loop” label (line 25) if the value of register four equals the value of register zero. To clarify, register zero is a special register that always has a value of zero. Lines 25 through 28 represent a while loop from a higher level language. The while loop causes the program to wait until the output device is ready to print the character. Line 29 outputs the contents of register two to the console. In other words, line 29 is the line responsible for making the letter appear on the screen. Line 30 and 31 restore the values of register three and four to their values before entering the PrintChar: function. After the values are restored, the stack pointer (sp) no longer needs to store data, thus line 32 adds 8 bytes to the stack pointer to return sp to its original state. Finally, the program returns to the line following the call to PrintChar or line 15 upon hitting “ret” on line 33.

Once we return to line 15, register two is given the address of the string we are trying to print, “Hello World\n”. Then, on line 16, the PrintString: method is called. To keep it concise, this method loops through the string, sending each letter to the PrintChar: method. So initially, the “H” in “Hello World\n” is sent to the PrintChar: method. Then, the “e” is sent to the PrintChar: method. This process (loop) will continue until the “\n” character.

Upon termination of the PrintString: routine, the program returns to line 17, or the _end: label. Then, on line 18, the program branches back to line 17 an infinite number of times which essentially cause the program to terminate as it is stuck in an infinite loop.

For anyone wondering, lines 54 and 55 let the program know that the “Hello World\n” string begins in memory location 0x1000.

Conclusion

Assembly is a very interesting language that is a lot harder to learn as it requires knowledge of the hardware you are working with. As previously mentioned, this assembly program was written in RISC style Nios II architecture (a version of assembly). The Hello World program is a lot harder in assembly than any high level programming language as it requires the programmer to define the program entirely such as specifying memory locations. Furthermore, in assembly, the programmer must specify what appears on the screen and when, which is why the program loops through the string and prints one character at a time. However, assembly allows programmers to optimize programs and algorithms by taking advantage of hardware features which may not be possible otherwise.

Источник

Основы ассемблера

Ты решил освоить ассемблер, но не знаешь, с чего начать и какие инструменты для этого нужны? Сейчас расскажу и покажу — на примере программы «Hello, world!». А попутно объясню, что процессор твоего компьютера делает после того, как ты запускаешь программу.

Основы ассемблера

Я буду исходить из того, что ты уже знаком с программированием — знаешь какой-нибудь из языков высокого уровня (С, PHP, Java, JavaScript и тому подобные), тебе доводилось в них работать с шестнадцатеричными числами, плюс ты умеешь пользоваться командной строкой под Windows, Linux или macOS.

Если наборы инструкций у процессоров разные, то на каком учить ассемблер лучше всего?

Знаешь, что такое 8088? Это дедушка всех компьютерных процессоров! Причем живой дедушка. Я бы даже сказал — бессмертный и бессменный. Если с твоего процессора, будь то Ryzen, Core i9 или еще какой-то, отколупать все примочки, налепленные туда под влиянием технологического прогресса, то останется старый добрый 8088.

SGX-анклавы, MMX, 512-битные SIMD-регистры и другие новшества приходят и уходят. Но дедушка 8088 остается неизменным. Подружись сначала с ним. После этого ты легко разберешься с любой примочкой своего процессора.

Больше того, когда ты начинаешь с начала — то есть сперва выучиваешь классический набор инструкций 8088 и только потом постепенно знакомишься с современными фичами, — ты в какой-то миг начинаешь видеть нестандартные способы применения этих самых фич.

Что и как процессор делает после запуска программы

После того как ты запустил софтину и ОС загрузила ее в оперативную память, процессор нацеливается на первый байт твоей программы. Вычленяет оттуда инструкцию и выполняет ее, а выполнив, переходит к следующей. И так до конца программы.

Некоторые инструкции занимают один байт памяти, другие два, три или больше. Они выглядят как-то так:

Хотя погоди! Только машина может понять такое. Поэтому много лет назад программисты придумали более гуманный способ общения с компьютером: создали ассемблер.

Благодаря ассемблеру ты теперь вместо того, чтобы танцевать с бубном вокруг шестнадцатеричных чисел, можешь те же самые инструкции писать в мнемонике:

Согласись, такое читать куда легче. Хотя, с другой стороны, если ты видишь ассемблерный код впервые, такая мнемоника для тебя, скорее всего, тоже непонятна. Но мы сейчас это исправим.

Регистры процессора: зачем они нужны, как ими пользоваться

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

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

У процессора 8088 регистры 16-битные, их восемь штук (в скобках указаны типичные способы применения регистра):

С теорией пока закончили. Давай теперь подготовим рабочее место и напишем программу «Hello, world!», чтобы понять, как эта теория работает вживую.

Подготовка рабочего места

Написание, компиляция и запуск программы «Hello, world!»

Если тебе непонятно, что тут написано, — не переживай. Пока просто постарайся привыкнуть к ассемблерному коду, пощупать его пальцами. Чуть ниже я все объясню. Плюс студенческая мудрость гласит: «Тебе что-то непонятно? Перечитай и перепиши несколько раз. Сначала непонятное станет привычным, а затем привычное — понятным».

Теперь запусти командную строку, в Windows это cmd.exe. Потом зайди в папку nasm и скомпилируй программу, используя вот такую команду:

Чтобы запустить этот файл в современной ОС, открой DOSBox и введи туда вот такие три команды:

Само собой, вместо c : \ nasm тебе надо написать ту папку, куда ты скопировал компилятор. Если ты все сделал правильно, в консоли появится сообщение «Hello, world!».

Инструкции, директивы

В нашей с тобой программе есть только три вещи: инструкции, директивы и метки.

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

Директивы (в нашей программе их две: org и db ) — это распоряжения, которые ты даешь компилятору. Каждая отдельно взятая директива говорит компилятору, что на этапе ассемблирования нужно сделать такое-то действие. В машинный код директива не переводится, но она влияет на то, каким образом будет сгенерирован машинный код.

Директива org говорит компилятору, что все инструкции, которые последуют дальше, надо размещать не в начале сегмента кода, а отступить от начала столько-то байтов (в нашем случае 0x0100).

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

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

Метки, условные и безусловные переходы

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

Что значит «прыгать из других мест программы»? В норме процессор выполняет инструкции последовательно, одну за другой. Но если тебе надо организовать ветвление (условие или цикл), ты можешь задействовать инструкцию перехода. Прыгать можно как вперед от текущей инструкции, так и назад.

У тебя в распоряжении есть одна инструкция безусловного перехода ( jmp ) и штук двадцать инструкций условного перехода.

Обрати внимание: метки начинаются либо с буквы, либо со знака подчеркивания, либо со знака собаки. Цифры вставлять тоже можно, но только не в начало. В конце метки обязательно ставится двоеточие.

Комментарии, алгоритм, выбор регистров

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

Как добавлять комментарии? Просто поставь точку с запятой, и все, что напишешь после нее (до конца строки), будет комментарием. Давай добавим комментарии в нашу программу.

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

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

Взаимодействие с пользователем: получение данных с клавиатуры

Потом иди в командную строку и скомпилируй его в NASM:

Источник

5. Hello world на ассемблер 8086

Статья основана на материале xrnd с сайта asmworld (из учебного курса по программированию на ассемблер 16-битного процессора 8086 под DOS).

В четвёртой строке FASM подставит адрес строки вместо hello. Не трудно догадаться, что завершение программы — это тоже функция DOS с номером 4Ch. Перед её вызовом в регистр AL помещается код завершения программы (ноль соответствует успешному завершению). Можно объединить эти две операции и сразу поместить в AX значение 4C00h.

Результат работы программы:

Если вы запустите программу в отладчике, то просмотреть выводимую строку можно, нажав Alt+F5 или выбрав в меню Turbo Debuger пункт Window->User Screen.

Источник

Hello world assembler

Now we will write our program, the old classic «Hello, world» ( hello.asm ). You can download its source and binaries here But before you do, let me explain several basics.

System calls

Unless a program is just implementing some math algorithms in assembly, it will deal with such things as getting input, producing output, and exiting. For this, it will need to call on OS services. In fact, programming in assembly language is quite the same in different OSes, unless OS services are touched.

There are two common ways of performing a system call in UNIX OS: through the C library ( libc ) wrapper, or directly.

This tutorial will show how to use direct kernel calls, since this is the fastest way to call kernel service; our code is not linked to any library, does not use ELF interpreter, it communicates with kernel directly.

Things that differ in different UNIX kernels are set of system calls and system call convention (however as they strive for POSIX compliance, there’s a lot of common between them).

Program layout

As a rule, modern IA-32 UNIXes are 32bit (*grin*), run in protected mode, have a flat memory model, and use the ELF format for binaries.

Ok, now we’ll dive into OS specific details.

Linux

System calls in Linux are done through int 0x80. (actually there’s a kernel patch allowing system calls to be done via the syscall ( sysenter ) instruction on newer CPUs, but this thing is still experimental).

There have been several attempts to write an up-to-date documentation of the Linux system calls, examine URLs in the References section below.

So, our Linux program will look like:

Kernel source references:

FreeBSD

most of this section should apply to other BSD systems (OpenBSD, NetBSD) as well, however the source references may be different.

Ok, I think the source will explain this better:

Kernel source references:

For information where to find system call function numbers and other interesting details, examine asmutils, especially the os_beos.inc file.

Building an executable

Building an executable is the usual two-step process of compiling and then linking. To make an executable out of our hello.asm we must do the following:

OpenBSD and NetBSD users should issue the following sequence instead (because of a.out executable format):

Источник

ARM assembly hello world tutorial

This tutorial will show the basics of how to create and build a simple hello world program written in ARM assembly language, for this tutorial I am using the VIM editor but any plain text editor will work since assembly has very simple syntax, aditional software required for this tutorial is an ARM assembler and linker, and also a Linux operating system.

Creating an new file

Exiting

The file now has a entry point and could be assembled, but the program is missing a way to terminate properly. so we will use a system call to tell the operating system that we are done. system call codes are passed in register r7 and the number for SYS_EXIT is 1, to move small numbers directly into registers we use the » mov » instuction, here how » mov r7, #1 «, the pound sign in front of the number tells the assembler that it is a literal, numbers up to 255 can be used this way. next well call the software interrupt with the instuction » swi 0 «. the file should now look like this:

Defining the data

Displaying the text

Now we display the message that we defined. to display text to the console the system call SYS_WRITE is used, it is call number 4, SYS_WRITE needs some arguments such as where to display the message, the memory location and the string length. In register r0 we tell it to display the message to stdout using the code 1, then we load into r1 the memory address of the label used to indentify the string using the load into register instruction » ldr «, this is how the ldr instruction is used » ldr r1, =message » the first argument is the destination register and the 2nd is the label name.
The next step is to load the label containing the length of the string into r2, this is how » ldr r2, =len «, then we move into r7 SYS_WRITE which is number 4, the last step is to call the software interrupt using » swi 0 «, after that the text will be displayed. The file should now look like this:

Building the program

If you have any questions or comments please add a comment bellow.

Источник

Hello world assembler

Лабораторная работа №1. Первая программа на языке ассемблера

Краткие теоретические сведения

Структура ассемблерной программы

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

Команда может быть директивой — указанием транслятору, которое выполняется в процессе превращения программы в машинный код. Многие директивы начинаются с точки. Для удобства чтения программы они обычно пишутся БОЛЬШИМИ БУКВАМИ. Кроме директив еще бывают инструкции — команды процессору. Именно они и будут составлять машинный код программы.

Нужно отметить, что понятие «машинного кода» очень условно. Часто оно обозначает просто содержимое выполняемого файла, хранящего кроме собственно машинных команд еще и данные (в нашем случае — текст выводимого сообщения «Hello world»).

Особенности создания ассемблерной программы

На платформе Linux язык ассемблера является самым низкоуровневым языком программирования. Т.е. он больше любых других приближен к архитектуре ЭВМ и ее аппаратным возможностям, позволяет получить к ним более полный доступ, нежели в языках выского уровня, наподобие C/C++, Perl, Python и пр. Заметим, что получить полный доступ к ресурсам компьютера в современных архитектурах нельзя, самым низким уровнем работы прикладной программы является обращение напрямую к ядру ОС. Именно на этом уровне и работают программы, написанные на ассемблере в Linux. Но, в отличие от языков высокого уровня (ЯВУ), ассемблерная программа содержит только тот код, который ввел программист, и конечно же вся ответственность за логичность кода полностью лежит на плечах программиста.

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

Еще пример. Можно попробовать «выполнить» данные вместо кода. Часто это лишено смысла. Но если программист это сделает, транслятор не выдаст никаких сообщений об ошибке. Язык ассемблера позволяет делать все! Вопрос состоит лишь в том, какие усилия придется приложить, чтобы реализовать идею на этом языке. Тут меньше ограничений, чем в ЯВУ, но, в то же время, и удобства и простоты создания программ тоже меньше.

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

Важно помнить, что в 90% случаев зависание является простым. Чаще всего не хватает аппаратных возможностей компьютера для быстрой обработки данных и необходимо просто подождать или нажать Ctrl+C.

Процесс обработки программы на языке ассемблера

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

Таким образом, процесс создания ассемблерной программы можно изобразить в виде следующей схемы. Конечной целью, напомним, является работоспособный выполняемый файл hello (см. рис. [pic:l1]).

Основные возможности текстового редактора mcedit

mcedit — это текстовый редактор, встроенный в двухпанельный файловый менеджер Midnight Commander. Сама по себе среда Midnight Commander (или просто mc ) очень схожа с другими «командерами». Например, чтобы создать в текущем каталоге файл lab1.asm и начать его редактирование, можно набрать:

Общий вид командной строки для запуска:

mcedit [-bcCdfhstVx?] [+число] file

+число	переход к указанной числом строке (не ставьте пробел между знаком + и числом)
-b	черно-белая цветовая гамма
-c	цветовой режим ANSI для терминалов без поддержки цвета
-d	отключить поддержку мыши
-V	вывести версию программы

mcedit — это полноценный полноэкранный редактор, позволяющий редактировать файлы размером до 64 Мб, с возможностью редактирования бинарных файлов. Основными возможностями являются: копирование блока, перемещение, удаление, вырезка, вставка; отмена; выпадающие меню; вставка файлов; макро-команды; поиск регулярных выражений и их замена; подсветка синтаксиса; перенос по словам; изменяемая длина табуляции; использование перенаправления потоков для применения, например, проверки орфографии при помощи ispell.

Редактор крайне прост в использовании и может быть использован без предварительного изучения. Выпадающее меню вызывается клавишей F9. Список наиболее часто используемых горячих клавиш приведен ниже (Ctrl и Shift обозначают соответствующие клавиши клавиатуры, Meta — условное обозначение для набора мета-клавиш, на современном компьютере это обычно Alt или Esc):

F3	Начать выделение текста. Повторное нажатие F3 закончит выделение
Shift+F3	Начать выделение блока текста. Повторное нажатие F3 закончит выделение
F5	Скопировать выделенный текст
F6	Переместить выделенный текст
F8	Удалить выделенный текст
Meta+l	Переход к строке по её номеру
Meta+q	Вставка литерала (непечатного символа). См. ниже
Meta+t	Сортировка строк выделенного текста
Meta+u	Выполнить внешнюю команду и вставить в позицию под курсором её вывод
Ctrl+f	Занести выделенный фрагмент во внутренний буфер обмена mc (записать во внешний файл)
Ctrl+k	Удалить часть строки до конца строки
Ctrl+n	Создать новый файл
Ctrl+s	Включить или выключить подсветку синтаксиса
Ctrl+t	Выбрать кодировку текста
Ctrl+u	Отменить действия
Ctrl+x	Перейти в конец следующего слова
Ctrl+y	Удалить строку
Ctrl+z	Перейти на начало предыдущего слова
Shift+F5	Вставка текста из внутреннего буфера обмена mc (прочитать внешний файл)
Meta+Enter	Диалог перехода к определению функции
Meta+-	Возврат после перехода к определению функции
Meta++	Переход вперед к определению функции
Meta+n	Включение/отключение отображения номеров строк
tab	Отодвигает вправо выделенный текст, если выключена опция «Постоянные блоки»
Meta-tab	Отодвигает влево выделенный текст, если выключена опция «Постоянные блоки»
Shift+Стрелки	Выделение текста
Meta+Стрелки	Выделение вертикального блока
Meta+Shift+-	Переключение режима отображения табуляций и пробелов
Meta+Shift++	Переключение режима «Автовыравнивание возвратом каретки»

Также работают и привычные по Norton и Volkov Commander’ам клавиши:

Ctrl-Ins	копировать
Shift-Ins	вставить
Shift-Del	вырезать
Ctrl-Del	удалить выделенный текст

Выделение мышью также работает на некоторых терминалах.

Клавиши автозавершения (обычно Alt-Tab или Escape Tab) завершают слово, на котором находится курсор, используя ранее применявшиеся в файле слова.

Правила оформления ассемблерных программ

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

Оптимальной считается такая строка:

mov eax, ebx ; текст комментария

Количество табуляций перед комментарием определяется длиной аргументов команды и может быть от 1 до 3.

По мере знакомства с синтаксисом языка будут приводиться дополнительные правила.

NASM всегда создает выходные файлы в текущем каталоге.

NASM не запускают без параметров, т. к. он — всего лишь транслятор, а не интегрированная среда разработки.

Рекомендуется в рабочем каталоге все файлы хранить в определенной иерархии. Например, для первой работы создайте каталог

Например, для компиляции приведенного выше текста программы «Hello World» необходимо писать:

Более подробно синтаксис командной строки рассмотрен в следующих работах.

Как видно из схемы на рис. [pic:l1], чтобы получить исполняемую программу, объектный файл необходимо передать на обработку компоновщику (или, как его еще называют, линковщику):

Примечание: в данном случае исполняемый файл hello выполняется из текущего каталога (что обеспечивают символы «./» перед его именем).

Источник

Be cool admin

Если вы дадите человеку программу, то займете его на один день. Если вы научите человека программировать, то займете его на всю жизнь.

TASM до сих пор изучают в некоторых университетах, поэтому будем считать что он справляется с образовательной целью. Где же взять исходники? В статье «MASM, TASM, FASM, NASM под Windows и Linux«, находим необходимый нам TASM, успешно работающий из Dosbox. Однако, мы не сможем проделать линкование, так как нам не будет хватать библиотеки DPMI16BI.OVL, которую необходимо поместить в папку с TASM.

Далее нам необходимо установить DOSbox — программа хороша тем, что одинаково успешно работает на Windows, Linux, Mac, а также сразу имеет установленную операционную систему. Если вы никогда не работали с DOSBox, то в интернете полно гайдов о том как её настроить для своей системы ( например настройка для linux). В целом настройка конфигурационного файла и горячих клавиш будет одинаковой на разных системах.

После того как вы добавите папку (жесткий диск) для вашей DosBox, нам необходимо будет создать файл ассемблера. (Также стоит помнить команды DOS для отображения файлов и перехода в каталог — DIR CD). Для графической навигации можете установить файловый менеджер вроде Norton Commander.

Создадим наш hello.asm в любом текстовом редакторе

Для простых случаев можно запускать транслятор и компоновщик TASM без параметров. После запуска tasm hello.asm в нашем каталоге появится два файла — hello.obj hello.map. Их легко можно открыть в редакторе и посмотреть что происходит с программой. После этого можно пропустить наш объектный файл через транслятор, чтобы получить исполняемый файл.

Что будет если забыть добавить файл-библиотеку Добавляем необходимую библиотеку и наслаждаемся результатом

Вот так довольно легко и просто можно настроить себе среду для обучения одного из intel ассемблера.

Источник

KyleNehman/Linux-ASM-Hello-World

Use Git or checkout with SVN using the web URL.

Work fast with our official CLI. Learn more.

Launching GitHub Desktop

If nothing happens, download GitHub Desktop and try again.

Launching GitHub Desktop

If nothing happens, download GitHub Desktop and try again.

Launching Xcode

If nothing happens, download Xcode and try again.

Launching Visual Studio Code

Your codespace will open once ready.

There was a problem preparing your codespace, please try again.

Latest commit

Git stats

Files

Failed to load latest commit information.

README.md

A simplistic Hello World for nasm w/ intel syntax

The makefile assumes you’ve got nasm and ld installed, and uses the ‘-m elf_i386’ linker flag for my own pc, you’ll probably have to adjust this.

What’s this crazy code do? (Breakdown)

This program is more or less the equivalent of the following python:

Let’s go line by line, since this is for total beginners.

The section ‘.data’ tells the computer that data, similar to variables, are to be stored here.

‘msg’ and ‘msgLen’ act similar to variables, but they are actually there just for the programmer to mark specific memory offsets of where we’ve stored data.

db defines bytes, generally (with ascii), each character is stored as 1 byte. So here we list the bytes we want to store in order. In this case «Hello, World!» followed by 0x0a, the newline character.

equ says that we want to evaulate the expression ‘$-msg’ which takes the current memory address (represented by the ‘$’ character) and subtracts the address labeled ‘msg’. Since msgLen is stored directly after msg in memory this difference will actually be the length, or number of elements in, the array of bytes we stored as ‘msg’.

Text Section (The first chunk):

The remainder of the program is technically the text section so we’ll go at it in chunks

Similar to ‘.data’, ‘.text’ is where our instructions (and the bulk of the program) go. Defining the global ‘_start’ is similar, and is like a main() function in other languages. It’s the required entry point for the program.

The program begins execution at the ‘_start’ label, by moving the data from ‘msg’ and ‘msgLen’ into the registers ‘ecx’ and ‘edx’ respectively. Similar to how you pass a string into python’s print function the string and length must be passed into these registers in order to output them to the screen.

After moving our data into those registers we call the print subroutine (think of subroutines like functions) and then the exit subroutine. But those haven’t been defined! How does our program know what that even means? It wouldn’t if we didn’t define them, but thankfully we did lower down. Since the assembler and linker will rearrange our subroutine definitions for us you can define them in whatever order makes the most sense (and looks cleanest) to you.

So we defined the print label, now our program knows where to go when we call print, what’s up with pushing those registers? This step is actually totally unecessisary for our program, but it’s good practice. We push the current values of eax and ebx onto the stack so that when we write to them in a second the data isn’t lost. The last thing you want to do is lose data in a register because you called a subroutine that modified it without your knowledge.

Similar to how we just had to put the string and length in ecx and edx, eax needs to contain the int 4 in it so the computer knows we want to print, and ebx needs 1 so it knows the printed data is going to stdout. Simple stuff!

int 0x80 actually ins’t the integer 128, I mean it is, but not as a variable. int here means interrupt, so the program triggers a cpu interrupt, causing the computer to read eax and determine what to do. It sees 4 in eax, checks ebx for the output (stdout here) and then prints what’s in ecx, up to the number of chars specified by edx. Get it? Good!

Then we pop the values off the stack back into the registers that we modified and return! Notice we don’t return a value? ret is required here to specify the end of our function, now the stack pointer can do it’s magic and get us back to where we originally called the print subroutine.

At this point you should see what’s going on but we’ll run through it. The label exit is defined so that we can refer to this memory address in our program. Then we move the value 1 into eax and trigger a cpu interrupt causing something to happen based on the value of eax. What happens with interrupt code 1 on linux? The program exits with the code specified in ebx (0 for successful exit by standard).

About

A simplistic Hello World for x64 nasm w/ intel syntax

Источник

Hello world assembler

lstewart/articles/cpumemory.pdf) by Ulrich Drepper. It is a fantastic resource that goes into more details in a far more comprehensive fashion than I could ever hope to achieve. It’s a long read, so make yourself comfy before getting started! ## Types of memory ## This could be an entire article on its own, so we’re just going to go over the basics here. By now, you should be familiar with the fact that everything that happens with computers happens by moving memory around; all we’re doing is just writing code at an abstraction level higher than that to help us manage that movement of memory. As such, how fast the hardware can move memory from one place to another is one of the most important considerations when we write code that uses different types of memory in different ways. The common types of memory available to us when programming x64 assembly are, in order of speed of access (for the current generation of Intel Core i7 processors): * **CPU registers** (mostly 64 bits per register, with exceptions for some special registers that could go up to 512 bits wide) * **CPU caches** (L1, L2 and L3, with L1 and L2 being

In order to follow the x64 calling convention, we must therefore pass `a`, `b`, `c` and `d` in the registers `rcx`, `rdx`, `r8` and `r9` respectively, with `e` being pushed onto the stack before calling the function `foo()`. Thus, if I wanted to call `foo()` like so:

void foo_fp(float a, float b, float c, float d, float e) < // Do something with these floats. return; >

Assuming I wanted to call `foo_fp()` like so:

foo_fp(0.1f, 0.2f, 0.3f, 0.4f, 0.5f);

void foo_mixed(int a, int b, float c, int d, float e) < // Variable types of arguments. now what? return; >

Which values go in which registers now? #### Mixing parameter types #### The answer is that the _position_ of the argument dictates which register it goes in. Therefore, if we called `foo_mixed()` like so:

foo_mixed(1, 2, 0.3f, 4, 0.5f);

void foo_unprototyped(); void foo2()

dp0` is a special variable in batch script syntax that specifies the current directory that the batch script is being run in, including the trailing slash. Thus, if we ran `build.bat` from `C:\tmp\build.bat`, `%

dp0` would expand to `C:\tmp\`. * The `if` statement is used for conditional execution in batch syntax, much like other programming/scripting languages. In this case, we’re checking if the user entered `clean` as an argument, in which case we _prompt_ the user for confirmation before removing the directory and all files in it to perform a clean build. * The `setlocal EnableDelayedExpansion` line allows execution of expressions to be done at **execution time**, instead of **parsing time**. This is an important distinction in batch files, because we want to parse the user input to the confirmation prompt _only_ when the script executes at this point, _not_ at the time when the script is parsed itself (otherwise the user input would not be correct). We use `setlocal` here since we only want this to affect the local scope of the batch file, and not the user’s global environment. * The `set` command with the `/p` flag tells the command prompt to wait for user input, parse it, and then we store it in the `ConfirmCleanBuild` variable. We then basically delete the build directories if the user gives a `Y` answer. «` if not exist %BuildDir% mkdir %BuildDir% pushd %BuildDir% set EntryPoint=»%

Источник

x86 Assembly Language Programming

Introduction

This document contains very brief examples of assembly language programs for the x86. The topic of x86 assembly language programming is messy because:

WeвЂ™ll give examples written for NASM, MASM and gas for both Win32 and Linux. We will even include a section on DOS assembly language programs for historical interest. These notes are not intended to be a substitute for the documentation that accompanies the processor and the assemblers, nor is it intended to teach you assembly language. Its only purpose is to show how to assemble and link programs using different assemblers and linkers.

Assemblers and Linkers

Regardless of the assembler, object file format, linker or operating system you use, the programming process is always the same:

Источник

Пишем Hello World на FASM

Одним томным пятничным вечером взбрела мне в голову безумная идея: а почему бы мне не поразмять мозг, и не написать HelloWorld на ассемблере. Однако это показалось слишком простым. А давайте соберем не x86 программу, а java class? Сказано — сделано.

Первым делом находим спецификацию JVM. Как мы видим, файл класса Java состоит из:

Вообще, язык макросов FASM настолько мощный, что на нем можно написать еще один язык, причем не одним способом.

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

Элементы константного пула в общем случае выглядят так:

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

Конструкция вида const#name — склеивает текст const и значение из константы name. Конструкция аналогична такой же из макросов языка C.

Хоть в терминологии FASM-a константы называются константами, на самом деле они ведут себя как переменные, и с ними можно производить многие манипуляции.

Дальше объявляем макросы для начала и для конца:

Но ведь такой переменной не существует, скажете вы. И будете правы. Пока не существует. FASM — многопроходной ассемблер, и что не было найдено при первом проходе, он запомнит и подключит при втором или дальнейших.

При следующем проходе ассемблер подставит вместо const_count_end ровно столько, сколько он насчитал констант.

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

Ну и напоследок сам исходник:

» Полный код можно посмотреть здесь.

Источник

BartMassey/asm-hello

Use Git or checkout with SVN using the web URL.

Work fast with our official CLI. Learn more.

Launching GitHub Desktop

If nothing happens, download GitHub Desktop and try again.

Launching GitHub Desktop

If nothing happens, download GitHub Desktop and try again.

Launching Xcode

If nothing happens, download Xcode and try again.

Launching Visual Studio Code

Your codespace will open once ready.

There was a problem preparing your codespace, please try again.

Latest commit

Git stats

Files

Failed to load latest commit information.

README.md

Hello World in x86-64 assembly for Linux

I’ve scratch-written an assembly version of «hello world» in x86-64 assembly to see what’s going on there. You can simply say «make» in this directory to build it, and then «./hello» to run it. It should do the obvious thing, and then exit with status 0.

The assembly code here has several jobs:

Define the «hello world» string needed by the program.

Define the entry point «_start» at which the dynamic loader will start the program.

Set up %rbp so that the C calling conventions are satisfied. We needn’t save the old %rbp here, because we will never use it.

Set up the arguments to «printf» and call it.

Check the return value to see if there was an error and call the «abort» system call if so. (It should never return, so we just jump to it.)

Call the exit system call to end program execution.

We put the assembly code in file with extension «.S» rather than «.s». The assembler is fine with this, and it means we will never accidentally overwrite or remove our hand-written assembly when working with the C compiler.

C calling conventions for x86-64 Linux

The C compiler expects that functions will be called with %rsp pointing at top of stack, %rbp pointing at the location where the return value will be held, and the arguments passed as follows:

System Call conventions for x86-64 Linux

There is nothing terribly special about the assembly command. The only thing of note is «—gstabs+», which adds a debugging section to the object file such that gdb knows that it is assembly code and makes it easier to work with.

Most of the linker stuff is straightforward. For dynamic loading, the executable needs to know where the shared libraries will live and what dynamic loader to use to get them.

Note that we have deliberately ignored the C setup routines that arrange to have main called. This is a bit iffy, since this code potentially also initializes some C library stuff. If one chose, one could modify our code to build a normal main function, and then link with

to get things set up. In this case, we could just return normally instead of exiting.

Источник

Duerocraft/Simple-Hello-World-Operating-System-In-Assembler

Use Git or checkout with SVN using the web URL.

Work fast with our official CLI. Learn more.

Launching GitHub Desktop

If nothing happens, download GitHub Desktop and try again.

Launching GitHub Desktop

If nothing happens, download GitHub Desktop and try again.

Launching Xcode

If nothing happens, download Xcode and try again.

Launching Visual Studio Code

Your codespace will open once ready.

There was a problem preparing your codespace, please try again.

Latest commit

Git stats

Files

Failed to load latest commit information.

readme.md

Simple Hello World Operating System In Assembler

About

Simple Hello World Operating System In Assembler

Resources

License

Stars

Watchers

Forks

Releases

Packages 0

Languages

Footer

You can’t perform that action at this time.

You signed in with another tab or window. Reload to refresh your session. You signed out in another tab or window. Reload to refresh your session.

Источник

DOS Assembly 101

Hello World, Today Will Gonna Explain a lovely topic for me which is assembly and specifically dos assembly. So lets go without further delays.

So Assembly is just a programming language but its a very very low level one. why its low level well because u mostly dealing with registers, interrupts u are actually dealing with the CPU u are talking to it directly actually there another more low level layer which microcode which is basically a interface between your assembly language / instructions and the hardware.

How Assembly Assembles to Machine Code:

DosBox (MS-DOS Emulator we will use it alot another option is using emu8086)

Make sure to install both in the C Drive. Now open DosBox and follow with me First mount to C:\8086 folder with this command

mount c C:\8086 (u must make sure the folder is in the C Drive and its named 8086)

No Just type c: and then edit helloworld.asm

and we are ready to go and write our program. I will write the code and then explain it line by line. here u go

Источник

NASM Tutorial

Scope of the Tutorial

This tutorial will show you how to write assembly language programs on the x86-64 architecture.

You will write both (1) standalone programs and (2) programs that integrate with C.

DonвЂ™t worry, we wonвЂ™t get too fancy.

Your First Program

Before learning any details, letвЂ™s make sure you can type in and run programs.

Make sure both nasm and gcc are installed. Save one of the following programs as hello.asm, depending on your machine platform. Then run the program according to the given instructions.

If you are on a Linux-based OS:

If you are on macOS:

Structure of a NASM Program

InstructionDescription$\mathtt\;\mathit,\mathit$

$\mathit[63..0] \leftarrow \mathrm(\mathit)$

$\mathtt\;\mathit,\mathit$

$\mathit[31..0] \leftarrow \mathrm(\mathit)$

$\mathtt\;\mathit,\mathit$

$\mathit \leftarrow \mathrm(\mathit)$

$\mathtt\;\mathit,\mathit$

$\mathit \leftarrow \mathrm(\mathit)$

Recursion

Perhaps surprisingly, thereвЂ™s nothing out of the ordinary required to implement recursive functions. You just have to be careful to save registers, as usual. Pushing and popping around the recursive call is a typical strategy.

SIMD Parallelism

The XMM registers can do arithmetic on floating point values one operation at a time (scalar) or multiple operations at a time (packed). The operations have the form:

For floating point addition, the instructions are:

Instruction	Description
$\mathtt$	Do two double-precision additions in parallel (add packed double)
$\mathtt$	Do just one double-precision addition, using the low 64-bits of the register (add scalar double)
$\mathtt$	Do four single-precision additions in parallel (add packed single)
$\mathtt$	Do just one single-precision addition, using the low 32-bits of the register (add scalar single)

HereвЂ™s a function that adds four floats at once:

Saturated Arithmetic

The XMM registers can also do arithmetic on integers. The instructions have the form:

For integer addition, the instructions are:

Instruction	Description
$\mathtt$	Do 16 byte-additions
$\mathtt$	Do 8 word-additions
$\mathtt$	Do 4 dword-additions
$\mathtt$	Do 2 qword-additions
$\mathtt$	Do 16 byte-additions with signed saturation (80..7F)
$\mathtt$	Do 8 word-additions with signed saturation (8000..7F)
$\mathtt$	Do 16 byte-additions with unsigned saturation (00..FF)
$\mathtt$	Do 8 word-additions with unsigned saturation (00..FFFF)

HereвЂ™s an example. It also illustrates how you load the XMM registers. You canвЂ™t load immediate values; you have to use movaps to move from memory. There are other ways, but weвЂ™re not covering everything in this tutorial.

Graphics

Any C program can be вЂњportedвЂќ to assembly language. That goes for graphics programs, too.

This program probably does not work.

I last tested this in 2003. Back in the old-school OpenGL days. Used Win32. Pre-GLSL days. Used GLUT. I havenвЂ™t had access to a Windows box in a while and IвЂ™m not even sure it will work anymore. This is presented here for historical interest only. If you can modify it to work under modern OpenGL, please let me know. IвЂ™ll update the program and cite your contribution, of course!

Local Variables and Stack Frames

First, please read Eli BenderskyвЂ™s article. That overview is more complete than my brief notes.

When a function is called the caller will first put the parameters in the correct registers then issue the call instruction. Additional parameters beyond those covered by the registers will be pushed on the stack prior to the call. The call instruction puts the return address on the top of stack. So if you have the function:

If you are running on a machine that respect the standard ABI, you can leave rsp where it is and access the вЂњextra parametersвЂќ and the local variables directly from rsp for example:

Источник

Как написать hello world в ассемблере под Windows?

Я хотел написать что-то основное в сборке под Windows, я использую NASM, но я ничего не могу заставить работать.

Как написать и скомпилировать hello world без помощи функций C в Windows?

8 ответов

там же невежественные новички руководство Hello World в Nasm без использования библиотеки C. Тогда код будет выглядеть так.

16-битный код с системными вызовами MS-DOS: работает в эмуляторах DOS или в 32-битных окнах с поддержкой NTVDM. Невозможно запустить » напрямую» (прозрачно) под любой 64-разрядной Windows, потому что ядро x86-64 не может использовать режим vm86.

в этом примере показано, как перейти непосредственно к API Windows и не связываться в стандартной библиотеке C.

для компиляции вам понадобится NASM и LINK.EXE (из Visual studio Standard Edition)

это примеры Win32 и Win64 с использованием вызовов Windows API. Они предназначены для MASM, а не NASM, но посмотрите на них. Вы можете найти более подробную информацию в этой статьи.

чтобы собрать и связать их с помощью MASM, используйте это для 32-разрядного исполняемого файла:

или это для 64-битного исполняемого файла:

Плоский Ассемблер не нужен дополнительный компоновщик. Это делает программирование ассемблера довольно простым. Он также доступен для Linux.

это hello.asm из примеров Fasm:

Fasm создает исполняемый файл:

Если этот код сохранен, например, на » test64.asm», затем скомпилировать:

производит «test64.параметр obj» Затем перейти по ссылке из командной строки:

здесь path_to_link может быть C:\Program файлы (x86)\Microsoft Visual Studio 10.0\VC\bin или где ваша ссылка.exe программы на вашем компьютере, path_to_libs может быть C:\Program файлы (x86)\Windows Kits\8.1\Lib\winv6.3 \ um\x64 или где находятся ваши библиотеки (в этом случае оба kernel32.lib и библиотека user32.lib находятся на одном месте, в противном случае используйте один вариант для каждого пути, который вам нужен) и /largeaddressaware:нет опция необходима, чтобы избежать жалоб компоновщика на адреса long (для user32.lib в данном случае). Кроме того, как это делается здесь, если компоновщик Visual вызывается из командной строки, необходимо настроить среда ранее (запустите один раз vcvarsall.bat and/or see в MS c++ 2010 и mspdb100.dll файлы).

Если вы не позвоните некоторые функция это совсем не тривиально. (И, серьезно, нет никакой реальной разницы в сложности между вызовом printf и вызовом функции win32 api.)

даже DOS int 21h-это просто вызов функции, даже если это другой API.

Если вы хотите сделать это без помощи, вам нужно напрямую поговорить с вашим видеооборудованием, вероятно, написав растровые изображения букв «Hello world» в фреймбуфер. Даже тогда видеокарта выполнение работы по переводу этих значений памяти в сигналы VGA/DVI.

обратите внимание, что, действительно, ни один из этих вещей вплоть до аппаратного обеспечения не более интересен в ASM, чем в C. программа «hello world» сводится к вызову функции. Одна хорошая вещь в ASM заключается в том, что вы можете использовать любой ABI, который хотите, довольно легко; вам просто нужно знать, что такое ABI.

Если вы хотите использовать компоновщик NASM и Visual Studio (ссылка.exe) с примером Hello World от anderstornvig вам придется вручную связать с библиотекой времени выполнения C, содержащей функцию printf ().

надеюсь, это кому-то поможет.

лучшими примерами являются fasm, потому что fasm не использует компоновщик, который скрывает сложность программирования windows другим непрозрачным слоем сложности. Если вы довольны программой, которая записывает в окно gui, то есть пример для этого в каталоге примера fasm.

Если вы хотите консольную программу, которая позволяет перенаправление standard in и standard out, что также возможно. Существует (helas очень нетривиальная) примерная программа, Доступная, что не использует gui и работает строго с консолью, то есть с самим fasm. Это может быть сведено к основам. (Я написал четвертый компилятор, который является еще одним примером без gui, но он также нетривиален).

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

раздел под названием ‘.idata ‘ содержит таблицу, которая помогает windows во время запуска связывать имена функций со временем выполнения адреса. Он также содержит ссылку на KERNEL.DLL, которая является операционной системой Windows.

формат таблицы накладывается windows и содержит имена, которые просматриваются в системных файлах при запуске программы. FASM скрывает некоторые из сложность за ключевым словом rva. Таким образом, _ExitProcess@4-это метка fasm, а _exitProcess-строка, которая просматривается Windows.

программа находится в разделе ‘.текст». Если вы объявите этот раздел доступным для чтения и записи, исполняемый файл, это единственный раздел, который вам нужно добавить.

вы можете вызвать все объекты, которые вы объявили в.секции idata по. Для консольной программы вам нужно _GetStdHandle найти его filedescriptors для standard in и standardout (используя символические имена, такие как STD_INPUT_HANDLE, который fasm находит в файле include win32a.inc). После того, как у вас есть файловые дескрипторы, вы можете сделать WriteFile и ReadFile. Все функции описаны в документации kernel32. Вы, вероятно, знаете или вы не стали бы пытаться программировать ассемблер.

в резюме: есть таблица с именами asci, которые соединяются с ОС windows. Во время запуска это преобразуется в таблицу вызываемых адресов, которую вы используете в своей программе.

Источник

Простая программа на ассемблере x86: Решето Эратосфена

Вступительное слово

По своей профессии я не сталкиваюсь с низкоуровневым программированием: занимаюсь программированием на скриптовых языках. Но поскольку душа требует разнообразия, расширения горизонтов знаний или просто понимания, как работает машина на низком уровне, я занимаюсь программированием на языках, отличающихся от тех, с помощью которых зарабатываю деньги – такое у меня хобби.

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

Итак, посмотрим, что получилось.

С чего начать?

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

Так же встает вопрос, каким образом на таком низком уровне реализуется обмен данными между внутренним миром программы и внешней средой. Тут на сцену выходит API операционной системы. В DOS, как уже было упомянуто, интерфейс был достаточно простой. К примеру, программа «Hello, world» выглядела так:

В Windows же для этих целей используется Win32 API, соответственно, программа должна использовать методы соответствующих библиотек:

Здесь используется файл win32n.inc, где определены макросы, сокращающие код для работы с Win32 API.

Я решил не использовать напрямую API ОС и выбрал путь использования функций из библиотеки Си. Так же это открыло возможность компиляции программы в Linux (и, скорее всего, в других ОС) – не слишком большое и нужное этой программе достижение, но приятное достижение.

Вызов подпрограмм

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

Для ее вызова нужно было бы использовать инструкцию call :

Для себя я решил передавать аргументы подпрограммам через регистры и указывать в комментариях, в каких регистрах какие аргументы должны быть, но в языках высокого уровня аргументы передаются через стек. К примеру, вот так вызывается функция printf из библиотеки Си:

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

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

Соответственно, перед выходом нужно восстановить прежнее состояние стека:

Для локальных переменных так же используется стек, на котором после создания нового кадра выделяется нужное количество байт:

Так же архитектура x86 предоставляет специальные инструкции, с помощью которых можно более лаконично реализовать эти действия:

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

Непосредственно программа

Источник

Ассемблер. BIOS. Hello World. Инструменты для создания загрузочного сектора.

Рассказ будет для самых маленьких. Писать будем на FASM. Здесь есть небольшая документация по компилятору. Отсюда брал исходный код для тестирования. Ну и самое главное, использовал для своей задачи архаичный флоппи диск, купленный на AliExress, так как есть в наличии старый ноутбук с флоппиком. И к стати да, это будет тестовая программка, которая будет лежать в загрузочном секторе флоппи диска, и её будет запускать BIOS после старта.

use16
org 0x7c00
start:
mov ax,cs
mov ds,ax

message:
db ‘Hello World!’,0

finish:
times 0x1fe-finish+start db 0
db 0x55,0xaa ; сигнатура загрузочного диска

Запускаем текстовый редактор компилятора (FASMW.exe) и закидываем этот небольшой демонстрационный код в него. Далее его сохраним под любым именем (у меня просто test.asm) и затем компилируем исходник. На выходе получится BIN файл. Это было не самое трудное в нашей задаче. Самое интересное — это чем всё это записать на нулевую дорожку первого сектора дискеты. Как всегда было перерыто дофига форумов и статей, и в результате поиска наконец то нашёл нужную программку DM Disk Editor. Ну и дальше в картинках:

По подсказке, нажимаем на иконку выбора диска Я в своём случае выбрал USB Floppy.

Ну и как бы всё. В BIOSе выбираем загрузку с флоппи диска, и ждём результата — белые буковки на чёрном экране:

Источник

Hello world assembler

This project was put together to teach myself NASM x86 assembly language on linux.

Lesson 1

The obligatory ‘Hello, world!’

Introduction to the Linux System Call Table. In this lesson we use software interrupts to request system functions from the kernel in order to print out ‘Hello World!’ to the console.

Lesson 2

Proper program exit

A very brief lesson about memory addresses, sequential code execution and how to properly terminate a program without errors.

Lesson 3

Calculate string length

What if we wanted to output something that we don’t know the length of? Like user input? Learn about loops, labels and pointer arithmic.

Lesson 4

Subroutines

Introduction to the stack and how to write clean, reusable code in assembly.

Lesson 5

External include files

To further simplify our code we can move our subroutines into an external include file.

Lesson 6

NULL terminating bytes

A quick lesson on how memory is handled. This lesson also fixes the duplication bug we added in lesson 5.

Lesson 7

Linefeeds

How you can use the stack to print linefeeds after strings and an introduction to the Extended Stack Pointer ESP.

Lesson 8

Passing arguments

Passing arguments to your program from the command line.

Lesson 9

User input

Introduction to the BSS section and how to trigger a call to sys_read to process user input.

Lesson 10

Count to 10

Introduction to numbers and counting in assembly.

Lesson 11

Count to 10 (itoa)

Introduction to ASCII and how to convert integers to their string representations in assembly.

Lesson 12

Introduction to calulating numbers in assembly. This tutorial describes a simple program to add two numbers together.

Lesson 13

Introduction to calulating numbers in assembly. This tutorial describes a simple program to subtract one number from another.

Lesson 14

Introduction to calulating numbers in assembly. This tutorial describes a simple program to multiply two numbers together.

Lesson 15

Introduction to calulating numbers in assembly. This tutorial describes a simple program to divide one number by another.

Lesson 16

Calculator (atoi)

This program takes a series of passed string arguments, converts them to integers and adds them all together.

Lesson 17

Namespace

Introduction to how NASM handles namespace when it comes to global and local labels.

Lesson 18

Fizz Buzz

The Fizz Buzz programming challenge recreated in NASM.

Lesson 19

Execute Command

In this lesson we replace the currently running process with a new process that executes a command.

Lesson 20

Process Forking

In this lesson we create a new process that duplicates our current process.

Lesson 21

Telling the time

In this lesson we ask the kernel for the current unix timestamp.

Lesson 22

In this lesson we learn how to create a new file in Assembly.

Lesson 23

In this lesson we write content to a newly created text file.

Lesson 24

In this lesson we open a text file and print it’s file descriptor.

Lesson 25

In this lesson we read content from a newly created text file.

Lesson 26

In this lesson we close a newly created text file using it’s file descriptor.

Lesson 27

In this lesson we update the content of an included text file using seek.

Lesson 28

In this lesson we learn how to delete a file.

Lesson 29

In this lesson we learn how to create a new socket in assembly and store it’s file descriptor.

Lesson 30

In this lesson we learn how to bind a socket to an IP Address & Port Number.

Lesson 31

In this lesson we learn how to make a socket listen for incoming connections.

Lesson 32

In this lesson we learn how to make a socket accept incoming connections.

Lesson 33

In this lesson we learn how to read incoming requests on a socket.

Lesson 34

In this lesson we learn how to make a socket respond to incoming requests.

Lesson 35

In this lesson we learn how to shutdown and close an open socket connection.

Lesson 36

Download a Webpage

In this lesson we’re going to connect to a webserver and send a HTTP request for a webpage. We’ll then print the server’s response to our terminal.

Lesson 1

Hello, world!

First, some background

Assembly language is bare-bones. The only interface a programmer has above the actual hardware is the kernel itself. In order to build useful programs in assembly we need to use the linux system calls provided by the kernel. These system calls are a library built into the operating system to provide functions such as reading input from a keyboard and writing output to the screen.

When you invoke a system call the kernel will immediately suspend execution of your program. It will then contact the necessary drivers needed to perform the task you requested on the hardware and then return control back to your program.

Note: Drivers are called drivers because the kernel literally uses them to drive the hardware.

We can accomplish this all in assembly by loading EAX with the function number (operation code OPCODE) we want to execute and filling the remaining registers with the arguments we want to pass to the system call. A software interrupt is requested with the INT instruction and the kernel takes over and calls the function from the library with our arguments. Simple.

For example requesting an interrupt when EAX=1 will call sys_exit and requesting an interrupt when EAX=4 will call sys_write instead. EBX, ECX & EDX will be passed as arguments if the function requires them. Click here to view an example of a Linux System Call Table and its corresponding OPCODES.

Writing our program

We will be using the system call sys_write to output our message to the console window. This function is assigned OPCODE 4 in the Linux System Call Table. The function also takes 3 arguments which are sequentially loaded into EDX, ECX and EBX before requesting a software interrupt which will perform the task.

We compile, link and run the program using the commands below.

Error: Segmentation fault

Lesson 2

Proper program exit

Some more background

After successfully learning how to execute a system call in Lesson 1 we now need to learn about one of the most important system calls in the kernel, sys_exit.

Notice how after our ‘Hello, world!’ program ran we got a Segmentation fault? Well, computer programs can be thought of as a long strip of instructions that are loaded into memory and divided up into sections (or segments). This general pool of memory is shared between all programs and can be used to store variables, instructions, other programs or anything really. Each segment is given an address so that information stored in that section can be found later.

To execute a program that is loaded in memory, we use the global label _start: to tell the operating system where in memory our program can be found and executed. Memory is then accessed sequentially following the program logic which determines the next address to be accessed. The kernel jumps to that address in memory and executes it.

Writing our program

Sys_exit has a simple function definition. In the Linux System Call Table it is allocated OPCODE 1 and is passed a single argument through EBX.

We then compile, link and run it again.

Note: Only new code added in each lesson will be commented.

Lesson 3

Calculate string length

Firstly, some background

Why do we need to calculate the length of a string?

Well sys_write requires that we pass it a pointer to the string we want to output in memory and the length in bytes we want to print out. If we were to modify our message string we would have to update the length in bytes that we pass to sys_write as well, otherwise it will not print correctly.

You can see what I mean using the program in Lesson 2. Modify the message string to say ‘Hello, brave new world!’ then compile, link and run the new program. The output will be ‘Hello, brave ‘ (the first 13 characters) because we are still only passing 13 bytes to sys_write as its length. It will be particularly necessary when we want to print out user input. As we won’t know the length of the data when we compile our program, we will need a way to calculate the length at runtime in order to successfully print it out.

Writing our program

To calculate the length of the string we will use a technique called pointer arithmetic. Two registers are initialised pointing to the same address in memory. One register (in this case EAX) will be incremented forward one byte for each character in the output string until we reach the end of the string. The original pointer will then be subtracted from EAX. This is effectively like subtraction between two arrays and the result yields the number of elements between the two addresses. This result is then passed to sys_write replacing our hard coded count.

The CMP instruction compares the left hand side against the right hand side and sets a number of flags that are used for program flow. The flag we’re checking is the ZF or Zero Flag. When the byte that EAX points to is equal to zero the ZF flag is set. We then use the JZ instruction to jump, if the ZF flag is set, to the point in our program labeled ‘finished’. This is to break out of the nextchar loop and continue executing the rest of the program.

Lesson 4

Subroutines

Introduction to subroutines

Why don’t we JMP to subroutines?

The great thing about writing a subroutine is that we can reuse it. If we want to be able to use the subroutine from anywhere in the code we would have to write some logic to determine where in the code we had jumped from and where we should jump back to. This would litter our code with unwanted labels. If we use CALL and RET however, assembly handles this problem for us using something called the stack.

Introduction to the stack

The stack is a special type of memory. It’s the same type of memory that we’ve used before however it’s special in how it is used by our program. The stack is what is call Last In First Out memory (LIFO). You can think of the stack like a stack of plates in your kitchen. The last plate you put on the stack is also the first plate you will take off the stack next time you use a plate.

The stack in assembly is not storing plates though, its storing values. You can store a lot of things on the stack such as variables, addresses or other programs. We need to use the stack when we call subroutines to temporarily store values that will be restored later.

Any register that your function needs to use should have it’s current value put on the stack for safe keeping using the PUSH instruction. Then after the function has finished it’s logic, these registers can have their original values restored using the POP instruction. This means that any values in the registers will be the same before and after you’ve called your function. If we take care of this in our subroutine we can call functions without worrying about what changes they’re making to our registers.

The CALL and RET instructions also use the stack. When you CALL a subroutine, the address you called it from in your program is pushed onto the stack. This address is then popped off the stack by RET and the program jumps back to that place in your code. This is why you should always JMP to labels but you should CALL functions.

Lesson 5

External include files

External include files allow us to move code from our program and put it into separate files. This technique is useful for writing clean, easy to maintain programs. Reusable bits of code can be written as subroutines and stored in separate files called libraries. When you need a piece of logic you can include the file in your program and use it as if they are part of the same file.

In this lesson we will move our string length calculating subroutine into an external file. We fill also make our string printing logic and program exit logic a subroutine and we will move them into this external file. Once it’s completed our actual program will be clean and easier to read.

We can then declare another message variable and call our print function twice in order to demonstrate how we can reuse code.

Note: I won’t be showing the code in functions.asm after this lesson unless it changes. It will just be included if needed.

Error: Our second message is outputted twice. This is fixed in the next lesson.

Lesson 6

NULL terminating bytes

Ok so why did our second message print twice when we only called our sprint function on msg2 once? Well actually it did only print once. You can see what I mean if you comment out our second call to sprint. The output will be both of our message strings.

But how is this possible?

What is happening is we weren’t properly terminating our strings. In assembly, variables are stored one after another in memory so the last byte of our msg1 variable is right next to the first byte of our msg2 variable. We know our string length calculation is looking for a zero byte so unless our msg2 variable starts with a zero byte it keeps counting as if it’s the same string (and as far as assembly is concerned it is the same string). So we need to put a zero byte or 0h after our strings to let assembly know where to stop counting.

Note: In programming 0h denotes a null byte and a null byte after a string tells assembly where it ends in memory.

Lesson 7

Linefeeds

Linefeeds are essential to console programs like our ‘hello world’ program. They become even more important once we start building programs that require user input. But linefeeds can be a pain to maintain. Sometimes you will want to include them in your strings and sometimes you will want to remove them. If we continue to hard code them in our variables by adding 0Ah after our declared message text, it will become a problem. If there’s a place in the code that we don’t want to print out the linefeed for that variable we will need to write some extra logic remove it from the string at runtime.

It would be better for the maintainability of our program if we write a subroutine that will print out our message and then print a linefeed afterwards. That way we can just call this subroutine when we need the linefeed and call our current sprint subroutine when we don’t.

A call to sys_write requires we pass a pointer to an address in memory of the string we want to print so we can’t just pass a linefeed character (0Ah) to our print function. We also don’t want to create another variable just to hold a linefeed character so we will instead use the stack.

The way it works is by moving a linefeed character into EAX. We then push EAX onto the stack and get the address pointed to by the Extended Stack Pointer. ESP is another register. When you push items onto the stack, ESP is decremented to point to the address in memory of the last item and so it can be used to access that item directly from the stack. Since ESP points to an address in memory of a character, sys_write will be able to use it to print.

Note: I’ve highlighted the new code in functions.asm below.

Lesson 8

Passing arguments

Passing arguments to your program from the command line is as easy as popping them off the stack in NASM. When we run our program, any passed arguments are loaded onto the stack in reverse order. The name of the program is then loaded onto the stack and lastly the total number of arguments is loaded onto the stack. The last two stack items for a NASM compiled program are always the name of the program and the number of passed arguments.

So all we have to do to use them is pop the number of arguments off the stack first, then iterate once for each argument and perform our logic. In our program that means calling our print function.

Note: We are using the ECX register as our counter for the loop. Although it’s a general-purpose register it’s original intention was to be used as a counter.

Lesson 9

User input

The syntax to declare variables is as follows:

Writing our program

We will be using the system call sys_read to receive and process input from the user. This function is assigned OPCODE 3 in the Linux System Call Table. Just like sys_write this function also takes 3 arguments which will be loaded into EDX, ECX and EBX before requesting a software interrupt that will call the function.

When sys_read detects a linefeed, control returns to the program and the users input is located at the memory address you passed in ECX.

Lesson 10

Count to 10

Firstly, some background

Counting by numbers is not as straight forward as you would think in assembly. Firstly we need to pass sys_write an address in memory so we can’t just load our register with a number and call our print function. Secondly, numbers and strings are very different things in assembly. Strings are represented by what are called ASCII values. ASCII stands for American Standard Code for Information Interchange. A good reference for ASCII can be found here. ASCII was created as a way to standardise the representation of strings across all computers.

Writing our program

What we will do with our program is count from 1 to 10 using the ECX register. We will then add 48 to our counter to convert it from a number to it’s ASCII string representation. We will then push this value to the stack and call our print function passing ESP as the memory address to print from. Once we have finished counting to 10 we will exit our counting loop and call our quit function.

Error: Our number 10 prints a colon (:) character instead. What’s going on?

Lesson 11

Count to 10 (itoa)

So why did our program in Lesson 10 print out a colon character instead of the number 10?. Well lets have a look at our ASCII table. We can see that the colon character has a ASCII value of 58. We were adding 48 to our integers to convert them to their ASCII string representations so instead of passing sys_write the value ’58’ to print ten we actually need to pass the ASCII value for the number 1 followed by the ASCII value for the number 0. Passing sys_write ‘4948’ is the correct string representation for the number ’10’. So we can’t just simply add 48 to our numbers to convert them, we first have to divide them by 10 because each place value needs to be converted individually.

We will write 2 new subroutines in this lesson ‘iprint’ and ‘iprintLF’. These functions will be used when we want to print ASCII string representations of numbers. We achieve this by passing the number in EAX. We then initialise a counter in ECX. We will repeatedly divide the number by 10 and each time convert the remainder to a string by adding 48. We will then push this onto the stack for later use. Once we can no longer divide the number by 10 we will enter our second loop. In this print loop we will print the now converted string representations from the stack and pop them off. Popping them off the stack moves ESP forward to the next item on the stack. Each time we print a value we will decrease our counter ECX. Once all numbers have been converted and printed we will return to our program.

How does the divide instruction work?

The DIV and IDIV instructions work by dividing whatever is in EAX by the value passed to the instruction. The quotient part of the value is left in EAX and the remainder part is put into EDX (Originally called the data register).

If we are only storing the remainder won’t we have problems?

No, because these are integers, when you divide a number by an even bigger number the quotient in EAX is 0 and the remainder is the number itself. This is because the number divides zero times leaving the original value as the remainder in EDX. How good is that?

Note: Only the new functions iprint and iprintLF have comments.

Lesson 12

In this program we will be adding the registers EAX and EBX together and we’ll leave our answer in EAX. Firstly we use the MOV instruction to load EAX with an integer (in this case 90). We then MOV an integer into EBX (in this case 9). Now all we need to do is use the ADD instruction to perform our addition. EBX & EAX will be added together leaving our answer in the left most register in this instruction (in our case EAX). Then all we need to do is call our integer printing function to complete the program.

Lesson 13

In this program we will be subtracting the value in the register EBX from the value in the register EAX. Firstly we load EAX and EBX with integers in the same way as Lesson 12. The only difference is we will be using the SUB instruction to perform our subtraction logic, leaving our answer in the left most register of this instruction (in our case EAX). Then all we need to do is call our integer printing function to complete the program.

Lesson 14

In this program we will be multiplying the value in EBX by the value present in EAX. Firstly we load EAX and EBX with integers in the same way as Lesson 12. This time though we will be calling the MUL instruction to perform our multiplication logic. The MUL instruction is different from many instructions in NASM, in that it only accepts one further argument. The MUL instruction always multiples EAX by whatever value is passed after it. The answer is left in EAX.

Lesson 15

In this program we will be dividing the value in EBX by the value present in EAX. We’ve used division before in our integer print subroutine. Our program requires a few extra strings in order to print out the correct answer but otherwise there’s nothing complicated going on.

Firstly we load EAX and EBX with integers in the same way as Lesson 12. Division logic is performed using the DIV instruction. The DIV instruction always divides EAX by the value passed after it. It will leave the quotient part of the answer in EAX and put the remainder part in EDX (the original data register). We then MOV and call our strings and integers to print out the correct answer.

Lesson 16

Calculator (atoi)

Our program will take several command line arguments and add them together printing out the result in the terminal.

Writing our program

Our program begins by using the POP instruction to get the number of passed arguments off the stack. This value is stored in ECX (originally known as the counter register). It will then POP the next value off the stack containing the program name and remove it from the number of arguments stored in ECX. It will then loop through the rest of the arguments popping each one off the stack and performing our addition logic. As we know, arguments passed via the command line are received by our program as strings. Before we can add the arguments together we will need to convert them to integers otherwise our result will not be correct. We do this by calling our Ascii to Integer function (atoi). This function will convert the ascii value into an integer and place the result in EAX. We can then add this value to EDX (originally known as the data register) where we will store the result of our additions. If the value passed to atoi is not an ascii representation of an integer our function will return zero instead. When all arguments have been converted and added together we will print out the result and call our quit function.

How does the atoi function work

Converting an ascii string into an integer value is not a trivial task. We know how to convert an integer to an ascii string so the process should essentially work in reverse. Firstly we take the address of the string and move it into ESI (originally known as the source register). We will then move along the string byte by byte (think of each byte as being a single digit or decimal placeholder). For each digit we will check if it’s value is between 48-57 (ascii values for the digits 0-9).

Once we have performed this check and determined that the byte can be converted to an integer we will perform the following logic. We will subtract 48 from the value вЂ“ converting the ascii value to it’s decimal equivalent. We will then add this value to EAX (the general purpose register that will store our result). We will then multiple EAX by 10 as each byte represents a decimal placeholder and continue the loop.

When all bytes have been converted we need to do one last thing before we return the result. The last digit of any number represents a single unit (not a multiple of 10) so we have multiplied our result one too many times. We simple divide it by 10 once to correct this and then return. If no integer arguments were pass however, we skip this divide instruction.

What is the BL register

The EBX register is 32bits. EBX’s 16 bit segment is referenced as BX. BX contains the 8bit segments BL and BH (Lower and Higher bits). We wanted the first 8bits (lower bits) of EBX and so we referenced that storage area using BL.

Almost every assembly language tutorial begins with a history of the registers, their names and their sizes. These tutorials however were written to provide a foundation in NASM by first writing code and then understanding the theory. The full story about the size of registers, their history and importance are beyond the scope of this tutorial but we will return to that story in later tutorials.

Note: Only the new function in this file ‘atoi’ is shown below.

Источник

HackWare.ru

Этичный хакинг и тестирование на проникновение, информационная безопасность

Введение в Ассемблер

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

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

Руководство по программированию на Ассемблер

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

Для кого эти уроки по ассемблеру

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

Что нужно для изучения Ассемблера

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

Что такое язык Ассемблер?

Каждый персональный компьютер имеет микропроцессор, который управляет арифметической, логической и контрольной активностью.

Каждая семья процессоров имеет свой собственный набор инструкций для обработки различных операций, таких как получения ввода с клавиатуры, отображение информации на экране и выполнения различных других работ. Этот набор инструкций называется «инструкции машинного языка» (‘machine language instructions’).

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

Преимущества языка Ассемблер

Знание языка ассемблера позволяет понять:

Другие преимущества использования ассемблера:

Системы счисления

Основные характеристики аппаратной составляющей ПК

Каждый компьютер содержит процессор и оперативную память. Процессор содержит регистры — компоненты, которые содержат данные и адреса. Для выполнения программы, система копирует её с устройства постоянного хранения во внутреннюю память. Процессор выполняет инструкции программы.

Фундаментальной единицей компьютерного хранилища является бит. Он может быть в состоянии Включён (1) или Выключен (0). Группа из восьми связанных битов составляет байт, из которых семь бит используются для данных, а ещё один используется для контроля чётности. Согласно правилу чётности, количество битов, которые Включены (1) в каждом байте, всегда должно быть чётным. То есть бит чётности имеет значение 1, если у соответствующего байта количество 1-х битов нечётно. 0 — если иначе (чётно).

Таким образом, бит чётности используется для того, чтобы сделать количество битов в байте чётным. Если соотношение является нечётным, система предполагает, что произошла ошибка соотношения (хотя и редко), которая могла быть вызвана неисправностью оборудования или электрическими помехами.

Выше бит чётности рассмотрен на примере «even parity», то есть «чётная чётность». Также существует «odd parity», то есть «нечётная чётность». В первом случае подгоняется под чётное количество единиц как было показано выше. А во втором случае подгоняется под нечётное количество единиц.

Двоичная система счисления

В каждой системе счисления используются позиционные обозначения, то есть каждая позиция, в которой записана цифра, имеет различное позиционное значение. Каждая позиция — это степень базы, которая равна 2 для двоичной системы счисления, и эти степени начинаются с 0 и увеличиваются на 1.

В следующей таблице приведены позиционные значения для 8-битного двоичного числа, где все биты установлены в положение ON (Включено).

Значение бита	1	1	1	1	1	1	1	1
Значение позиции как степень основания 2	128	64	32	16	8	4	2	1
Номер бита	7	6	5	4	3	2	1	0

Значение двоичного числа, как и в десятичном, зависит от составляющих его цифр и расположения этих цифр. Но в двоичном числе используются только цифры 1 и 0, и расположение цифр имеет другое значение степени. Первая цифра, как и в десятичном числе, может означать 0 или 1. Вторая цифра (смотрим число справа на лево) может означать 2 (если этот бит установлен на 1) или 0 (если бит установлен на 0). Третья цифра (смотрим число справа на лево) может означать 4 (если этот бит установлен на 1) или 0 (если бит установлен на 0). И так далее. В десятичном числе значение каждого символа нужно умножить на 10 в степени порядкового номера этой цифры за минусом единицы.

То есть число 1337 это 1 * 10 3 + 3 * 10 2 + 3 * 10 1 + 7 * 10 0 = 1337

В двоичной системе всё точно также, только вместо десятки в степени порядкового номера за минусом единицы, нужно использовать двойку — вот и всё!

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

1 * 2 5 * + 1 * 2 4 + 0 * 2 3 + 1 * 2 2 + 0 * 2 1 + 1 * 2 0 = 1 * 32 + 1 * 16 + 0 * 8 + 1 * 4 + 0 * 2 + 1 * 1 = 53

Итак, значение бинарного числа основывается на наличии битов 1 и их позиционном значении. Поэтому значение числа 11111111 в двоичной системе является:

1 + 2 + 4 + 8 +16 + 32 + 64 + 128 = 255

Шестнадцатеричная система счисления

Шестнадцатеричная система счисления использует основание 16. Цифры в этой системе варьируются от 0 до 15. По соглашению, буквы от A до F используются для представления шестнадцатеричных цифр, соответствующих десятичным значениям с 10 по 15.

Десятичное число	Двоичный вид	Шестнадцатеричный вид
0	0	0
1	1	1
2	10	2
3	11	3
4	100	4
5	101	5
6	110	6
7	111	7
8	1000	8
9	1001	9
10	1010	A
11	1011	B
12	1100	C
13	1101	D
14	1110	E
15	1111	F

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

Чтобы преобразовать шестнадцатеричное число в двоичное, просто запишите каждую шестнадцатеричную цифру в её 4-значный двоичный эквивалент.

Отрицательные двоичные числа

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

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

Во-первых, нужно помнить, что если старшие биты (крайние слева), равны нулю, то их иногда не записывают. Например, восьмибитное число 10 (в десятичной системе счисления оно равно 2), также можно записать как 0000 0010. Обе эти записи означают число 2.

Если старший бит равен нулю, то это положительное число. Например, возьмём число 110. В десятичной системе счисления это 6. Данное число является положительным или отрицательным? На самом деле, однозначно на этот вопрос можно ответить только зная разрядность числа. Если это восьмиразрядное число, то его полная запись будет такой: 0000 0110. Как можно увидеть, старший бит равен нулю, следовательно, это положительное число.

Для трёхбитовых чисел было бы справедливо следующее:

Двоичное значение трёхбитового числа со знаком
(в представлении Дополнительный код)

Десятичное значение
0	000
1	001
2	010
3	011
-4	100
-3	101
-2	110
-1	111

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

Отрицательные двоичные числа записываются без знака минус и для получения этого же числа со знаком минус (то есть для получения числа в Дополненном коде) нужно выполнить два действия:

На русском языке такая форма записи называется Дополнительный код, в англоязычной литературе это называется Two’s complement.

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

Десятичное значение	Двоичное значение трёхбитового числа со знаком (в представлении Дополнительный код)
0	0000 0000
1	0000 0001
2	0000 0010
126	0111 1110
127	0111 1111
−128	1000 0000
−127	1000 0001
−126	1000 0010
−2	1111 1110
−1	1111 1111

Двоичное представление (8 бит)

(в виде Дополнительного кода)

Десятичное представление
127	0111 1111
1	0000 0001
0	0000 0000
-0	—
-1	1111 1111
-2	1111 1110
-3	1111 1101
-4	1111 1100
-5	1111 1011
-6	1111 1010
-7	1111 1001
-8	1111 1000
-9	1111 0111
-10	1111 0110
-11	1111 0101
-127	1000 0001
-128	1000 0000

Числа в дополненном коде удобно применять для вычитания — это будет показано далее.

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

Добавив к результату 1 получим положительное число 5 в прямом коде:

И проверим, сложив с дополнительным кодом

0000 0101 + 1111 1011 = 1 0000 0000, десятый разряд выбрасывается, то есть получается 0000 0000, то есть 0. Следовательно, преобразование выполнено правильно, так как 5 + (-5) = 0.

Двоичная арифметика

Следующая таблица иллюстрирует четыре простых правила для двоичного сложения:

(i)	(ii)	(iii)	(iv)
1
0	1	1	1
+0	+0	+1	+1
=0	=1	=10	=11

Эту таблицу нужно читать по столбцам сверху вниз. В первом столбце складываются 0 и 0 — в результате получается 0. Во втором примере складываются 1 и 0 (или 0 и 1 — без разницы), в результате получается 1. В третьем столбце складываются две единицы — в результате в текущей позиции получается 0, но на одну позицию влево добавляется единица. Если в этой позиции уже есть единица — то применяется это же правило, то есть в позиции пишется 0, и 1 передаётся влево. В четвёртом примере складываются три единицы — в результате, в текущей позиции записывается 1, и ещё одна 1 передаётся влево.

Десятичные	Двоичные
60	00111100
+42	00101010
102	01100110

Рассмотрим, как делается вычитание.

Для вычитания число, которое вычитается, записывается в форме Дополнительного кода, а затем эти два числа складываются.

Пример: Вычесть 42 из 53

Бит который вызывает переполнение — крайней левый, девятый по счёту, просто отбрасывается.

Адресация данных в памяти

Процессор может одновременно обращаться к одному или нескольким байтам памяти. Давайте рассмотрим шестнадцатеричное число 0725H (буква H означает, что перед нами шестнадцатеричное число). Для этого числа потребуется два байта памяти. Байт старшего разряда или старший значащий байт — 07, а младший байт — 25.

Процессор хранит данные в последовательности обратного байта, то есть байт младшего разряда хранится в низком адресе памяти и байт старшего разряда в старшем адресе памяти. Таким образом, если процессор переносит значение 0725H из регистра в память, он сначала перенесёт 25 на нижний адрес памяти и 07 на следующий адрес памяти.

Когда процессор получает числовые данные из памяти для регистрации, он снова переворачивает байты. Есть два вида адресов памяти:

Настройка рабочего окружения для Ассемблер

Настройка локального рабочего окружения

Язык ассемблера зависит от набора команд и архитектуры процессора. В этом руководстве мы сосредоточимся на процессорах Intel-32, таких как Pentium. Чтобы следовать этому уроку, вам понадобится:

Есть много хороших ассемблерных программ, таких как:

Мы будем использовать ассемблер NASM, так как он:

Установка NASM

Если вы выбираете «Инструменты разработки» при установке Linux, вы можете установить NASM вместе с операционной системой Linux, и вам не нужно загружать и устанавливать его отдельно. Чтобы проверить, установлен ли у вас NASM, сделайте следующее:

Откройте терминал Linux.

и нажмите клавишу ВВОД.

Если он уже установлен, появляется строка типа

В противном случае вы увидите просто

значит вам нужно установить NASM.

NASM должен присутствовать в стандартных репозиториях, поэтому попробуйте поискать там этот пакет и установить его.

Например, для установки в Debian, Ubuntu, Linux Mint, Kali Linux и их производные выполните:

Для установки в Arch Linux, BlackArch и их производные выполните:

Чтобы установить NASM из исходного кода, сделайте следующее:

Проверьте веб-сайт ассемблера (NASM) на последнюю версию.

Распакуйте архив в каталог, который создаст подкаталог nasm-X.XX.

Перейдите к nasm-X.XX

Этот скрипт оболочки найдёт лучший компилятор C для использования и сделает настройки в соответствии с Makefiles.

чтобы создать двоичные файлы nasm и ndisasm.

чтобы установить nasm и ndisasm в /usr/local/bin и установить справочные страницы (man).

Это должно установить NASM в вашей системе. Кроме того, вы можете использовать RPM-дистрибутив для Fedora Linux. Эта версия проще в установке, просто дважды щёлкните файл RPM.

Основы синтаксиса Ассемблера

Программу на языке Ассемблер можно разделить на три раздела:

Раздел data

Раздел data используется для объявления инициализированных данных или констант. Эти данные не изменяются во время выполнения. В этом разделе вы можете объявить различные постоянные значения, имена файлов или размер буфера и т. д.

Синтаксис объявления раздела data:

Раздел BSS

Секция bss используется для объявления переменных. Синтаксис объявления раздела bss:

Раздел text

Раздел text используется для хранения самого кода. Этот раздел должен начинаться с объявления global _start, которое сообщает ядру, где начинается выполнение программы.

Синтаксис объявления раздела text:

Комментарий на ассемблере начинается с точки с запятой (;). Он может содержать любой печатный символ, включая пробел. Он может появиться в строке сам по себе, например:

или в той же строке вместе с инструкцией, например:

Операторы Ассемблера

Программы на ассемблере состоят из трёх типов операторов:

Исполняемые инструкции или просто инструкции говорят процессору, что делать. Каждая инструкция состоит из кода операции (opcode). Каждая исполняемая инструкция генерирует одну инструкцию на машинном языке.

Директивы ассемблера или псевдооперации говорят ассемблеру о различных аспектах процесса сборки. Они не являются исполняемыми и не генерируют инструкции машинного языка.

Макросы — это в основном механизм подстановки текста.

Синтаксис операторов ассемблера

Операторы языка ассемблера вводятся по одной инструкции в каждой строке. Каждое утверждение имеет следующий формат:

Поля в квадратных скобках являются необязательными. Основная инструкция состоит из двух частей: первая — это имя инструкции (или мнемоника), которая должна быть выполнена, а вторая — операнды или параметры команды.

Ниже приведены некоторые примеры типичных операторов языка ассемблера.

Программа Hello World на Ассамблере

Следующий код на ассемблере выводит на экран строку «Hello World»:

Когда приведённый выше код скомпилирован и выполнен, он даст следующий результат:

Компиляция и связывание (Linking) программы на Ассемблере в NASM

Убедитесь, что вы установили путь до исполнимых файлов nasm и ld в вашей переменной окружения PATH (в Linux это уже сделано). Теперь пройдите следующие шаги для компиляции и связывания приведённой выше программы:

Выполните программу набрав:

Если вы всё сделали правильно, то она отобразит на экране ‘Hello, world!’.

Возможно, вас интересует, что такое связывание (Linking) и зачем оно требуется после сборки программы. Если коротко, то на этом этапе объектные файлы (если их несколько) собираются в один исполнимый файл, также благодаря этому процессу исполнимый файл теперь может использовать библиотеки. Линкеру указывается (обычно) целевой исполнимый формат. Если совсем коротко — это просто нужно. Я не буду в этом базовом курсе по ассемблеру останавливаться на этом более подробно — если вас интересует эта тема, то вы всегда сможете найти по ней дополнительную информацию в Интернете.

Ассемблер: сегменты памяти

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

Обратите внимание, что если вы замените ключевое слово section на слово segment, вы получите тот же самый результат. Попробуйте этот код:

После компиляции и выполнения вышеприведённого кода он даст следующий результат:

Сегменты памяти

Модель сегментированной памяти делит системную память на группы независимых сегментов, на которые ссылаются указатели, расположенные в регистрах сегментов. Каждый сегмент используется для хранения данных определённого типа. Один сегмент используется для хранения кодов команд, другой — для хранения элементов данных, а третий — для программного стека.

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

Ассемблер: регистры (Registers)

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

Для ускорения работы процессора процессор включает в себя несколько мест хранения внутренней памяти, называемых регистрами (registers).

Регистры хранят элементы данных для обработки без необходимости доступа к памяти. Ограниченное количество регистров встроено в чип процессора.

Регистры процессора

В архитектуре IA-32 имеется десять 32-разрядных и шесть 16-разрядных процессорных регистров. Регистры сгруппированы в три категории:

Общие регистры далее делятся на следующие группы:

Регистры данных

Четыре 32-битных регистра данных используются для арифметических, логических и других операций. Эти 32-битные регистры можно использовать тремя способами:

Некоторые из этих регистров данных имеют конкретное применение в арифметических операциях.

AX — основной аккумулятор; он используется во вводе/выводе и большинстве арифметических инструкций. Например, в операции умножения один операнд сохраняется в регистре EAX или AX или AL в соответствии с размером операнда.

BX известен как базовый регистр, поскольку его можно использовать при индексированной адресации.

CX известен как регистр подсчёта, так как регистры ECX, CX хранят счётчик циклов в итерационных операциях.

DX известен как регистр данных. Он также используется в операциях ввода/вывода. Он также используется с регистром AX вместе с DX для операций умножения и деления с большими значениями.

Регистры указателя

Регистры указателя являются 32-разрядными регистрами EIP, ESP и EBP и соответствующими 16-разрядными правыми частями IP, SP и BP. Есть три категории регистров указателей:

Индексные регистры

32-разрядные индексные регистры ESI и EDI и их 16-разрядные крайние правые части. SI и DI, используются для индексированной адресации и иногда используются для сложения и вычитания. Есть два набора указателей индекса:

Регистры управления

Регистр указателя 32-битной инструкции и регистр 32-битных флагов рассматриваются как регистры управления.

Многие инструкции включают сравнения и математические вычисления и изменяют состояние флагов, а некоторые другие условные инструкции проверяют значение этих флагов состояния, чтобы перенести поток управления в другое место.

Популярные биты флага:

В следующей таблице указано положение битов флага в 16-битном регистре флагов:

Флаг:	O	D	I	T	S	Z	A	P	C
Номер бита:	15	14	13	12	11	10	9	8	7	6	5	4	3	2	1	0

Сегментные регистры

Сегменты — это специальные области, определённые в программе для хранения данных, кода и стека. Есть три основных сегмента:

Помимо регистров DS, CS и SS существуют и другие регистры дополнительных сегментов — ES (дополнительный сегмент), FS и GS, которые предоставляют дополнительные сегменты для хранения данных.

При программировании на ассемблере программе необходим доступ к ячейкам памяти. Все области памяти в сегменте относятся к начальному адресу сегмента. Сегмент начинается с адреса, равномерно делимого на 16 или в шестнадцатеричном виде числа 10. Таким образом, крайняя правая шестнадцатеричная цифра во всех таких адресах памяти равна 0, что обычно не сохраняется в регистрах сегментов.

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

Пример

Посмотрите на следующую простую программу, чтобы понять использование регистров в программировании на Ассемблере. Эта программа отображает 9 звёзд на экране вместе с простым сообщением.

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

Ассемблер: Системные вызовы

Системные вызовы — это API для интерфейса между пространством пользователя и пространством ядра. Мы уже использовали системные вызовы sys_write и sys_exit для записи на экран и выхода из программы соответственно.

Системные вызовы Linux

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

Существует шесть регистров, в которых хранятся аргументы используемого системного вызова. Это EBX, ECX, EDX, ESI, EDI и EBP. Эти регистры принимают последовательные аргументы, начиная с регистра EBX. Если существует более шести аргументов, ячейка памяти первого аргумента сохраняется в регистре EBX.

В следующем фрагменте кода показано использование системного вызова sys_exit:

В следующем фрагменте кода показано использование системного вызова sys_write:

Все системные вызовы перечислены в /usr/include/asm/unistd.h вместе с их номерами (значение, которое нужно указать в EAX перед вызовом int 80h). Точнее говоря, сейчас это файлы /usr/include/asm/unistd_32.h и /usr/include/asm/unistd_64.h.

Чтобы посмотреть содержимое файла /usr/include/asm/unistd_32.h:

Начало этого файла:

Чтобы получить справку по системным вызовам:

Чтобы получить справку по конкретному вызову, укажите вначале man 2, а затем название вызова. Например, чтобы узнать о вызове read:

Чтобы узнать о вызове mkdir:

В следующей таблице приведены некоторые системные вызовы, используемые в этом руководстве:

%eax	Имя	%ebx	%ecx	%edx	%esx	%edi
1	sys_exit	int (целое число)	—	—	—	—
2	sys_fork	struct pt_regs	—	—	—	—
3	sys_read	unsigned int (целое беззнаковое число)	char *	size_t	—	—
4	sys_write	unsigned int (целое беззнаковое число)	const char *	size_t	—	—
5	sys_open	const char *	int (целое число)	int (целое число)	—	—
6	sys_close	unsigned int (целое беззнаковое число)	—	—	—	—

Пример

Следующий пример читает число с клавиатуры и отображает его на экране:

Скомпилированный и запущенный вышеприведённый код даёт следующий результат:

Ассемблер: Режимы адресации

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

Когда инструкции требуется два операнда, первый операнд обычно является пунктом назначения, который содержит данные в регистре или ячейке памяти, а второй операнд является источником. Источник содержит либо данные для доставки (немедленная адресация), либо адрес (в регистре или памяти) данных. Как правило, исходные данные остаются неизменными после операции.

Три основных режима адресации:

Адресации на регистр

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

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

Немедленная адресация

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

Адресация на память

Когда операнды указываются в режиме адресации на память, требуется прямой доступ к основной памяти, обычно к сегменту данных. Этот способ адресации приводит к более медленной обработке данных. Чтобы найти точное местоположение данных в памяти, нам нужен начальный адрес сегмента, который обычно находится в регистре DS, и значение смещения. Это значение смещения также называется действующим адресом (effective address).

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

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

Прямая адресация со смещением

Этот режим адресации использует арифметические операторы для изменения адреса. Например, посмотрите на следующие определения, которые определяют таблицы данных:

Следующие операции обращаются к данным из таблиц в памяти в регистрах:

Косвенная адресация на память

В этом режиме адресации используется способность компьютера Segment:Offset (Сегмент:Смещение). Обычно для этой цели используются базовые регистры EBX, EBP (или BX, BP) и регистры индекса (DI, SI), закодированные в квадратных скобках для ссылок на память.

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

В следующем фрагменте кода показано, как получить доступ к различным элементам переменной.

Инструкция MOV

Мы уже задействовали инструкцию MOV, которая используется для перемещения данных из одного пространства хранения в другое. Инструкция MOV принимает два операнда.

Синтаксис

Синтаксис инструкции MOV:

Инструкция MOV может иметь одну из следующих пяти форм:

Пожалуйста, обратите внимание, что:

Инструкция MOV порой вызывает двусмысленность. Например, посмотрите на утверждения:

Не ясно, хотите ли вы переместить байтовый эквивалент или словесный эквивалент числа 110. В таких случаях целесообразно использовать спецификатор типа (type specifier).

В следующей таблице приведены некоторые общие спецификаторы типов:

Спецификатор типа	Байты
BYTE	1
WORD	2
DWORD	4
QWORD	8
TBYTE	10

Пример

Следующая программа иллюстрирует некоторые из концепций, обсуждённых выше. Он сохраняет имя «Zara Ali» в разделе данных памяти, затем программно меняет его значение на другое имя «Nuha Ali» и отображает оба имени.

Когда приведённый выше код скомпилирован и выполнен, он даёт следующий результат:

Ассемблер: Переменные

NASM предоставляет различные директивы определения (define directives) для резервирования места для хранения переменных. Директива определения ассемблера используется для выделения пространства хранения. Его можно использовать для резервирования, а также для инициализации одного или нескольких байтов.

Выделение пространства хранения для инициализированных данных

Синтаксис для оператора распределения памяти для инициализированных данных:

Где имя-переменной — это идентификатор для каждого пространства хранения. Ассемблер связывает значение смещения для каждого имени переменной, определённого в сегменте данных.

Существует пять основных форм директивы определения:

Директива	Цель	Размер хранения
DB	Определить Byte	выделяет 1 байт
DW	Определить Word	выделяет 2 байта
DD	Определить Doubleword	выделяет 4 байта
DQ	Определить Quadword	выделяет 8 байта
DT	Определить Ten Bytes	выделяет 10 байта

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

Пожалуйста, обратите внимание, что:

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

Когда приведённый выше код компилируется и выполняется, он даёт следующий результат:

Выделение дискового пространства для неинициализированных данных

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

Существует пять основных форм директив резервирования:

Директива	Цель
RESB	Зарезервировать Byte
RESW	Зарезервировать Word
RESD	Зарезервировать Doubleword
RESQ	Зарезервировать Quadword
REST	Зарезервировать 10 байт

Множественность определений

Вы можете иметь несколько операторов определения данных в программе. Например:

Ассемблер выделяет непрерывную память для нескольких определений переменных.

Множественность инициализаций

Директива TIMES позволяет выполнить несколько инициализаций к одному и тому же значению. Например, массив с именем marks размера 9 может быть определён и инициализирован на начальное значение ноль с помощью следующего оператора:

Директива TIMES полезна при определении массивов и таблиц. Следующая программа отображает 9 звёздочек на экране:

Результат выполнения скомпилированной программы:

Ассемблер: Константы

NASM предоставляет несколько директив, определяющих константы. Мы уже использовали директиву EQU в предыдущих разделах. Особое внимание мы уделим трём директивам:

Директива EQU

Директива EQU используется для определения констант. Синтаксис директивы EQU следующий:

Затем вы можете использовать это постоянное значение в вашем коде, например:

Операндом оператора EQU может быть выражение:

Приведённый фрагмент кода определит AREA как 200.

Пример

Следующий пример иллюстрирует использование директивы EQU:

Скомпилированный и выполненный код даст следующие результаты:

Кстати, в коде программы мы использовали 0xA,0xD в качестве части строк. Точнее говоря, в качестве окончания строк. Как можно догадаться, это шестнадцатеричные цифры. При выводе на экран эти шестнадцатеричные цифры трактуются как коды символов ASCII. То есть, чтобы понять их значение, нужно заглянуть в таблицу ASCII символов, например в статье «ASCII и шестнадцатеричное представление строк. Побитовые операции со строками».

Там мы можем найти, что 0xA (в той таблице он обозначен как 0A) и означает он перевод строки. Во многих языках программирования символ обозначается как «\n». Нажатие на клавишу ↵ Enter при выводе текста переводит строку.

Что касается 0xD (там в таблице он обозначен как 0D) и означает enter / carriage return — возврат каретки. Во многих языках программирования — символ «CR» обозначается как «\r».

Итак, если вы программируете на каком либо языке, то последовательность из двух шестнадцатеричных чисел 0xA,0xD, соответствует последовательности «\n\r», то есть, упрощённо говоря, это универсальный способ (чтобы срабатывал и в Linux, и в Windows) перейти на новую строку.

Директива %assign

По аналогии с директивой EQU, директива %assign может использоваться для определения числовых констант. Эта директива допускает переопределение. Например, вы можете определить постоянную TOTAL следующим образом:

Позже в коде вы можете переопределить её так:

Эта директива чувствительна к регистру.

Директива %define

Директива %define позволяет определять как числовые, так и строковые константы. Эта директива похожа на #define в C. Например, вы можете определить постоянную PTR так:

Приведённый выше код заменяет PTR на [EBP+4].

Эта директива также допускает переопределение и учитывает регистр.

Ассемблер: Арифметические инструкции

Инструкция INC

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

Инструкция INC имеет следующий синтаксис:

Операндом может быть 8-битный, 16-битный или 32-битный операнд.

Инструкция DEC

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

Инструкция DEC имеет следующий синтаксис:

Операндом может быть 8-битный, 16-битный или 32-битный операнд.

Инструкции ADD и SUB

Команды ADD и SUB используются для выполнения простого сложения/вычитания двоичных данных размером в byte, word и doubleword, т.е. для сложения или вычитания 8-битных, 16-битных или 32-битных операндов соответственно.

Инструкции ADD и SUB имеют следующий синтаксис:

Инструкция ADD/SUB может выполняться между:

Однако, как и другие инструкции, операции с память-в-память невозможны с использованием инструкций ADD/SUB. Операция ADD или SUB устанавливает или очищает флаги переполнения (overflow) и переноса (carry).

Пример

В следующем примере программа спросит у пользователя две цифры; сохранит их в регистрах EAX и EBX, соответственно; сложит эти значения; сохранит результат в ячейке памяти «res» и, наконец, отобразит результат.

Скомпилированный и выполненный код даст следующие результаты:

Код программы сильно упрощается, если прописать значения переменных для арифметических действий прямо в самом коде:

Результат выполнения этого кода:

Инструкции MUL/IMUL

Есть две инструкции для умножения двоичных данных. Инструкция MUL (Multiply) обрабатывает беззнаковые данные, а IMUL (Integer Multiply) обрабатывает данные со знаком. Обе инструкции влияют на флаг переноса и переполнения.

Синтаксис для инструкций MUL/IMUL следующий:

Множимое в обоих случаях будет в аккумуляторе, в зависимости от размера множимоего и умножителя, и результат умножения также сохраняется в двух регистрах в зависимости от размера операндов. Следующий раздел объясняет инструкции MUL в трёх разных случаях:

Когда перемножаются два байта

Множимое находится в регистре AL, а множитель — это байт в памяти или в другом регистре. Результат произведения находится в AX. Старшие 8 битов произведения хранятся в AH, а младшие 8 битов хранятся в AL.

Когда умножаются два значения word

Множимое должно быть в регистре AX, а множитель — это word в памяти или в другом регистре. Например, для такой инструкции, как MUL DX, вы должны сохранить множитель в DX и множимое в AX.

В результате получается двойное word, для которого понадобятся два регистра. Часть высшего порядка (крайняя слева) сохраняется в DX, а часть нижнего порядка (крайняя справа) сохраняется в AX.

Когда умножаются два значения doubleword

Когда умножаются два значения doubleword, множимое должно быть в EAX, а множитель — это значение doubleword, хранящееся в памяти или в другом регистре. Результат умножения сохраняется в регистрах EDX:EAX, то есть 32-разрядные старшие разряды сохраняются в регистре EDX, а 32-разрядные младшие разряды сохраняются в регистре EAX.

В следующем примере 3 умножается на 2 и отображается результат:

Результат выполнения программы:

Инструкции DIV/IDIV

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

Инструкция DIV (Divide) используется для данных без знака, а IDIV (Integer Divide) используется для данных со знаком.

Формат для инструкции DIV/IDIV:

Делимое находится в аккумуляторе. Обе инструкции могут работать с 8-битными, 16-битными или 32-битными операндами. Операция влияет на все шесть флагов состояния. Следующий раздел объясняет три случая деления с различным размером операнда:

Номер	Сценарии
1

Когда делитель равен 1 байту

Предполагается, что делимое находится в регистре AX (16 бит). После деления частное переходит в регистр AL, а остаток — в регистр AH.

Когда делителем является 1 word

Предполагается, что делимое имеют длину 32 бита и оно размещено в регистрах DX:AX. Старшие 16 битов находятся в DX, а младшие 16 битов — в AX. После деления 16-битное частное попадает в регистр AX, а 16-битное значение попадает в регистр DX.

Когда делитель doubleword

Предполагается, что размер делимого составляет 64 бита и оно размещено в регистрах EDX:EAX. Старшие 32 бита находятся в EDX, а младшие 32 бита находятся в EAX. После деления 32-битное частное попадает в регистр EAX, а 32-битный остаток попадает в регистр EDX.

В следующем примере 8 делится на 2. Делимое 8 сохраняется в 16-битном регистре AX, а делитель 2 сохраняется в 8-битном регистре BL.

Результат выполнения приведённого выше кода:

Ассемблер: Логические инструкции

Набор команд процессора содержит инструкции логики AND, OR, XOR, TEST и NOT, которые проверяют, устанавливают и очищают биты в соответствии с потребностями программы.

Формат для этих инструкций:

Номер	Сценарии
1

Номер	Инструкция	Формат
1	AND	AND операнд1, операнд2
2	OR	OR операнд1, операнд2
3	XOR	XOR операнд1, операнд2
4	TEST	TEST операнд1, операнд2
5	NOT	NOT операнд1

Первый операнд во всех случаях может быть либо в регистре, либо в памяти. Второй операнд может быть либо в регистре/памяти, либо в непосредственном (постоянном) значении. Однако операции память-и-память невозможны. Эти инструкции сравнивают или сопоставляют биты операндов и устанавливают флаги CF, OF, PF, SF и ZF.

Инструкция AND (И)

Инструкция AND используется для поддержки логических выражений путём выполнения побитовой операции AND. Побитовая операция AND возвращает 1, если совпадающие биты обоих операндов равны 1, в противном случае она возвращает 0. Например:

Операция AND может использоваться для очистки одного или нескольких битов. Например, допустим, регистр BL содержит 0011 1010. Если вам нужно очистить старшие биты до нуля, то вы выполняете операцию AND этого регистра с 0FH.

Давайте рассмотрим другой пример. Если вы хотите проверить, является ли данное число нечётным или чётным, простой тест будет проверять младший значащий бит числа. Если это 1, число нечётное, иначе число чётное.

Предполагая, что номер находится в регистре AL, мы можем написать:

Следующая программа иллюстрирует это.

Результат выполнения кода:

Измените значение в регистре ax на нечётную цифру, к примеру:

Программа будет отображать:

Точно так же очистить весь регистр вы можете сделав AND с 00H.

Инструкция OR

Инструкция OR (ИЛИ) используется для выполнения логической побитовой операции OR. Побитовый оператор OR возвращает 1, если совпадающие биты одного или обоих операндов равны единице. Возвращает 0, если оба бита равны нулю.

Операция OR может использоваться для установки одного или нескольких битов. Например, предположим, что регистр AL содержит 0011 1010, вам нужно установить на единицы четыре младших бита, тогда вы можете сделать OR со значением 0000 1111, т.е.

В следующем примере демонстрируется инструкция OR. Давайте сохраним значения 5 и 3 в регистрах AL и BL, соответственно, затем

затем в регистре AL в результате выполнения операции OR получится 7

Результат работы программы:

Инструкция XOR

Инструкция XOR реализует побитовую операцию XOR. Операция XOR устанавливает результирующий бит в 1, если и только если биты из операндов отличаются. Если биты из операндов одинаковы (оба 0 или оба 1), результирующий бит сбрасывается в 0.

XOR операнд числа с самим собой меняет операнд на 0. Это используется для очистки регистра.

Инструкция TEST

Инструкция TEST работает так же, как и операция AND, но в отличие от инструкции AND она не меняет первый операнд. Таким образом, если нам нужно проверить, является ли число в регистре чётным или нечётным, мы также можем сделать это, используя инструкцию TEST, не меняя исходного числа.

Инструкция NOT

Инструкция NOT реализует побитовую операцию NOT. Операция NOT меняет биты в операнде на противоположные. Операнд может быть либо в регистре, либо в памяти.

Ассемблер: Условия

Выполнение в зависимости от выполнения условия на ассемблере реализовано несколькими инструкциями зацикливания и ветвления. Эти инструкции могут изменить поток управления в программе. Условное исполнение рассматривается в двух сценариях:

Безусловный прыжок

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

Условный переход

Он выполняется с помощью набора инструкций перехода j и зависит от выполнения условия. Условные инструкции передают управление, прерывая последовательный поток, и делают это, изменяя значение смещения в IP.

Давайте обсудим инструкцию CMP, прежде чем обсуждать условные инструкции.

Инструкция CMP

Инструкция CMP сравнивает два операнда. Обычно используется в условном исполнении. Эта инструкция в основном вычитает один операнд из другого для сравнения, равны ли операнды или нет. Она не мешает операндам назначения или источника. Она используется вместе с инструкцией условного перехода для принятия решения.

CMP сравнивает два числовых поля данных. Операнд-адресат может быть либо в регистре, либо в памяти. Исходным операндом могут быть постоянные (непосредственные) данные, регистр или память.

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

Безусловный переход

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

Инструкция JMP предоставляет имя метки, куда поток управления передаётся немедленно. Синтаксис инструкции JMP:

Следующий фрагмент кода иллюстрирует инструкцию JMP:

Условный переход

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

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

№	Инструкции условия
1

Инструкция	Описание	Тестируемые флаги
JE/JZ	Jump Equal or Jump Zero (равно или ноль)	ZF
JNE/JNZ	Jump not Equal or Jump Not Zero (не равно или не ноль)	ZF
JG/JNLE	Jump Greater or Jump Not Less/Equal (больше или не меньше/равно)	OF, SF, ZF
JGE/JNL	Jump Greater/Equal or Jump Not Less (больше/равно или не меньше)	OF, SF
JL/JNGE	Jump Less or Jump Not Greater/Equal (меньше или не больше/равно)	OF, SF
JLE/JNG	Jump Less/Equal or Jump Not Greater (меньше/равно или не больше)	OF, SF, ZF

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

Инструкция	Описание	Тестируемые флаги
JE/JZ	Jump Equal или Jump Zero (равно или ноль)	ZF
JNE/JNZ	Jump not Equal или Jump Not Zero (не равно или не ноль)	ZF
JA/JNBE	Jump Above или Jump Not Below/Equal (больше или не меньше/равно)	CF, ZF
JAE/JNB	Jump Above/Equal или Jump Not Below (больше/равно или не меньше)	CF
JB/JNAE	Jump Below или Jump Not Above/Equal (меньше или не больше/равно)	CF
JBE/JNA	Jump Below/Equal или Jump Not Above (меньше/равно или не больше)	AF, CF

Следующие инструкции условного перехода имеют специальное использование и проверяют значение флагов:

Инструкция	Описание	Тестируемый флаг
JXCZ	Переход если CX равен нулю	нет
JC	Переход если Перенос	CF
JNC	Переход если нет Переноса	CF
JO	Переход если переполнение	OF
JNO	Переход если нет переполнения	OF
JP/JPE	Переход при наличии чётности	PF
JNP/JPO	Переход при отсутствии чётности	PF
JS	Переход при наличии знака (отрицательная величина)	SF
JNS	Переход при отсутствии знака (положительная величина)	SF

Синтаксис для набора инструкций J :

Пример

Следующая программа отображает наибольшую из трёх переменных. Переменные являются двузначными переменными. Три переменные num1, num2 и num3 имеют значения 47, 22 и 31 соответственно:

Результат работы программы:

Ассемблер: Петли

Инструкция JMP может использоваться для реализации циклов. Например, следующий фрагмент кода может использоваться для выполнения тела цикла 10 раз.

Набор инструкций процессора, однако, включает в себя группу команд цикла для реализации итерации. Основная инструкция LOOP имеет следующий синтаксис:

Где label — метка цели, которая идентифицирует целевую инструкцию, как в инструкциях перехода. Инструкция LOOP предполагает, что регистр ECX содержит количество циклов. Когда инструкция цикла выполняется, регистр ECX уменьшается, и управление переходит к метке назначения, пока значение регистра ECX, то есть счётчик не достигнет нуля.

Приведённый выше фрагмент кода может быть записан как:

Пример

Следующая программа печатает цифры от 1 до 9 на экране:

Когда приведённый выше код скомпилирован и выполнен, он даёт следующий результат:

Ассемблер: Числа

Числовые данные обычно представлены в двоичной системе. Арифметические инструкции работают с двоичными данными. Когда числа отображаются на экране или вводятся с клавиатуры, они имеют форму ASCII (смотрите также ASCII и шестнадцатеричное представление строк. Побитовые операции со строками).

До сих пор мы преобразовывали эти входные данные в форме ASCII в двоичные для арифметических вычислений и преобразовывали результат обратно в ASCII. Следующий код показывает это:

После компиляции и выполнения приведённый выше код даёт следующий результат:

Однако такие преобразования имеют накладные расходы, и программирование на ассемблере позволяет более эффективно обрабатывать числа в двоичной форме. Десятичные числа могут быть представлены в двух формах:

ASCII представление

В представлении ASCII десятичные числа хранятся в виде строки символов ASCII. Например, десятичное значение 1234 сохраняется как:

Где 31H — это значение ASCII для 1, 32H — это значение ASCII для 2 и т. д. Есть четыре инструкции для обработки чисел в представлении ASCII:

Эти инструкции не принимают никаких операндов и предполагают, что требуемый операнд находится в регистре AL.

В следующем примере инструкция AAS используется для демонстрации концепции:

После компиляции и выполнения приведённый выше код даёт следующий результат:

BCD представление

Существует два типа представления BCD:

В неупакованном представлении BCD каждый байт хранит двоичный эквивалент десятичной цифры. Например, число 1234 хранится как:

Есть две инструкции для обработки этих чисел:

Четыре инструкции настройки ASCII, AAA, AAS, AAM и AAD, также могут использоваться с неупакованным представлением BCD. В упакованном представлении BCD каждая цифра сохраняется с использованием четырёх битов. Две десятичные цифры упакованы в байт. Например, число 1234 хранится как:

Есть две инструкции для обработки этих чисел:

В упакованном представлении BCD отсутствует поддержка умножения и деления.

Пример

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

Результат после компиляции и выполнения:

Ассемблер: Строки

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

Мы можем хранить длину строки явно, используя символ счётчика местоположения $, который представляет текущее значение счётчика расположения. В следующем примере:

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

Строковые инструкции

Каждая строковая инструкция может требовать исходного операнда, целевого операнда или обоих. Для 32-битных сегментов строковые инструкции используют регистры ESI и EDI для указания на операнды источника и назначения соответственно.

Однако для 16-битных сегментов регистры SI и DI используются для указания на источник и пункт назначения соответственно.

Существует пять основных инструкций для обработки строк, а именно:

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

В этих инструкциях используются пары регистров ES:DI и DS:SI, где регистры DI и SI содержат действительные адреса смещения, которые относятся к байтам, хранящимся в памяти. SI обычно ассоциируется с DS (сегмент данных), а DI всегда ассоциируется с ES (дополнительный сегмент).

Регистры DS:SI (или ESI) и ES:DI (или EDI) указывают на операнды источника и назначения соответственно. Предполагается, что в памяти операндом-источником является DS:SI (или ESI), а операндом-адресатом — ES:DI (или EDI).

Для 16-битных адресов используются регистры SI и DI, а для 32-битных адресов используются регистры ESI и EDI.

В следующей таблице представлены различные версии строковых инструкций и предполагаемое пространство операндов.

Основная инструкция	Операнды в	Операция с байтом	Операция с Word	Операция с Double
MOVS	ES:DI, DS:SI	MOVSB	MOVSW	MOVSD
LODS	AX, DS:SI	LODSB	LODSW	LODSD
STOS	ES:DI, AX	STOSB	STOSW	STOSD
CMPS	DS:SI, ES: DI	CMPSB	CMPSW	CMPSD
SCAS	ES:DI, AX	SCASB	SCASW	SCASD

Префиксы повторения

Префикс REP, если он установлен перед строковой инструкцией, например — REP MOVSB, вызывает повторение инструкции на основе счётчика, размещённого в регистре CX. REP выполняет инструкцию, уменьшает CX на 1 и проверяет, равен ли CX нулю. Он повторяет обработку инструкций, пока CX не станет равным нулю.

Флаг направления (DF) определяет направление операции.

Префикс REP также имеет следующие варианты:

Ассемблер: Массивы

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

Например, мы можем определить переменную word ‘months’ любым из следующих способов:

Директивы определения данных также могут использоваться для определения одномерного массива. Определим одномерный массив чисел.

Вышеприведённое определение объявляет массив из шести слов (word), каждое из которых инициализируется числами 34, 45, 56, 67, 75, 89. Это выделяет 2×6 = 12 байтов последовательного пространства памяти. Символический адрес первого числа будет NUMBERS, а второго номера — NUMBERS + 2 и т. д.

Давайте рассмотрим другой пример. Вы можете определить массив с именем inventory размером 8 и инициализировать все значения с нуля следующим образом:

Который может быть сокращён до:

Директива TIMES также может использоваться для нескольких инициализаций одного и того же значения. Используя TIMES, массив INVENTORY можно определить как:

Пример

В следующем примере демонстрируются вышеуказанные концепции, определяя массив из трёх элементов x, в котором хранятся три значения: 2, 3 и 4. Программа добавляет значения в массив и отображает сумму 9:

Результат после компиляции и выполнения приведённого выше кода:

Ассемблер: Процедуры

Процедуры или подпрограммы очень важны для ассемблера, так как программы на ассемблере, как правило, имеют большой размер. Процедуры идентифицируются по имени. После её названия описывается тело процедуры, которая выполняет чётко определённую работу. Конец процедуры указывается оператором ret (return, возврат).

Ниже приведён синтаксис для определения процедуры:

Процедура вызывается из другой функции с помощью инструкции CALL. Инструкция CALL должна иметь имя вызываемой процедуры в качестве аргумента, как показано ниже:

Вызываемая процедура возвращает управление вызывающей процедуре с помощью инструкции RET.

Пример

Давайте напишем очень простую процедуру с именем sum, которая складывает переменные, хранящиеся в регистре ECX и EDX, и возвращает сумму в регистр EAX:

Скомпилированный и выполненный код даст следующий результат:

Структура данных стеков

Стек представляет собой массив данных в виде массива в памяти, в котором данные могут храниться и удаляться из места, называемого «вершиной» стека. Данные, которые необходимо сохранить, «помещаются» в стек, а извлекаемые данные «выталкиваются» из стека. Стек — это структура данных LIFO, то есть данные, сохранённые первыми, извлекаются последними.

Язык ассемблера предоставляет две инструкции для операций со стеком: PUSH и POP. Эти инструкции имеют следующий синтаксис:

Пространство памяти, зарезервированное в сегменте стека, используется для реализации стека. Регистры SS и ESP (или SP) используются для реализации стека. На вершину стека, которая указывает на последний элемент данных, вставленный в стек, указывает регистр SS:ESP, где регистр SS указывает на начало сегмента стека, а SP (или ESP) даёт смещение в сегмент стека.

Реализация стека имеет следующие характеристики:

Для хранения данных регистров в стеке, он может использоваться следующим образом:

Пример

Следующая программа отображает весь набор символов ASCII. Основная программа вызывает процедуру с именем display, которая отображает набор символов ASCII.

Приведённый выше код после компиляции и выполнения даст следующий результат:

Ассемблер: Рекурсия

Рекурсивная процедура — это та, которая вызывает сама себя. Существует два вида рекурсии: прямая и косвенная. При прямой рекурсии процедура вызывает себя, а при косвенной рекурсии первая процедура вызывает вторую процедуру, которая, в свою очередь, вызывает первую процедуру.

Рекурсию можно наблюдать в многочисленных математических алгоритмах. Например, рассмотрим случай вычисления факториала числа. Факториал числа задаётся уравнением:

Например: факториал 5 равен 1 x 2 x 3 x 4 x 5 = 5 x факториал 4, и это может быть хорошим примером демонстрации рекурсивной процедуры. Каждый рекурсивный алгоритм должен иметь конечное условие, то есть рекурсивный вызов программы должен быть остановлен при выполнении условия. В случае алгоритма факториала конечное условие достигается, когда n равно 0.

Следующая программа показывает, как факториал числа n реализован на ассемблере. Для простоты программы мы вычислим факториал 3.

Скомпилированный и выполненный вышеприведённый код даст следующий результат:

Ассемблер: Макросы

Написание макроса — это ещё один способ обеспечения модульного программирования на ассемблере.

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

В NASM макросы определяются с помощью директив %macro и %endmacro.

Макрос начинается с директивы %macro и заканчивается директивой %endmacro.

Синтаксис для определения макроса:

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

Например, очень распространённая потребность в программах заключается в написании строки символов на экране. Для отображения строки символов вам понадобится следующая последовательность инструкций:

В приведённом выше примере отображения строки символов регистры EAX, EBX, ECX и EDX были использованы вызовом функции INT 80H. Таким образом, каждый раз, когда вам нужно отобразить что-то на экране, вам нужно сохранить эти регистры в стеке, вызвать INT 80H, а затем восстановить исходное значение регистров из стека. Таким образом, было бы полезно написать два макроса для сохранения и восстановления данных.

Мы заметили, что некоторые инструкции, такие как IMUL, IDIV, INT и т. д нуждаются в том, чтобы некоторая информация была сохранена в некоторых конкретных регистрах и даже возвращала значения в некоторых конкретных регистрах. Если программа уже использовала эти регистры для хранения важных данных, то существующие данные из этих регистров должны быть сохранены в стеке и восстановлены после выполнения инструкции.

Пример

Следующий пример показывает создание и использование макросов:

Выполнение этой программы даст следующий результат:

Ассемблер: Управление файлами

Система рассматривает любые входные или выходные данные как поток байтов. Есть три стандартных файловых потока:

Файловый дескриптор

Файловый дескриптор — это 16-разрядное целое число, назначаемое файлу в качестве идентификатора файла. Когда создаётся новый файл или открывается существующий файл, дескриптор файла используется для доступа к файлу.

Файловый дескриптор стандартных файловых потоков — stdin, stdout и stderr — равны 0, 1 и 2 соответственно.

Файловый указатель

Файловый указатель определяет местоположение для последующей операции чтения/записи в файле в виде байтов. Каждый файл рассматривается как последовательность байтов. Каждый открытый файл связан с указателем файла, который задаёт смещение в байтах относительно начала файла. Когда файл открыт, указатель файла устанавливается в ноль.

Системные вызовы обработки файлов

В следующей таблице кратко описаны системные вызовы, связанные с обработкой файлов.

%eax	Имя	%ebx	%ecx	%edx
2	sys_fork	struct pt_regs	—	—
3	sys_read	unsigned int	char *	size_t
4	sys_write	unsigned int	const char *	size_t
5	sys_open	const char *	int	int
6	sys_close	unsigned int	—	—
8	sys_creat	const char *	int	—
19	sys_lseek	unsigned int	off_t	unsigned int

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

Создание и открытие файла

Для создания и открытия файла выполните следующие задачи:

Системный вызов возвращает дескриптор файла созданного файла в регистр EAX, в случае ошибки код ошибки находится в регистре EAX.

Открытие существующего файла

Чтобы открыть существующий файл, выполните следующие задачи:

Системный вызов возвращает дескриптор файла созданного файла в регистре EAX, в случае ошибки код ошибки находится в регистре EAX.

Среди режимов доступа к файлам чаще всего используются: только чтение (0), только запись (1) и чтение-запись (2).

Чтение из файла

Для чтения из файла выполните следующие задачи:

Системный вызов возвращает количество байтов, считанных в регистре EAX, в случае ошибки код ошибки находится в регистре EAX.

Запись в файл

Для записи в файл выполните следующие задачи:

Системный вызов возвращает фактическое количество байтов, записанных в регистр EAX, в случае ошибки код ошибки находится в регистре EAX.

Закрытие файла

Для закрытия файла выполните следующие задачи:

Системный вызов возвращает, в случае ошибки, код ошибки в регистре EAX.

Обновление файла

Для обновления файла выполните следующие задачи:

Исходная позиция может быть:

Системный вызов возвращает, в случае ошибки, код ошибки в регистре EAX.

Пример

Следующая программа создаёт и открывает файл с именем myfile.txt и записывает текст «Привет от HackWare!» в этом файле. Далее программа читает файл и сохраняет данные в буфере с именем info. Наконец, онf отображает текст как сохранённый в info.

Результат выполнения программы:

Ассемблер: Управление памятью

Системный вызов sys_brk() предоставляется ядром для выделения памяти без необходимости её перемещения позже. Этот вызов выделяет память прямо за изображением приложения в памяти. Эта системная функция позволяет вам установить максимальный доступный адрес в разделе данных.

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

Пример

Источник