Ос на ассемблере исходники: Маленькая ОС с нуля на C++ и ассемблере / Хабр

Маленькая ОС с нуля на C++ и ассемблере / Хабр

Сразу говорю, не закрывайте статью с мыслями «Блин, еще один Попов». У него всего-то слизанная Ubuntu, а у меня все с нуля, включая ядро и приложения. Итак, продолжение под катом.

Группа ОС: вот.
Сначала я кину вам один скриншот.

Больше их нет, а теперь поподробнее о том, зачем я ее пишу.

Был теплый апрельский вечер, четверг. Я еще с детства мечтал написать ОС, как вдруг подумал: «Я же теперь знаю плюсы и асм, чего бы не воплотить мою мечту?». Загуглил сайты по этой тематике и нашел статью с Хабра: «Как начать и не бросить писать ОС». Спасибо ее автору за ссылку на OSDev Wiki внизу. Я зашел туда и начал работу. Там были в одной статье все данные о минимальной ОС. Я начал собирать кросс-gcc и binutils, а потом все переписал оттуда. Видели вы бы мою радость, когда я увидел надпись «Hello, kernel World!» Я прямо со стула подпрыгнул и понял — я не сдамся. Я написал «консоль» (в кавычках, у меня не было доступа к клавиатуре), но потом решил написать оконную систему. В итоге она заработала, но доступа к клавиатуре у меня не было. А потом я решил придумать название, опираясь на X Window System. Загуглил Y Window System — она есть. В итоге назвал Z Window System 0.1, входящая в OS365 pre-alpha 0.1. И да, ее не видел никто, кроме меня самого. Потом я понял, как реализовать поддержку клавиатуры. Скрин самой первой версии, когда еще не было ничего, даже оконной системы:

В ней даже не двигался курсор текста, как вы видите. Затем я написал парочку простых приложений на основе Z. И вот релиз 1.0.0 alpha. Там были много вещей, даже меню системы. А файловый менеджер и калькулятор просто не работали.

Далее 1.0.1 с текстовым редактором, 1.0.2 с граф. режимом 640×480, 1.0.3 с рабочим столом, 1.0.4 с русским языком, 1.0.5 с фиксами и чем-то еще, 1.0.6 с часами, а вот на 1.1 остановимся поподробнее.

Меня прямо терроризировал друг, которому важны одни красивости (Митрофан, сорри). Говорил «Запили VBE-режим 1024*768*32, запили, запили! Ну запили!». Ну я уже устал его выслушивать и все-таки запилил его. О реализации ниже.

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

.set ALIGN,	1<<0
.set MEMINFO,	1<<1
.set GRAPH,     1<<2
.set FLAGS,	ALIGN | MEMINFO | GRAPH
.set MAGIC,	0x1BADB002
.set CHECKSUM, 	-(MAGIC + FLAGS)
.align 4
.long MAGIC
.long FLAGS
.long CHECKSUM
.long 0, 0, 0, 0, 0
.long 0 # 0 = set graphics mode
.long 1024, 768, 32 # Width, height, depth

А потом из структуры информации Multiboot я беру адрес фреймбуфера и разрешение экрана и пишу туда пиксели. VESA все сделали очень замороченно — цвета RGB надо вводить в обратном порядке (не R G B, а B G R). Я несколько дней не понимал — почему пиксели не выводятся!? В итоге я понял, что забыл поменять значения 16 цветовых констант с 0…15 на их RGB-эквиваленты. В итоге релизнул, заодно запилил градиентный фон. Потом я сделал консоль, 2 приложения и релизнул 1.2. Ах да, чуть не забыл — скачать ОС можно на сайте (хабраэффект, он лежит).
И да, вы не поверите, но мне 11 лет.
Продолжение следует…

Полет «Колибри». На что способна ОС, целиком написанная на ассемблере — «Хакер»

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

Развитие «Колибри» шло довольно быстро вплоть до 2009 года. Птичка научилась летать на разном железе, минимально требуя первый «Пентиум» и восемь мегабайт оперативной памяти. Минимальные системные требования «Колибри» таковы:

• ЦП: Pentium, AMD 5×86 или Cyrix 5×86 без MMX с частотой 100 МГц;
• ОЗУ: 8 Мбайт;
• видеокарта: VESA-совместимая с поддержкой режима VGA (640 × 480 × 16).

Современная «Колибри» — это регулярно обновляемые «ночные сборки» последней официальной версии, вышедшей в конце 2009 года. Мы тестировали билд 0.7.7.0+ от 20 августа 2017 года.

WARNING

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

Изменения в ночных сборках хоть и невелики, но за годы их накопилось достаточно. Обновленная «Колибри» может писать на разделы FAT16–32 / ext2 — ext4 и поддерживает другие популярные файловые системы (NTFS, XFS, ISO-9660) в режиме чтения. В ней появилась поддержка USB и сетевых карт, был добавлен стек TCP/IP и звуковые кодеки. В общем, в ней уже можно что-то делать, а не просто посмотреть разок на сверхлегкую операционку с GUI и впечатлиться скоростью запуска.

KolibriOS X-edition

Как и предшествующие версии, последняя «Колибри» написана на flat assembler (FASM) и занимает одну дискету — 1,44 Мбайт. Благодаря этому ее можно целиком разместить в какой-нибудь специализированной памяти. Например, умельцы записали KolibriOS прямо во Flash BIOS. Во время работы она может целиком размещаться в кеше некоторых процессоров. Только представь: вся операционка вместе с программами и драйверами кеширована!

INFO

При посещении сайта kolibrios.org браузер может предупредить об опасности. Причина, судя по всему, — это ассемблерные программы в дистрибутиве. Сейчас VirusTotal определяет сайт как совершенно безопасный.

«Колибри» легко загружается с дискеты, винчестера, флешки, Live CD или в виртуальной машине. Для эмуляции достаточно указать тип ОС «другая», выделить ей одно ядро процессора и немного оперативки. Диск подключать необязательно, а при наличии роутера с DHCP «Колибри» моментально подключится к интернету и локальной сети. Сразу при загрузке ты увидишь соответствующее уведомление.

Мгновенное подключение к сети

Одна проблема — протокол HTTPS не поддерживается встроенным в «Колибри» браузером. Поэтому сайт Xakep.ru посмотреть в ней не удалось, так же как открыть страницы Google, Yandex, Wikipedia, «Сбербанка»… собственно, никакой привычный адрес. Все давно перешли на защищенный протокол. Единственный сайт с олдскульным чистым HTTP, который мне попался, — это «портал Правительства России», но и он выглядел в текстовом браузере не лучшим образом.

Текстовый браузер работает только с HTTP

Настройки внешнего вида в «Колибри» с годами улучшаются, но все еще далеки от идеала. Список поддерживаемых видеорежимов отображается на экране загрузки «Колибри» при нажатии клавиши с латинской буквой a.

Выбор разрешения

Перечень доступных вариантов невелик, и нужного разрешения в нем может не оказаться. Если у тебя видеокарта с ГП AMD (ATI), то можно сразу добавить кастомные настройки. Для этого нужно загрузчику ATIKMS передать параметр -m<width>x<height>x<refresh>, например:

/RD/1/DRIVERS/ATIKMS -m1280x800x60 -1

