Assembler для arm сканирование битов. Школа ассемблера: язык ассемблера для центральных процессоров архитектуры ARM

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

Что дальше? Дальше, собственно говоря, можно писать программу, используя набор команд thumb-2, поддерживаемый ядром Cortex-M3. Список и описание поддерживаемых команд можно посмотреть в документе под названием Cortex-M3 Generic User Guide (глава The Cortex-M3 Instruction Set ), который можно найти на вкладке Books в менеджере проекта, в Keil uVision 5. Подробно о командах thumb-2 будет написано в одной из следующих частей этой статьи, а пока поговорим о программах для STM32 в общем.

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

Например, разбить программу на отдельные секции позволяет специальная директива — AREA . Она имеет следующий синтаксис: AREA Section_Name {,type} {, attr} … , где:

1. Section_name — имя секции.
2. type — тип секции. Для секции, содержащей данные нужно указывать тип DATA, а для секции, содержащей команды — тип CODE.
3. attr — дополнительные атрибуты. Например, атрибуты readonly или readwrite указывают в какой памяти должна размещаться секция, атрибут align=0..31 указывает каким образом секция должна быть выровнена в памяти, атрибут noinit используется для выделения областей памяти, которые не нужно инициализировать или инициализирующиеся нулями (при использовании этого атрибута можно не указывать тип секции, поскольку он может использоваться только для секций данных).

Директива EQU наверняка всем хорошо знакома, поскольку встречается в любом ассемблере и предназначена для присвоения символьных имён различным константам, ячейкам памяти и т.д. Она имеет следующий синтаксис: Name EQU number и сообщает компилятору, что все встречающиеся символьные обозначения Name нужно заменять на число number . Скажем, если в качестве number использовать адрес ячейки памяти, то в дальнейшем к этой ячейке можно будет обращаться не по адресу, а используя эквивалентное символьное обозначение (Name ).

Директива GET filename вставляет в программу текст из файла с именем filename . Это аналог директивы include в ассемблере для AVR. Её можно использовать, например, для того, чтобы вынести в отдельный файл директивы присвоения символьных имён различным регистрам. То есть мы выносим все присвоения имён в отдельный файл, а потом, чтобы в программе можно было пользоваться этими символьными именами, просто включаем этот файл в нашу программу директивой GET.

Разумеется, кроме перечисленных выше есть ещё куча всяких разных директив, полный список которых можно найти в главе Directives Reference документа Assembler User Guide , который можно найти в Keil uVision 5 по следующему пути: вкладка Books менеджера проектов -> Tools User’s Guide -> Complete User’s Guide Selection -> Assembler User Guide .

Большинство команд, псевдокоманд и директив в программе имеют следующий синтаксис:

{label} SYMBOL {expr} {,expr} {,expr} {; комментарий}

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

SYMBOL — команда, псевдокоманда или директива. Команда, в отличии от метки, наоборот, должна иметь некоторый отступ от начала строки даже если перед ней нет метки.

{expr} {,expr} {,expr} — операнды (регистры, константы…)

; — разделитель. Весь текст в строке после этого разделителя воспринимается как комментарий.

Ну а теперь, как и обещал, простейшая программа:

AREA START , CODE , READONLY dcd 0x20000400 dcd Program_start ENTRY Program_start b Program_start END

AREA START, CODE, READONLY dcd 0x20000400 dcd Program_start ENTRY Program_start b Program_start END

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

Первые 4 байта этой секции содержат адрес вершины стека (в нашем случае 0x20000400), а вторые 4 байта — адрес точки входа (начало исполняемого кода). Далее следует сам код. В нашем простейшем примере исполняемый код состоит из одной единственной команды безусловного перехода на метку Program_start, то есть снова на выполнение этой же команды.

Поскольку секция во флеше всего одна, то в scatter-файле для нашей программы в качестве First_Section_Name нужно будет указать именно её имя (то есть START).

В данном случае у нас перемешаны данные и команды. Адрес вершины стека и адрес точки входа (данные) записаны с помощью директив dcd прямо в секции кода. Так писать конечно можно, но не очень красиво. Особенно, если мы будем описывать всю таблицу прерываний и исключений (которая получится достаточно длинной), а не только вектор сброса. Гораздо красивее не загромождать код лишними данными, а поместить таблицу векторов прерываний в отдельную секцию, а ещё лучше — в отдельный файл. Аналогично, в отдельной секции или даже файле можно разместить и инициализацию стека. Мы, для примера, разместим всё в отдельных секциях:

