Библиотека сайта rus-linux.net
Школа ассемблера: язык ассемблера для центральных процессоров архитектуры ARM
Оригинал: Bare Metal: ARM Assembly Language
Автор: Mike Saunders
Дата публикации: 19 сентября 2016 г.
Перевод: А.Панин
Дата перевода: 12 ноября 2016 г.
Разрабатываем самый низкоуровневый код для одноплатного компьютера Raspberry Pi (а также тысяч других устройств).
Для чего это нужно?
- Вы научитесь разрабатывать беспрецедентно быстрый код.
- Вы узнаете об особенностях еще одной архитектуры центрального процессора.
- Вы сможете начать разработку собственной операционной системы!
Прошлые статьи серии (ссылки см. в конце этой статьи), в которых мы рассматривали вопросы применения языка ассемблера для создания программ исполняющихся на компьютерах с центральными процессорами архитектуры x86 (PC), получили массу положительных отзывов. Хотя язык ассемблера на сегодняшний день и может считаться не особо актуальным, так как практически все современное программное обеспечение разрабатывается с использованием высокоуровневых языков программирования, он все еще находит свое применение в области встраиваемых систем, где всегда не хватает объемов оперативной памяти и устройств хранения данных. К тому же, возможность непосредственного использования инструкций центрального процессора не будет лишней при необходимости оптимизации тех или иных подпрограмм, которые исполняются тысячи раз в секунду и зачастую присутствуют в видеоиграх или системах симуляции физических процессов. Ну и конечно же, изучение языка ассемблера позволит вам удовлетворить свою природную любознательность и приятно провести время.
Цикл статей, посвященный использованию языка ассемблера для работы с центральным процессором архитектуры x86, начинался с рассмотрения базовых вопросов разработки приложений для Linux, после чего в рамках него были рассмотрены вопросы, касающиеся создания (крайне упрощенной) операционной системы и добавления в нее графических эффектов.
В любом случае, некоторые читатели просили нас продолжить эту серию статей и рассмотреть нюансы использования языка ассемблера для работы с центральными процессорами архитектуры ARM. Такие процессоры используются в популярном одноплатном компьютере Raspberry Pi, практически в любом из существующих смартфонов, а также в тысячах других устройств. С момента представления Софи Уилсон и ее командой из компании Acorn в далеком 1983 году первых дизайнов процессоров ARM до сегодняшнего дня было произведено около 50 миллиардов чипов данной архитектуры. И хотя центральные процессоры архитектуры x86 доминируют на рынке персональных компьютеров с 1980 годов ввиду более высокой производительности по сравнению с эквивалентами архитектуры ARM, чипы ARM все еще имеют ряд преимуществ, основными из которых является более низкое энергопотребление и более элегантный набор инструкций.
Настройка рабочего окружения
В данном руководстве мы сфокусируем свое внимание на одноплатном компьютере Raspberry Pi, так как он позволяет организовать практически идеальное окружение для разработки программ на языке ассемблера для центрального процессора архитектуры ARM: он достаточно дешев (на данный момент стоит всего 5$ !), его не сложно приобрести и он позволяет вполне комфортно работать с Linux (и, следовательно, с отличным набором инструментов GNU).
Если у вас нет Raspberry Pi, но вы все же хотите самостоятельно поработать с инструкциями центрального процессора архитектуры ARM, вы можете попытаться установить версию любого дистрибутива Linux для архитектуры ARM в рамках эмулятора ПК под названием Qemu. К примеру, на веб-сайте проекта Fedora приводятся некоторые рекомендации относительно запуска устаревших версий дистрибутива с помощью эмулятора Qemu: .
Вам не понадобятся дорогие отладочные платы для разработки кода для центрального процессора архитектуры ARM, ведь хранящийся в шкафу одноплатный компьютер Raspberry Pi идеально подходит для этой задачи.
Если вы используете дистрибутив 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 систему по протоколу SSH, запустили программу Tmux для разделения экрана, запустили текстовый редактор Nano для редактирования исходного кода и осуществили его ассемблирование.
Создание собственной операционной системы для Raspberry Pi
Если вы читали предыдущие статьи серии, посвященные программированию на языке ассемблера для архитектуры x86, вы наверняка помните тот момент, когда вы в первый раз запустили свою собственную операционную систему, выводящую сообщение на экран без помощи Linux или какой-либо другой операционной системы. После этого мы доработали ее, добавив простой интерфейс командной строки и механизм загрузки и запуска программ с диска, оставив задел на будущее. Это была очень интересная, но не очень сложная работа главным образом благодаря помощи со стороны прошивки BIOS - она предоставляла упрощенный интерфейс для доступа к экрану, клавиатуре и устройству чтения флоппи-дисков.
В случае Raspberry Pi в вашем распоряжении больше не будет полезных функций BIOS, поэтому вам придется самостоятельно разрабатывать драйверы для устройств, что само по себе является сложной и малоинтересной работой по сравнению с рисованием на экране и реализацией механизма исполнения собственных программ. При этом в сети существует несколько руководств, в которых подробно описаны начальные этапы процесса загрузки Raspberry Pi, особенности механизма доступа к выводам GPIO и так далее.
Одним из лучших подобных документов является документ под названием Baking Pi () от сотрудников Университета Кэмбриджа. По сути, он является набором руководств, описывающих приемы работы с языком ассемблера для включения светодиодов, доступа к пикселям на экране, получения клавиатурного ввода и так далее. В процессе чтения вы узнаете очень много об аппаратном обеспечении Raspberry Pi, причем руководства были написаны для оригинальных моделей этих одноплатных компьютеров, поэтому нет никаких гарантий того, что они будут актуальны для таких моделей, как A+, B+ и Pi 2.
Если вы предпочитаете язык программирования C, вам следует обратиться к документу с ресурса Valvers, расположенному по адресу и содержащему описание процесса настройки кросскомпилятора и сборки простейшего ядра операционной системы, причем в разделе Wiki полезного ресурса OSDev, расположенном по адресу , также приведена информация о том, как создать и запустить простейшее ядро ОС на Raspberry Pi.
Как говорилось выше, самой большой проблемой в данном случае является необходимость разработки драйверов для различных аппаратных устройств Raspberry Pi: контроллера USB, слота SD-карты и так далее. Ведь даже код для упомянутых устройств может занять десятки тысяч строк. Если вы все же хотите разработать собственную полнофункциональную операционную систему для Raspberry Pi, вам стоит посетить форумы по адресу и поинтересоваться, не разработал ли уже кто-либо драйверы для этих устройств и, при наличии возможности, адаптировать их для ядра своей операционной системы, сэкономив тем самым большое количество своего времени.
Как все это работает
Первые две строки кода являются не инструкциями центрального процессора, а директивами ассемблера и линковщика. Каждая программа должна иметь четко заданную точку входа под названием _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 доступен по ссылке .
Совет: при работе с языком ассемблера следует не скупиться на комментарии. Мы не использовали большого количества комментариев в данной статье для того, чтобы код занимал как можно меньше места на страницах журнала (а также потому, что мы подробно описали назначение каждой из инструкций). Но при разработке сложных программ, код которых кажется очевидным на первый взгляд вы всегда должны задумываться о том, как он будет выглядеть после того, как вы частично забудете синтаксис языка ассемблера для архитектуры 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, [r1] 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 (обратитесь к таблице символов, расположенной по адресу ). Теперь мы используем инструкцию cmp для выполнения операции сравнения, после чего используем инструкцию beq, имя которой расшифровывается как "branch if equal" (переход при условии равенства), для перехода к метке done в том случае, если значение из регистра r2 равно 113. Если это не так, то мы выводим нашу вторую строку, после чего осуществляем переход к началу цикла с помощью инструкции b.
Наконец, после метки done мы сообщаем ядру ОС о том, что мы хотим завершить исполнение программы, точно так же, как и в первой программе. Для запуска данной программы следует просто осуществить ее ассемблирование и связывание в соответствии с инструкциями, приведенными для первой программы.
Чипы ARM были впервые использованы в линейке компьютеров Acorn Archimedes, а на сегодняшний день практически захватили рынок мобильных устройств (источник изображения: ).
Итак, мы рассмотрели достаточно большой объем информации в максимально сжатой форме, но будет лучше, если вы займетесь самостоятельным изучением материала, экспериментируя с приведенным выше кодом. Нет лучшего способа знакомства с языком программирования, чем проведение экспериментов, заключающихся в модификации чужого кода и наблюдении за достигнутым эффектом. Теперь вы можете разрабатывать простые программы на языке ассемблера для архитектуры ARM, осуществляющие чтение пользовательского ввода и вывод данных, при этом использующие циклы, операции сравнения и подпрограммы. Если вы не сталкивались с языком ассемблера до сегодняшнего дня, я надеюсь, что данная статья сделала этот язык немного более понятным для вас помогла развеять популярный стереотип о том, что он является мистическим ремеслом, доступным лишь нескольким талантливым разработчикам.
Разумеется, приведенная в статье информация относительно использования языка ассемблера для архитектуры ARM является всего лишь вершиной айсберга. Использование данного языка программирования всегда связано с огромным количеством нюансов и если вы хотите, чтобы мы написали о них в одной из следующих статей, просто дайте нам знать об этом! Пока же рекомендуем посетить отличный ресурс с множеством материалов для изучения приемов создания программ для систем Linux, исполняющихся на компьютерах с центральными процессорами архитектуры ARM, который расположен по адресу . Удачного программирования!
Предыдущие статьи из серии "Школа ассемблера":
- "Начинаем программировать на языке ассемблера"
- "Школа ассемблера: условные инструкции, циклы и библиотеки"
- "Начинаем программировать на языке ассемблера: переход на уровень аппаратного обеспечения"
- "Школа ассемблера: разработка операционной системы"
- "Школа ассемблера: расширение возможностей разработанной операционной системы"
- ""