Здесь /RD/1/DRIVERS/ATIKMS — это путь до загрузчика (RD — RAM Disk).

При работе системы выбранный видеорежим можно посмотреть командой vmode и (теоретически) переключать вручную. Если «Колибри» запущена в виртуалке, то это окно останется пустым, а вот при чистой загрузке драйверы видео Intel можно добавить от i915 до Skylake включительно.

Удивительно, но в KolibriOS уместилась куча игр. Среди них есть логические и аркадные, пятнашки, змейка, танки (нет, не WoT) — целый «Игровой центр»! На «Колибри» портировали даже Doom и Quake.

Игровой центр

Еще из важного нашлась читалка FB2READ. Она корректно работает с кириллицей и имеет настройки отображения текста.

Самая легкая читалка FB2

Все пользовательские файлы рекомендую хранить на флешке, но подключать ее нужно обязательно через порт USB 2.0. Наша флешка USB 3.0 (в порте USB 2.0) объемом 16 Гбайт с файловой системой NTFS определилась сразу. Если нужно записывать файлы, то стоит подключить флешку с разделом FAT32.

Подключаем флешку

В дистрибутив «Колибри» входит три файловых менеджера, утилиты для просмотра изображений и документов, аудио- и видеоплееры и прочие пользовательские приложения. Однако основное внимание в ней уделено разработке на ассемблере.

Средства разработчика

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

Запуск программы прямо из TinyPad

Среди средств разработки есть компилятор Oberon-07/11 для i386 Windows, Linux и KolibriOS, а также низкоуровневые эмуляторы: E80 — эмулятор ZX Spectrum, FCE Ultra — один из лучших эмуляторов NES, DOSBox v.0.74 и другие. Все они были специально портированы на «Колибри».

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

Не пугайся, это скринсейвер!

Как появилась KolibriOS

Интересна и сама идея появления «Колибри». Это не очередной клон Linux, а совершенно уникальная разработка. Единственное, что роднит ее с Linux, — это открытый исходный код и финские корни.

Многие из авторов «Колибри» до этого работали в другом проекте — MenuetOS, из которой и выросла эта птичка. Они заметили, что у всех операционок есть общая проблема — дико раздутое и уже потому ненадежное ядро. Еще в начале нулевых об этом писал Брюс Шнайер в книге «Секреты и ложь. Безопасность данных в цифровом мире». Тогда ему казалось, что у популярных в то время ОС — всевозможных клонов UNIX, Windows NT 4.0 и следующей за ней Windows 2000 (NT 5.0) — все очень плохо с безопасностью именно из-за огромного ядра.

«Когда система UNIX была написана впервые, считалось обязательным помещение несущественных кодов за пределами ядра. <…> Все имеющиеся сейчас разновидности UNIX в той или иной степени страдают распуханием ядра: у них либо слишком много команд в ядре, либо имеются непонятные утилиты, запускающиеся в случае корневого доступа, либо что-то еще.
Windows NT устроена намного хуже. Эта операционная система может служить примером того, как полностью игнорируются исторические уроки безопасности. <…> Windows, похоже, придерживается мнения, что, поскольку то, что содержится в ядре, защищено по определению, следует просто побольше всего разместить прямо в ядре. Если разработчикам было непонятно, как обеспечить безопасность чего-либо, они просто запихивали это в ядро и считали его уже защищенным. <…>
<…> …Философия Windows NT в том, чтобы всегда отдавать предпочтение простому над безопасным — и в обращении, и в разработке», — писал Шнайер в 2000 году. Не сказать, что его книга стала откровением, но в ней были сформулированы те идеи, которые давно витали в воздухе.

Примерно тогда же группа программистов из Финляндии, Польши и стран бывшего СССР предприняла попытку создать принципиально новую операционку. Написать ее почти с нуля и сделать как можно компактнее — в идеале, чтобы она помещалась на дискету (флешек в те времена еще не было, и даже пишущий CD-привод казался диковиной).

Этой системой была MenuetOS. Идейным вдохновителем выступил Вилле Микаэль Турьянмаа. Когда-то он работал с MrOS — графической многозадачной оболочкой для DOS, со временем выросшей в отдельную операционку. Идеи MrOS легли в основу «Менуэта».

Поначалу MenuetOS развивалась такими же малыми шажками, какие были характерны для французского танца, в честь которого она названа. Перелом наступил в 2001 году, когда на сайте OSNews было опубликовано интервью с разработчиком. Вскоре к проекту присоединились другие программисты, а после портирования FASM дальнейший код можно было компилировать прямо в MenuetOS.

Позже состав команды разработчиков постоянно менялся. Очередные разногласия привели к тому, что в 2003 году отделившаяся группа решила сделать свой форк. Во время разработки он назывался MENUETOS RE, но на этапе релиза был переименован в Kolibri 0.1.0.0. Название было предложено Станиславом «VaStaNi» Валыйских. По замыслу оно должно отражать легковесность и скорость работы операционки. Официально «Колибри» вышла в мае 2004 года. Полноценным форком считается KolibriOS 0.50 — именно в ней более половины кода отличалось от MenuetOS.

Настоящее и будущее маленькой птички

Сейчас «Колибри» распространяется на условиях GPLv2, в то время как ее предшественница MenuetOS стала проприетарной в 64-битной версии.

Помимо базового дистрибутива KolibriOS, существует и расширенная версия. В ней доступна утилита установки драйверов DrvInst и другие дополнительные компоненты. DrvInst позволяет установить драйверы устройств, отсутствующие в образе IMG. Например, драйвер SATA с поддержкой AHCI, драйвер видео для процессоров Intel, видеокарт AMD и виртуалки VMware.

Постепенно в «Колибри» появляется расширенный набор шрифтов и функция их сглаживания. Это будет нелишним, поскольку встроенный набор был оптимизирован для старых экранов с невысоким разрешением.

INFO

«Колибри» уже вошла в историю науки и киберпанка. Сотрудники Колумбийского университета и Нью-Йоркского геномного центра записали в ДНК операционную систему KolibriOS (PDF) вместе с другими данными общим объемом 2342 Кбайт.

Основное назначение KolibriOS осталось прежним — программирование на ассемблере в чистой среде безо всяких программных прослоек. Однако разработчик может писать свой код для KolibriOS и на языках высокого уровня (С/С++, Modula, Fort, Pascal). Это куда более простой способ создавать библиотеки, драйверы и программы.

WWW

MASM, TASM, FASM, NASM под Windows и Linux / Хабр

Часть I
Часть II
Часть III

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

MASM

Используется для создания драйверов под Windows.

По ссылке переходим на сайт и скачиваем пакет (masm32v11r.zip). После инсталляции программы на диске создается папка с нашим пакетом C:\masm32. Создадим программу prog11.asm, которая ничего не делает.

.586P
.model flat, stdcall 
_data segment 
_data ends
_text segment
start:
ret   
_text ends
end start

Произведём ассемблирование (трансляцию) файла prog11.asm, используя ассемблер с сайта masm32.

Ключ /coff используется здесь для трансляции 32-битных программ.

Линковка производится командой link /subsystem:windows prog11.obj (link /subsystem:console prog11.obj)

Как сказано в Википедии