AREA STACK, NOINIT, READWRITE SPACE 0x400 ; пропускаем 400 байт Stack_top ; и ставим метку AREA RESET, DATA, READONLY dcd Stack_top ; адрес метки Stack_top dcd Program_start ; адрес метки Program_start AREA PROGRAM, CODE, READONLY ENTRY ; точка входа (начало исполняемого кода) Program_start ; метка начала программы b Program_start END

Ну вот, та же самая программа (которая по прежнему не делает нифига полезного), но теперь выглядит намного нагляднее. В scatter-файле для этой программы нужно указать в качестве First_Section_Name имя RESET, чтобы эта секция располагалась во flash-памяти первой.

Если вы используете дистрибутив Raspbian в качестве операционной системы вашего Raspberry Pi, вам понадобятся две утилиты, а именно, as (ассемблер, который преобразует исходный код на языке ассемблера в бинарный код) и ld (линковщик, который создает результирующий исполняемый файл). Обе утилиты находятся в пакете программного обеспечения binutils , поэтому они уже могут присутствовать в вашей системе. Разумеется, вам также понадобится хороший текстовый редактор; я всегда рекомендую использовать Vim для разработки программ, но он имеет высокий порог вхождения, поэтому Nano или любой другой текстовый редактор с графическим интерфейсом также отлично подойдет.

Готовы начать? Скопируйте следующий код и сохраните его в файле myfirst.s:

Global _start _start: mov r7, #4 mov r0, #1 ldr r1, =string mov r2, #stringlen swi 0 mov r7, #1 swi 0 .data string: .ascii "Ciao!\n" stringlen = . - string

Эта программа всего-навсего выводит строку "Ciao!" на экран и если вы читали статьи, посвященные использованию языка ассемблера для работы с центральными процессорами архитектуры x86, некоторые из использованных инструкций могут быть вам знакомы. Но все же, существует множество различий между инструкциями архитектур x86 и ARM, что также можно сказать и синтаксисе исходного кода, поэтому мы подробно разберем его.

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

As -o myfirst.o myfirst.s && ld -o myfirst myfirst.o

Теперь вы можете запустить созданную программу с помощью команды./myfirst . Вы наверняка обратили внимание на то, что исполняемый файл имеет очень скромный размер около 900 байт - если бы вы использовали язык программирования C и функцию puts() , размер бинарного файла был бы больше примерно в пять раз!

Создание собственной операционной системы для Raspberry Pi

Если вы читали предыдущие статьи серии, посвященные программированию на языке ассемблера для архитектуры x86, вы наверняка помните тот момент, когда вы в первый раз запустили свою собственную операционную систему, выводящую сообщение на экран без помощи Linux или какой-либо другой операционной системы. После этого мы доработали ее, добавив простой интерфейс командной строки и механизм загрузки и запуска программ с диска, оставив задел на будущее. Это была очень интересная, но не очень сложная работа главным образом благодаря помощи со стороны прошивки BIOS - она предоставляла упрощенный интерфейс для доступа к экрану, клавиатуре и устройству чтения флоппи-дисков.

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

Одним из лучших подобных документов является документ под названием Baking Pi (www.cl.cam.ac.uk/projects/raspberrypi/tutorials/os/index.html) от сотрудников Университета Кэмбриджа. По сути, он является набором руководств, описывающих приемы работы с языком ассемблера для включения светодиодов, доступа к пикселям на экране, получения клавиатурного ввода и так далее. В процессе чтения вы узнаете очень много об аппаратном обеспечении Raspberry Pi, причем руководства были написаны для оригинальных моделей этих одноплатных компьютеров, поэтому нет никаких гарантий того, что они будут актуальны для таких моделей, как A+, B+ и Pi 2.

Если вы предпочитаете язык программирования C, вам следует обратиться к документу с ресурса Valvers, расположенному по адресу http://tinyurl.com/qa2s9bg и содержащему описание процесса настройки кросскомпилятора и сборки простейшего ядра операционной системы, причем в разделе Wiki полезного ресурса OSDev, расположенном по адресу http://wiki.osdev.org/Raspberry_Pi_Bare_Bones , также приведена информация о том, как создать и запустить простейшее ядро ОС на Raspberry Pi.

