Arm руководство пользователя

Подробное объяснение набора инструкций ARM

1. Сборка

1.1 Общие регистры

Общий регистр

37 регистров, 31 регистр общего назначения, 6 регистров состояния, указатель стека R13 sp, указатель возврата R14, R15 — указатель ПК,cpsr_c представляет младшие 8 из этих 32 битов, которые являются управляющим битом

Регистр CPSR

В чем разница между FIQ и IRQ?

РЕЖИМ (бинарный ниже)
10000	Пользовательский режим	PC,CPSR,R0~R14
10001	FIQ	PC,CPSR,SPSR_fiq，R14_fiq~R8_fiq,R7~R0
10010	IRQ	PC,CPSR,SPSR_irq，R14_irq~R13_irq,R12~R0
10011	Режим управления (SVC)	PC,CPSR,SPSR_svc，R14_svc~R13_svc,R12~R0
10111	Режим завершения	PC,CPSR,SPSR_abt，R14_abt~R13_abt,R12~R0
11011	Неопределенный	PC,CPSR,SPSR_und，R14_und~R13_und,R2~R0
11111	Системный режим (sys)	PC,CPSR，R14 ~R0

1.2 Формат команды

1) Базовый формат

<opcode>{<cond>}{S} <Rd>,<Rn>{,<opcode2>}

Среди них элементы в <> являются обязательными, элементы в {} являются необязательными, например, <opcode> является мнемоникой команды, требуется, и {<cond>} является условием выполнения инструкции, является необязательным , Если не записано, используется условие по умолчанию AL (безусловное выполнение).

opcodeКомандная мнемоника, такая как LDR, STR и т. Д.

condУсловия выполнения, такие как EQ, NE и т. Д.

SВлияет ли это на значение регистра CPSR, влияет на CPSR при записи, иначе это не влияет

RdЦелевой регистр

RnРегистр первого операнда

operand2Второй операнд

Примеры форматов команд:

LDREX — эта инструкция в основном берет число из памяти и затем помещает его в регистр, но по сравнению с обычной инструкцией LDR, его основные атомарные рабочие характеристики, семафор и спин-блокировка являются основными. Это последовательность загрузки-обновления-хранения. Чтобы предотвратить параллелизм, необходимо убедиться, что последовательность является атомарной. Так называемый атомарный означает, что когда процессор выполняет эту последовательность инструкций, он должен полностью занимать процессор и не может быть выключен. На ARM, начиная с V6, для этого используются инструкции LDREX и STREX.

LDR R0, [R1]; прочитать содержимое ячейки памяти по адресу R1, выполнить условие AL
BEQ DATAEVEN; инструкция перехода, EQ условия выполнения, равный переход к DATAEVEN
ADDS R1, R1, # 1; инструкция сложения R1 + 1 = R1 влияет на регистр CPSR, где S
SUBNES R1, R1, # 0xD; вычитание условного выполнения (NE), R1-0xD => R1, влияет на регистр CPSR, с S

2) Второй операнд

В инструкции ARM гибкое использование второго операнда может повысить эффективность кода. Форма второго операнда следующая:

＃immed_8r

Постоянное выражение：

Константа должна соответствовать 8-битной битовой карте, то есть константа состоит из 8-битной константыВращать четные битыПолучить.

Правовые константы:

0x3FC, 0, 0xF0000000, 200, 0xF0000001 и т. Д. Являются законными константами.

Нелегальная константа:

0x1FE, 511, 0xFFFF, 0x1010, 0xF0000010 и т. Д. Являются недопустимыми константами.

Примеры применения константных выражений:

MOV R0,#1 ;R0=1

И R1, R2, # 0x0F; R2 и 0x0F, результат сохраняется в R1

LDR R0, [R1], # -4; прочитать содержимое ячейки памяти по адресу R1, а R1 = R1-4

Rm

В режиме регистров операндом является значение регистра в режиме регистров.

Зарегистрировать примеры приложений:

SUB R1，R1，R2 ；R1-R2=＞R1

MOV PC, R0; PC = R0, программа переходит на указанный адрес

LDR R0, [R1], -R2; прочитать содержимое ячейки памяти по адресу R1 и сохранить его в R0, а R1 = R1-R2

Rm， shift

Регистрация режима сдвига. Результат сдвига регистра используется в качестве операнда, но значение RM остается неизменным. Метод сдвига следующий:

ASR #n арифметический сдвиг вправо n мест (1≤n≤32)

LSL # n сдвиг влево логически на n бит (1≤n≤31)

LSR #n логический сдвиг влево n бит (1≤n≤32)

ROR # n повернуть вправо на n бит (1≤n≤31)

RRX вращается вправо на 1 бит с расширением

type Среди них type — один из ASR, LSL и ROR; регистр смещения Rs, младшие 8 битов действительны, если значение больше или равно 32, результат второго операнда равен 0 (ASR, ROR исключения).
Пример применения метода смещения регистра:

ADD R1，R1，R1，LSL #3 ；R1=R1*9

SUB R1，R1，R2，LSR#2 ；R1=R1-R2*4

R15 является программным счетчиком ПК процессора, как правило, им не управляют, и некоторые инструкции не могут использовать R15, например, инструкция UMULL.
(3) Код условия
Использование кодов условий команд может реализовать эффективные логические операции и повысить эффективность кода. Таблица A-1 показывает таблицу кодов условий.

Таблица A-1 Таблица кодов условий

Для набора команд Thumb только команда B имеет функцию выполнения кода условия. Код условия этой команды такой же, как в таблице A- ?, но если это безусловное выполнение, мнемоника кода AL в инструкции не записывается.

Примеры применения кодов условий:

Сравните два значения и добавьте соответственно 1. Код C:
 if（a＞b）a++ ;
 else b++ ;
Соответствующие инструкции ARM следующие. Где R0 является a и R1 является b.
CMP R0, R1; R0 по сравнению с R1
ADDHI R0, R0, # 1, если R0> R1, то R0 = R0 + 1
ADDLS R1, R1, # 1; если R0 ＜ = R1, то R1 = R1 + 1
Если оба условия выполняются, два значения добавляются вместе, а код C:

If(（a!=10）&&(b!=20))a=a+b;

Соответствующие инструкции ARM следующие, где R0 — это a, а R1 — это b.
CMPR0, # 10; сравнить R0 с 10
CMPNE R1, # 20; Если R0 не 10, сравните, равно ли R1 20
ADDNE R0, R0, R1; если R0 не 10 и R1 не 20, инструкция выполняется, R0 = R0 + R1

1.3 Набор инструкций

1.3.1 Инструкция доступа к памяти ARM

Обработка ARM — это типичный RISC-процессор архитектуры загрузки / хранения, и доступ к памяти может быть достигнут только с помощью инструкций загрузки и хранения. Команда загрузки / сохранения ARM может реализовывать операцию слова, полуслова, байта без знака / знака, команда пакетной загрузки / сохранения может реализовывать одну инструкцию для загрузки / хранения содержимого нескольких регистров, что значительно повышает эффективность; инструкция SWP является регистром Инструкции, которыми обмениваются с содержимым памяти, могут использоваться для операций с семафорами и т. Д. Процессор ARM представляет собой структуру памяти фон Неймана.Программное пространство, пространство ОЗУ и пространство отображения ввода-вывода адресованы единообразно.В дополнение к операции ОЗУ доступ к периферийному вводу-выводу и программным данным должен выполняться посредством инструкций загрузки / сохранения. Таблица A-2 показывает список инструкций доступа к памяти ARM.