MASM — один из немногих инструментов разработки Microsoft, для которых не было отдельных 16- и 32-битных версий.

Также ассемблер версии 6. можно взять на сайте Кипа Ирвина kipirvine.com/asm, автора книги «Язык ассемблера для процессоров Intel».

Кстати, вот ссылка на личный сайт Владислава Пирогова, автора книги “Ассемблер для Windows”.

MASM с сайта Microsoft

Далее скачаем MASM (версия 8.0) с сайта Microsoft по ссылке. Загруженный файл носит название «MASMsetup.exe». При запуске этого файла получаем сообщение -«Microsoft Visual C++ Express Edition 2005 required».

Открываем этот файл архиватором (например 7zip). Внутри видим файл setup.exe, извлекаем его, открываем архиватором. Внутри видим два файла vc_masm.msi,vc_masm1.cab. Извлекаем файл vc_masm1.cab, открываем архиватором. Внутри видим файл FL_ml_exe_____X86.3643236F_FC70_11D3_A536_0090278A1BB8. Переименовываем его в файл fl_ml.exe, далее, произведём ассемблирование файла prog11.asm, используя ассемблер fl_ml.exe.

MASM в Visual Studio

Также MASM можно найти в папке с Visual Studio (у меня VS 10) вот здесь: C:\Program Files\Microsoft Visual Studio 10.0\VC\bin\ml.exe.

Для того, чтобы запустить на 32- или 64-разрядной системе и создавать программы, работающие как под 32-, так и под 64-разрядной Windows, подходит MASM32 (ml.exe, fl_ml.exe). Для того, чтобы работать на 32- и 64-разрядных системах и создавать программы, работающие под 64-разрядной Windows, но неработающие под 32-разрядной нужен ассемблер ml64.exe. Лежит в папке C:\Program Files\Microsoft Visual Studio 10.0\VC\bin\amd64 и вот здесь — C:\Program Files\Microsoft Visual Studio 10.0\VC\bin\x86_amd64.

TASM

Программный пакет компании Borland, предназначенный для разработки программ на языке ассемблера для архитектуры x86. В настоящее время Borland прекратила распространение своего ассемблера.

Скачать можно, например, здесь. Инсталлятора нет, просто извлекаем программу. Вот исходник из книги Питера Абеля (рис. 3.2) «Язык Ассемблера для IBM PC и программирования».

stacksg segment para stack 'stack'
    db 12 dup ('stackseg')
stacksg ends
codesg segment para 'code'
begin proc far
 assume ss:stacksg,cs:codesg,ds:nothing
 push ds
 sub ax,ax
 push ax
 mov ax, 0123h
 add ax, 0025h
 mov bx,ax
 add bx,ax
 mov cx,bx
 sub cx,ax
 sub ax,ax
 nop
 ret
begin endp
codesg ends
 end begin

Выполним ассемблирование (трансляцию) файла abel32.asm.

Корректность работы программы можно проверить, произведя линковку (tlink.exe) объектного файла и запустив полученный файл в отладчике.

Как было сказано выше, MASM можно использовать для работы с 16-битными программами. Выполним ассемблирование (трансляцию) программы abel32.asm с помощью ассемблера MASM:

Ключ /coff здесь не используется.

Линковка производится файлом link16.exe

FASM

В статье Криса Касперски «Сравнение ассемблерных трансляторов» написано, что «FASM — неординарный и весьма самобытный, но увы, игрушечный ассемблер. Пригоден для мелких задач типа „hello, world“, вирусов, демок и прочих произведений хакерского творчества.»

Скачаем FASM с официального сайта. Инсталлятора нет, просто извлекаем программу. Откроем fasm editor — C:\fasm\fasmw.exe. В папке C:\fasm\EXAMPLES\HELLO есть файл HELLO.asm.

include 'win32ax.inc' 
.code
  start:
 invoke    MessageBox,HWND_DESKTOP,"Hi! I'm the example program!",invoke GetCommandLine,MB_OK
    invoke    ExitProcess,0
.end start

Откроем файл HELLO.asm из fasmw.exe. Изменим строку include ‘win32ax.inc’ на строку include ‘c:\fasm\INCLUDE\WIN32AX.INC’. Запускаем из меню Run → Run.

Вот ссылки на ресурсы, посвященные FASM:

→ FASM на Cyberforum’е

→ FASM на asmworld .com программы под Dos

→ Цикл статей «Ассемблер под Windows для чайников»

→ Сайт на narod’е

FASM в Linux

Для того, использовать FASM в Linux (у меня Ubuntu), скачаем соответствующий дистрибутив (fasm-1.71.60.tgz), распакуем его, в папке у нас будет бинарный файл fasm, копируем этот файл в /usr/local/bin для того, чтобы можно было запускать его из консоли, как любую другую команду.Выполним ассемблирование программы hello.asm из папки fasm/examples/elfexe/hello.asm.

Корректность работы программы можно проверить в отладчике.

Nasm

Nasm успешно конкурирует со стандартным в Linux- и многих других UNIX-системах ассемблером Gas.

Nasm в Linux можно установить его с помощью менеджера пакетов или из командной строки: в дистрибутиве Debian (Ubuntu) командой apt-get install nasm, в дистрибутивах Fedora, CentOS, RedHat командой yum install nasm.

Создадим программу, которая 5 раз выводит сообщение “Hello”. Пример взят из книги Андрея Викторовича Столярова “Программирование на языке ассемблера NASM для ОС UNIX”. Учебник, а также библиотека “stud_io.inc” есть на личном сайте автора.

%include "stud_io.inc"
global _start
section .text
_start: mov eax, 0
again:  PRINT "Hello"
PUTCHAR 10
inc eax
cmp eax, 5
jl again
FINISH

Выполним ассемблирование и линковку и запустим файл hello.asm.

$ nasm -f elf hello.asm
$ ld hello.o -o hello
$ ./hello

Для 64bit необходимо использовать команду nasm -f elf64 hello.asm

NASM для Windows

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

Ассемблирование:
nasm -f bin имя_файла.asm -o имя_файла.com

Ссылки на ресурсы, посвященные Nasm:

→ Сайт А.В. Столярова

→ Сайт, на котором лежит электронный учебник (в архиве)

→ То же самое

AS

Стандартный ассемблер практически во всех разновидностях UNIX, в том числе Linux и BSD. Свободная версия этого ассемблера называется GAS (GNU assembler). Позволяет транслировать программы с помощью компилятора GCC.

Из учебников удалось найти только книгу на английском «Programming from the ground up». На русском удалось найти только одну главу из книги С. Зубкова «Assembler для DOS, Windows и UNIX».

Возьмем пример программы, которая ничего не делает, с сайта. Создадим программу gas.s

.section .text
   .globl _start
   _start:
      movl  $1, %eax
      movl  $2, %ebx
      int   $0x80

Выполним ассемблирование (трансляцию), линковку и запуск программы:

$ as -o gas.o gas.s
$ ld -o gas gas.o
$ ./gas

Если в данной программе изменить _start на main, то можно выполнить ассемблирование (трансляцию) и линковку компилятором gcc.

.section .text
   .globl main
   main:
      movl  $1, %eax
      movl  $2, %ebx
      int   $0x80

Выполним ассемблирование (трансляцию), линковку и запуск программы:

$ gcc gas.s -o gas
$ ./gas

Выводы: если вы изучаете программирование под Windows, то вы можете остановить свой выбор на Masm; Tasm больше не поддерживается, но для обучения по старым классическим учебникам подойдёт.
Под Linux Gas подойдет тем, кто использует GCC, а тем, кому не нравится синтаксис Gas, подойдёт Nasm.

P.S. Следующие две части, в целом, посвящены обработке строки в цикле.
P.P.S. Little Man Computer — учебная модель компьютера с ограниченым набором ассемблерных инструкций рассматривается в этой статье.

Разработка на ассемблере в Linux / Хабр

Вообще программирование на ассемблере в Linux мало распространено и занимаются им, разве что, фанаты ассемблера. Сегодня мы и поговорим о программировании на ассемблере и инструментарий.Что нам понадобится:

• FASM. Берем на flatassembler.net версию для Linux
• ald. Берем на ald.sourceforge.net
• shed. Берем на shed.sourceforge.net
• ld. Есть в большинстве дистрибутивов

Собственно каждый для себя выбирает инструменты сам. Я выбрал для себя эти.

Установка FASM

После загрузки архива с офф. сайта распакуем его:

tar zxvf fasm-1.69.11.tgz

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

sudo ln -s /home/username/fasm/fasm /usr/local/bin

ald и shed устанавливаются не сложнее:

$ ./configure

$ make

# make install

В итоге у нас будет 3 полезных инструмента для программирования на ассемблере.

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

Как и большинство других операционных систем, Linux предоставляет т.н. API — набор полезных для программиста функций. В большинстве случаев вызов системной функции производится с помощью прерывания 80h. Следует отметить, что Linux используется fastcall-конвенция передачи параметров. Согласно ей параметры передаются через регистры (в windows, например, используется stdcall, где параметры передаются через стек). Номер вызываемой функции кладется в eax, а параметры в регистры:

Номер параметра / Регистр

1 / ebx

2 / ecx

3 / edx

4 / esi

5 / edi

6 / ebp

Как видите все не так сложно. Узнать номер системной функции, ее описание и параметры можно, хотя бы здесь. Возьмем, к примеру sys_exit. Как можно увидеть на той странице у нее есть один параметр — код возврата и она имеет порядковый номер 1. Таким образом мы можем вызвать ее следующим кодом:

mov eax, 1 ; 1 - номер системной функции

sub ebx, ebx ; Обнуляем регистр (можно было записать mov ebx, 0)

int 80h ; Вызываем прерывание 80h

Надеюсь, что все понятно.

Hello, World!

Ну что же. Писать мы ничего не будем, т.к. за нас все написано 🙂 В папке fasm/examples/elfexe есть файл hello.asm, в котором находится следующий код:

; fasm demonstration of writing simple ELF executable

format ELF executable 3

entry start

segment readable executable

start:

mov eax,4

mov ebx,1

mov ecx,msg

mov edx,msg_size

int 0x80

mov eax,1

xor ebx,ebx

int 0x80

segment readable writeable

msg db ‘Hello world!’,0xA

msg_size = $-msg

Как видите здесь вызываются 2 системных функции — sys_write (с порядковым номером 4) и sys_exit. sys_write принимает 3 параметра — дескриптор потока вывода (1 — stdout), указатель на строку и размер строки. Сам номер функции, как уже говорилось, мы должны положить в eax. Функцию sys_exit мы уже разобрали. Скомпилировать это чудо можно так: fasm hello.asm (но не обязательно, т.к. там же, где лежит исходник, есть и бинарник).

Посмотрим, что внутри

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

shed hello

Мы видим всю нашу программу, данные, elf-заголовок. Неплохо? Теперь мы посмотрим на нашу программу в отладчике. Наберем в консоли:

ald hello

Нас должна поприветствовать строка с предложением ввести команду. Список команд вы можете узнать, набрав help или получить помощь по отдельной команде, набрав help command. Дизассемблировать нашу программу можно командой disassemble (или ее алиас — «d«). Вы увидете дизассемблированный листинг вашей программы. Слева — адрес, справа — сама команда, а посередине — опкод команды.

Получить дамп можно командой dump (странно, но ее нет в выводе команды help).

Теперь попробуем поработать с командой next. Выполните ее и в ответ вам покажут значения регистров, установленные флаги, а так же адрес, опкод и дизассемблированную команду, которая должна выполниться следующей. Попробуйте выполнять команды и следите за изменением флагов и регистров. После вызова первого прерывания у вас на экране должна появиться надпись «Hello world!».

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

PS. Первая статья на хабре.

Полезные ссылки

asm.sourceforge.net
www.int80h.org

SASM – IDE для ассемблера / Хабр

Здравствуйте, уважаемые хабравчане!

Данным постом хочу представить сообществу проект, который время от времени писался мной последний год: SASM (SimpleASM) — IDE для разработки программ на языке ассемблера x86 и x86-64.

SASM — простая кроссплатформенная (доступна на Windows и Linux) среда разработки для языков ассемблера NASM, MASM, GAS, FASM с подсветкой синтаксиса и отладчиком. Программа работает «из коробки» и хорошо подойдет для начинающих изучение языка ассемблера. Основана на Qt. Распространяется по свободной лицензии GNU GPL v3.0.

Исходники лежат в репозитории на GitHub.

Бинарники можно скачать на сайте программы.

Под катом Вы найдете немножко истории и более подробное описание возможностей.

Откуда все пошло

На 1 курсе в моём университете проходил учебный курс «Архитектура и язык ассемблера», в котором мы изучали ассемблер NASM и сдавали задачи на нем в ejudge контестах. Привыкший к использованию IDE при программировании до этого, я был не очень рад компилить все в командной строке. Удобных на мой взгляд IDE для NASM не было. Универсальные решения типа Geany мне не очень нравились (хотя на вкус и цвет товарища нет — кто-то пользовался всем этим и был доволен). Да и хотелось уже сделать что-нибудь большое и заодно выучить C++.
Итак, было решено написать свою IDE для NASM, в первую очередь для себя и может быть однокурсников.

Опыта написания GUI у меня до этого не было. После недолгих раздумий было решено использовать Qt — хороший бесплатный фреймворк, заодно и кроссплатформенный. Сначала был написан просто текстовый редактор с простой подсветкой, логом построения и окнами ввода/вывода. Гордо называемая «IDE» программа умела собирать текст, который был в текстовом редакторе и запускать построенную программу.

Затем я, немного подучив регулярные выражения, сделал красивую подсветку. Прикрутил отладчик (GDB). Добавил вкладки и всякие простые фичи в текстовом редакторе типа поиска и комментирования куска кода. Постепенно допиливал программу до более-менее нормального вида, исправлял ошибки.

Весной этого года SASM был включен в вышеописанный учебный курс, и первокурсники уже пользовались им. Недавно добавил в программу поддержку и других ассемблеров, кроме NASM — MASM, FASM и GAS.

Возможности

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

В логе указывается информация о времени работы программы. Есть 2 формы для ввода и вывода. Как я уже говорил, программа изначально предназначалась для сдачи контестов. Две последние возможности очень удобны для этого. Если все-таки понадобиться сохранить exe’шник, это можно сделать в меню «Файл».