Как говорилось выше, самой большой проблемой в данном случае является необходимость разработки драйверов для различных аппаратных устройств Raspberry Pi: контроллера USB, слота SD-карты и так далее. Ведь даже код для упомянутых устройств может занять десятки тысяч строк. Если вы все же хотите разработать собственную полнофункциональную операционную систему для Raspberry Pi, вам стоит посетить форумы по адресу www.osdev.org и поинтересоваться, не разработал ли уже кто-либо драйверы для этих устройств и, при наличии возможности, адаптировать их для ядра своей операционной системы, сэкономив тем самым большое количество своего времени.

Как все это работает

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

С помощью следующей инструкции мы помещаем число 4 в регистр r7 . (Если вы никогда не работали с языком ассемблера ранее, вам следует знать, что регистром называется ячейка памяти, расположенная непосредственно в центральном процессоре. В большинстве современных центральных процессоров реализовано небольшое количество регистров по сравнению с миллионами или миллиардами ячеек оперативной памяти, но при этом регистры незаменимы, так как работают гораздо быстрее.) Чипы архитектуры ARM предоставляют разработчикам большое количество регистров общего назначения: разработчик может использовать до 16 регистров с именами от r0 до r15 , причем эти регистры не связаны с какими-либо историческими сложившимися ограничениями, как в случае архитектуры x86, где некоторые из регистров могут использоваться для определенных целей в определенные моменты.

Итак, хотя инструкция mov и очень похожа на одноименную инструкцию архитектуры x86, вам в любом случае следует обратить внимание на символ решетки рядом с числом 4 , указывающий на то, что далее расположено целочисленное значение, а не адрес в памяти. В данном случае мы желаем использовать системный вызов write ядра Linux для вывода нашей строки; для использования системных вызовов следует заполнять регистры необходимыми значениями перед тем, как простить ядро выполнить свою работу. Номер системного вызова должен помещаться в регистр r7 , причем число 4 является номером системного вызова write.

С помощью следующей инструкции mov мы помещаем дескриптор файла, в который должна быть записана строка "Ciao!", то есть, дескриптор стандартного потока вывода, в регистр r0 . Так как в данном случае используется поток стандартного вывода, в регистр помещается его стандартный дескриптор, то есть, 1 . Далее нам нужно поместить адрес строки, которую мы хотим вывести, в регистр r1 с помощью инструкции ldr (инструкция "загрузки в регистр"; обратите внимание на знак равенства, указывающий на то, что далее следует метка, а не адрес). В конце кода, а именно, в секции данных мы объявляем эту строку в форме последовательности символов ASCII. Для успешного использования системного вызова "write" нам также придется сообщить ядру операционной стемы о том, какова длина выводимой строки, поэтому мы помещаем значение stringlen в регистр r2 . (Значение stringlen рассчитывается путем вычитания адреса окончания строки из адреса ее начала.)

На данный момент мы заполнили все регистры необходимыми данными и готовы к передаче управления ядру Linux. Для этого мы используем инструкцию swi , название которой расшифровывается как "software interrupt" ("программное прерывание"), осуществляющую переход в пространство ядра ОС (практически таким же образом, как и инструкция int в статьях, посвященных архитектуре x86). Ядро ОС исследует содержимое регистра r7 , обнаруживает в нем целочисленное значение 4 и делает вывод: "Так, вызывающая программа хочет вывести строку". После этого оно исследует содержимое других регистров, осуществляет вывод строки и возвращает управление нашей программе.

Таким образом мы видим на экране строку "Ciao!", после чего нам остается лишь корректно завершить исполнение программы. Мы решаем эту задачу путем помещения номера системного вызова exit в регистр r7 с последующим вызовом инструкции программного прерывания номер ноль. И на этом все - ядро ОС завершает исполнение нашей программы и мы снова перемещаемся в командную оболочку.

Vim (слева) является отличным текстовым редактором для написания кода на языке ассемблера - файл для подсветки синтаксиса данного языка для архитектуры ARM доступен по ссылке http://tinyurl.com/psdvjen .

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

Обратный инжиниринг

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

