Ассемблер учебник: Assembler. Учебник для вузов. 2-е изд. В. И. Юров

36111 золотой знак55 серебряных знаков1313 бронзовых знаков

ответ дан 27 июл ’12 в 19:11

911 бронзовый знак

Всё ещё ищете ответ? Посмотрите другие вопросы с метками ассемблер или задайте свой вопрос.

default

Ваша конфиденциальность

Нажимая «Принять все файлы cookie» вы соглашаетесь, что Stack Exchange может хранить файлы cookie на вашем устройстве и раскрывать информацию в соответствии с нашей [Политикой в отношении файлов cookie] (https://stackoverflow.com/legal/cookie-policy).

Принять все файлы cookie Настроить параметры

NASM — asmtutor.com

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

sys_close ожидает 1 аргумент — дескриптор файла в EBX. Затем в EAX загружается код операции sys_close, и вызывается ядро, чтобы закрыть сокет и удалить активный дескриптор файла.

Примечание: Запустите программу и используйте команду curl http: // localhost: 9001 в другом терминале или подключитесь к тому же адресу с помощью любого стандартного веб-браузера.

                                ; Разъем
                                ; Скомпилируйте с помощью: nasm -f elf socket.asm
                                ; Связать с (64-битные системы требуют опции elf_i386): ld -m elf_i386 socket.o -o socket
                                ; Запустите с: ./socket

                                % включают "functions.asm"

                                РАЗДЕЛ .data
                                ; наша строка ответа
                                ответ db 'HTTP / 1.1 200 OK ', 0Dh, 0Ah,' Content-Type: text / html ', 0Dh, 0Ah,' Content-Length: 14 ', 0Dh, 0Ah, 0Dh, 0Ah,' Hello World! ', 0Dh, 0Ah, 0h

                                РАЗДЕЛ .bss
                                буфер resb 255,; переменная для хранения заголовков запросов

                                РАЗДЕЛ. Текст
                                global _start

                                _Начало:

                                    xor eax, eax; инициализировать некоторые регистры
                                    xor ebx, ebx
                                    xor edi, edi
                                    xor esi, esi

                                _разъем:

                                    толкнуть байт 6; создать сокет из урока 29
                                    толкнуть байт 1
                                    толкнуть байт 2
                                    mov ecx, esp
                                    mov ebx, 1
                                    mov eax, 102
                                    int 80h

                                _связывать:

                                    mov edi, eax; привязать розетку из урока 30
                                    нажать dword 0x00000000
                                    нажать слово 0x2923
                                    нажать слово 2
                                    mov ecx, esp
                                    толкнуть байт 16
                                    толкнуть ecx
                                    толкни эди
                                    mov ecx, esp
                                    mov ebx, 2
                                    mov eax, 102
                                    int 80h

                                _Слушать:

                                    толкнуть байт 1; послушайте розетку из урока 31
                                    толкни эди
                                    mov ecx, esp
                                    mov ebx, 4
                                    mov eax, 102
                                    int 80h

                                _принимать:

                                    нажать байт 0; принять розетку из урока 32
                                    толкнуть байт 0
                                    толкни эди
                                    mov ecx, esp
                                    mov ebx, 5
                                    mov eax, 102
                                    int 80h

                                _вилка:

                                    mov esi, eax; вилка розетка из урока 33
                                    mov eax, 2
                                    int 80h

                                    cmp eax, 0
                                    jz _read

                                    jmp _accept

                                _читать:

                                    mov edx, 255; читать розетку из урока 33
                                    mov ecx, буфер
                                    mov ebx, esi
                                    mov eax, 3
                                    int 80h

                                    mov eax, буфер
                                    вызов sprintLF

                                _написать:

                                    mov edx, 78; запись сокета из урока 34
                                    mov ecx, ответ
                                    mov ebx, esi
                                    mov eax, 4
                                    int 80h

                                _Закрыть:

                                    mov ebx, esi; переместить esi в ebx (принятый дескриптор файла сокета)
                                    mov eax, 6; вызвать SYS_CLOSE (код операции ядра 6)
                                    int 80h; вызвать ядро

                                _выход:

                                    вызов выйти; вызовите нашу функцию выхода
                             

~ $ nasm -f elf socket.как м ~ $ ld -m elf_i386 socket.o -o сокет ~ $ ./socket

~ $ curl http: // локальный: 9001 Привет мир!

Примечание: Мы правильно закрыли соединения сокетов и удалили их активные файловые дескрипторы.

Запись сборки ARM (Часть 1)

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

Пошагово будут рассмотрены следующие темы:

:
Часть 1: Введение в сборку ARM
Часть 2: Регистры типов данных
Часть 3: Набор инструкций ARM
Часть 4: Инструкции памяти: Загрузка и сохранение данных
Часть 5: Загрузка и сохранение нескольких частей
6: Условное выполнение и ветвление
Часть 7: Стек и функции

Чтобы следовать примерам, вам понадобится лабораторная среда на базе ARM.Если у вас нет устройства ARM (например, Raspberry Pi), вы можете настроить свою собственную лабораторную среду на виртуальной машине с помощью QEMU и дистрибутива Raspberry Pi, следуя этому руководству. Если вы не знакомы с базовой отладкой с помощью GDB, вы можете получить основы в этом руководстве. В этом руководстве основное внимание будет уделено 32-разрядной версии ARM, а примеры скомпилированы на ARMv6.

Почему ARM?

Это руководство обычно предназначено для людей, которые хотят изучить основы сборки ARM. Специально для тех из вас, кто интересуется написанием эксплойтов на платформе ARM.Возможно, вы уже заметили, что процессоры ARM повсюду вокруг вас. Когда я оглядываюсь вокруг, я могу насчитать в моем доме гораздо больше устройств с процессором ARM, чем процессоры Intel. Сюда входят телефоны, маршрутизаторы и, не говоря уже об устройствах Интернета вещей, продажи которых в наши дни, похоже, стремительно растут. Тем не менее, процессор ARM стал одним из самых распространенных ядер ЦП в мире. Это подводит нас к тому факту, что, как и ПК, устройства IoT подвержены неправильным злоупотреблениям при проверке ввода, таким как переполнение буфера.Учитывая широкое использование устройств на базе ARM и возможность неправильного использования, атаки на эти устройства стали гораздо более распространенными.

Тем не менее, у нас больше экспертов, специализирующихся на исследованиях безопасности x86, чем в ARM, хотя язык ассемблера ARM, пожалуй, самый простой из широко распространенных языков ассемблера. Итак, почему все больше людей не уделяют внимания ARM? Возможно, потому, что существует больше учебных ресурсов, посвященных эксплуатации на Intel, чем на ARM. Подумайте о великолепных руководствах по Intel x86 Exploit, написанных Fuzzy Security или Corelan Team — подобные руководства помогают людям, интересующимся этой конкретной областью, получить практические знания и вдохновение для изучения, выходящего за рамки того, что описано в этих руководствах.Если вы заинтересованы в написании эксплойтов для x86, учебники Corelan и Fuzzysec станут вашей идеальной отправной точкой. В этой серии руководств мы сосредоточимся на основах сборки и написании эксплойтов на ARM.

ARM против процессора Intel

Между Intel и ARM много различий, но главное отличие — это набор команд. Intel — это процессор CISC (Compstruction Set Computing), который имеет более крупный и многофункциональный набор инструкций и позволяет многим сложным инструкциям обращаться к памяти.Поэтому у него больше операций, режимов адресации, но меньше регистров, чем у ARM. Процессоры CISC в основном используются на обычных ПК, рабочих станциях и серверах.

ARM является процессором RISC (вычисление с сокращенным набором команд) и, следовательно, имеет упрощенный набор команд (100 команд или меньше) и регистры более общего назначения, чем CISC. В отличие от Intel, ARM использует инструкции, которые работают только с регистрами, и использует модель памяти загрузки / сохранения для доступа к памяти, что означает, что только инструкции загрузки / сохранения могут получить доступ к памяти.Это означает, что для увеличения 32-битного значения по определенному адресу памяти на ARM потребуется три типа инструкций (загрузка, увеличение и сохранение), чтобы сначала загрузить значение по определенному адресу в регистр, увеличить его в регистре и сохранить это обратно в память из реестра.

Уменьшенный набор команд имеет свои достоинства и недостатки. Одним из преимуществ является то, что инструкции могут выполняться быстрее, что потенциально позволяет увеличить скорость (системы RISC сокращают время выполнения за счет сокращения тактовых циклов на инструкцию).Обратной стороной является то, что меньшее количество инструкций означает больший акцент на эффективном написании программного обеспечения с ограниченными доступными инструкциями. Также важно отметить, что ARM имеет два режима: режим ARM и режим Thumb. Инструкции Thumb могут быть 2 или 4 байтами (подробнее об этом в Части 3: Набор инструкций ARM).

Еще больше различий между ARM и x86:

• В ARM большинство инструкций можно использовать для условного выполнения.
• Процессоры Intel серии x86 и x86-64 используют формат с прямым порядком байтов
• Архитектура ARM была прямым порядком байтов до версии 3.С тех пор процессоры ARM стали BI-endian и имеют настройку, которая позволяет переключать endianness .

Различия не только между Intel и ARM, но и между разными версиями ARM. Эта серия руководств призвана сделать ее как можно более общей, чтобы вы получили общее представление о том, как работает ARM. Как только вы поймете основы, легко узнать нюансы для выбранной вами целевой версии ARM. Примеры в этом руководстве были созданы на 32-битной ARMv6 (Raspberry Pi 1), поэтому пояснения относятся именно к этой версии.

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

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

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

Так что же такое ассемблер? Язык ассемблера — это всего лишь тонкий слой синтаксиса поверх машинного кода, который состоит из инструкций, закодированных в двоичных представлениях (машинный код), что и понимает наш компьютер. Так почему бы вместо этого просто не написать машинный код? Что ж, это было бы занозой в заднице. По этой причине мы напишем сборку ARM, которая намного проще для понимания людьми.Наш компьютер не может запускать ассемблерный код сам, потому что ему нужен машинный код. Инструмент, который мы будем использовать для сборки кода сборки в машинный код, — это GNU Assembler из проекта GNU Binutils с именем as , который работает с исходными файлами с расширением * .s.

После того, как вы написали файл сборки с расширением * .s, вам нужно собрать его с помощью as и связать с ld:

 $ как program.s -o program.o
$ ld program.o -o программа 

Давайте начнем с самого низа и перейдем к языку ассемблера.На самом низком уровне у нас есть электрические сигналы в нашей цепи. Сигналы формируются путем переключения электрического напряжения на один из двух уровней, например, 0 вольт («выключено») или 5 вольт («включено»). Поскольку просто посмотрев, мы не можем легко определить, какое напряжение находится в цепи, мы предпочитаем записывать шаблоны включенных / выключенных напряжений, используя визуальные представления, цифры 0 и 1, чтобы не только представить идею отсутствия или присутствия сигнал, но также потому, что 0 и 1 — цифры двоичной системы. Затем мы группируем последовательность 0 и 1, чтобы сформировать инструкцию машинного кода, которая является наименьшей рабочей единицей процессора компьютера.Вот пример инструкции на машинном языке:

1110 0001 1010 0000 0010 0000 0000 0001

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

MOV R2, R1

Теперь, когда мы знаем, что программа сборки состоит из текстовой информации, называемой мнемоникой, нам нужно преобразовать ее в машинный код.Как упоминалось выше, в случае сборки ARM проект GNU Binutils предоставляет нам инструмент под названием как . Процесс использования ассемблера, такого как как , для преобразования из языка ассемблера (ARM) в машинный код (ARM) называется сборкой.

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

HYMN Assembler Tutorial

ПРИМЕЧАНИЕ: Эта страница устарела и заменена новый, значительно усовершенствованный ассемблер.Подробности смотрите на его странице.

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

Как выглядит программа в HYMN Assembly?

HYMN описан в таблице на стр. 17 примечания к курсу с примером программы на стр. 18. Эта программа, которая проверяет простоту ввода, является текстом по умолчанию при вводе ассемблер.

Программа немного изменена под этот ассемблер. Вещи существенно проще с возможностью давать имена строкам. Таким образом, когда мы ответвляемся, мы можем перейти к значимому месту; адрес 00011110, одна из строк на странице 18, просто не так описательный как NOTPRIME. Что еще более важно, с метками линий нам не нужно переписывать каждую инструкцию ветвления в программе, просто чтобы вставить новую строку.

Чтобы обозначить строку, начните ее с подписи в круглых скобках. (« (НЕПРАЙМ) LR R0, 0 »).Затем мы можем перейти к этой строке с инструкцией « BLESS R3, (NOTPRIME) ». Это демонстрируется на примере программы простоты ниже.

Ассемблер автоматически нумерует строку с адресами памяти. с шагом 0 и увеличением на 2 (поскольку HYMN имеет двухбайтовые слова) каждая строка. Эта нумерация для вас невидима. (Однако это означает, что программы ограничены 64 строками, так как n должно быть в памяти место 128.)

Вот снова текст программы.Построчное описание на странице 18 примечаний.

            LR R0, 2
            LR R1, 1
            LRA R2, 10000000
            SUB R3, R2, R0
            БЛАГОСЛОВЕНИЕ R3, (НЕ ПРАЙМ)
            BEQUAL R3, (ISPRIME)
(СЛЕДУЮЩИЙ) РАЗДЕЛ R3, R4, R2, R0
            BEQUAL R4, (НЕ ПРАЙМ)
            ДОБАВИТЬ R0, R0, R1
            МУЛЬТ R3, R0, R0
            SUB R3, R3, R2
            БЛАГОСЛОВЕНИЕ R3, (СЛЕДУЮЩИЙ)
            BEQUAL R3, (НЕ ПРАЙМ)
(ISPRIME) LR R0, 1
            B (ENDPROG)
(НЕПРАЙМ) LR R0, 0
(ENDPROG) МАГАЗИН 10000010, R0
 

Как пользоваться ассемблером?

Чтобы запустить программу, перейдите в HYMN Assembler. Измените программу появляется в разделе « Программа ». Входные данные программы — одно целое число, который вы можете установить в поле под названием « Значение для проверки ( n ) ». Это установит для ячейки памяти 128 это значение. когда программа запущена.

Для записи доступна только одна ячейка памяти.Это ячейка памяти 130, называемая dest . Намерение состоит в том, чтобы программа поместит 1 в dest , если n простое и 0 в противном случае.

Чтобы отладить программу, установите флажок « Печать отладки выход». Это напечатает состояние HYMN перед выполнением каждого инструкция. Строка отладочного вывода содержит 10 столбцов. Первый сообщает, сколько тактов прошло с начала. Вторая — это номер строки (нумерация от 1 с шагом 1), которая вот-вот будет казнен.Следующие восемь полей содержат содержимое восемь регистров.

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

Наслаждайтесь программированием на ассемблере!

Учебное пособие по простому 8-битному симулятору ассемблера на Javascript · GitHub

Здравствуйте! Это учебное пособие по простому 8-битному симулятору ассемблера на Javascript.

CPU

В ЦП хранится несколько фрагментов памяти, которые называются регистрами . В этом случае эти регистры содержат один байт (8 бит) памяти. Таким образом, в любой момент времени каждый из этих 8-битных регистров хранит одно значение от 0 до 255 или от $ 00 до $ FF в шестнадцатеричном формате.

Этот ЦП также имеет внутри несколько фрагментов памяти, называемых флагами , каждый из которых содержит один бит памяти и используется для представления логических значений.Таким образом, в любой момент времени каждый из этих 1-битных флагов имеет значение либо ИСТИНА , либо ЛОЖЬ .

Эти регистры и флаги вместе составляют внутреннее состояние ЦП в любой момент времени и имеют различные цели, которые вы увидите!

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

Этот ЦП также имеет два регистра специального назначения , называемых указателем инструкции ( IP ) и указателем стека ( SP ). Они называются указателями , потому что они содержат значение, которое представляет местоположение в ОЗУ. То есть они указывают на место в памяти.

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

Этот процессор имеет три флага, называемых нулевым флагом ( Z ), флагом переноса , ( C ) и … честно говоря, я понятия не имею, для чего здесь используется флаг F . XD Так что давайте пока просто проигнорируем это. Эти флаги используются для хранения результатов выполнения различных операций.Программист может прочитать эти результаты и использовать их, чтобы решить, что делать дальше. Например, при вычитании двух чисел нулевой флаг устанавливается на ИСТИНА , если результат равен 0. Точное использование этих флагов зависит от инструкции, поэтому мы вернемся к этому позже.

Память

К этому смоделированному ЦП прикреплен блок из 256 байтов ОЗУ. Каждый из этих байтов расположен в порядке от верхнего левого угла к нижнему правому и имеет назначенный номер, который является адресом памяти этого байта.Например, на снимке экрана значение в ячейке памяти $ 00 равно $ 1F , а значение в ячейке памяти $ 12 равно $ 06 . Программист может проинструктировать ЦП читать и записывать байтовые значения в каждый адрес памяти и из него в произвольном порядке (отсюда и название «память с произвольным доступом»).

Вход / выход

На самом деле, этот смоделированный ЦП не имеет средств ввода, но имеет некоторую форму вывода: 24-ячеечный символьный дисплей ASCII!

Этот простой символьный дисплей просто отображает символы, соответствующие закодированным значениям ASCII, присутствующим в определенной части памяти, а именно в ячейках памяти от $ E8 до $ FF .Это пример IO с отображением в память , что означает, что к некоторой форме ввода и / или вывода системы можно получить доступ путем чтения или записи в определенные места в памяти.

Программы

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

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

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

В конечном итоге ЦП понимает только числа. Когда вы нажимаете кнопку «Собрать», ассемблерный код преобразуется в числовое представление программы под названием машинный код и затем помещается в память.

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

Режимы адресации

Режим адресации — это способ обращения к фактическому значению, используемому в качестве операнда.

Немедленная адресация — это когда значение задается сразу после задания операции.Это называется немедленной адресацией, потому что закодированное значение помещается сразу после кода операции в машинном коде.

Прямая адресация — это когда используемое значение находится где-то в памяти. Вместо прямого указания значения вместо него указывается адрес значения в памяти. Это называется прямой адресацией в отличие от косвенной адресации .

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

Стек

Стек — это структура данных, которая выглядит как физический стек элементов. Это структура LIFO (last in first out), означающая, что первое, что вы получаете из стека, — это последнее, что вы вставляете.Представьте себе стопку блоков. Единственный блок, который вы можете снять с вершины стека, — это последний блок, который был помещен поверх него.

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

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

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

Этот процессор имеет единственный встроенный стек! Указатель стека этого встроенного стека содержится в собственном регистре указателя стека ЦП. В этом случае стек растет вниз на , и когда ЦП сбрасывается, указатель стека инициализируется на $ E7 , что означает, что нижняя часть стека расположена в ячейке памяти $ E7 .Но эти детали не важны для фактического использования стека.

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

Выполнение программы

Когда ЦП работает, он функционирует, выполняя инструкции в памяти одну за другой.Сначала он ищет инструкцию в памяти, на которую указывает указатель инструкции. Это включает в себя код операции, а также любые значения байтов операнда, которые могут следовать в зависимости от операции. Затем он выполняет эту инструкцию, возможно, влияя на внутреннее состояние ЦП и / или содержимое памяти. Наконец, указатель инструкции устанавливается в положение, следующее сразу за только что выполненной инструкцией, и процесс продолжается.

Когда CPU сбрасывается, указатель инструкции устанавливается в 0, что означает, что первая выполняемая инструкция — это инструкция, расположенная в самом начале памяти.Когда CPU запущен, он будет продолжать работать до тех пор, пока не встретит команду halt ( HLT ), после чего он остановится. В качестве альтернативы вы можете выполнять по одной инструкции за раз (так называемый шаг ).

Язык ассемблера

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

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

Содержимое регистров ЦП можно использовать в качестве операндов, просто записав имя регистра ЦП. Например, A относится к регистру A.

Значения, присутствующие в памяти, можно использовать в качестве операндов, заключив другое значение в [ и ] . Например, значение по адресу памяти $ 20 можно использовать в качестве операнда, записав [$ 20] . Это прямая адресация.

Вы также можете поместить имя регистра между [ и ] , чтобы использовать его в качестве операнда для значения в памяти, расположенного по адресу, содержащемуся в этом регистре.Например, если регистр A содержит $ 5 , тогда [A] относится к значению, находящемуся в памяти по адресу $ 5 .

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

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

Наконец, комментарии на ассемблере обычно помечаются точкой с запятой.

Привет, мир!

Пройдемся по Привет, мир! пример!

Для справки вот пример кода из симулятора:

; Простой пример
; Записывает Hello World на вывод

JMP начало
привет: БД "Hello World!" ; Переменная
       DB 0; Терминатор строки

Начало:
MOV C, привет; Укажите на var
МОВ Д, 232; Укажите на вывод
ЗВОНИТЕ печать
        HLT; Остановить выполнение

Распечатать:			; print (C: * от, D: * до)
НАЖАТЬ А
НАЖАТЬ B
MOV B, 0
.петля:
MOV A, [C]; Получить char из var
MOV [D], A; Записать на вывод
INC C
INC D
CMP B, [C]; Проверить если конец
JNZ .loop; прыгать, если нет

POP B
POP A
RET 

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

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

 начало:
    MOV C, привет; Укажите на var
    МОВ Д, 232; Укажите на вывод
    ЗВОНИТЕ печать
    HLT; Остановить выполнение 

 MOV C, привет; Укажите на var 

 привет: БД "Hello World!" ; Переменная 

 МОВ Д, 232; Указать на выход 

. Петля:
MOV A, [C]; Получить char из var
MOV [D], A; Записать на вывод
INC C
INC D
CMP B, [C]; Проверить если конец
JNZ.петля	; прыгать если не 

 MOV A, [C]; Получить char от var 

 MOV [D], A; Запись на выход 

 привет: БД "Hello World!" ; Переменная
       DB 0; Терминатор строки 

 CMP B, [C]; Проверить, не закончился ли