Отладчик

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

Да, отладчик реализован на базе GDB. Сделать его было не очень просто из-за ограничений ассемблера. В частности, NASM не умеет генерировать нормальную отладочную информацию и приходится определять текущее местонахождение в программе, ставя в соответствие листинг, генерируемый ассемблером и текущий адрес в счетчике команд EIP.

Библиотека макросов для NASM

В SASM включена библиотека макросов для ввода/вывода «io.inc», используемая в курсе «Архитектура и язык ассемблера» и немного переписанная для отладки и поддержки 64-битного режима. Она очень удобна на начальных этапах обучения — позволяет выводить данные, не задумываясь о соглашениях и правилах вызова функций.

Например, чтобы вывести число содержащееся в регистре EAX, достаточно написать

PRINT_DEC 4, eax ; 4 - количество байт

вместо

section .data
    format db "%d", 0
section .text
    push eax
    push format
    call printf
    add esp, 8

Команды, содержащиеся в «io.inc» можно найти в справке.

Опции

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

Там же задается язык (доступны русский и английский).

Также в параметрах доступен выбор ассемблера (NASM, MASM, GAS или FASM) и разрядности (x86 или x64). Эти опции влияют на выбор программ — ассемблера и компоновщика, и опций для них. Также под новый ассемблер подстраивается подсветка и начальный текст. Пути и опции сборки можно задать и вручную.

Дополнительно

Программа содержит справку и примеры программ для каждого ассемблера — программы Hello World в папке Projects и начальные шаблоны, чтобы можно было сразу приступить к написанию кода.

На Windows все нужные для сборки программ компоненты уже включены в SASM. Программа работает «из коробки» — можно начинать программировать сразу же после запуска.

На Linux следует установить gcc, gdb и необходимый ассемблер.

Заключение

Больше информации о программе и исходники можно посмотреть по ссылкам выше. Качество кода в начале может быть не очень — только осваивал C++ и ООП, сразу на всякий случай прошу прощения.

Проект Open Source — так что, если вдруг кто-то хочет присоединиться и что-то поменять — Welcome!

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

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

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

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

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

До ее написания я сформулировал такие требования к будущей программе:

• Моя программа не должна быть программой под DOS. Слишком много примеров ориентировано на нее в связи с простым API. Моя программа обязательно должна была запускаться на современных ОС.
• Программа должна использовать кучу – получать в свое распоряжение динамически распределяемую память.
• Чтобы не быть слишком сложной, программа должна работать с целыми беззнаковыми числами без использования переносов.

Задачей для своей программы я выбрал поиск простых чисел с помощью Решета Эратосфена. В качестве ассемблера я выбрал nasm.

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

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

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

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

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

SECTION .text
    org 0x100

    mov ah, 0x9
    mov dx, hello
    int 0x21
    
    mov ax, 0x4c00
    int 0x21

SECTION .data
    hello: db "Hello, world!", 0xD, 0xA, '$'

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

%include "win32n.inc"

extern MessageBoxA
import MessageBoxA user32.dll
extern ExitProcess
import ExitProcess kernel32.dll

SECTION code use32 class=code
    ..start:

    push UINT MB_OK
    push LPCTSTR window_title
    push LPCTSTR banner
    push HWND NULL
    call [MessageBoxA]

    push UINT NULL
    call [ExitProcess]

SECTION data use32 class=data
    banner: db "Hello, world!", 0xD, 0xA, 0
    window_title: db "Hello", 0

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

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

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

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

Подпрограммы представляют собой метку, по которой располагается код. Заканчивается подпрограмма инструкцией ret. К примеру, вот такая подпрограмма в DOS выводит в консоль строку «Hello, world»:

print_hello:
    mov ah, 0x9
    mov dx, hello
    int 0x21
    ret

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

call print_hello

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

push hello
call _printf
add esp, 4

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

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

print_hello:
    push ebp ;сохраняем указатель начала стекового кадра на стеке
    mov ebp, esp ;теперь началом кадра является вершина предыдущего

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

    mov esp, ebp
    pop ebp
    ret

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

print_hello:
    push ebp
    mov ebp, esp
    sub esp, 8 ;опускаем указатель вершины стека на 8 байт, чтобы выделить память

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

print_hello:
    enter 8, 0 ;создать новый кадр, выделить 8 байт для локальных переменных

    leave ;восстановить стек
    ret

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

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

Проект содержит такие файлы:

• main.asm – главный файл,
• functions.asm – подпрограммы,
• string_constants.asm – определения строковых констант,
• Makefile – сценарий сборки

Рассмотрим код основного файла:main.asm

%define SUCCESS 0
%define MIN_MAX_NUMBER 3
%define MAX_MAX_NUMBER 4294967294

global _main
extern _printf
extern _scanf
extern _malloc
extern _free

SECTION .text
_main:
	enter 0, 0
	
	;ввод максимального числа
	call input_max_number
	cmp edx, SUCCESS
	jne .custom_exit
	mov [max_number], eax
	
	;выделяем память для массива флагов
	mov eax, [max_number]
	call allocate_flags_memory
	cmp edx, SUCCESS
	jne .custom_exit
	mov [primes_pointer], eax
	
	;отсеять составные числа
	mov eax, [primes_pointer]
	mov ebx, [max_number]
	call find_primes_with_eratosthenes_sieve
	
	;вывести числа
	mov eax, [primes_pointer]
	mov ebx, [max_number]
	call print_primes
	
	;освободить память от массива флагов
	mov eax, [primes_pointer]
	call free_flags_memory
	
	;выход
	.success:
		push str_exit_success
		call _printf
		jmp .return
			
	.custom_exit:
		push edx
		call _printf
		
	.return:
		mov eax, SUCCESS
		leave
		ret
	
	%include "functions.asm"

SECTION .data
	max_number: dd 0
	primes_pointer: dd 0
	
	%include "string_constants.asm"

Видно, что программа поделена по смыслу на 5 блоков, оформленных в виде подпрограмм:

1. input_max_number — с помощью консоли запрашивает у пользователя максимальное число, до которого производится поиск простых; во избежание ошибок значение ограничено константами MIN_MAX_NUMBER и MAX_MAX_NUMBER
2. allocate_flags_memory — запросить у ОС выделение памяти для массива пометок чисел (простое/составное) в куче; в случае успеха возвращает указатель на выделенную память через регистр eax
3. find_primes_with_eratosthenes_sieve — отсеять составные числа с помощью классического решета Эратосфена;
4. print_primes — вывести в консоль список простых чисел;
5. free_flags_memory — освободить память, выделенную для флагов

Для функций было условлено такое правило: значение возвращается через регистр eax, регистр edx содержит статус. В случае успеха он содержит значение SUCCESS, то есть, 0, в случае неудачи — адрес строки с сообщением об ошибке, которое будет выведено пользователю.

Файл string_constants.asm содержит определение строковых переменных, значения которых, как намекает название файла, менять не предполагается. Только ради этих переменных было сделано исключение к правилу «не использовать глобальные переменные». Я так и не нашел более удобного способа доставлять строковые константы функциям ввода-вывода – подумывал даже записывать на стек непосредственно перед вызовами функций, но решил, что эта идея куда хуже идеи с глобальными переменными.

string_constants.asm