Objdump -d myfirst

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

Подпрограммы, циклы и условные инструкции

Теперь, когда мы знаем, как разрабатывать, ассемблировать и связывать простые программы, давайте перейдем к рассмотрению кое-чего более сложного. В следующей программе для вывода строк используются подпрограммы (благодаря им мы можем повторно использовать фрагменты кода и избавить себя от необходимости выполнения однотипных операций заполнения регистров данными). В данной программе реализован главный цикл обработки событий, который позволяет осуществлять вывод строки до того момента, как пользователь введет "q". Изучите код и попытайтесь понять (или угадать!) назначение инструкций, но не отчаивайтесь, если вам что-то не понятно, ведь чуть позже мы также рассмотрим его в мельчайших подробностях. Обратите внимание на то, что с помощью символов @ в языке ассемблера для архитектуры ARM выделяются комментарии.

Global _start _start: ldr r1, =string1 mov r2, #string1len bl print_string loop: mov r7, #3 @ read mov r0, #0 @ stdin ldr r1, =char mov r2, #2 @ два символа swi 0 ldr r1, =char ldrb r2, cmp r2, #113 @ Код ASCII символа "q" beq done ldr r1, =string2 mov r2, #string2len bl print_string b loop done: mov r7, #1 swi 0 print_string: mov r7, #4 mov r0, #1 swi 0 bx lr .data string1: .ascii "Enter q to quit!\n" string1len = . - string1 string2: .ascii "That wasn"t q...\n" string2len = . - string2 char: .word 0

Наша программа начинается с помещения указателя на начало строки и значения ее длины в соответствующие регистры для последующего осуществления системного вызова write , причем сразу же после этого осуществляется переход к подпрограмме print_string , расположенной ниже в коде. Для осуществления этого перехода используется инструкция bl , название которой расшифровывается как "branch and link" ("ветвление с сохранением адреса"), причем сама она сохраняет текущий адрес в коде, что позволяет вернуться к нему впоследствии с помощью инструкции bx . Подпрограмма print_string просто заполняет другие регистры для осуществления системного вызова write таким же образом, как и в нашей первой программе перед переходом в пространство ядра ОС с последующим возвратом к сохраненному адресу кода с помощью инструкции bx .

Вернувшись к осуществляющему вызов коду, мы можем обнаружить метку под названием loop - название метки уже намекает на то, что мы вернемся к ней через некоторое время. Но сначала мы используем еще один системный вызов с именем read (под номером 3) для чтения символа, введенного пользователем с помощью клавиатуры. Поэтому мы помещаем значение 3 в регистр r7 и значение 0 (дескриптор стандартного потока ввода) в регистр r0 , так как нам нужно прочитать пользовательский ввод, а не данные из файла.

Далее мы размещаем адрес, по которому мы хотим сохранить символ, прочитанный и помещенный ядром ОС в регистр r1 - в нашем случае это область памяти char , описанная в конце секции данных. (На самом деле, нам нужно машинное слово, то есть, область памяти для хранения двух символов, ведь в ней будет храниться и код клавиши Enter. При работе с языком ассемблера важно всегда помнить о возможности переполнения областей памяти, ведь в нем нет никаких высокоуровневых механизмов, готовых прийти вам на помощь!).

Вернувшись к основному коду, мы увидим, что в регистр r2 помещается значение 2 , соответствующее двум символам, которые мы хотим сохранить, после чего осуществляется переход в пространство ядра ОС для выполнения операции чтения. Пользователь вводит символ и нажимает клавишу Enter. Теперь нам нужно проверить, что это за символ: мы помещаем адрес области памяти (char в секции данных) в регистр r1 , после чего с помощью инструкции ldrb загружаем байт из области памяти, на которую указывает значение из этого регистра.

Квадратные скобки в данном случае указывают на то, что данные хранятся в интересующей нас области памяти, а не в самом регистре. Таким образом, регистр r2 теперь содержит единственный символ из области памяти char из секции данных, причем это именно тот символ, который ввел пользователь. Наша следующая задача будет заключаться в сравнении содержимого регистра r2 с символом "q" , который является 113 символом таблицы ASCII (обратитесь к таблице символов, расположенной по адресу www.asciichart.com). Теперь мы используем инструкцию cmp для выполнения операции сравнения, после чего используем инструкцию beq , имя которой расшифровывается как "branch if equal" (переход при условии равенства), для перехода к метке done в том случае, если значение из регистра r2 равно 113. Если это не так, то мы выводим нашу вторую строку, после чего осуществляем переход к началу цикла с помощью инструкции b .

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

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

