Погружение в assembler. Полный курс по программированию на асме от ][. Программирование: язык Ассемблера. Основы языка Ассемблера
Когда вы пишете программу на ассемблере, вы просто пишете команды процессору. Команды процессору - это просто коды или коды операций или опкоды. Опкоды - фактически "читаемый текст"- версии шестнадцатеричных кодов. Из-за этого, ассемблер считается самым низкоуровневым языком программирования, все в ассемблере непосредственно преобразовывается в шестнадцатеричные коды. Другими словами, у вас нет компилятора, который преобразовывает язык высокого уровня в язык низкого уровня, ассемблер только преобразовывает коды ассемблера в данные.
В этом уроке мы обсудим несколько опкодов, которые имеют отношение к вычислению, поразрядным операциям, и т.д. Другие опкоды: команды перехода, сравнения и т.д, будут обсуждены позже.
Комментарии в ваших программах оставляются после точки с запятой. Точно также как в дельфи или си через //.
Числа в ассемблере могут представляться в двоичной, десятеричной или шестнадцатеричной системе. Для того, чтобы показать в какой системе использовано число надо поставить после числа букву. Для бинарной системы пишется буква b (пример: 0000010b, 001011010b), для десятеричной системы можно ничего не указывать после числа или указать букву d (примеры: 4589, 2356d), для шестнадцатеричной системы надо указывать букву h, шестнадцатеричное число надо обязательно писать с нулём в начале (примеры: 00889h, 0AC45h, 056Fh, неправильно F145Ch, С123h).
Самая первая команда будет хорошо всем известная MOV. Эта команда используется для копирования (не обращайте внимания на имя команды) значения из одного места в другое. Это "место" может быть регистр, ячейка памяти или непосредственное значение (только как исходное значение). Синтаксис команды:
Mov приемник, источник
Вы можете копировать значение из одного регистра в другой.
Mov edx, ecx
Вышеприведенная команда копирует содержание ecx в edx. Размер источника и приемника должны быть одинаковыми,
например: эта команда - НЕ допустима:
Mov al, ecx ; не правильно
Этот опкод пытается поместить DWORD (32-битное) значение в байт (8 битов). Это не может быть сделано mov командой (для этого есть другие команды).
А эти команды правильные, потому что у них источник и приемник не отличаются по размеру:
Mov al, bl mov cl, dl mov cx, dx mov ecx, ebx
Вы также можете получить значение из памяти и поместить эго в регистр. Для примера возьмем следующую схему памяти:
| смещение | 34 | 35 | 36 | 37 | 38 | 39 | 3A | 3B | 3C | 3D | 3E | 3F | 40 | 41 | 42 |
| данные | 0D | 0A | 50 | 32 | 44 | 57 | 25 | 7A | 5E | 72 | EF | 7D | FF | AD | C7 |
Значение смещения обозначено здесь как байт, но на самом деле это это - 32-разрядное значение. Возьмем для примера 3A, это также - 32-разрядное значение: 0000003Ah. Только, чтобы с экономить пространство, некоторые используют маленькие смещения.
Посмотрите на смещение 3A в таблице выше. Данные на этом смещении - 25, 7A, 5E, 72, EF, и т.д. Чтобы поместить значение со смещения 3A, например, в регистр, вы также используете команду mov:
Mov eax, dword ptr
Означает: поместить значение с размером DWORD (32-бита) из памяти со смещением 3Ah в регистр eax. После выполнения этой команды, eax будет содержать значение 725E7A25h. Возможно вы заметили, что это - инверсия того что находится в памяти: 25 7A 5E 72. Это потому, что значения сохраняются в памяти, используя формат little endian . Это означает, что самый младший байт сохраняется в наиболее значимом байте: порядок байтов задом на перед. Я думаю, что эти примеры покажут это:
- dword (32-бит) значение 10203040 шестнадцатиричное сохраняется в памяти как: 40, 30, 20, 10
- word (16-бит) значение 4050 шестнадцатиричное сохраняется в памяти как: 50, 40
Вернемся к примеру выше. Вы также можете это делать и с другими размерами:
Mov cl, byte ptr ; cl получит значение 0Dh mov dx, word ptr ; dx получит значение 7DEFh
Вы, наверное, уже поняли, что префикс ptr обозначает, что надо брать из памяти некоторый размер. А префикс перед ptr обозначает размер данных:
Byte - 1 байт Word - 2 байта Dword - 4 байта
Иногда размер можно не указывать:
Mov eax,
Так как eax - 32-разрядный регистр, ассемблер понимает, что ему также требуется 32-разрядное значение, в данном случае из памяти со смещением 403045h.
Можно также непосредственные значения:
Mov edx, 5006h
Эта команда просто запишет в регистр edx, значение 5006. Скобки, [ и ], используются, для получения значения из памяти (в скобках находится смещение), без скобок, это просто непосредственное значение.
Можно также использовать регистр как ячейку памяти (он должен быть 32-разрядным в 32-разрядных программах):
Mov eax, 403045h ; пишет в eax значение 403045 mov cx, ; помещает в регистр CX значение (размера word) из памяти; указанной в EAX (403045)
В mov cx, , процессор сначала смотрит, какое значение (= ячейке памяти) содержит eax, затем какое значение находится в той ячейке памяти, и помещает это значение (word, 16 бит, потому что приемник, cx, является 16-разрядным регистром) в CX.
Стековые операции - PUSH, POP. Перед тем, как рассказать вам о стековых операциях, я уже объяснял вам, что такое стек. Стек это область в памяти, на которую указывает регистр стека ESP. Стек это место для хранения адресов возврата и временных значений. Есть две команды, для размещения значения в стеке и извлечения его из стека: PUSH и POP. Команда PUSH размещает значение в стеке, т.е. помещает значение в ячейку памяти, на которую указывает регистр ESP, после этого значение регистра ESP увеличивается на 4. Команда Pop извлекает значение из стека, т.е. извлекает значение из ячейки памяти, на которую указывает регистр ESP, после этого уменьшает значение регистра ESP на 4. Значение, помещенное в стек последним, извлекается первым. При помещении значения в стек, указатель стека уменьшается, а при извлечении - увеличивается. Рассмотрим пример:
(1) mov ecx, 100 (2) mov eax, 200 (3) push ecx ; сохранение ecx (4) push eax (5) xor ecx, eax (6) add ecx, 400 (7) mov edx, ecx (8) pop ebx (9) pop ecx
- 1: поместить 100 в ecx
- 2: поместить 200 в eax
- 3: разместить значение из ecx (=100) в стеке (размещается первым)
- 4: разместить значение из eax (=200) в стеке (размещается последним)
- 5/6/7: выполнение операций над ecx, значение в ecx изменяется
- 8: извлечение значения из стека в ebx: ebx станет 200 (последнее размещение, первое извлечение)
- 9: извлечение значения из стека в ecx: ecx снова станет 100 (первое размещение, последнее извлечение)
Чтобы узнать, что происходит в памяти, при размещении и извлечении значений в стеке, см. на рисунок ниже:
(стек здесь заполнен нулями, но в действительности это не так, как здесь). ESP стоит в том месте, на которое он указывает)
Mov ax, 4560h push ax mov cx, FFFFh push cx pop edx edx теперь 4560FFFFh.
Вызов подпрограмм возврат из них - CALL, RET. Команда call передает управление ближней или дальней процедуре с запоминанием в стеке адреса точки возврата. Команда ret возвращает управление из процедуры вызывающей программе, адрес возврата получает из стека. Пример:
Code.. call 0455659 ..more code.. Код с адреса 455659: add eax, 500 mul eax, edx ret
Когда выполняется команда call, процессор передает управление на код с адреса 455659, и выполняет его до команды ret, а затем возвращает управление команде следующей за call. Код который вызывается командой call называется процедурой. Вы можете поместить код, который вы часто используете в процедуру и каждый раз когда он вам нужен вызывать его командой call.
Подробнее: команда call помещает регистр EIP (указатель на следующюю команду, которая должна быть выполнена) в стек, а команда ret извлекает его и передаёт управление этому адресу. Вы также можете определить аргументы, для вызываемой программы (процедуры). Это можно сделать через стек:
Push значение_1 push значение_2 call procedure
Внутри процедуры, аргументы могут быть прочитаны из стека и использованы. Локальные переменные, т.е. данные, которые необходимы только внутри процедуры, также могут быть сохранены в стеке. Я не буду подробно рассказывать об этом, потому, что это может быть легко сделано в ассемблерах MASM и TASM. Просто запомните, что вы можете делать процедуры и что они могут использовать параметры.
Одно важное замечание: регистр eax почти всегда используется для хранения результата процедуры.
Это также применимо к функциям windows. Конечно, вы можете использовать любой другой регистр в ваших собственных процедурах, но это стандарт.
Вот и кончился очередной урок. На следующем уроке мы напишем первую программу на ассемблере.
Назад | Оглавление |Оставить комментарий
Комментарии
стёк растёт в низ и чем он больше тем ESP меньше
То есть как то так?:
|| типа пустой стёк
V
| |ESP
| |6
| |5
| |4
| |3
| |2
| |1
| |0
После кода
push 0fh
push 0ffh
|| типа стёк
V
|0fh|7
|0ffh|6
| |ESP
| |4
| |3
| |2
| |1
| |0
Если это так то
какое значение имеет ESP когда стёк пуст?
В современных операционных система задания по ВССиТ выполнять, мягко говоря проблематично. Для написания контрольных, да и просто освоения начальных навыков необходимо разобраться с компилятором MASM или TASM которые работают из под DOS.
Сами компиляторы, линковщики и все другие приблуды можно найти, например, на http://kalashnikoff.ru/ или http://www.wasm.ru/ . А тут будет рассказываться о том, что ближе к телу.
Необходимые инструменты и их настройка.
И так, что нам нужно. Нам нужен эмулятор DOS-терминала и компилятор. Компилятор я выбрал MASM 6.11, так как им до этого пользовался, и кое что в моей памяти уже было.Как DOS-эмулятор я советую DOSBox. Версии есть и под Windows и под Linux. Под Linux его можно установить из стандартного репозитория. Для Ubuntu:
$sudo apt-get install dosbox
или из Центра приложений.
После запуска вы увидите экран с приглашением:
Z:\>
Смонтируйте диск C:\ для этого наберите:
Z:\>mount c /home/user/folder_prodject
И перейдите в неё:
Z:\>c:
командой dir вы сможете посмотреть содержание директории, а командой cd имя_директории перейти в другую папку находящуюся в точке монтирования или в её подпапках.
Пример на моем проекте:
Если вы работаете много в DOS-эмуляторе, то такой способ может оказаться не очень удобным. Но моно настроить автоматическое монтирование диска C:\
Открываем /home/user/.dosbox/dosbox-0.74.conf в редакторе, и ищем строки:
# Lines in this section will be run at startup.
# Yju can put your MOUNT lines here.
и пишем тут что-то типа:
mount C /home/user/asm
PATH=%PATH%;C:\masm611\bin\
C:
При старте будет монтироваться C:\ диск в /home/user/asm, при этом эта директория должна существовать. PATH назначает пути поиска программ, это нужно что бы нам не мусорить в одной директории, а была возможность разнести компилятор и проект в разные. В конце стоит C: что бы DOSBox самостоятельно переводил нас на диск C:\ и берег наши телодвижения.
На последнем рисунке показана команда cd и dir, обратите внимание на то как отражаются имена файлов написанных русскими буквами. Возможно это и лечиться, но нужно ли это нам? И не забывайте, что MS-DOS использовал название файлов в формате 8.3. То есть, на имя отводилось 8 символов, потом шла точка (.), а затем расширение файла. При других названиях тоже могут возникнуть проблемы.
Как использовать MASM 6.11.
Теперь разберем как нам компилировать код, который мы напишем.
C:\>ml /с имя_файла.asm
получим файл имя_файла.obj Ключ /c говорит компилятору не проводить линковку.
C:\>link имя_файла.obj
получим исполняемый файл.
Но можно сделать всё быстрее:
C:\>ml имя_файла.asm /AT
При этом мы получим и.obj файл и исполняемый.com. Флаг /AT говорит компилятору вызвать линковщик и передает ему флаг /T который обозначает модель TINY.
Ещё часто бывает нужен файл листинга программы, для этого используйте ключ /Fl:
C:\>ml имя_файла.asm /Fl
Файл листинга будет записан в имя_файла.lst
Пишем программку.
Всё, на этом самое сложное закончилось. Теперь начинаем писать программу на ассемблере.
Так как в задачах часто просят вывести решение формул на экран, то и будем разбирать подобный пример. Сумма делений с x= от 1 до 10:
Основные команды которые будем использовать
Регистры, ох уж эти регистры. Краткий экскурс.
Сейчас, что бы начать читать код, достаточно знать регистры общего назначения:
Они могут быть 8 битные (например, al, ah), 16 битные (например, ax) и 32 битные (например, eax).
Все 16 битные регистры делятся на на младший и старший, например, ax делиться на al и ah. Делиться значит состоит, а не математическое действие.
eax, ax, al - очень часто выступают как приёмник значений, например, при умножении и делении.
ebx, bx. bl, bh - свободный регистр, который можно использовать в хвост и гриву.
edx, dx - часто используется для пересылки дополнительной информации или остатка от деления.
ecx, cx - называется счетчик, используется в циклах.
Всё остальное в комментариях программы. Кстати точка с запятой (;) используется как команда начать комментарий, и всё что написано за ней в строке не интерпретируется компилятором
Тренируемся
Первое что нам нужно - это разложить наш пример на простые составляющие, что бы составить алгоритм. К примеру: x в кубе - это x*x*x. Вспоминаем: умножение это mul, то есть мы можем это записать:
mov ax,1 ; присвоили значение
mul ax ; умножили первый раз, то есть возвели в квадрат
mul ax ; умножили второй раз, то есть возвели в куб
Вот, так пошагово это и происходит.
А теперь сам листинг решения примера:
.MODEL tiny ; задаём модель в данном случае.com .CODE .486 ; указываем модель процессора org 100h ; выделяем память start: mov ecx,10 ; задаём количество циклов. 10 потому, что у нас x от 1 до 10 Lb1: ; устанавливаем метку для цикла mov eax,11 ; находим х sub eax,ecx ; x=11-число циклов (1, 2, 3... 11-1=10) push ecx ; сохраним в стеке сх для использования в цикле push eax ; сохраним в стеке ax что бы больше не высчитывать его mul eax ; x^2 (^ - будет означать "в степени") mov ecx,eax ; сохраним eax в ecx потом отнимать нужно будет mov ebx,3 ; ebx = 3 mul ebx ; 3x^2 sub eax,1 ; 3x^2-1 mov ebx,eax ; сохраняем eax в ebx потом понадобиться pop eax ; восстанавливаем eax так как уже нужен eax опять = x push ebx ; и сохраняем ebx так как потом понадобиться mov ebx,eax ; ebx = eax mov eax,ecx ; помните ecx=x^2, теперь eax = ecx, но можно было просто перемножать mul ebx ; eax = x^3 mov ebx,4 ; ebx = 4 mul ebx ; eax = 4x^3 sub eax,ecx ; eax = 4x^3-x^2 add eax,2 ; eax = 4x^3-x^2+2 pop ebx ; восстанавливаем ebx mov a,eax ; делимое (a - это переменная) mov z,ebx ; делитель (z - это тоже переменная) описаны в конце программы finit ; инициализируем сопроцессор fld a ; делимое в сопроцессор fdiv z ; проводим деление в сопроцессоре call tEnter ; это вызов функции которая переводит строку call pFloat ; выводим результат деления в консоль @4: fadd t ; добавляем предыдущий результат деления, для получения суммы; значений функции (t - это переменная) fst t ; запоминаем сумму в переменной pop ecx ; вынимаем ecx из памяти для корректной работы цикла loop Lb1 ; переходим на метку Lb1 пока ecx не станет равным нулю call pEnter ; это вызов функции которая переводит строку call pFloat ; выводим sum((4x^3-x^2+2)/(3x^2-1)) при x от 1 до 10 с шагом 1 int 20h ; Завершение работы программы (это называется; вызвать прерывание 20h) ret ; конец блока; дальше начинается настоящее колдовство;выводит целое число pInt: pushad ; сохраняем все регистры mov bx,sp ; bx = sp mov byte ptr ss:,"$" ; символ конца строки @1:cdq ; метка цикла. и команда cdq копирует знаковый бит регистра eax на; все биты регистра edx div ecx ; делим число на основание edx - остаток, eax - частное add dl,"0" ; преобразование в ASCII dec bx ; уменьшаем bx на 1 mov ss:,dl ; добавляем в стоку перед предыдущим test eax,eax ; проверяем есть ли в eax ещё что-нибудь jne @1 ; если есть повторяем цикл mov ax,ss ; выводим строку на экран mov ds,ax ; ds = ax dec bx ; уменьшаем bx на 1 mov dx,bx ; dx = bx xchg sp,bx ; если не обменять вылезет мусор mov ah,9 ; номер функции прерывания int 21h ; вызываем прерывание xchg sp,bx ; если не обменять программа завершиться popad ; восстанавливаем данные из стека ret ;выводит число pFloat: pushad ; сохраняем все регистры mov ecx,10 ; задаём основание системы счисления push ecx ; сохраняем основание mov bp,sp ; bp = sp fst dword ptr ss: ; выводим из сопроцессора как двойное слово в регистр ss xor eax,eax ; обнуляем eax (xor бинарное или) mov edx,ss: ; edx = ss: shl edx,1 ; сдвигаем в edx все биты на 1 влево mov ecx,edx ; ecx = edx shr ecx,24 ; сдвигаем в ecx все биты в право на 24 sub cx,126 ; вычитаем их cx 126 - Порядок (экспонента) shl edx,7 ; сдвигаем edx влево на 7 or edx,80000000h ; значащие биты (мантисса) shld eax,edx,cl ; eax - целая часть shl edx,cl ; edx - дробная часть pop ecx ; сохраняем ecx call pInt ; выводим на экран целую часть;выводим на экран дробную часть xchg eax,edx ; обмениваемся значениями cdq ; преобразуем двойное слово в четверное sub bp,28 ; вычитаем из bp 28 mov byte ptr ss:,"." ; добавляем разделитель десятичной дроби @2:mul ecx ; умножаем на основание 10 add dl,"0" ; преобразование в ASCII inc bp ; увеличиваем bp на единицу mov ss:,dl ; добавляем в строку test eax,eax ; проверяем есть ли ещё знаки после запятой jne @2 ; да? повторяем цикл mov byte ptr ss:,"$" ; нет? добавляем знак конца строки, иначе выведет мусор sub sp,32 ; приводим строку в нормальное состояние push ss pop ds mov dx,sp ; помещаем в dx откуда её и будем печатать mov ah,9 ; функция прерывания прерывания int 21h ; вызов прерывания call nEnter ; вызов функции перевода строки add sp,32 ; восстанавливаем sp popad ; восстанавливаем регистры ret ;вспомогательная функция - переводит строку nEnter: pushad mov dx,offset str0 mov ah,9 int 21h popad ret ;вспомогательная функция, печатает строку "Temp rezult:" tEnter: pushad mov dx,offset str1 mov ah,9 int 21h popad ret ;вспомогательная функция, печатает строку "Result:" pEnter: pushad mov dx,offset strE mov ah,9 int 21h popad ret ;переменные a dd ? z dd ? t dd 0 str0 db 10,13,"$" str1 db "Temp result: ","$" strE db 10,13,"Result: ","$" end start ; конец программыНаписание ОС-загрузчиков, драйверов, переписывание области памяти и другие задачи по работе с ЭВМ реализовываются с помощью ассемблера. Выбранные книги по ассемблеру помогут понять принцип работы машинно-ориентированного языка и освоить его.
1. Ревич Ю. – Практическое программирование микроконтроллеров Atmel AVR на языке ассемблера, 2014 г.
«Свежая кровь» в области программирования микроконтроллеров. Подробно изложены особенности Atmel AVR, есть перечень команд и готовые рецепты – ассемблер на примерах. Хорошая вещь для радиолюбителей и инженерно-технических работников, хотя подойдет и начинающим кодерам: затронуты история, семейства и возможности МК AVR. Стоит отметить, что введение лаконичное, быстро перетекающее в суть, поэтому сетовать на лирику не придется.
2. Калашников О. – Ассемблер – это просто. Учимся программировать, 2011 г.
Настоящее раздолье для новичков, которые еще гуглят базовую терминологию и ищут ассемблер учебник. Это он и есть. Помимо ознакомления с языком и первых программ, также затронуты болевые точки – прерывания: штука несложная, но поначалу тяжелая для восприятия. С каждой главой ассемблер уроки усложняются, и на выходе читатель сможет писать программы на ассемблере, оптимизировать их, работать с вирусами, антивирусами, памятью и файловыми системами.
3. Аблязов Р. – Программирование на ассемблере на платформе x86-64, 2011 г.
Акцент делается на работе процессора в защищенном режиме и long mode. Это незаменимая база для программирования в Win32 и Win64, которая затрагивает команды ассемблера, прерывания, механизмы трансляции и защиты с учетом режимных отличий. Рассматривается разработка оконных приложений и драйверов. Данный ассемблер учебник подойдет начинающим кодерам и тем, кто сразу перешел к программированию на ассемблере, но плохо разобрался в аппаратной платформе x86-64.
4. Столяров А. – Программирование на языке ассемблера NASM для ОС Unix, 2011 г.
Начиная терминологией и заканчивая взаимодействием с ОС, это без преувеличений одно из лучших учебных пособий. Для тех, кто стремится освоить программирование на ассемблере, но при этом не хочет перегружать книжные полки, достаточно этого учебника. Подробно расписан синтаксис языка ассемблера NASM, затронуты регистры и память, операции различной сложности, команды, а также приведены примеры.
После многих лет занятия чем не попадя, решил вернуться к истокам. К программированию. Опять же, ввиду множества «современных достижений» в этой области было трудно определиться, чего же на самом деле не хватет, за что взяться чтобы было и приятно и полезно. Попробовав много чего понемногу, все же решил вернуться туда, куда тянуло с первых дней знакомства с компьютером (еще с копией творения сэра Синклера) – к программированию на ассемблере. На самом деле, в свое время Ассемблер я знал достаточно неплохо (в данном случае говорю про x86), но почти 15 лет ничего на нем не писал. Таким образом это своеобразное возвращение «блудного сына».
Но тут поджидало первое разочарование. Найденные на просторах Интернета книги, руководства и прочие справочники по ассемблеру, к моему глубокому сожалению, содержат минимум информации о том, как надо программировать на ассемблере, почему именно так, и что это дает.
Пример из другой области
Если брать в качестве примера бокс, то все подобные руководства учат исполнять удар, перемещаться стоя на полу, но абсолютно отсуствует то, что делает бокс - боксом, а не «разрешенным мордобитием». То есть комбинационная работа, особенности использования ринга, защитные действия, тактическое построение боя и, тем более, стратегия боя не рассматриваются вообще. Научили человека бить по «груше» и сразу на ринг. Это в корне неверно. Но именно так построены практически все «учебники» и «руководства» по программированию на ассемблере.
Однако нормальные книги должны быть, скорее всего под горой «шлака» я их просто не нашел. Поэтому прежде чем восполнять знания глобальным описание архитектуры, мнемоники и всяческих фокусов «как слепить фигу из 2х пальцев», подойдем к вопросу программирования на ассемблере с «идеологической» точки зрения.
Идилия?
Маленькое замечание, далее по тексту будет использована классификация, отличающаяся от распространненной в настоящее время. Однако это не является поводом для «споров о цвете истины», просто в данном виде проще объяснить точку зрения автора на программирование.Итак, на сегодняшний день, казалось бы, для программистов наступила эпоха счастья. Огромный выбор средств на все случаи жизни и пожелания. Тут тебе и миллионы «фреймворков»/«паттернов»/«шаблонов»/«библиотек» и тысячи средств «облегчающих» программирование, сотни языков и диалектов, десятки методологий и различные подходы у программированию. Бери – нехочу. Но не «берется». И дело не в религиозных убеждениях, а в том, что это все выглядит как попытка питаться чем-то невкусным. При желании и усердии можно приноровиться и к этому, конечно. Но, возвращаясь к программированию, в большинстве из предлагаемого не видно технической красоты – видно лишь множество «костылей». Как результат, при использовании этих «достижения», из-под «кисти художников» вместо завораживающих пейзажей выходит сплошная «абстракция», или лубки - если повезет. Неужели большинство программистов такие бездари, неучи и имеют проблемы на уровне генетики? Нет, не думаю. Так в чем же причина?
На сегодняшний день имеется множество идей и способов программирования. Рассмотрим наиболее «модные» из них.
- Императивное программирование – в данном подходе программист задает последовательность действий, приводящих к решению задачи. В основе лежит разделение программы на части, выполняющие логически независимые операции (модули, функции, процедуры). Но в отличии от типизированного подхода (см. ниже) тут есть важная особенность – отсутствие «типизации» переменных. Иными словами отсутствует понятие «тип переменной», вместо него используется понимание, что значения у одной и той же переменной могут иметь различный тип. Яркими представителем данного подхода являются Basic, REXX, MUMPS.
- Типизированное программирование – модификация императивного программирования, когда программист и система ограничивают возможные значения переменных. Из наиболее известных языков - это Pascal, C.
- Функциональное программирование – это более математический способ решения задачи, когда решение состоит в «конструировании» иерархии функций (и соответственно создание отсутствующих из них), приводящей к решению задачи. Как примеры: Lisp, Forth.
- Автоматное программирование – подход, где программист строит модель/сеть, состоящую из обменивающихся сообщениями объектов/исполнительных элементов, как изменяющих/хранящих свое внутреннее «состояние» так и могущих взаимодействовать с внешним миром. Иными словами это то, что обычно называют «объектное программирование» (не объектно-ориентированное). Этот способ программирования представлен в Smalltalk.
Как видим, каждый из подходов (даже без учета ограничений конкретных реализаций) накладывает собственные ограничения на саму технику программирования. Но иначе и быть не может. К сожалению, эти ограничения зачастую созданы искуственно для «поддержания чистоты идеи». В итоге, программисту приходится «извращать» изначально найденное решение в вид, хоть как-то соответствующий идеологии используемого языка или используемому «шаблону». Это даже без учета новомодных методик и способов проектирования и разработки.
Казалось бы, программируя на ассемблере, мы вольны делать все и так, что и как пожелаем и позволяет нам «железо». Но как только нам захочется использовать «универсальный драйвер» для какого-либо типа оборудования, мы вынуждены менять свободу «творчества» на предписанные (стандартизированные) подходы и способы использования драйвера. Как только нам понадобилась возможность использовать наработки других коллег или дать им возможность делать тоже самое с плодами нашего труда - мы вынуждены менять свободу выбора взаимодействия между частями программы на некие обговоренные/стандартизированные способы.
Таким образом та «свобода», за которой часто рвутся в ассемблер зачастую оказывается «мифом». И этому (пониманию ограничений, и способам их организации), на мой взгляд, должно уделяться повышенное внимание. Программист должен понимать причину вносимых ограничений, и, что отличает ассемблер от многих языков высокого уровня, иметь возможность менять их, при возникновении такой необходимость. Однако сейчас программист на ассемблере вынужден мириться с ограничениями, вводимыми языками высокого уровня, не имея «пряников» доступных программирующими на них. С одной стороны, операционные системы предоставляют множество уже реализованных функций, есть готовые библиотеки и много многое другое. Но способы их использования, как специально, реализованы без учета вызова их из программ, написанных на ассемблере, а то и вообще наперекор логике программирования для x86 архитектуры. В результате, сейчас программирование на ассемблере с вызовом функций ОС или внешних библиотек языков высокого уровня – это «страх» и «ужас».
Чем дальше в лес, тем толще
Итак, мы осознали, что хотя ассемблер очень прост, но пользоваться им надо уметь. И основная слажность - это необходимость взаимодействия со средой исполнения, где запускается наша программа. Если программисты на языках высокого уровня уже имеют доступ к необходимым библиотекам, функциям, подпрограммам на многие случаи жизни и им доступны способы взаимодействия с внешним миром, в виде, согласованном с идеей языка, то программисту на ассемблере приходится продираться сквозь чащу всевозможных препонов, водруженных на пустом месте. Когда смотришь на то, что генерируют языки высокого уровня при компиляции, то складывает ощущение, что, те, кто писал компиляторы, либо понятия не имеют, как работает процессор с архитектурой x86, «или одно из двух» (ц).Итак, давайте по-порядку. Программирование - это в первую очередь инженерия, то есть научное творчество, направленное на эффективное (по показателям надежности, использования доступных ресурсов, сроков реализации и удобства применения) решение практических задач. И, в основе любой инженерии лежит системный подход. То есть нельзя рассматривать любое решение как некий «неразборный» черный ящик, функционирующий в полном и идеальном вакууме.
Еще один пример из другой области
Как яркий пример системного подхода можно привести производство грузовиков в США. В данном случае, производитель грузовика – это просто изготовитель рамы и кабины + сборщик конструктора. Все остальное (двигатель, трансмиссия, подвеска, электрооборудование и т.д.) берется исходя из пожеланий заказчика. Захотел один заказчик получиться себе некий Kenworth с двигателем от Detroit Diesel, ручной коробкой Fuller, рессорной подвеской от какой-нибудь Dana – пожалуйста. Понадобилась другу этого заказчика та же модель Kenworth, но с «родным» двигателем Paccar, коробкой-автоматом Allison и пневмоподвеской от другого производителя – легко! И так делают все сборщики грузовиков в США. То есть грузовик – это система, в котором каждый модуль может быть заменен на другой, того же назначения и безпроблемно состыкован с уже имеющимися. Причем способ стыковки модулей сделан с максимально доступной универсальностью и удобством дальнейшего расширения функционала. Вот к чему должен стремиться инженер.
К сожалению, нам придется жить с тем, что есть, но в дальнейшем подобного следует избегать. Итак, программа – это, по сути, набор модулей (невожно как они называются, и как себя «ведут»), компонуя которые мы добиваемся решения стоящей задачи. Для эффективности крайне желательно, чтобы можно было эти модули использовать повторно. Причем не просто использовать любой ценой, а использовать удобным способом. И вот тут нас ждет очередной неприятный «сюрприз». Большинство языков высокого уровня оперируют такими структурными единицами как «фунция» и «процедура». И, как способ взяимодействия с ними, применяется «передача параметров». Это вполне логично, и тут никаких вопросов не возникает. Но как всегда, «важно не то, что делается – важно как делается» (ц). И вот тут начинается самое непонятное. На сегодня распространены 3 способа организации передачи параметров: cdecl , stdcall , fastcall . Так вот, ни один из этих способов не является «родным» для x86. Более того, все они ущербны с точки зрения расширения функционала вызываемых подпрограмм. То есть, увеличив количество передаваемых параметров, мы вынуждены менять все точки вызова этой функции/подпрограммы, или же плодить новую подпрограмму с похожим функционалом, которая будет вызываться немного иным способом.
Указанные выше методы передачи параметров относительно неплохо работают на процессорах с 2мя раздельными стеками (стеком данных, и стеком адресов/управления) и развитыми командами манипулирования стеком (хотя бы индексное обращение к элементам стека). Но при программировании на x86 приходится сначала извращаться при передаче/получении параметров, а потом не забыть «структурное» их удаление из стека. Попутно стараясь угадать/рассчитать максимальную глубину стека. Напомним, что x86 (16/32 битный режим), это процессор, у которого:
- специализированные регистры (РОНы – регистры общего назначения – как таковые отсутствуют: то есть, мы не можем одной командой умножить содержимое регистра GS на значение из EDI и результат получить в паре EDX:ECX, или же разделить значение из пары регистров EDI:ESI на содержимое регистра EAX);
- регистров мало;
- один стек;
- ячейка памяти не дает никакой информации от типа хранящегося там значения.
Следующая особенность взамиодействия с готовыми модулями, написанными на «языках высокого уровня»- это «борьба» с «типами переменных». С одной стороны, причина появления типов переменных ясна – программист знает какие значения используются внутри его подпрограммы / модуля. Исходя из этого, видится вполне логичным, что, задав тип значений переменной, мы можем «упростить» написание программы, возложив контроль типов/пределов значений на транслятор языка. Но и тут с водой выплеснули младенца. Потому как любая программа пишется не для генерации сферических коней в вакууме, а для практической работы с пользовательскими данными. То есть очевидное нарушение системного подхода – как будто разработчики языков высокого уровня рассматривали свои системы без учета взаимодействия с внешним миром. В итоге, программируя на типизированном языке разработчик должен предсматривать все возможные виды «неправильных» входных данных, и искать способы обхода неопределенностей. И вот тут на сцену выходят монструозные системы поддержки регулярных выражений, обработки исключительных ситуаций, сигнатуры методов/процедур для разных типов значений и прочая прочая генерация костылей.
Как было уже указано выше, для архитектуры x86 само значение, хранимое в ячейке памяти, не обладает никаким типом. Программист на ассемблере получает привилегию и ответственность за определение способа обработки этого самого значение. А уж каким образом определять тип значения и как его обрабатывать – тут на выбор множество вариантов. Но, подчеркнем еще раз, все они касаются только значений, получаемых от пользователя. Как верно заметили разработчики типизированных языков: типы значений внутренних и служебных переменных практически всегда известны заранее.
Эта причина (извращенная передача параметров в модули, написанные на языках высого уровня и необходимость строго следить за типами передаваемых параметров в теже самые модули) видится основной, из-за которой программирование на ассемблере неоправданно затруднено. И большинство предпочитает разбираться в дебрях «языков высокого уровня», чтобы воспользоваться тем, что уже наработано другими, чем мучиться, вставляю одни и те же «типовые» костыли, для исправления того, чего они не делали. И редкий транслятор ассемблера хоть как-то «разгружает» программиста от этой рутины.
Что делать?
Предварительные выводы с учетом 15ти летного перерыва в программировании на ассемблере.Во-первых, по поводу модулей или частей программы. В общем случае стоит выделить два вида исполнительных модулей программы на языке ассемблера – «операция» и «подпрограмма».
- «Операцией» будем называть модуль, выполняющий «атомарное» действие и не требующий для своего выполнения множества параметров (например, операция очистки всего экрана, или операция расчета медианы числового ряда и т.п.).
- «Подпрограммой» же стоит назвать фунциональный модуль, требующий, для корректного функционирования, множество входных параметров (больше 2х-3х).
Полезно также следовать правилу немутабельности – то есть неизменности передаваемых параметров. Подпрограмма не может (не должна) менять значения в передаваемой ей структуре и результат возврашает либо в регистрах (не более 2х-3х параметров), либо также в новой, создаваемой структуре. Таким образом мы избавлены от необходимости делать копии структур, на случай «забытого» изменения данных подпрограммами, и можем использовать уже созданную структуру целиком или основную ее часть для вызова нескольких подпрограмм, оперирующих одним/схожим набором параметров. Более того, практически «автоматом» приходим к очередному «функциональному» правилу – внутренней контексто-независимости подпрограмм и операций. Иными словами - к разделению состояния/данных от метода/подпрограммы их обработки (в отличие от автоматной модели). В случаях параллельного программирования, а также совместного использования одной подпрограммы мы избавляемся как от необходимости плодить множество контекстов исполнения и следить за их «непересечением», так и от создания множества экземляров одной подпрограмм с разными «состояниями», в случае нескольких ее вызовов.
Что касается «типов» данных, то тут можно как оставить «все как есть», а можно тоже не изобретать велосипеда и воспользоваться тем, что давно используют разработчики трансляторов императивных языков – «идентификатор типа значения». То есть все данные, поступающие из внешнего мира анализируются и каждому полученному значению присваивается идентификатор обрабатываемого типа (целое, с плавающей точкой, упакованное BCD, код символа и т.д.) и размер поля/значения. Имея эту информацию, программист, с одной стороны, не загоняет пользователя в излишне узкие рамки «правил» ввода значений, а с другой - имеет возможность в процессе работы выбрать наиболее эффективный способ обработки данных пользователя. Но, повторюсь еще раз, это касается только работы с пользовательскими данными.
Это были общие соображения о программировании на ассемблере, не касающиеся вопросов проектирования, отладки и обработки ошибок. Надеюсь что разработчикам ОС, которые пишут их с 0-ля (а тем более на ассемблере), будет о чем подумать и они выберут (пусть не описанные выше, а любые иные) способы сделать программирование на ассемблере более систематизированным, удобным и приятным, а не будут слепо копировать чужие, зачастую безнадежно «кривые» варианты.
Поляков Андрей Валерьевич | ||
http://info-master.su | ||
av-inf.blogspot.ru | ||
В контакте: | vk.com/id185471101 | |
facebook.com/100008480927503 | ||
Страница книги: | http://av-assembler.ru/asm/afd/assembler-for-dummy.htm | |
ВНИМАНИЕ!
Все права на данную книгу принадлежат Полякову Андрею Валерьевичу. Никакая часть данной книги не может быть воспроизведена в какой бы то ни было форме без согласования с автором.
Информация, содержащаяся в данной книге, получена из источников, рассматриваемых автором как надёжные. Тем не менее, имея в виду возможные человеческие или технические ошибки, автор не может гарантировать абсолютную точность и полноту приводимых сведений и не несёт ответственности за возможные ошибки и ущерб, связанные с использованием этого документа.
1. РАЗРЕШЕНИЯ
Разрешается использование книги в ознакомительных и образовательных целях (только для личного использования). Разрешается бесплатное распространение книги.
2. ОГРАНИЧЕНИЯ
Запрещается использование книги в коммерческих целях (продажа, размещение на ресурсах с платным доступом и т.п.). Запрещается вносить изменения в текст книги. Запрещается присваивать авторство.
См. также ЛИЦЕНЗИОННОЕ СОГЛАШЕНИЕ .
Поляков А.В.
Ассемблер для чайников
Поляков А.В. Ассемблер для чайников. | |
ПРЕДИСЛОВИЕ................................................................................................................................................................ | |
ВВЕДЕНИЕ....................................................................................................................................................................... | |
НЕМНОГО О ПРОЦЕССОРАХ ....................................................................................................................................................... | |
1. БЫСТРЫЙ СТАРТ......................................................................................................................................................... | |
1.1. ПЕРВАЯ ПРОГРАММА ......................................................................................................................................................... | |
1.1.1. Emu8086................................................................................................................................................................ | |
1.1.2. Debug .................................................................................................................................................................. | |
1.1.3. MASM, TASM и WASM........................................................................................................................................ | |
1.1.3.1. Ассемблирование в TASM ............................................................................................................................................. | |
1.1.3.2. Ассемблирование в MASM............................................................................................................................................ | |
1.1.3.3. Ассемблирование в WASM............................................................................................................................................ | |
1.1.3.4. Выполнение программы............................................................................................................................................... | |
1.1.3.5. Использование BAT-файлов.......................................................................................................................................... | |
1.1.4. Шестнадцатеричный редактор.................................................................................................................... | |
Резюме.......................................................................................................................................................................... | |
2. ВВЕДЕНИЕ В АССЕМБЛЕР.......................................................................................................................................... | |
2.1. КАК УСТРОЕН КОМПЬЮТЕР ............................................................................................................................................... | |
2.1.1. Структура процессора.................................................................................................................................... | |
2.1.2. Регистры процессора....................................................................................................................................... | |
2.1.3. Цикл выполнения команды.............................................................................................................................. | |
2.1.4. Организация памяти........................................................................................................................................ | |
2.1.5. Реальный режим............................................................................................................................................... | |
2.1.6. Защищённый режим......................................................................................................................................... | |
2.2. СИСТЕМЫ СЧИСЛЕНИЯ ..................................................................................................................................................... | |
2.2.1. Двоичная система счисления.......................................................................................................................... | |
2.2.2. Шестнадцатеричная система счисления..................................................................................................... | |
2.2.3. Другие системы................................................................................................................................................ | |
2.3. ПРЕДСТАВЛЕНИЕ ДАННЫХ В ПАМЯТИ КОМПЬЮТЕРА ............................................................................................................. | |
2.3.1. Положительные числа..................................................................................................................................... | |
2.3.2. Отрицательные числа..................................................................................................................................... | |
2.3.3. Что такое переполнение................................................................................................................................. | |
2.3.4. Регистр флагов................................................................................................................................................. | |
2.3.5. Коды символов................................................................................................................................................... | |
2.3.6. Вещественные числа........................................................................................................................................ | |
2.3.6.1. Первая попытка.............................................................................................................................................................. | |
2.3.6.2. Нормализованная запись числа.................................................................................................................................... | |
2.3.6.3. Преобразование дробной части в двоичную форму.................................................................................................. | |
2.3.6.4. Представление вещественных чисел в памяти компьютера...................................................................................... | |
2.3.6.5. Числа с фиксированной точкой..................................................................................................................................... | |
2.3.6.6. Числа с плавающей точкой............................................................................................................................................ | |
ЛИЦЕНЗИОННОЕ СОГЛАШЕНИЕ................................................................................................................................... |
ПРЕДИСЛОВИЕ
Ассемблер – это магическое слово взывает благоговейный трепет у начинающих программистов. Общаясь между собой, они обязательно говорят о том, что где-то у кого-то есть знакомый «чувак», который может читать исходные коды на языке ассемблера как книжный текст. При этом, как правило, язык ассемблера воспринимается как нечто недоступное простым смертным.
Отчасти это действительно так. Можно выучить несколько простых команд и даже написать какую-нибудь программку, но настоящим гуру (в любом деле) можно стать только в том случае, когда человек очень хорошо знает теоретические основы и понимает, что и зачем он делает.
Есть другая крайность – бывалые программисты на языках высокого уровня убеждены, что язык ассемблера – это пережиток прошлого. Да, средства разработки за последние 20 лет шагнули далеко вперёд. Теперь можно написать простенькую программу вообще не зная ни одного языка программирования. Однако не стоит забывать о таких вещах, как, например, микроконтроллеры. Да и в компьютерном программировании некоторые задачи проще и быстрее решить с помощью языка ассемблера.
Данная книга предназначена для тех, кто уже имеет навыки программирования на языке высокого уровня, но хотел бы перейти «ближе к железу» и разобраться с тем, как выполняются команды процессора, как происходит распределение памяти, как управляются разные «железяки» типа дисководов и т.п.
Книга разбита на несколько разделов. Первый раздел – быстрый старт. Здесь очень кратко описаны основные принципы программирования на языке Ассемблера, сами ассемблеры (компиляторы) и методы работы с ассемблерами. Если вы уверенно себя чувствуете в программировании на высоком уровне, но хотели бы освоить азы низкоуровневого программирования, то, быть может, вам будет достаточно прочитать только этот раздел.
Второй раздел описывает такие вещи, как системы исчисления, представления данных в памяти компьютера и т.п., то есть вещи, которые непосредственно к программированию не относятся, но без которых профессиональное программирование невозможно. Также во втором разделе более подробно рассматриваются общие принципы программирования на языке Ассемблера.
Остальные разделы описывают некоторые конкретные примеры программирования на языке Ассемблера, содержат справочные материалы и т.п.
Основы программирования вообще в этой книге не описаны, поэтому для начинающих настоятельно рекомендую ознакомиться с книгой Как стать программистом , где разъяснены «на пальцах» общие принципы программирования и подробно рассмотрены примеры создания простых программ от программ для компьютеров до программ для станков с ЧПУ.
ВВЕДЕНИЕ
Для начала разберёмся с терминологией.
Машинный код – система команд конкретной вычислительной машины (процессора), которая интерпретируется непосредственно процессором. Команда, как правило, представляет собой целое число, которое записывается в регистр процессора. Процессор читает это число и выполняет операцию, которая соответствует этой команде. Популярно это описано в книгеКак стать программистом .
Язык программирования низкого уровня (низкоуровневый язык программирования) – это язык программирования, максимально приближённый к программированию в машинных кодах. В отличие от машинных кодов, в языке низкого уровня каждой команде соответствует не число, а сокращённое название команды (мнемоника). Например, команда ADD – это сокращение от слова ADDITION (сложение). Поэтому использование языка низкого уровня существенно упрощает написание и чтение программ (по сравнению с программированием в машинных кодах). Язык низкого уровня привязан к конкретному процессору. Например, если вы написали программу на языке низкого уровня для процессора PIC, то можете быть уверены, что она не будет работать с процессором AVR.
Язык программирования высокого уровня – это язык программирования, максимально приближённый к человеческому языку (обычно к английскому, но есть языки программирования на национальных языках, например, язык 1С основан на русском языке). Язык высокого уровня практически не привязан ни к конкретному процессору, ни к операционной системе (если не используются специфические директивы).
Язык ассемблера – это низкоуровневый язык программирования, на котором вы пишите свои программы. Для каждого процессора существует свой язык ассемблера.
Ассемблер – это специальная программа, которая преобразует (ассемблирует, то есть собирает) исходные тексты вашей программы, написанной на языке ассемблера, в исполняемый файл (файл с расширением EXE или COM). Если быть точным, то для создания исполняемого файла требуются дополнительные программы, а не только ассемблер. Но об этом позже…
В большинстве случаев говорят «ассемблер», а подразумевают «язык ассемблера». Теперь вы знаете, что это разные вещи и так говорить не совсем правильно. Хотя все программисты вас поймут.
В отличие от языков высокого уровня, таких, как Паскаль , Бейсик и т.п., для КАЖДОГО АССЕМБЛЕРА существует СВОЙ ЯЗЫК АССЕМБЛЕРА. Это правило в корне отличает язык ассемблера от языков высокого уровня. Исходные тексты программы (или просто «исходники»), написанной на языке высокого уровня, вы в большинстве случаев можете откомпилировать разными компиляторами для разных процессоров и разных операционных систем. С ассемблерными исходниками это сделать будет намного сложнее. Конечно, эта разница почти не ощутима для разных ассемблеров, которые предназначены для одинаковых процессоров. Но в том то и дело, что для КАЖДОГО ПРОЦЕССОРА существует СВОЙ АССЕМБЛЕР и СВОЙ ЯЗЫК АССЕМБЛЕРА. В этом смысле программировать на языках высокого уровня гораздо проще. Однако за все удовольствия надо платить. В случае с языками высокого уровня мы можем столкнуться с такими вещами как больший размер исполняемого файла, худшее быстродействие и т.п.
В этой книге мы будем говорить только о программировании для компьютеров с процессорами Intel (или совместимыми). Для того чтобы на практике проверить приведённые
в книге примеры, вам потребуются следующие программы (или хотя бы некоторые из них):
1. Emu8086 . Хорошая программа, особенно для новичков. Включает в себя редактор исходного кода и некоторые другие полезные вещи. Работает в Windows, хотя программы пишутся под DOS. К сожалению, программа стоит денег (но оно того стоит))). Подробности см. на сайтеhttp://www.emu8086.com .
2. TASM – Турбо Ассемблер от фирмы Borland. Можно создавать программы как для DOS так и для Windows. Тоже стоит денег и в данный момент уже не поддерживается (да и фирмы Borland уже не существует). А вообще вещь хорошая.
3. MASM – Ассемблер от компании Microsoft (расшифровывается как МАКРО ассемблер, а не Microsoft Assembler, как думают многие непосвящённые). Пожалуй, самый популярный ассемблер для процессоров Intel. Поддерживается до сих пор. Условно бесплатная программа. То есть, если вы будете покупать её отдельно, то она будет стоить денег. Но она доступна бесплатно подписчикам MSDN и входит в пакет программ Visual Studio от Microsoft.
4. WASM – ассемблер от компании Watcom. Как и все другие, обладает преимуществами и недостатками.
5. Debug - обладает скромными возможностями, но имеет большой плюс - входит в стандартный набор Windows. Поищите ее в папке WINDOWS\COMMAND или WINDOWS\SYSTEM32. Если не найдете, тогда в других папках каталога WINDOWS.
6. Желательно также иметь какой-нибудь шестнадцатеричный редактор . Не помешает и досовский файловый менеджер, например Волков Коммандер (VC) или Нортон Коммандер (NC). С их помощью можно также посмотреть шестнадцатеричные коды файла, но редактировать нельзя. Бесплатных шестнадцатеричных редакторов в Интернете довольно много. Вот один из них:McAfee FileInsight v2.1 . Этот же редактор можно использовать для работы с исходными текстами программ. Однако мне больше нравится делать это с помощью следующего редактора:
7. Текстовый редактор . Необходим для написания исходных текстов ваших программ. Могу порекомендовать бесплатный редакторPSPad , который поддерживает множество языков программирования, в том числе и язык Ассемблера.
Все представленные в этой книге программы (и примеры программ) проверены на работоспособность. И именно эти программы используются для реализации примеров программ, приведённых в данной книге.
И еще – исходный код, написанный, например для Emu8086, будет немного отличаться от кода, написанного, например, для TASM. Эти отличия будут оговорены.
Большая часть программ, приведённых в книге, написана для MASM. Во-первых, потому что этот ассемблер наиболее популярен и до сих пор поддерживается. Во-вторых, потому что он поставляется с MSDN и с пакетом программ Visual Studio от Microsoft. Ну и в третьих, потому что я являюсь счастливым обладателем лицензионной копии MASM.
Если же у вас уже есть какой-либо ассемблер, не вошедший в перечисленный выше список, то вам придётся самостоятельно разобраться с его синтаксисом и почитать руководство пользователя, чтобы научиться правильно с ним работать. Но общие рекомендации, приведённые в данной книге, будут справедливы для любых (ну или почти для любых) ассемблеров.
Немного о процессорах
Процессор – это мозг компьютера. Физически это специальная микросхема с несколькими сотнями выводов, которая вставляется в материнскую плату. Если вы с трудом представляете себе, что это такое, рекомендую ознакомиться со статьёй Чайникам о компьютерах .
Процессоров существует довольно много даже в мире компьютеров. Но кроме компьютеров ещё есть телевизоры, стиральные машины, кондиционеры, системы управления двигателями внутреннего сгорания и т.п., где также очень широко используются процессоры (микропроцессоры, микроконтроллеры).
Каждый процессор обладает своим набором регистров. Регистры процессора – это такие специальные ячейки памяти, которые находятся непосредственно в микросхеме процессора. Регистры используются для разных целей (более подробно о регистрах будет написано ниже).
Каждый процессор имеет свой набор команд. Команда процессора записывается в определённый регистр, и тогда процессор выполняет эту команду. О командах процессора и регистрах мы будем говорить много и часто на протяжении всей книги. Для начинающих рекомендую книгу Как стать программистом , где в самых общих чертах, но зато понятным языком рассказано о принципах выполнения программы компьютером.
Что такое команда с точки зрения процессора? Это просто число. Однако современные процессоры могут иметь несколько сотен команд. Запомнить все их будет сложно. Как же тогда писать программы? Для упрощения работы программиста был придуман язык Ассемблера , где каждой команде соответствует мнемонический код. Например, число4 соответствует мнемоникеADD . Иногда язык ассемблера ещё называют языком мнемонических команд.
1. БЫСТРЫЙ СТАРТ
1.1. Первая программа
Обычно в качестве первого примера приводят программу, которая выводит на экран строку «Hello World!». Однако для человека, который только начал изучать Ассемблер, такая программа будет слишком сложной (вы будете смеяться, но это действительно так – особенно в условиях отсутствия доходчивой информации). Поэтому наша первая программа будет еще проще – мы выведем на экран только один символ – английскую букву «A». И вообще – если вы уж решили стать программистом – срочно установите по умолчанию английскую раскладку клавиатуры. Тем более что некоторые ассемблеры и компиляторы не воспринимают русские буквы. Итак, наша первая программа будет выводить на экран английскую букву «А». Далее мы рассмотрим создание такой программы с использованием различных ассемблеров.
Если вы скачали и установили эмулятор процессора 8086 (см. раздел «ВВЕДЕНИЕ »), то вы можете использовать его для создания ваших первых программ на языке ассемблера. На текущий момент (ноябрь 2011 г) доступна версия программы 4.08. Справку на русском языке вы можете найти здесь:http://www.avprog.narod.ru/progs/emu8086/help.html .
Программа Emu8086 платная. Однако в течение 30 дней вы можете использовать её для ознакомления бесплатно.
Итак, вы скачали и установили программу Emu8086 на свой компьютер. Запускаем её и создаём новый файл через меню FILE – NEW – COM TEMPLATE (Файл – Новый – Шаблон файла COM). В редакторе исходного кода после этого мы увидим следующее:
Рис. 1.1. Создание нового файла в Emu8086.
Здесь надо отметить, что программы, создаваемые с помощью Ассемблеров для компьютеров под управлением Windows, бывают двух типов: COM и EXE. Отличия между этими файлами мы рассмотрим позже, а пока вам достаточно знать, что на первое время мы будем создавать исполняемые файлы с расширением COM, так как они более простые.
После создания файла в Emu8086 описанным выше способом в редакторе исходного кода вы увидите строку «add your code hear» - «добавьте ваш код здесь» (рис. 1.1). Эту строку мы удаляем и вставляем вместо неё следующий текст:
Таким образом, полный текст программы будет выглядеть так:
Кроме этого в верхней части ещё имеются комментарии (на рис. 1.1 – это текст зелёного цвета). Комментарий в языке Ассемблера начинается с символа ; (точка с запятой) и продолжается до конца строки. Если вы не знаете, что такое комментарии и зачем они нужны, см. книгуКак стать программистом . Как я уже говорил, здесь мы не будем растолковать азы программирования, так как книга, которую вы сейчас читаете, рассчитана на людей, знакомых с основами программирования.
Также отметим, что регистр символов в языке ассемблера роли не играет. Вы можете написать RET ,ret илиRet – это будет одна и та же команда.
Вы можете сохранить этот файл куда-нибудь на диск. Но можете и не сохранять. Чтобы выполнить программу, нажмите кнопку EMULATE (с зелёным треугольником) или клавишу F5. Откроется два окна: окно эмулятора и окно исходного кода (рис. 1.2).
В окне эмулятора отображаются регистры и находятся кнопки управления программой. В окне исходного кода отображается исходный текст вашей программы, где подсвечивается строка, которая выполняется в данный момент. Всё это очень удобно для изучения и отладки программ. Но нам это пока не надо.
В окне эмулятора вы можете запустить вашу программу на выполнение целиком (кнопка RUN) либо в пошаговом режиме (кнопка SINGLE STEP). Пошаговый режим удобен для отладки. Ну а мы сейчас запустим программу на выполнение кнопкой RUN. После этого (если вы не сделали ошибок в тексте программы) вы увидите сообщение о завершении программы (рис. 1.3). Здесь вам сообщают о том, что программа передала управление операционной системе, то есть программа была успешно завершена. Нажмите кнопку ОК в этом окне и вы увидите, наконец, результат работы вашей первой программы на языке ассемблера (рис.
Рис. 1.2. Окно эмулятора Emu8086.
Рис. 1.3. Сообщение о завершении программы.
Рис. 1.4. Ваша первая программа выполнена.