;подписи ввода-вывода, форматы
str_max_number_label: db "Max number (>=3): ", 0
str_max_number_input_format: db "%u", 0
str_max_number_output_format: db "Using max number %u", 0xD, 0xA, 0

str_print_primes_label: db "Primes:", 0xD, 0xA, 0
str_prime: db "%u", 0x9, 0
str_cr_lf: db 0xD, 0xA, 0
	
;сообщения выхода
str_exit_success: db "Success!", 0xD, 0xA, 0
str_error_max_num_too_little: db "Max number is too little!", 0xD, 0xA, 0
str_error_max_num_too_big: db "Max number is too big!", 0xD, 0xA, 0
str_error_malloc_failed: db "Can't allocate memory!", 0xD, 0xA, 0

Для сборки применяется такой сценарий:Makefile

ifdef SystemRoot
   format = win32
   rm = del
   ext = .exe
else
   format = elf
   rm = rm -f
   ext = 
endif

all: primes.o
	gcc primes.o -o primes$(ext)
	$(rm) primes.o

primes.o:
	nasm -f $(format) main.asm -o primes.o

Подпрограммы (функции)

input_max_number

Код подпрограммы

; Ввести максимальное число
; Результат: EAX - максимальное число
input_max_number:	
	;создать стек-фрейм,
	;4 байта для локальных переменных
	enter 4, 1

	;показываем подпись
	push str_max_number_label ;см. string_constants.asm
	call _printf
	add esp, 4

	;вызываем scanf
	mov eax, ebp
	sub eax, 4
	
	push eax
	push str_max_number_input_format ;см. string_constants.asm
	call _scanf
	add esp, 8
	
	mov eax, [ebp-4]

	;проверка
	cmp eax, MIN_MAX_NUMBER
	jb .number_too_little
	cmp eax, MAX_MAX_NUMBER
	ja .number_too_big
	jmp .success

	;выход
	.number_too_little:
		mov edx, str_error_max_num_too_little ;см. string_constants.asm
		jmp .return	
		
	.number_too_big:
		mov edx, str_error_max_num_too_big ;см. string_constants.asm
		jmp .return	

	.success:
		push eax
		push str_max_number_output_format ;см. string_constants.asm
		call _printf
		add esp, 4
		pop eax
		mov edx, SUCCESS
	
	.return:
		leave
		ret

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

        mov eax, ebp
        sub eax, 4
	
        push eax
        push str_max_number_input_format ;см. string_constants.asm
        call _scanf
        add esp, 8
	
        mov eax, [ebp-4]

Таким образом, сначала в eax записывается адрес памяти на 4 байта ниже указателя базы стека. Это память, выделенная для локальных нужд подпрограммы. Указатель на эту память передается функции scanf как цель для записи данных, введенных с клавиатуры.

После вызова функции, в eax из памяти перемещается введенное значение.

allocate_flags_memory и free_flags_memory

Код подпрограмм

; Выделить память для массива флагов
; Аргумент: EAX - максимальное число
; Результат: EAX - указатель на память
allocate_flags_memory:
	enter 8, 1

	;выделить EAX+1 байт
	inc eax
	mov [ebp-4], eax
	
	push eax
	call _malloc
	add esp, 4
	
	;проверка
	cmp eax, 0
	je .fail
	mov [ebp-8], eax
	
	;инициализация
	mov byte [eax], 0
	
	cld
	mov edi, eax
	inc edi
	mov edx, [ebp-4]
	add edx, eax
	
	mov al, 1
	.write_true:
		stosb
		cmp edi, edx
		jb .write_true
	
	;выход
	mov eax, [ebp-8]
	jmp .success
	
	.fail:
		mov edx, str_error_malloc_failed ;см. string_constants.asm
		jmp .return
	
	.success:
		mov edx, SUCCESS
			
	.return:
		leave
		ret

; Освободить память от массива флагов
; Аргумент: EAX - указатель на память
free_flags_memory:
	enter 0, 1
	
	push eax
	call _free
	add esp, 4
	
	leave
	ret

Ключевыми местами этих подпрограмм являются вызовы функций malloc и free из библиотеки Си.

malloc в случае удачи возвращает через регистр eax адрес выделенной памяти, в случае неудачи этот регистр содержит 0. Это самое узкое место программы касательно максимального числа. 32 бит вполне достаточно для поиска простых чисел до 4 294 967 295, но выделить разом столько памяти не получится.

find_primes_with_eratosthenes_sieve

Код подпрограммы

;Найти простые числа с помощью решета Эратосфена
;Аргументы: EAX - указатель на массив флагов, EBX - максимальное число	
find_primes_with_eratosthenes_sieve:
	enter 8, 1
	mov [ebp-4], eax
		
	add eax, ebx
	inc eax
	mov [ebp-8], eax
	
	;вычеркиваем составные числа
	cld
	mov edx, 2 ;p = 2
	mov ecx, 2 ;множитель с = 2
	.strike_out_cycle:
		;x = c*p
		mov eax, edx
		push edx
		mul ecx
		pop edx
		
		cmp eax, ebx
		jbe .strike_out_number
		jmp .increase_p
		
		.strike_out_number:
			mov edi, [ebp-4]
			add edi, eax
			mov byte [edi], 0
			inc ecx ;c = c + 1
			jmp .strike_out_cycle
			
		.increase_p:
			mov esi, [ebp-4]
			add esi, edx
			inc esi
			
			mov ecx, edx
			inc ecx
			.check_current_number:
				mov eax, ecx
				mul eax
				cmp eax, ebx
				ja .return
			
				lodsb
				inc ecx
				cmp al, 0
				jne .new_p_found
				jmp .check_current_number
			
				.new_p_found:
					mov edx, ecx
					dec edx
					mov ecx, 2
					jmp .strike_out_cycle			
	
	.return:
		leave
		ret

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

print_primes

Код подпрограммы

; Вывести простые числа
; Параметры: EAX - указатель на массив флагов, EBX - максимальное число
print_primes:
	enter 12, 1
	mov [ebp-4], eax
	mov [ebp-8], ebx
	
	push str_print_primes_label
	call _printf
	add esp, 4
	
	cld
	mov esi, [ebp-4]
	mov edx, esi
	add edx, [ebp-8]
	inc edx
	
	mov [ebp-12], edx
	mov ecx, 0
	.print_cycle:
		lodsb
		cmp al, 0
		jne .print
		jmp .check_finish
		.print:
			push esi
			push ecx
			push str_prime ;см. string_constants.asm
			call _printf
			add esp, 4
			pop ecx
			pop esi
			mov edx, [ebp-12]
		.check_finish:
			inc ecx
			cmp esi, edx
			jb .print_cycle
			
	push str_cr_lf
	call _printf
	add esp, 4
			
	leave
	ret

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

Заключение

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

Так же привожу полные исходники программы.

Могу так же привести интересный факт. Поскольку с детства нас учили, что программы на языке ассемблера выполняются быстрее, я решил сравнить скорость выполнения этой программы со скоростью программы на C++, которую я писал когда-то и которая искала простые числа с помощью Решета Аткина. Программа на С++, скомпилированная в Visual Studio с /O2 выполняла поиск до числа 2³⁰ примерно за 25 секунд на моей машине. Программа же на ассемблере показала 15 секунд с Решетом Эратосфена.

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