Разумеется, приведенная в статье информация относительно использования языка ассемблера для архитектуры ARM является всего лишь вершиной айсберга. Использование данного языка программирования всегда связано с огромным количеством нюансов и если вы хотите, чтобы мы написали о них в одной из следующих статей, просто дайте нам знать об этом! Пока же рекомендуем посетить отличный ресурс с множеством материалов для изучения приемов создания программ для систем Linux, исполняющихся на компьютерах с центральными процессорами архитектуры ARM, который расположен по адресу http://tinyurl.com/nsgzq89 . Удачного программирования!

Предыдущие статьи из серии "Школа ассемблера":

1. Счетчик часов реального времени должен быть включен (1); бит выбора источника тактирования сброшен (2), если тактирование не осуществляется от основного тактового генератора.

2. Один или оба бита выбора прерывающего события (3) должны быть установлены. И выбрано, какие именно события будут вызывать запрос прерывания (5).

3. Должны быть заданы маски прерывающих событий (4, 7).

2.5 О программировании ARM7 на ассемблере

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

с трудом читается. Поэтому ассемблер редко применяется в программировании для архитектуры ARM7.

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

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

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

2. В ходе поиска ошибок или причин возникновения исключительных ситуаций (раздел 2.4.1).

3. Для получения кода, абсолютно оптимального по быстродействию или расходу памяти (разделы 2.2.20, 3.1.5).

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

с целью продемонстрировать весь код исполняемый микроконтроллером, как есть, и без посредничества Си-компилятора.

Порядок создания проекта на основе ассемблера почти тот же, что и для Си-программ (разделы 2.3.1–2.3.3). Исключения лишь два:

а) файлу исходного текста присваивается расширение *.S;

б) здесь предполагается, что файл STARTUP.S к программе не подключается.

2.5.1 Основные правила записи программ на ассемблере

Текст программы на ассемблере принято оформлять в четыре колонки. Можно сказать, что каждая строка состоит из четырех полей, а именно: поля меток, операций, операндов, комментариев. Поля отделяются друг от друга символом «табуляция» или пробелами.

Основными являются поля операций и операндов. Допустимые операции и их синтаксис приведены в таблице (1.4.2)

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

Комментарии по желанию помещаются в конце строки и отделяются точкой с запятой («; »).

Приведем простой пример.

2.5.2 Псевдокоманды

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

2.5.3 Директивы ассемблера

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

Рассмотрим часто используемые директивы ассемблера RealView 4.

Имя EQU Константа

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

AREA Имя, Параметры

Определяет область памяти с заданным Именем . С помощью параметров указывается назначение области памяти, например, DATA (данные) или CODE (код). От выбранного назначения зависят адреса определяемой области. Область CODE размещается, начиная с адреса 0x00000000, область DATA - с адреса 0x40000000. В программе обязательно должна существовать область CODE c именем RESET . Константы, размещаемые в памяти программ, следует объявлять в секции с парой параметров CODE, READONLY .

Обозначает точку входа в программу, показывает ее «начало». Одна такая директива всегда должна присутствовать в программе. Обычно помещается непосредственно после директивы AREA RESET, CODE .

Таблица 2.5.1 – Псевдокоманды, поддерживаемые ассемблером RealView 4

Мнемоническое обозначение			Операция		Фактическая реализация
и синтаксис
ADR{Усл }				в регистр	Сложение или вычитание константы из PC ко-
					мандами ADD или SUB
ADRL{Усл }				в регистр	Дважды ADD или SUB с участием PC
			(расширенный диапазон адресов)
ASR{Усл }{S}			Арифметический сдвиг вправо
ASR{Усл }{S}					нием сдвигового операнда
LDR{Усл }				в регистр
					адресацией (PC + непосредственное смещение)
					Размещение константы		в памяти программ