Таблица A-2 Таблица инструкций доступа к хранилищу ARM

 ЛДР и СТР
Загрузка / сохранение слова и беззнаковых байтовых инструкций. Используйте отдельные инструкции по передаче данных (STR и LDR) для загрузки и сохранения одного байта или слова данных из / в память. Инструкция LDR используется для считывания данных из памяти в регистр, инструкция STR используется для сохранения данных из регистра в память. Формат команды следующий:
LDR {cond} {T} Rd, <адрес>; загрузить данные (слово) по указанному адресу и поместить их в Rd
STR {cond} {T} Rd, <адрес>; хранить данные (слово) в блоке хранения указанного адреса, данные для хранения находятся в Rd
LDR {cond} B {T} Rd, <адрес>; загрузить байтовые данные и поместить их в Rd, то есть младший байт Rd действителен, а старшие 24 бита очищены
STR {cond} B {T} Rd, <адрес>; хранить байтовые данные, данные для хранения — Rd, младший байт действителен
Среди них необязательный суффикс T. Если инструкция имеет T, то даже если процессор находится в привилегированном режиме, система хранения обрабатывает доступ так, как если бы процессор находился в режиме пользователя. T недопустим в пользовательском режиме и не может использоваться с предыдущим смещением индекса.
Адресация команд LDR / STR очень гибкая и состоит из двух частей: одна часть является регистром базовых адресов, который может быть любым регистром общего назначения, а другая часть является смещением адреса. Смещение адреса имеет следующие три формата:
(1) немедленно. Непосредственное значение может быть значением без знака.Эти данные могут быть добавлены в регистр базового адреса, или это значение может быть вычтено из регистра базового адреса. Примеры инструкций следующие:
LDR R1, [R0, # 0x12]; Считать данные по адресу R0 + 0x12 и сохранить их в R1 (значение R0 остается неизменным)
LDR R1, [R0, # -0x12]; Считайте данные по адресу R0-0x12 и сохраните их в R1 (значение R0 остается неизменным)
LDR R1, [R0]; прочитать данные по адресу R0 и сохранить их в R1 (смещение нуля)
(2) Зарегистрируйтесь. Значение в регистре может быть добавлено в регистр базового адреса, или значение может быть вычтено из регистра базового адреса. Значение примера инструкции. Примеры инструкций следующие:
LDR R1, [R0, R2], считайте измеритель данных адреса R0 + R2 и сохраните его в R1 (значение R0 остается неизменным)
LDR R1, [R0, -R2]; Считайте измеритель данных по адресу R0-R2 и сохраните его в R1 (значение R0 остается неизменным)
(3) Регистры и константы сдвига. Смещенное значение регистра может быть добавлено в регистр базового адреса, или это значение может быть вычтено из регистра базового адреса. Примеры инструкций следующие:
LDR R1, [R0, R2, LSL # 2]; прочитать данные по адресу R0 + R2 * 4 и сохранить их в R1 (значения R0 и R2 остаются без изменений)
LDR R1, [R0, -R2, LSL # 2]; Считайте измеритель данных по адресу R0-R2 * 4 и сохраните его в R1 (значения R0 и R2 не изменились)
В соответствии с методом вычисления адреса в режиме адресации инструкция загрузки / сохранения имеет следующие 4 формы:
(1) Смещение нуля. Значение Rn используется в качестве адреса для передачи данных, то есть смещение адреса равно 0. Примеры инструкций следующие:
 LDR Rd,[Rn]
(2) Смещение переднего указателя. Перед передачей данных смещение добавляется в Rn, и результат используется в качестве адреса хранения переданных данных. Если используется суффикс «!», Результат записывается обратно в Rn, и значение Rn не может быть равно R15. Примеры инструкций следующие:
 LDR Rd,[Rn,#0x04]!
 LDR Rd,[Rn,#-0x04]
(3) Программа относительно смещена. Относительное смещение программы является еще одной версией формы индекса. Ассемблер вычисляет смещение из регистра ПК и использует регистр ПК в качестве Rn для генерации прединдексной инструкции. Суффикс «!» Не может быть использован. Примеры инструкций следующие:
LDR Rd, метка; метка — метка программы, метка должна быть в пределах ± 4 КБ от текущей инструкции
(4) Смещение заднего индекса. Значение Rn используется в качестве адреса хранения передаваемых данных. После передачи данных смещение добавляется в Rn, а результат записывается обратно в Rn. Rn не может быть R15. Примеры инструкций следующие:
 LDR Rd,[Rn],#0x04
Выравнивание адреса. В большинстве случаев необходимо обеспечить, чтобы адрес, используемый для 32-разрядной передачи, был выровнен по 32-разрядному.
Примеры загрузки / сохранения слова и беззнаковых байтов приведены ниже:
LDR R2, [R5]; загрузить данные (слово) по указанному адресу R5 и поместить их в R2
STR R1, [R0, # 0x04]; Сохранить данные от R1 до R0 + 0x04 единицы хранения, значение R0 остается неизменным
LDRB R3, [R2], # 1, прочитать один байт данных по адресу R2 и сохранить его в R3, R2 = R3 + 1
STRB R6, [R7]; прочитать данные R6 и сохранить их по адресу, указанному в R7, хранить только один байт данных
Загрузка / хранение полуслов и подписанных байтов. Такие инструкции LDR / STR могут загружать подписанные байты загружать подписанные полуслова, загружать / хранить неподписанные полуслова. Формат смещения и метод адресации совпадают с инструкциями загрузки / сохранения и байтов без знака. Формат команды следующий:
LDR {cond} SB Rd, <адрес>; загрузить данные (байты со знаком) по указанному адресу и поместить их в Rd
LDR {cond} SH Rd, <адрес>; загрузить данные (байты со знаком) по указанному адресу и поместить их в Rd
LDR {cond} H Rd, <адрес>; загрузить данные половинного слова и поместить их в Rd, то есть младшие 16 бит Rd действительны, а верхние 16 бит очищены
STR {cond} H Rd, <адрес>; хранить данные половинного слова, данные, которые должны быть сохранены, — Rd, допустимы минимум 16 бит
Описание: загрузка половинного слова / байта со знаком относится к загрузке знакового бита, расширенной до 32 бит, загрузка по половинному слову без знака относится к нулю, расширенному до 32 бит.
Выравнивание адреса — адрес для передачи полуслов должен быть четным числом. Загрузка с полусловом, не выровненная по половинному слову, сделает содержимое Rd ненадежным, а при хранении с половиной слов, не выровненным по половинному слову, содержимое 2-байтового хранилища указанного адреса ненадежно.

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

Сохраняются ли данные над или под адресом базового регистра, и увеличивается ли адрес или уменьшается до или после сохранения первого значения. В таблице A-3 показана принципиальная схема многоадресного отображения команд передачи.

Таблица A-3 Таблица схемы отображения команд многоадресной передачи

1.3.2 Инструкции по обработке данных ARM

Инструкции по обработке данных можно условно разделить на 3 категории:

(1) Инструкции передачи данных (такие как MOV, MVN)

(2) Арифметические логические инструкции по работе (такие как ADD, SUM и AND)

(3) Сравнительные инструкции (такие как CMP, TST).

Инструкции по обработке данных могут работать только с содержимым регистров. Все инструкции по обработке данных ARM могут использовать суффикс S, чтобы влиять на флаг состояния. Команды сравнения CMP, CMN, TST и TEQ не нуждаются в суффиксе S, они напрямую влияют на флаги состояния. Инструкции по обработке данных ARM перечислены в таблице A-4.

Таблица A-4 Инструкции по обработке данных ARM

Таблица A-5 Все инструкции умножения ARM

1.3.3 Инструкция перехода ARM

Есть два способа перейти к программе:

（1） Прыгайте прямо, используя инструкции по прыжкуСуществуют инструкции перехода B, инструкции перехода BL со ссылками и инструкции перехода BX с переключением состояний.

（2） Перейти непосредственно к реестру ПК。

Таблица A-6 показывает все инструкции по переходу ARM.

Таблица A-6 Инструкция по переходу ARM

BИнструкция перехода, переход по указанному адресу для выполнения программы.

B{cond} label

Примеры следующие:

B WAITA; перейти к ярлыку WAITA

B 0x1234; перейти к абсолютному адресу 0x1234

Переход к инструкции B ограничен до ± 32 Мб текущей инструкции.

BLПерейти инструкции с ссылками. Инструкция копирует адрес следующей инструкции в регистр связи R14 (LR), а затем переходит на указанный адрес для запуска программы.
 BL{cond} label

Примеры следующие:

BL DELAY

Инструкция перехода B ограничена до ± 32 МБ текущей инструкции. Инструкция BL используется для вызова подпрограммы.
 

BXИнструкция перехода с переключением состояний. Для выполнения программы перейдите к адресу, указанному в Rm.Если бит [0] в Rm равен 1, при переходе автоматически устанавливается флаг T в CPSR, то есть код целевого адреса интерпретируется как код Thumb; 0] равно 0, флаг T в CPSR автоматически сбрасывается при переходе, то есть код целевого адреса интерпретируется как код ARM. Формат команды следующий:
 BX{cond} Rm
Примеры следующие:
 ADRL R0,ThumbFun+1
BX R0; перейти к адресу, указанному в R0, и переключить состояние процессора в соответствии с младшим битом R0

BLX

Целевой адрес BLX: переход, изменение состояния и сохранение значения ПК

1.3.4 Инструкции ARM сопроцессора

5  ARM поддерживает работу сопроцессора, и управление сопроцессором должно осуществляться с помощью команд сопроцессора. В таблице A-7 приведены все инструкции ARM-сопроцессора.

Таблица A-7 Инструкции ARM сопроцессора

1.3.5 ARM Разные инструкции

В таблице A-8 приведены все инструкции ARM-сопроцессора.

Таблица A-8 ARM Разные инструкции

1.3.6 Псевдоинструкция ARM

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

1.4.1 Немедленная адресация

Непосредственному номеру предшествует знак «#», а если это шестнадцатеричное число, после «#» добавляется «0x» или «&», а после двоичного числа «#» следует «%».

1.4.2 Адресация регистра

1.4.3 Регистрация косвенной адресации

Значение в регистре используется в качестве адреса операнда, а сам операнд помещается в память.

Например: ADD R0, R1, [R2]

1.4.4 Индексирование базовых адресов

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

Например: LDR R0, [R1, # 4] R0 <- [R1 + 4]

1.4.5 Многоадресная адресация

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

LDMIA R0，{R1，R2，R3，R4}

1.4.6 Относительная адресация

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

Например: BL NEXT;

1.4.7 Стековая адресация

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

Увеличение стека: рост к высоким адресам

Уменьшить стек: расти к младшим адресам

Полный стек: указатель стека указывает на последние действительные данные, помещенные в стек

Пустой стек: указатель стека указывает на следующее пустое место, где должны быть размещены данные

2. GNU ARM гибрид

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

1.1 Формат заявления на ассемблере GNU

любойLinuxСборочная линия имеет следующую структуру:[<label>:][<instruction or directive orpseudo-instruction>}@comment

l инструкция есть инструкция

l директива является псевдооперацией

l псевдо-инструкция для директивы

l <label>:естьЭтикетка,В сборке GNU,Любой идентификатор, заканчивающийся двоеточием, считается меткой，Не обязательно в начале строки。

l комментарий — комментарий к заявлению

Далее определяется функция «add», которая в итоге возвращает сумму двух параметров:

.section.text, “x”

.globaladd @ give the symbol “add” externallinkage

add:

ADD r0, r0, r1 @ add input arguments

MOV pc, lr @ return from subroutine

@ endof program

Примечание:

l Инструкции ARM, псевдоинструкции, псевдооперации, имена регистров могут состоять из прописных или строчных букв,Но не смешанный случай。

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

1.2 Символ (или метка) в ассемблере GNU

Метка может быть только от А до Я, от А до Я, от 0 до 9 «..«, _ И т. Д. (Состоит из точек, букв, цифр, подчеркиваний и т. Д., Кроме локальных меток, не может начинаться с цифр) символов.

Суть символа: представляетПоэтому адрес, по которому он расположен, также может использоваться как переменная или функция.

l Значение адреса метки в сегменте определяется при сборке;

l Значение адреса метки вне сегмента определяется во время подключения.

Классификация символов: 3 типа (по методу генерации меток).

<1> ПК-этикетка.Метка на основе ПК — это метка перед целевой инструкцией или метка перед псевдооперацией определения данных в программе.Эта метка будет преобразована в значение ПК плюс (или минус) числовую константу во время сборки,Обычно используется для указания команд перехода”b”Адрес назначения и т. Д.,Или небольшое количество данных, встроенных в сегмент кода.

<2> Регистр на основе метки. Метки на основе регистров обычно определяются MAP и FIELD, а также могут быть определены EQU. Эта метка будет преобразована в значение регистра плюс (или минус) числовую константу во время сборки, которая часто используется для доступа к данным в сегменте данных.

<3> Абсолютный адрес.Абсолютный адрес — это 32-битные данные.Диапазон адресов: [0, 232-1], то есть все пространство памяти может быть адресовано напрямую.

Специальное примечание:Местный символ

Местные метки в основном используются в местном масштабе,И местные ярлыки могут появляться неоднократно。Он состоит из двух частей:Он начинается с прямого числа 0-99, за которым следует символ, который обычно указывает область действия локальной переменной.Область локальных переменных обычно является текущим сегментом, вы также можете использоватьROUTОпределить область применения локальных переменных.

Синтаксический формат определения локальной переменной:N{routname}

l N: Это число от 0 до 99.

l Rouname: имя текущей локальной области (символ), обычно имя области переменной (Определяется с помощью псевдооперации ROUT）。

Синтаксический формат ссылки на локальную переменную:%{F|B}{A|T}N{routname}

l %: Указывает на справочную операцию

l N: номер локальной переменной

l Rouname: имя текущей области (Определяется с помощью псевдооперации ROUT）

l F: поручить компилятору искать только вперед

l B: поручить компилятору искать только в обратном направлении

l A: Поручить компилятору искать все уровни вложенности макроса

l T: поручить компилятору искать текущий уровень макроса

Пример: пример использования локальных символов, программа цикла

subsr0, r0, # 1 @ каждый цикл составляет r0 = r0-1

bne 1F @Перейти к 1 метке для выполнения

Примечание:

l Если ни F, ни B не указаны, компилятор сначала ищет вперед, а затем назад

l Если не указаны ни A, ни T, компилятор ищет все текущие уровни до самого высокого уровня макроса, и уровни ниже текущего уровня больше не ищутся.

l Если указано имя маршрута, компилятор выполняет поиск самой последней псевдо операции ROUT.Если имя маршрута не совпадает с именем, определенным псевдо операцией ROUT, компилятор сообщает об ошибке, и сборка завершается неудачно.

1.3 Сегментация в ассемблере GNU

<1> псевдооперация .section

.section <section_name> {,”<flags>”}

Startsa new code or data section. Sections in GNU are called .text, a code section, .data, an initializeddata section, and .bss, an uninitialized data section.

Thesesections have default flags, and the linker understands the default names(similardirective to the armasm directive AREA).The following are allowable.section flagsfor ELF format files:

<Flag> Meaning

a allowable section

w writable section

x executable section

Китайское объяснение:

Пользователь может настроить раздел с помощью псевдооперации .section,Формат выглядит следующим образом:

.section section_name [,»flags»[, %type[,flag_specific_arguments]]]

Каждый сегмент начинается с имени сегмента и заканчивается следующим именем сегмента или концом файла.Эти сегменты имеют флаги по умолчанию，Разъем может распознавать эти метки.(То же, что ОБЛАСТЬ в руке). Ниже приведены допустимые сегменты в формате ELF.flags：

Значение <Logo>

разрешенный раздел

w записываемый сегмент

х Исполнительный раздел

Пример: определить «сегмент»

.section.mysection @Пользовательский сегмент данныхНазвание раздела “.mysection”

.align 2

strtemp:

.ascii «Temp string n» @Чтобы понять это предложение, я думаю, что это должно быть: сохранить строку «Temp string n 0» в разделе пространства памяти, начинающемся с метки strtemp

<2> Предопределенные имена сегментов системы сборки

l .text @Фрагмент кода

l .data @Инициализировать сегмент данных.data Read-write initialized long data.

l .bss @Неинициализированный сегмент данных

l .sdata @ .sdata Read-write initialized short data.

l .sbss @

Примечание:Раздел .bss в исходной программе должен находиться перед разделом .text.

1.4 Точка входа в определение языка ассемблера GNU

Запись по умолчанию для ассемблера_startЭтикетка,Пользователи также могут использовать флаг ENTRY для указания других точек входа в сценарии подключения.。

Пример: определение точки входа

.section .data

< initialized data here>

.section .bss

< uninitialized data here>

.section .text

.globl _start

_start:

<instruction code goes here>

1.5 Определение макро в ассемблере GNU

Формат выглядит следующим образом:

Макро имя макроса имя параметра @Директива. Макрос определяет макрос

Макро тело

.endm @.endmУказывает конец макроса

Если макрос использует параметр, добавьте префикс при использовании параметра в теле макроса“”。Параметры, используемые в определении макроса, также могут использовать значения по умолчанию.Вы можете использовать директиву .exitm для выхода из макроса.

Пример: определение макроса

.macroSHIFTLEFT a, b

.if b< 0

MOV a,a, ASR #-b

.exitm

.endif

MOV a,a, LSL #b

.endm

1.6 Константы в ассемблере GNU

<1> Десятичные числа начинаются с ненулевых цифр, таких как: 123 и 9876;

<2> Двоичное число начинается с 0b, и буквы также могут быть заглавными;

<3> Восьмеричное число начинается с 0, например: 0456,0123;

<4> Шестнадцатеричные числа начинаются с 0x, например: 0xabcd, 0X123f;

<5> Строковые константы должны быть заключены в кавычки, а в середине можно также использовать escape-символы, такие как: «Добро пожаловать! N»;

<6> Текущий адрес начинается с «.«Означает, что вGNUЭтот символ может использоваться в ассемблере для представления адреса текущей инструкции;

<7> Выражение: выражение в ассемблере может использовать постоянное или числовое значение, «-» означает взятие отрицательного числа, «~» означает дополнение, «<>» означает не равно, другие символы, такие как: +, -, *, ,%, <, <<,>, >>, |, &, ^,!, ==,> =, <=, &&, || аналогичны использованию в языке Си.

1.7 Общие псевдо-операции сборки GNU ARM

Некоторые операции были упомянуты ранее, и следующие операции:

l Псевдооперация определения данных: .byte, .short, .long, .quad, .float, .string / .asciz / .ascii, многократно определяют псевдо-операции.rept, оператор присваивания .equ / .set;

l Определение функции

l Выравнивание псевдооперации .align；

l Псевдо-операция завершения исходного файла .end;

l .включить псевдооперацию;

l если псевдо операция

l псевдооперация .global / .globl;

l .type псевдооперация;

l Оператор управления списком;

Отличается отGNUASОбщие псевдо-операции сборки, следующие ARM-специфические псевдо-операции:

.reg ，.unreq，.code ，.thumb ，.thumb_func，.thumb_set， .ltorg，.pool

<1> Псевдооперация определения данных

l .byte: однобайтовое определение, например: .byte1,2,0b01,0x34,072, ‘s’;

l .short: определяет двухбайтовые данные, такие как: .short 0x1234,60000;

l .long: определяет 4 байта данных, например: .long0x12345678,23876565

l .quad: определить 8 байтов, например: .quad 0x1234567890abcd

l .float: определить числа с плавающей запятой, такие как: .float0f-314159265358979323846264338327

95028841971.693993751E-40 @ — pi

l .string / .asciz / .ascii: определить несколько строк, например:

.string «abcd»,»efgh», «hello!»

.asciz «qwer»,»sun», «world!»

.ascii «welcome»

Примечание:Строка, определенная псевдооперацией ascii, должна добавить конечный символ ‘ 0’ сама по себе.

l .rept: неоднократно определять псевдооперацию, формат выглядит следующим образом:

.rept Количество повторений

Определение данных

.endr @Конец повторения определения

Пример:

.rept 3

.byte 0x23

.endr

l .equ / .set: оператор присваивания, формат которого следующий:

.equ(.set)Имя переменной, выражение

Пример:

.equ abc, 3 @Пусть abc = 3

<2> Псевдооперация определения функции

l Определение функции, формат выглядит следующим образом:

Имя функции:

Тело функции

Возврат заявления

В общемЕсли функцию необходимо вызывать в других файлах, необходимо использовать псевдооперацию .global для объявления функции как глобальной функции.Чтобы не вызывать путаницы, когда другие программы вызывают функцию C, нам нужно следить за использованием регистров.APCSРекомендации.Компилятор функций обработает код функции как код сборки .global.

l Написание функции должно следовать следующим правилам:

a. Регистры a1-a4 (параметры, регистры результата или временные регистры, синонимы от r0 до r3) и регистры с плавающей запятой f0-f3 (если есть сопроцессор с плавающей запятой) не обязательно сохраняются в функции;

b. Если функция возвращает значение, не превышающее размер слова, значение должно быть отправлено в конец функции в г0;

c. Если функция возвращает число с плавающей запятой, поместите его в регистр с плавающей запятой f0 в конце функции;

d. Если процесс функции меняет sp (указатель стека, r13), fp (указатель кадра, r11), sl (предел стека, r10), lr (регистр соединения, r14), v1-v8 (регистр переменной, r4 на r11) и f4-f7, тогда эти регистры должны быть восстановлены в конце функции, чтобы содержать значение, которое она удерживала при входе в функцию.

<3> псевдо-операция .align.end.include.incbin

l .align: Используется для указания выравнивания данных, формат выглядит следующим образом:

.align [absexpr1, absexpr2]

В некотором раскладеЗаполните значения в неиспользованном хранилище.Первое значение указывает на выравнивание,4, 8, 16 или 32.Второе значение выражения представляет заполненное значение.

l .end: указывает на конец исходного файла.

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

.include “myarmasm.h”

l Псевдооперация .incbin может скомпилировать неповрежденный двоичный файл в текущий файлИ способ использования заключается в следующем:

.incbin»file»[,skip[,count]]

skipОн указывает, что файл читается с начала файла, пропускает пропущенные байты, а count — это количество прочитанных слов.

<4> ..если псевдооперация

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

.if имеет несколько вариантов:

.ifdefsymbol @Определите, определен ли символ

.ifcstring1,string2 @Если строки string1 и string2 равны, строку можно заключить в одинарные кавычки

.ifeqexpression @Определите, равно ли значение выражения 0

.ifeqsstring1,string2  @Определите, равны ли string1 и string2, строка должна быть заключена в двойные кавычки

.ifgeexpression @Определите, является ли значение выражения больше или равно 0

.ifgtabsolute expression @ Определить, является ли значение выражения больше 0

.ifleexpression @Определите, является ли значение выражения меньше или равно 0

.ifltabsolute expression @Определите, является ли значение выражения меньше 0

.ifncstring1,string2  @Чтобы определить, не совпадают ли string1 и string2, их использование в точности противоположно .ifc.

.ifndefsymbol, .ifnotdef @ symbol @ Определить, не является ли символ определенным, как противоположность .ifdef

.ifneexpression @Если значение выражения не равно 0, то компилятор скомпилирует следующий код

.ifnesstring1,string2 @Если строки string1 и string2 не равны, компилятор скомпилирует следующий код.

<5> .global .type .title .list

l .global / .globl: используется для определения глобального символа, формат выглядит следующим образом:

.global symbol или .globl symbol

l .type：Используется для указания, является ли тип символа типом функции или типом объекта,Тип объекта, как правило, данные, Формат выглядит следующим образом:

 .typeСимвол, описание типа

Пример:

.globla

.data

.align4

.typea, @object

.sizea, 4

a:

.long10

Пример:

.section.text

.typeasmfunc, @function

.globlasmfunc

asmfunc:

mov pc,lr

<6> Контрольный оператор списка:

.title: Используется для указания заголовка списка сборки, например:

.title “my program”

.list: используется для вывода файла списка.

<7> ARM-специфичные псевдо-операции

l .reg: используется для присвоения псевдонима регистру, формат следующий:

Псевдонимы .req имя регистра

l .unreq: используется для отмены псевдонима регистра, формат выглядит следующим образом:

.unreq зарегистрировать псевдоним

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

l Псевдооперация .code используется для выбора набора команд ARM или Thumb, формат которого следующий:

.code выражение

Если значение выражения равно 16, это означает, что следующая инструкция является инструкцией Thumb, если значение выражения равно 32, это означает, что следующая инструкция является инструкцией ARM.

l Псевдооперация .thumb эквивалентна .code 16, указывая на то, что используется команда Thumb, и аналогичный .arm эквивалентен .code 32

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

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

l Псевдооперация .thumb_set аналогична .set, которую можно использовать для присвоения псевдониму флага. В дополнение к функции .set, флаг может быть помечен как вход в функцию thumb.

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

l .pool имеет тот же эффект, что и .ltorg

l .space<number_of_bytes> {,<fill_byte>}

Выделите число_байт_байт пространства данных и заполните его значением fill_byte. Если это значение не указано, по умолчанию заполняется 0. (Та же функция, что и у пробела в армасмах)

l .word <word1>{,<word2>} …Вставьте 32-битную очередь данных.(Та же функция, что и у DCD в армасмах)Вы можете использовать .word, чтобы использовать идентификатор как константу.

Пример:

Start:

valueOfStart:

.word Start

Таким образом, Start хранится в начале программыЗначение переменной памятиOfStartДюйм

l .hword<short1> {,<short2>} …

Вставьте 16-битную очередь данных. (То же, что DCW в оружии)

1.8 Специальные символы и синтаксис сборки GNU ARM

<1> Символ комментария в строке кода: ‘@’

<2> Весь символ комментария строки: ‘#’

<3> Символ разделения операторов: ‘‘; ’

<4> Немедленный префикс: ‘#’ или ‘$’

3. ARM GCC встроенная сборка

Для процессоров RISC на основе ARM компилятор GNUC обеспечивает функцию встроенной сборки в C-коде. Эта очень полезная функция предоставляет функции, которые не поддерживаются кодом C, такие как ручная оптимизация кода ключевых частей программного обеспечения и использование соответствующих инструкций процессора. Здесь предполагается, что читатель является специалистом по написанию ARM-ассемблера, поскольку этот документ не является руководством по сборке ARM. И это неЯзык CРуководство. В этом документе предполагается, что используется версия 4 GCC, но она действительна для более ранних версий.

GCCasm заявление

Давайте начнем с простого примера. Как и объявление в C, следующий код объявления может появиться в вашем коде.

/ * Пример NOP * /

asm(«movr0,r0»);

Цель этого утверждения — переместить r0 в r0. Другими словами, он ничего не делает. Типичной является инструкция NOP, роль — короткая задержка.

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

asm(

«mov r0, r0nt»

«mov r0, r0nt»

«mov r0, r0nt»

«mov r0, r0»

);

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

asm(code : output operand list : input operand list : clobberlist);

Связь между сборкой и оператором C осуществляется через необязательный список выходных операндов и список входных операндов в приведенном выше операторе asm., Клоббер списки позже.

Нижес языкомЦелочисленная переменная передается в сборку, и логика сдвигается влево на один бит перед передачей в другую целочисленную переменную на языке Си.

/* Rotating bits example */

asm(«mov %[result], %[value], ror #1» :[result] «=r» (y) : [value] «r» (x));

Каждое утверждение asm разделено на четыре части двоеточием (:).

Инструкции по сборке помещены в середине «» в первой части.

«mov %[result], %[value], ror #1»

Далее идет необязательный вывод и список после двоеточия,Каждая запись состоит из пары [] (квадратные скобки) и включенного в нее имени символа, за которым следует ограничительная строка, за которой следуют скобки и переменная C, заключенная в нее., В этом примере есть только одна запись.

[result] «=r» (y)

После двоеточия приведен список операторов ввода, его синтаксис такой же, как и список операций ввода

[value] «r» (x)

Список деструкторов, не использованный в этом примере

Как и в примере с NOP выше, в 4 частях оператора asmПока самая неиспользованная часть может быть опущена. Но есть одна вещь, которую следует отметить, это то, что пока используется последняя часть из 4-х частей, первая часть не может быть пропущена, если она не используется. Она должна быть пустой, но сохранять двоеточие, В следующем примере устанавливается регистр CPSR для ARMSoc, в котором есть входной, но нет выходного операнда.

asm(«msr cpsr,%[ps]» : : [ps]»r»(status))

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

asm(«»:::»memory»);

Чтобы повысить читабельность кода, вы можете использовать разрывы строк, пробелы и комментарии в стиле C。

asm(«mov %[result], %[value], ror#1»

: [result]»=r» (y) /*Rotation result. */

: [value]»r» (x) /*Rotated value. */

: /* No clobbers */

);

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

% [результат] представляет переменную С у второй части, а% [значение] представляет переменную С х трех частей;

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

asm(«mov %0, %1, ror #1″ :»=r» (result) : «r» (value))

В коде ассемблера ссылка операнда использует%, за которым следует число,% 1 представляет первый операнд,% 2 кодирует второй операнд и так далее. Этот метод в настоящее время поддерживается новейшими компиляторами. Но поддерживать код нелегко. Представьте, что вы написали много кода для инструкций по сборке. Если вы хотите вставить операнд, вам придется снова изменить номер операнда.

Оптимизировать код C

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

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

Ниже приведен пример кода.

[email protected]:~/embedded/basic-C$ arm-linux-gcc -c test.c

[email protected]:~/embedded/basic-C$ arm-linux-objdump -D test.o

Компилятор выбрал r3 в качестве циклического сдвига. Он также может выбрать распределение регистров для каждой переменной C. Загрузка или сохранение значения не выполняется явно. Ниже приведены результаты компиляции других компиляторов.

E420A0E1 mov r2, r4, ror #1 @ y, x

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

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

Вышеуказанные решения все еще доступны. ЭтоИспользуйте ключевое слово volatile. Его роль заключается в запрещении оптимизации оптимизатора, Модифицированный пример NOP выглядит следующим образом:

/* NOP example, revised */

asm volatile(«movr0, r0»);

Внизу нас ждут еще неприятности. Хорошо продуманный оптимизатор может изменить код. Посмотрите на код ниже:

i++;

if (j == 1)

x += 3;

i++;

Оптимизатор определенно реорганизует код, и два i ++ не влияют на условие if. Кроме того, значение i увеличивается на 2, и используется только одна инструкция по сборке ARM. Поэтому код должен быть реорганизован следующим образом:

if (j == 1)

x += 3;

i += 2;

Это сохраняет инструкцию ARM. Результат: эти операции не были одобрены.

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

asm volatile(«mrs r12,cpsrnt»

«orr r12, r12, #0xC0nt»

«msr cpsr_c, r12nt» ::: «r12», «cc»);

c *= b; /* This may fail. */

asm volatile(«mrs r12, cpsrn»

«bic r12, r12, #0xC0n»

«msr cpsr_c, r12» ::: «r12», «cc»);

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

Мы можем использовать clobberlist, чтобы помочь. Список Clobber в приведенном выше примере выглядит следующим образом:

«r12″,»cc»

Приведенный выше список clobber будет передавать следующую информацию компилятору, изменяя флаги r12 и регистр состояния программы. Между прочим, прямое указание используемых регистров, вероятно, помешает лучшим результатам оптимизации. Обычно вы просто передаете переменную и позволяете компилятору выбрать соответствующий регистр. Кроме того, имя регистра, cc (регистр условий, флаг регистра состояния) и память — все допустимые ключевые слова в списке клоббера.。Он используется для указания компилятору, что инструкция встроенной сборки изменила значение в памяти, Это заставит компилятор сохранить все кэшированные значения перед выполнением кода сборки, а затем перезагрузить значения после выполнения кода сборки. Это сохранит порядок выполнения программы, потому что после использования объявления asm с клоббером памяти содержимое всех переменных непредсказуемо.

asm volatile(«mrs r12,cpsrnt»

«orr r12, r12, #0xC0nt»

«msr cpsr_c, r12nt» :: : «r12», «cc»,»memory»);

c *= b; /* This is safe. */

asm volatile(«mrs r12, cpsrn»

«bic r12, r12, #0xC0n»

«msr cpsr_c, r12» ::: «r12», «cc»,»memory»);

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

asm volatile(«mrs r12,cpsrnt»

«orr r12, r12, #0xC0nt»

«msr cpsr_c, r12nt» : «=X» (b) :: «r12″,»cc»);

c *= b; /* This is safe. */

asm volatile(«mrs r12

Первый asm выше пытается сначала изменить переменную b, а второй asm пытается изменить c. Это сохранит порядок выполнения трех операторов без аннулирования кэшированных переменных.

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

Input and output operands

Как мы узнали ранее, каждый операнд ввода и вывода состоит из символического имени, заключенного в квадратные скобки [], строки с ограничениями и выражения C в скобках.

Что это за ограничительные строки и зачем они нам нужны? Вы должны знать, что каждая инструкция по сборке принимает только определенные типы операндов. Например: целевой адрес перехода, ожидаемый инструкцией перехода. Не все адреса памяти являются действительными. Потому что окончательный код операции принимает только 24-битное смещение. Но противоречие состоит в том, что и команда перехода, и команда обмена данными ожидают, что 32-разрядный целевой адрес будет сохранен в регистре. Во всех случаях указатель функции может быть передан от C к операнду. Таким образом, перед лицом констант, указателей и переменных, передаваемых встроенной сборке, компилятор должен знать, как организовать его в код сборки.

Для основных процессоров ARM GCC предоставляет следующие ограничения.

Constraint	Usage in ARM state	Usage in Thumb state
f	Floating point registers f0 .. f7	Not available
G	Immediate floating point constant	Not available
H	Same a G, but negated	Not available
I	Immediate value in data processing instructions e.g. ORR R0, R0, #operand	Constant in the range 0 .. 255 e.g. SWI operand
J	Indexing constants -4095 .. 4095 e.g. LDR R1, [PC, #operand]	Constant in the range -255 .. -1 e.g. SUB R0, R0, #operand
K	Same as I, but inverted	Same as I, but shifted
L	Same as I, but negated	Constant in the range -7 .. 7 e.g. SUB R0, R1, #operand
l	Same as r	Registers r0..r7 e.g. PUSH operand
M	Constant in the range of 0 .. 32 or a power of 2 e.g. MOV R2, R1, ROR #operand	Constant that is a multiple of 4 in the range of 0 .. 1020 e.g. ADD R0, SP, #operand
m	Any valid memory address
N	Not available	Constant in the range of 0 .. 31 e.g. LSL R0, R1, #operand
o	Not available	Constant that is a multiple of 4 in the range of -508 .. 508 e.g. ADD SP, #operand
r	General register r0 .. r15 e.g. SUB operand1, operand2, operand3	Not available
W	Vector floating point registers s0 .. s31	Not available
X	Any operand
= ：Write-only operand, usually used for all output operands + ：Read-write operand, must be listed as an output operand & ：A register that should be used for output only

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

Более строгое правило: не пытайтесь писать во входной операнд. Но если вы хотите использовать тот же операнд, что и для ввода и вывода. Ограничительный модификатор (+) может добиться эффекта. Примеры следующие:

asm(«mov %[value], %[value], ror #1″ : [value]»+r» (y))

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

Возможно, модификатор + не поддерживает более ранние версии компилятора. К счастью, здесь представлены другие решения, и этот метод все еще действует в последних компиляторах.Для операторов ввода можно использовать одно число n в ограниченной строке. Используйте число n, чтобы указать компилятору использовать n-й операнд, операнд начинает считать с 0, Вот пример:

asm(«mov %0, %0, ror #1» : «=r» (value) :»0″ (value))

Ограничительная строка «0» указывает компилятору использовать тот же регистр ввода, что и первый оператор вывода.

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

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

asm volatile(«ldr %0, [%1]»»nt»

«str %2, [%1, #4]»»nt»

: «=&r» (rdv)

: «r»(&table), «r» (wdv)

: «memory»);

Прочитайте значение в таблице, а затем запишите в другое место в таблице.

другое

Встроенная сборка как макрос предварительной обработки

Если вы часто используете частичную сборку, лучше всего определить ее в заголовочном файле в виде макроса. Использование этого заголовочного файла вызовет предупреждение в строгом режиме ANSI. Во избежание таких проблем, Вы можете использовать __asm__ вместо asm, __volatile__ вместо volatile, Это может быть эквивалентно псевдониму. Вот рутина:

#define BYTESWAP(val) 

__asm__ __volatile__ ( 

«eor r3, %1, %1, ror #16nt» 

«bic r3, r3, #0x00FF0000nt» 

«mov %0, %1, ror #8nt» 

«eor %0, %0, r3, lsr #8» 

: «=r» (val) 

: «0»(val) 

: «r3», «cc» 

);

Функция C ворс

Определение макроса содержит тот же код. Это недопустимо в больших процедурах. В этом случае лучше определить функцию-заглушку.

unsigned long ByteSwap(unsigned longval)

{

asm volatile (

«eor r3, %1, %1, ror #16nt»

«bic r3, r3, #0x00FF0000nt»

«mov %0, %1, ror #8nt»

«eor %0, %0, r3, lsr #8»

: «=r» (val)

: «0»(val)

: «r3»

);

return val;

}

Заменить символическое имя переменной C

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

unsigned long value asm(«clock») = 3686400

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

Заменить символическое имя функции C

Чтобы изменить имя функции, вам нужно объявление прототипа, потому что компилятор не принимает ключевое слово asm в определении функции.

extern long Calc(void) asm («CALCULATE»)

Вызов функции calc () создаст инструкцию по сборке, которая вызывает функцию CALCULATE.

Принудительное использование определенных регистров

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

void Count(void) {

register unsigned char counterasm(«r3»);

… some code…

asm volatile(«eor r3, r3,r3»);

… more code…

}

Инструкция по сборке «eor r3, r3, r3» очистит r3. Waring: этот пример проблематичен в большинстве случаев, потому что он конфликтует с оптимизатором. Потому что GCC не будет резервировать другие регистры. Если оптимизатор считает, что переменная некоторое время не использовалась, регистр будет использоваться снова. Но у компилятора нет возможности проверить, не конфликтует ли он с предопределенными регистрами компилятора. Если вы укажете слишком много регистров таким образом, компилятор исчерпает регистры во время генерации кода.

Регистр временного пользования

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

asm volatile(

«ands r3, %1, #3» «nt»

«eor %0, %0, r3» «nt»

«addne %0, #4»

: «=r» (len)

: «0» (len)

: «cc», «r3»

);

Лучший способ — использовать функции-заглушки и использовать локальные временные переменные.

Цель регистрации

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

Register	Alt. Name	Usage
r0	a1	First function argument Integer function result Scratch register
r1	a2	Second function argument Scratch register
r2	a3	Third function argument Scratch register
r3	a4	Fourth function argument Scratch register
r4	v1	Register variable
r5	v2	Register variable
r6	v3	Register variable
r7	v4	Register variable
r8	v5	Register variable=
r9	v6	rfp Register variable Real frame pointer
r10	sl	Stack limit
r11	fp	Argument pointer
r12	ip	Temporary workspace
r13	sp	Stack pointer
r14	lr	Link register Workspace
r15	pc	Program counter

Related Manuals for ARM Cortex-M4

Время на прочтение
6 мин

Количество просмотров 127K

Привет всем!
По роду деятельности я программист на Java. Последние месяцы работы заставили меня познакомиться с разработкой под Android NDK и соответственно написание нативных приложений на С. Тут я столкнулся с проблемой оптимизации Linux библиотек. Многие оказались абсолютно не оптимизированы под ARM и сильно нагружали процессор. Ранее я практически не программировал на ассемблере, поэтому сначала было сложно начать изучать этот язык, но все же я решил попробовать. Эта статья написана, так сказать, от новичка для новичков. Я постараюсь описать те основы, которые уже изучил, надеюсь кого-то это заинтересует. Кроме того, буду рад конструктивной критике со стороны профессионалов.

Введение

Итак, для начала разберёмся что же такое ARM. Википедия дает такое определение:

Архитектура ARM (Advanced RISC Machine, Acorn RISC Machine, усовершенствованная RISC-машина) — семейство лицензируемых 32-битных и 64-битных микропроцессорных ядер разработки компании ARM Limited. Компания занимается исключительно разработкой ядер и инструментов для них (компиляторы, средства отладки и т. п.), зарабатывая на лицензировании архитектуры сторонним производителям.

Если кто не знает, сейчас большая часть мобильных устройств, планшетов разработаны именно на этой архитектуре процессоров. Основным преимуществом данного семейства является низкое энергопотребление, благодаря чему он часто используется в различных встроенных системах. Архитектура развивалась с течением времени, и начиная с ARMv7 были определены 3 профиля: ‘A’(application) — приложения, ‘R’(real time) — в реальном времени,’M’(microcontroller) — микроконтроллер. Историю разработки этой технологии и другие интересный данные вы можете прочитать в Википедии или погуглив в интернете. ARM поддерживает разные режимы работы (Thumb и ARM, кроме того в последние время появился Thumb-2, являющийся смесью ARM и Thumb). В данной статье рассмотрим собственно режим ARM, в котором исполняется 32-битный набор команд.

Каждый ARM процессор создан из следующих блоков:

• 37 регистров (из которых видимых при разработке только 17)
• Арифметико-логи́ческое устройство (АЛУ) — выполняет арифметические и логические задачи
• Barrel shifter — устройство, созданное для перемещения блоков данных на определенное количество бит
• The CP15 — специальная система, контроллирующая ARM сопроцессоры
• Декодер инструкций — занимается преобразованием инструкции в последовательность микроопераций

Это не все составляющие ARM, но углубление в дебри построения процессоров не входит в тему данной статьи.

Конвейерное исполнение (Pipeline execution)

В ARM процессорах используется 3-стадийный конвейер (начиная с ARM8 был реализова 5-стадийный конвейер). Рассмотрим простой конвейер на примере процессора ARM7TDMI. Исполнение каждой инструкции состоит из трёх ступеней:

1. Этап выборки (F)
На этом этапе инструкции поступают из ОЗУ в конвейер процессора.
2. Этап декодирования (D)
Инструкции декодируются и распознаётся их тип.
3. Этап исполнения (E)
Данные поступают в ALU и исполняются и полученное значение записывается в заданный регистр.

Но при разработке надо учитывать, что, есть инструкции, которые используют несколько циклов исполнения, например, load(LDR) или store. В таком случае этап исполнения (E) разделяется на этапы (E1, E2, E3…).

Условное выполнение

Одна из важнейших функций ARM ассемблера — условное выполнение. Каждая инструкция может исполняться условно и для этого используются суффиксы. Если суффикс добавляется к названию инструкции, то прежде чем выполнить ее, происходит проверка параметров. Если параметры не соответствуют условию, то инструкция не выполняется. Суффиксы:
MI — отрицательное число
PL — положительное или ноль
AL — выполнять инструкцию всегда
Суффиксов условного выполнения намного больше. Остальные суффиксы и примеры прочитать в официальной документации: ARM документация
А теперь пришло время рассмотреть…

Основы синтаксиса ARM ассемблера

Тем, кто раньше работал с ассемблером этот пункт можно фактически пропустить. Для всех остальных опишу основы работы с этим языком. Итак, каждая программа на ассемблере состоит из инструкций. Инструкция создаётся таким образом:
{метка} {инструкция|операнды} {@ комментарий}
Метка — необязательный параметр. Инструкция — непосредственно мнемоника инструкции процессору. Основные инструкции и их использование будет разобрано далее. Операнды — константы, адреса регистров, адреса в оперативной памяти. Комментарий — необязательный параметр, который не влияет на исполнение программы.

Имена регистров

Разрешены следующие имена регистров:
1.r0-r15

2.a1-a4

3.v1-v8 (переменные регистры, с r4 по r11)

4.sb and SB (статический регистр, r9)

5.sl and SL (r10)

6.fp and FP (r11)

7.ip and IP (r12)

8.sp and SP (r13)

9.lr and LR (r14)

10.pc and PC (программный счетчик, r15).

Переменные и костанты

В ARM ассемблере, как и любом (практически) другом языке программирования могут использоваться переменные и константы. Они разделяются на такие типы:

• Числовые
• Логические
• Строковые

Числовые переменные инициализируются так:
a SETA 100; создается числовая переменная «a» с значением 100.
Строковые переменные:
improb SETS «literal»; создается переменная improb с значение «literal». ВНИМАНИЕ! Значение переменной не может превышать 5120 символов.
В логических переменных соответственно используются значения TRUE и FALSE.

Примеры инструкций ARM ассемблера

В данной таблице я собрал основные инструкции, которая потребуется для дальнейшей разработки (на самом базовом этапе:):

Название	Синтаксис	Применение
ADD (добавление)	ADD r0, r1, r2	r0 = r1 + r2
SUB (вычитание)	SUB r0, r1, r2	r0 = r1 — r2
RSB (обратное вычитание)	RSB r0, r1, #10	r0 = 10 — r1
MUL (умножение)	MUL r0, r1, r2	r0 = r1 * r2
MOV	MOV r0, r1	r0 = r1
ORR( логическая операция)	ORR r0, r1, r2	r0 = r1 | r2
TEQ	TEQ r0, r1	r0 == r1
LDR (загрузка)	LDR r4, [r5]	r4 = *r5
STR	STR r4, [r5]	*r5 = r4
ADR	ADR r3, a	a — переменная. r3 = &a

Чтобы закрепить использование основных инструкций давайте напишем несколько простых примеров, но сначала нам понадобится arm toolchain. Я работаю в Linux поэтому выбрал: frank.harvard.edu/~coldwell/toolchain (arm-unknown-linux-gnu toolchain). Ставится он проще простого, как и любая другая программа на Linux. В моем случае (Russian Fedora) понадобилось только установить rpm пакеты с сайта.
Теперь пришло время написать простейший пример. Программа будет абсолютно бесполезной, но главное, что будет работать:) Вот код, который я вам предлагаю:

start:                       @ Необязательная строка, обозначающая начало программы
        mov   r0, #3         @ Грузим в регистр r0 значение 3
        mov   r1, #2         @ Делаем тоже самое с регистром r1, только теперь с значением 2
        add   r2, r1, r0     @ Складываем значения r0 и r1, ответ записываем в r2
        mul   r3, r1, r0     @ Умножаем значение регистра r1 на значение регистра r0, ответ записываем в r3
stop:   b stop               @ Строка завершения программы

Компилируем программу до получения .bin файла:

/usr/arm/bin/arm-unknown-linux-gnu-as -o arm.o arm.s
/usr/arm/bin/arm-unknown-linux-gnu-ld -Ttext=0x0 -o arm.elf arm.o
/usr/arm/bin/arm-unknown-linux-gnu-objcopy -O binary arm.elf arm.bin

(код в файле arm.s, а toolchain в моем случае лежит в директории /usr/arm/bin/)
Если все прошло успешно, у вас будет 3 файла: arm.s (собственно код), arm.o, arm.elf, arm.bin (собственно исполняемая программа). Для того, чтобы проверить работу программы не обязательно иметь собственное arm устройство. Достаточно установить QEMU. Для справки:

QEMU — свободная программа с открытым исходным кодом для эмуляции аппаратного обеспечения различных платформ.

Включает в себя эмуляцию процессоров Intel x86 и устройств ввода-вывода. Может эмулировать 80386, 80486, Pentium, Pentium Pro, AMD64 и другие x86-совместимые процессоры; PowerPC, ARM, MIPS, SPARC, SPARC64, m68k — лишь частично.

Работает на Syllable, FreeBSD, FreeDOS, Linux, Windows 9x, Windows 2000, Mac OS X, QNX, Android и др.

Итак, для эмуляции arm понадобится qemu-system-arm. Этот пакет есть в yum, так что тем, у кого Fedora, можно не заморачиваться и просто выполнить комманду:
yum install qemu-system-arm

Далее надо запустить эмулятор ARM, так, чтобы он выполнил нашу программу arm.bin. Для этого создадим файл flash.bin, который будет флэш памятью для QEMU. Сделать это очень просто:

dd if=/dev/zero of=flash.bin bs=4096 count=4096
dd if=arm.bin of=flash.bin bs=4096 conv=notrunc

Теперь грузим QEMU с полученой flash памятью:

qemu-system-arm -M connex -pflash flash.bin -nographic -serial /dev/null

На выходе вы получите что-то вроде этого:

[anton@localhost ~]$ qemu-system-arm -M connex -pflash flash.bin -nographic -serial /dev/null
QEMU 0.15.1 monitor — type ‘help’ for more information
(qemu)

Наша программа arm.bin должна была изменить значения четырех регистров, следовательно для проверки правильности работы давайте посмотрим на эти самые регистры. Делается это очень простой коммандой: info registers
На выходе вы увидите все 15 ARM регистров, при чем у четырех из них будут измененные значения. Проверьте:) Значения регистров совпадают с теми, которые можно ожидать после исполнения программы:

(qemu) info registers
R00=00000003 R01=00000002 R02=00000005 R03=00000006
R04=00000000 R05=00000000 R06=00000000 R07=00000000
R08=00000000 R09=00000000 R10=00000000 R11=00000000
R12=00000000 R13=00000000 R14=00000000 R15=00000010
PSR=400001d3 -Z-- A svc32

P.S. В этой статье я постарался описать основы программирования на ARM ассемблер. Надеюсь вам понравилось! Этого хватит для того, чтобы далее углубляться в дебри этого языка и писать на нем программы. Если все получится, буду писать дальше о том, что узнаю сам. Если есть ошибки, прошу не пинать, так как я новичок в ассемблере.

Автор
проекта
Виниченко А.В.