Полезные ссылки

1. Список ресурсов для изучения ассемблера
2. Организация памяти
3. Решето Эратосфена
4. Решето Аткина
5. Стек
6. Стековый кадр

Дизассемблер своими руками / Хабр

     Знание структуры машинных команд уже много лет не является обязательным, для того, чтобы человек мог назвать себя программистом. Естественно так было не всегда. До появления первых ассемблеров программирование осуществлялось непосредственно в машинном коде. Каторжная работа, сопряженная с большим количеством ошибок. Современные ассемблеры позволяют (в разумной степени) абстрагироваться от железа, метода кодирования команд. Что уж говорить о компиляторах высокоуровневых языков. Они поражают сложностью своей реализации и той простотой, с которой программисту позволяется преобразовывать исходный код в последовательность машинных команд (причем преобразовывать, в достаточной степени, оптимально). От программиста требуется лишь знание любимого языка/ IDE. Знание того, во что преобразует компилятор исходный листинг вовсе не обязательно.
Тем же, кому интересно взглянуть на краткое описание структуры кодирования машинных команд, пример реализации и исходный код дизассемблера для x86 архитектуры, добро пожаловать.

     Создание дизассемблера для x86 архитектуры является, хотя задачей и не особо сложной, но все, же довольно специфичной. От программиста требуются определенного рода знания – знания того, как микропроцессор распознает последовательность “байтиков” в машинном коде. Далеко не в каждом вузе можно получить такие знания в объеме достаточном для написания полнофункционального современного дизассемблера – приходится искать самому (как правило, на английском языке). Данный пост не претендует на полноту освещение проблемы создания дизассемблера, в нем лишь кратко рассказывается то, как был написан дизассемблер для x86 архитектуры, 32-разрядного режима исполнения команд. Так же хотелось бы отметить вероятность возможных неточностей при переводе некоторых понятий из официальной спецификации.

     Структура команд для intel x86

Структура команды следующая:

• Опциональные префиксы (каждый префикс имеет размер 1 байт)

• Обязательный опкод команды (1 или 2 байта)

• Mod_R/M – байтик, определяющий структуру операндов команды — опциональный.

• Опциональные байты, занимаемые операндами команды (иногда разделено как один байт поля SIB[Scale, Index, Base], смещения и непосредственного значения).

Префиксы

     Существуют следующие префиксы:

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

• 0x26 – префикс замены сегмента ES

• 0x2E – префикс замены сегмента CS

• 0x36 – префикс замены сегмента SS

• 0x3E – префикс замены сегмента DS

• 0x64 – префикс замены сегмента FS

• 0x65 – префикс замены сегмента GS

• 0x0F – префикс дополнительных команд (иногда его не считают за настоящий префикс – в этом случае считается, что опкод команды состоит из двух байт, первый из которых 0x0F)

• 0x66 – префикс переопределения размера операнда (к примеру, вместо регистра eax будет использоваться ax)

• 0x67 – префикс переопределения размера адреса (см ниже)

• 0x9B – префикс ожидания (WAIT)

• 0xF0 – префикс блокировки (LOCK с его помощью реализуется синхронизация многопоточных приложений)

• 0xF2 – префикс повторенья команды REPNZ – работа с последовательностями байт (строками)

• 0xF3 – префикс повторенья команды REP – работа с последовательностями байт (строками)

Каждый из этих префиксов меняет семантику и (или) структуру машинной инструкции (например, ее длину или выбор мнемоники).

     Опкоды команд.

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

Байт Mod_R/M состоит из следующих полей:

• Mod – первые два бита (значение от 0 до 3)

• R/M – следующие три бита (значение от 0 до 7)

• Value of ModR/M – следующие три бита (значение от 0 до 7)

     Реализация:

Для написания дизассемблера мы будем использовать следующую страничку: http://ref.x86asm.net/geek32.html.

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

     В первой таблице представлен список машинных команд, не содержащих префикс 0x0F. Во второй список команд содержащих этот префикс (большинство этих команд появились в микропроцессорах семейства “Pentium with MMX” или более поздних).

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

     Последняя таблица позволяет преобразовать байт Mod_R/M в последовательность операндов команды для 16-битного режима кодировки команд. По умолчанию считается, что команда кодируется в 32-битном режиме. Для смены режима кодировки используется префикс переопределения размера адреса (0x67).

     Первое, что необходимо сделать, это перенести первые две таблицы в удобные для работы структуры данных. На том же сайте можно скачать xml-версии данных таблиц, и уже их преобразовать в красивые сишные структуры. Я же поступил иначе – загрузил html таблицы в Excel, и уже там, написав несложный скриптик на VBA, получил исходный сишный код, который, уже после ручных исправлений представлял собой требуемые структуры данных.

Сам алгоритм дизассемблирования достаточно прост:

• Собирается список префиксов, используемых в текущей машинной инструкции

• Ищется в одной из двух таблиц соответствующее поле в зависимости от опкода, префиксов и поколения (модели) целевого (искомого) микропроцессора.

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

     Количество операндов может колебаться от нуля до трех. Исходные таблицы содержат более сотни типов операндов. Некоторые операнды дублируются – у них различные названия, но последовательность действий обработки Mod_R/M байта (и возможно последующих байтов) у них одинакова.

     Для просмотра примера обработки различных операндов и примера дизассемблирования простейшей функции “Hello world” можно скачать исходный код дизассемблера для компилятора C++ Builder 6.

PS:

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

Как написать простую операционную систему на языке ассемблера

 sudo apt-get install build-essential qemu nasm 

 mov bx, 1000h
mov ax, [bx]
cmp топор, 50
этикетка jge
...

этикетка:
мов топор, 10
 

 mylabel: db 'Сообщение здесь', 0
 

 foo: db 0
 

 mov byte al, [foo]
 

 БИТЫ 16

Начало:
mov ax, 07C0h; Установите пространство стека 4K после этого загрузчика
добавить топор, 288; (4096 + 512) / 16 байт на параграф
mov ss, топор
mov sp, 4096

mov ax, 07C0h; Установите сегмент данных туда, где мы загружены
mov ds, топор


mov si, text_string; Поместите позицию строки в SI
вызов print_string; Вызовите нашу процедуру печати строк

jmp $; Прыгай сюда - бесконечный цикл!


text_string db 'Это моя крутая новая ОС!', 0


print_string:; Процедура: вывод строки в СИ на экран
mov ah, 0Eh; Функция int 10h 'print char'

.повторение:
lodsb; Получить символ из строки
cmp al, 0
je .done; Если char равен нулю, конец строки
int 10h; В противном случае распечатайте это
jmp .repeat

.сделанный:
Ret


умножить на 510 - ($ - $$) db 0; Заполните остаток загрузочного сектора нулями
dw 0xAA55; Стандартная подпись загрузки ПК
 

 nasm -f bin -o myfirst.bin myfirst.asm
 

 dd status = noxfer conv = notrunc if = myfirst.bin of = myfirst.flp
 

 qemu-system-i386 -fda myfirst.flp 

 mkisofs -o myfirst.iso -b myfirst.flp cdiso /
 

.

Создание операционной системы (ОС) на языке ассемблера

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