LDR{с индексной адреса-
					цией. Смещением служит PC.
LSL{Усл }{S}			Логический сдвиг влево
LSL{Усл }{S}					нием сдвигового операнда
LSR{Усл }{S}			Логический сдвиг вправо
LSR{Усл }{S}					нием сдвигового операнда
POP{Усл }			Восстановить регистры из стека		Восстановление	регистров		командой
					LDMIA R13!,{...}
PUSH{Усл }					Сохранение	регистров		командой
					STMDB R13!,{...}
ROR{Усл }{S}			Циклический сдвиг вправо
ROR{Усл }{S}					нием сдвигового операнда
RRX{Усл }{S}			Циклический сдвиг вправо через
			перенос на 1 разряд		нием сдвигового операнда

Имя SPACE Размер

Резервирует память для хранения данных заданного Размера . Имя становится синонимом адреса зарезервированного пространства. Единство адресного пространства позволяет применять эту директиву, как для постоянной, так и для оперативной памяти. Основное назначение - создание глобальных переменных в оперативной памяти (в области DATA ).

Метка DCB/DCW/DCD Константа

«Прошивают» данные (числовые Константы ) в памяти программ. Метка становиться синонимом адреса, по которому будут записаны данные. Разные директивы (DCB , DCW и DCD ) служат для данных разного размера: байт, 16-разрядное слово, 32-разрядное слово (соответственно).

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

2.5.4 Макросы

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

Для объявления макроса служит следующая конструкция

	$ Параметр1, $ Параметр2, ...

Параметры позволяют модифицировать текст макроса при каждом обращении к нему. Внутри (в теле) макроса параметры используются также с предшествующим знаком «$ ». Вместо параметров в теле макроса подставляются параметры, указанные при вызове.

Вызов макроса осуществляется так:

Имя Параметр1, Параметр2, ...

Имеется возможность организовать проверку условия и ветвление.

IF "$ Параметр" == " Значение"

Обращаем внимание на то, такая конструкция не приводит к программной проверке условия микроконтроллером. Проверку условия осуществляет ассемблер в ходе формирования исполнимого кода.

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

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

Прежде чем приступить к рассмотрению команд ARM7, необходимо отметить следующие ее особенности:

Поддержку двух наборов команд: ARM с 32-битными командами и THUMB с 16-битными командами. Далее рассматривается 32-битный набор команд, слово ARM будет означать команды, принадлежащие к этому формату, а слово ARM7 - собственно ЦПУ.

Поддержку двух форматов 32-х разрядного адреса: с обратным порядком бит (big-endian processor и с прямым порядком бит (little-endian processor)). В первом случае старший бит (Most Significant Bit - MSB) располагается в младшем бите слова, а во втором случае - в старшем. Это обеспечивает совместимость с другими семействами 32-х разрядных процессоров при использовании языков высокого уровня. Однако в ряде семейств процессоров с ядром ARMиспользуется только прямой порядок байтов (т.е. MSB является самым старшим битом адреса), что значительно облегчает работу с процессором. Поскольку компилятор, используемый для ARМ7, работает с код в обоих форматах, необходимо удостовериться, что формат слов задан правильно, в противном случае полученный код будет «вывернут наизнанку».

Возможность выполнения различных типов сдвига одного из операндов «на проходе» перед использованием в АЛУ

Поддержка условного выполнения любой команды

Возможность запрета изменения флагов результатов выполнения операции.

1. Условное выполнение команд

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

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

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

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

MOVEQ R1, #0x008

означает, что загрузка числа 0x00800000 в регистр R1 будет произведена только том случае, если результат выполнения последней команды обработки данных был «равно» или получен 0 результат и соответственно установлен флаг (Z) регистра CPSR.

Таблица 3

Префиксы команд

		Значение
	Z установлен
	Z сброшен
	С установлен	Выше или равно (беззнаковое)
	C сброшен	Ниже (беззнаковое)
	N установлен	Отрицательный результат
	N сброшен	Положительный результат или 0
	V установлен	Переполнение
	V сброшен	Нет переполнения
	С установлен, Z сброшен	Выше (беззнаковое)
	С сброшен, Z установлен	Ниже или равно (беззнаковое)
		Больше или равно (знаковое)
	N не равен V	Меньше (знаковое)
	Z сброшен И (N равен V)	Больше (знаковое)
	Z установлен ИЛИ (N не равен V)	Меньше или равно (знаковое)
	(игнорируются)	Безусловное выполнение