Недавно Райан обратил свое внимание на компьютеры.Например, всего несколько минут назад он отправил мне электронное письмо с вопросом: «Можно ли создать операционную систему на языке ассемблера? Кроме того, зачем нужна сборка в наши дни таких языков, как C / C ++ и Java, когда память настолько дешева? »

Итак, я должен признать, что у меня было искушение послать короткий, быстрый и легкий (для меня) ответ, но я помню, как все было для меня запутанным вначале — плюс я немного навязчиво-компульсивен по поводу такого рода вещи — поэтому я ответил следующим образом; Мне было бы интересно услышать ваши мысли о том, как я все это изложил.

Привет, Райан. Как обычно, в твоем вопросе больше, чем кажется на первый взгляд LOL. Начнем с того факта, что процессор (мы сосредоточимся на микропроцессорах / MPU или микроконтроллерах / MCU, но это применимо ко всему, вплоть до мэйнфреймов) в конечном итоге выполняет так называемые «инструкции машинного кода». В основном это числа, представляющие инструкции или данные, где число «x» может указывать на инструкцию «Добавить», число «y» может указывать на инструкцию «Сравнить» и так далее.

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

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

На самом деле это отличный пример «начальной загрузки»; то есть подтягиваться за шнурки. Вот как все пойдет. Вы бы определили очень простой язык ассемблера как упражнение с карандашом и бумагой. Затем вы должны написать очень элементарный ассемблер на своем языке ассемблера — снова используя карандаш и бумагу — и вручную собрать этот элементарный ассемблер в машинный код.

Здесь все становится интересно. Вы также могли бы написать очень простой текстовый редактор (вероятно, типа, известного как ca «Line Editor») на своем языке ассемблера в виде упражнения на бумаге и карандашом, и вы вручную собрали бы этот простой редактор в машинный код.

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

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

Теперь давайте рассмотрим, например, современный язык, такой как Си. Как вы знаете, мы используем программу-редактор для создания нашего исходного кода на C, затем мы запускаем этот код через программу компилятора и — в конечном итоге — нам предоставляется эквивалент машинного кода («исполняемый»).

Первый вопрос, который нам нужно задать: «Откуда взялась программа компилятора?» Фактически, если бы вы были человеком, создавшим компилятор, то первая версия (очень простой компилятор C) была бы написана на языке ассемблера и прошла через вашу программу ассемблера для генерации версии компилятора с машинным кодом.Эта первая версия вашего компилятора C может поддерживать только подмножество языка C — ровно настолько, чтобы вы могли начать работу.

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

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

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

Мы уже развлекаемся (LOL)? Хорошо, допустим, мы хотим создать программу, которая что-то делает; возможно, это игра в Breakout.Мы могли бы создать эту программу на языке ассемблера или C. В прошлом опытные программисты говорили, что они знают множество хитрых приемов, чтобы они могли создавать меньшие и более быстрые программы на языке ассемблера, чем те, которые могут быть созданы с помощью компилятора C. Вероятно, это было правдой, но на это им потребовалось бы гораздо больше времени; кроме того, современные компиляторы C очень сложны и обычно знают те же хитрые приемы, что и программисты.

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

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

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

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

Возвращаясь к вашему исходному вопросу, в случае систем очень низкого уровня, основанных на 8-битных микроконтроллерах, все еще есть довольно много старых программистов, которые программируют исключительно на языке ассемблера. Есть также такие вещи, как семейство программных 8-битных процессорных ядер PicoBlaze, используемых в ПЛИС Xilinx, которые могут быть запрограммированы только на языке ассемблера, потому что никто никогда не удосужился создать для них компилятор C.

Когда дело доходит до приложений более высокого уровня, некоторые программисты могут по-прежнему вручную создавать критически важные для производительности функции на языке ассемблера, но, вообще говоря, это становится все реже и реже. Наконец, на данный момент механизмы, лежащие в основе таких языков, как Python и Java, представляют собой совершенно другую игру с мячом, включающую такие вещи, как «байтовый код» и «виртуальные машины», поэтому я думаю, что мы оставим их на другой день.

Доброе горе! Бедный старый Райан. Теперь даже голова болит.Все это кажется таким простым, если вы не обращаете внимания на лежащие в основе механизмы и просто говорите что-то вроде: «Вы записываете свою программу на C, а затем используете компилятор для ее преобразования в исполняемый файл» , но это становится намного более запутанным, когда вы копаетесь глубже в болото.

С другой стороны, я лично считаю, что это действительно интересно. Иногда я думаю о том, что бы произошло, если бы я наткнулся на трещину во времени и пространстве, и мне пришлось бы разрабатывать компьютерную систему (аппаратное и программное обеспечение) с нуля.Эй, я уверен, что мы все беспокоимся о таких вещах… верно?

Итак, что вы думаете о моем объяснении выше? Для вас все это «так себе суп» , или есть элементы этого обсуждения, о которых вы никогда раньше не задумывались? Кроме того, есть ли что-то, что я исказил или упустил, или что, по вашему мнению, мне следовало рассказать более подробно?

.

Язык ассемблера для процессоров x86

; AddTwo.asm - складывает два 32-битных целых числа.
; Пример из главы 3

0,386
.model flat, stdcall
.stack 4096
Протокол ExitProcess, dwExitCode: dword

.код
главный процесс
mov eax, 5
добавить eax, 6

вызвать ExitProcess, 0
главный конец
конец основной
 

1> ------ Сборка началась: Проект: Проект, Конфигурация: Отладка Win32 ------
1> Сборка AddTwo.asm ...
1> Project.vcxproj -> ... \ Project32_VS2019 \ Debug \ Project.exe
========== Сборка: 1 выполнено успешно, 0 не выполнено, 0 пропущено ==========
 

; AddTwoSum_64.asm - пример главы 3.

ExitProcess proto

.данные
сумма qword 0

.код
главный процесс
   mov rax, 5
   добавить rax, 6
   сумма mov, rax

   mov ecx, 0
   вызов ExitProcess

главный конец
конец
 

1> ------ Сборка началась: Проект: Проект, Конфигурация: Отладка x64 ------
1> Сборка AddTwoSum_64.как м...
1> Project64_VS2019.vcxproj -> ... \ Project64_VS2019 \ x64 \ Debug \ Project.exe
========== Сборка: 1 выполнено успешно, 0 не выполнено, 0 обновлено, 0 пропущено ==========
 

; // AddTwo.asm - складывает два 32-битных целых числа.
; // Пример из главы 3

.Проекты

— OSDev Wiki

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

Операционные системы имеют высокий уровень смертности: с 2004 по 2006 год 112 из 213 проектов ОС исчезли из Интернета. И если посмотреть, как часто эти проекты запускаются с помощью форума объявлений о проектах ОС, за тот же период было объявлено о 68 проектах! В настоящее время общее количество проектов составляет 175, но только 58 из них являются активными (по состоянию на 1 января 2018 г.), и только 62 были обновлены хотя бы один раз с 2018 г. (три из которых были заброшены), а 27 — с 2019 г.Поддерживайте актуальность этого списка, исправляя его, если вы видите устаревшую информацию.

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

Содержание: A B C D E F G H I J K L M N O P Q R S T U V W X Y Z 9

.