Язык ассемблера 16-битного процессора. Справочник

Документ описывает входной язык ассемблера для процессора по спецификации cpu16_spec_r6 (ревизия 6) и служит нормативным описанием для реализации ассемблера. Слова «должен», «запрещено», «ошибка» нормативные. Остальное пояснения и примеры.

Нумерация разделов «Спецификация, разд. N» ссылается на документ архитектуры.

1. Структура исходного файла

Файл состоит из строк. Каждая строка имеет вид:

[метка:] [команда или директива] [; комментарий]

• Любая часть может отсутствовать. Пустые строки и строки только с комментарием допустимы.
• Комментарий начинается с ; и идёт до конца строки (кроме ; внутри строкового или символьного литерала).
• Начало строки (колонка) значения не имеет, пробелы и табуляции между токенами произвольны.
• На строке не более одной команды или директивы. Метка может стоять на отдельной строке или перед командой и директивой.
• Продолжения строк нет.
• Кодировка исходника — UTF-8. В комментариях допустимы любые символы. Строковые и символьные литералы перекодируются в кодировку машины (см. «Строки и символы»).

        .org    0          ; директива
start:  LD      SP, #$FF00 ; метка, команда, комментарий
loop:                      ; метка отдельно
        JMP     loop

Регистр символов

2. Лексика

Идентификаторы

• Глобальный идентификатор: [A-Za-z_][A-Za-z0-9_]*.
• Локальная метка: @ и идентификатор, например @loop (см. разд. 4).
• Зарезервированы и не могут быть именами меток и символов: имена регистров (разд. 5), все мнемоники (включая псевдокоманды, разд. 7) и функции lo, hi.

Числа

Правило для $: если сразу за $ идёт шестнадцатеричная цифра, это число. Иначе $ обозначает счётчик адреса (разд. 3). % в начале операнда или после оператора начинает двоичное число. Оператора остатка от деления нет.

Строки и символы

• Строка: "...". Символ: 'x', значение равно коду символа в кодировке машины.
• Кодировка. Символы строк и символьных литералов перекодируются из UTF-8 в кодировку машины («Машина CPU16: память и устройства», разд. 5): ASCII, кириллица А–я и ёЁ, псевдографика (рамки, блоки), значки (☺ ♥ → ▲…). Символ, которого в кодировке нет (например €, «, №), — ошибка character '€' is not in the CPU16 character set; неверная последовательность UTF-8 — ошибка invalid UTF-8 in string.
• Escape-последовательности (в строках и символах): \n (10), \r (13), \t (9), \0 (0), \\, \", \', \xHH (два шестнадцатеричных знака). Они задают байт напрямую, без перекодировки.
• Строки допустимы только в директивах .ascii, .asciz и .include. Имя файла в .include не перекодируется.

msg:    .asciz  "Привет, ёлка! ╔═╗"     ; кириллица и рамки - в кодировке машины
        .byte   'Ж', '\xD0'             ; $C6 и байт $D0 напрямую

3. Выражения

Выражение вычисляется в знаковой целочисленной арифметике не уже 32 бит. Допустимы числа, символы, метки, $ и вызовы функций.

• Скобки ( ) меняют порядок.
• lo(x) равно x & $FF, hi(x) равно (x >> 8) & $FF.
• $ значение адреса первого байта текущей команды или директивы.
• Регистры в выражениях запрещены.
• Деление на нуль, сдвиг на число вне 0..31, незакрытая скобка ошибки.
• Значение метки равно её адресу (0..65535).

Приведение к приёмнику

Итоговое значение должно помещаться в приёмник, иначе ошибка. Отрицательные значения записываются в дополнительном коде.

4. Символы и метки

• Метка имя: получает значение счётчика адреса с учётом неявного выравнивания (разд. 9): метка перед командой или .word всегда чётна. Определять метку дважды ошибка. Метка может использоваться до определения (ссылка вперёд).
• Локальная метка @имя: существует между двумя ближайшими глобальными метками (от предыдущей глобальной метки до следующей, не включая её). В разных областях одно и то же @имя разные метки. Локальная метка до первой глобальной принадлежит «безымянной» области.
• Константа .equ имя, выражение. Выражение может ссылаться на метки и константы, в том числе определённые ниже. Циклические определения ошибка.
• Имя символа должно быть уникальным среди меток и констант.

        .equ    CONSOLE, $FF20
        .equ    IF_BIT, $08

start:  LD      R0, #1
@wait:  SUB     R0, #1
        JNZ     @wait        ; локальная метка внутри start
other:  JMP     @wait        ; ошибка: в этой области @wait не определена

5. Регистры

Имена-синонимы полностью равноправны: SP и R13 дают одну и ту же кодировку.

6. Операнды и режимы адресации

Слово команды: OPCODE:5 R1:4 R2:4 R2MOD:3 (старший бит слева). Операнд-источник («второй операнд») определяет поля R2 и R2MOD и, возможно, второе слово disp.

Правила:

• Пробелы внутри скобок и вокруг +, -, ++, -- допустимы.
• Если первым токеном в скобках или в операнде стоит имя регистра, это регистровая форма. Иначе это выражение.
• Для Rn-выр смещение равно −выр (по модулю 2^16).
• Шаг ++/-- равен 2 для словных команд и 1 для байтовых (LDZX, LDSX, STB, XCHB).
• Запись [IP++] в исходном тексте запрещена: непосредственное значение задаётся только как #выр.
• Для переходов дополнительные формы описаны в разд. 7.5.
• Поле R2 при MOD=5 не используется и обязано быть нулём (Спецификация, разд. 3). Ассемблер всегда кодирует его нулём.

Выбор формы #выр

Для команд LD, MOV, ADD, ADC, SUB, SBC, AND, OR, XOR, CMP, TEST:

• значение вычислено и лежит в 0..15 — короткая форма (MOD=1, одно слово);
• иначе — длинная форма (MOD=3, R2=IP, два слова). Значение должно помещаться в слово (−32768..65535).

Решение принимается ассемблером по правилам разд. 10. Для остальных команд форма фиксирована, см. ниже.

7. Команды

Общее правило порядка операндов: в команде ОП Ra, B первый операнд занимает поле R1, второй поле R2/MOD (+ второе слово). Исключение составляют команды записи и обмена со словом ST, STB, XCHB: там первым пишется адрес в памяти, вторым регистр, причём регистр попадает в R1 (как и в псевдокоманде PUSH).

7.1. Загрузка, выгрузка, обмен

• src любая форма из таблицы разд. 6 с ограничениями разд. 8.
• mem одна из [Rn], [Rn++], [--Rn], [выр], [Rn+выр].
• LDZX/LDSX: #выр допустимо только как короткая константа 0..15 (MOD=1), форма Rn+выр недопустима. LDZX Rd, Rs берёт младший байт регистра.

        LD      R1, R2           ; копия регистра
        LD      R3, #1000        ; длинная константа
        LDZX    R0, [R4++]       ; байт с постинкрементом на 1
        LDSX    R0, [R4+2]
        ST      [$0200], R1      ; слово по абсолютному адресу
        STB     [R5], R0         ; младший байт R0
        XCHB    [lock], R1       ; атомарный обмен байтом

7.2. Арифметика и логика

NEG, NOT, BSX имеют один операнд и кодируются сборным опкодом MISC: операция в поле R2, поле R2MOD равно 0, команда однословная.

MUL, MULHU, DIVU, REMU - обычные команды группы АЛУ: допустимы все формы операнда, #выр выбирается короткой или длинной формой так же, как у ADD. Деление на 0 исключения не вызывает: DIVU даёт $FFFF, REMU оставляет делимое, OF = 1 (проверка - JO). Знаковых вариантов нет, они выполняются программно.

        ADD     R0, R1           ; регистр
        ADD     R0, #5           ; короткая константа
        SUB     R2, [R3]         ; из памяти
        AND     R0, #$00FF       ; длинная константа
        CMP     R0, #0
        TEST    R1, R1
        NEG     R2
        MUL     R0, #10          ; умножение на константу
        DIVU    R1, [R3]         ; делитель из памяти
        JO      div_by_zero

7.3. Сдвиги

cnt это #выр (только 0..15, всегда MOD=1) или регистр Rn (используются младшие 4 бита). Другие формы операнда допустимы по общим правилам (память, Rn+выр), но на практике не применяются.

        SHL     R0, #4
        SHR     R0, R1           ; на число из R1
        ROR     R2, #8           ; обмен байтов слова

7.4. Псевдокоманды

Псевдокоманды раскрываются в реальные команды без собственного опкода.

• INC и DEC, в отличие от многих процессоров, меняют и CF.

• Псевдокоманды работы с флагами однословные и атомарные. Их действие на флаги (Спецификация, разд. 2.2):

  Псевдокоманда	ZF	CF	SF	IF	OF
  STI	—	—	—	1	—
  CLI	—	—	—	0	0
  STC	—	1	—	—	—
  CLC	—	0	—	—	0
  CMC	—	инверсия	—	—	—

  «—» означает, что флаг не меняется.

• Побочный эффект: CLI и CLC обнуляют OF. Любая команда AND FLAGS с короткой константой обнуляет OF, потому что у короткой константы бит 4 (OF) нулевой. Если OF нужно сохранить, пишите длинную форму явно: AND FLAGS, #$FFF7 вместо CLI, AND FLAGS, #$FFFD вместо CLC (по 2 слова, без побочных эффектов).

• TEST FLAGS, #$08 (проверка IF) перезаписывает ZF, CF, SF, OF: ZF=1, если IF=0, остальные три обнуляются.

• PUSH SP кладёт значение SP до уменьшения. POP SP загружает SP из стека.

7.5. Передача управления

Целью является значение операнда (адрес). Поле R1 хранит условие (Jxx) или игнорируется (CALL).

CALL цель записывает адрес следующей команды в LR и переходит. Стек не используется.

Формы цели

Недопустимы [Rn++] и [--Rn].

Автоматический выбор для выр (цель T, $ адрес команды):

• Цель T должна быть чётной (ошибка, если нечётна).
• Короткая форма для Jxx (команда JR, опкод 6): слово 6<<11 | cond<<7 | (k & $7F), где k = (T − ($+2)) / 2, допустима при −64 ≤ k ≤ 63. Одно слово.
• Короткая форма для CALL: MOD=1, R2 = k & 15, допустима при −8 ≤ k ≤ 7. Одно слово.
• Длинная относительная форма (и для Jxx, и для CALL): MOD=7, R2=14 (IP), disp = (T − ($+4)) & $FFFF. Два слова.
• Форму Jxx с MOD=1 (±8 слов) ассемблер не порождает: JR покрывает тот же диапазон и шире. Отдельной мнемоники JR в языке нет: короткую форму условного перехода выбирает ассемблер.
• Абсолютную форму ассемблер сам не выбирает, её задают явно через #выр.

        JMP     start            ; авто
        JNZ     loop
        CALL    func
        JMP     R3               ; по регистру
        JMP     [vector]         ; косвенный через слово памяти
        CALL    #$8000           ; абсолютный адрес
        JZ      IP+6             ; сырое смещение: на 6 байт после следующей команды

7.6. Прерывания и ожидание

Для TRAP #выр значение вне 0..15 ошибка.

        TRAP    #9               ; программный вызов, вектор 9
        WFI                      ; ждать прерывания
        IRET

8. Допустимость операндов

Ассемблер обязан с понятным сообщением отвергать все запрещённые кодировки обоих классов: зарезервированные и ограниченно непредсказуемые (Спецификация, разд. 6.2 и 6.3). Программам они запрещены, даже если конкретная реализация процессора исполняет их без прерывания. Рекомендуется использовать при проверке ту же функцию допустимости, что и в эмуляторе.

8.1. Допустимые формы по группам

* для байтовых команд (LDZX, LDSX, STB, XCHB) запрещено при Rn = SP или IP; для ST запрещено при Rn = IP. ** [IP] запрещено для ST, STB, XCHB.

Для сдвигов #выр только 0..15 (MOD=1).

TRAP в языке поддерживает только формы #n и Rn. Остальные формы операнда, которые процессор для TRAP допускает (Спецификация, разд. 6.1), в языке не предусмотрены как практически бесполезные.

8.2. Дополнительные запреты

Нарушение каждого пункта ошибка ассемблирования (на процессоре это зарезервированная или ограниченно непредсказуемая кодировка):

1. Rn = FLAGS допустим только в форме Rn (MOD=0). В формах [Rn], [Rn++], [--Rn], [Rn+выр], Rn+выр недопустим (Спецификация, 6.3 п. 1).
2. [--IP] недопустим (6.3 п. 2).
3. Длинный #выр (непосредственное значение через IP) допустим только для LD, MOV, ALU, CMP, TEST, Jxx, CALL. Для сдвигов, LDZX, LDSX и TRAP #выр бывает только короткой константой 0..15; у ST, STB, XCHB непосредственного операнда нет (6.2 п. 3, 6.3 п. 3).
4. [IP] недопустим для ST, STB, XCHB (6.3 п. 4).
5. Байтовые команды с [Rn++] и [--Rn] при Rn = SP или IP недопустимы (6.3 п. 5).
6. Переходы (Jxx, CALL) с целью [Rn++] или [--Rn] недопустимы (6.2 п. 3, 6.3 п. 6).
7. Jxx и JR с кодом условия 15 в языке отсутствуют: такой мнемоники нет (6.2 п. 2).
8. Для любой команды не допускается лишний операнд или нехватка операндов.
9. Поля, которые команда не использует, ассемблер всегда кодирует нулями (Спецификация, разд. 3 и 6.2 п. 4): MOD у NEG, NOT, BSX, IRET, WFI (у них поле R2 - подкод сборного опкода MISC); R1 у IRET, WFI, CALL, TRAP; R2 при MOD=5. Мнемоники MISC в языке нет. Синтаксиса, позволяющего задать в них другие значения, нет.

9. Директивы

Имя директивы начинается с ., регистр не важен.

• Начальное значение счётчика адреса равно 0.
• Адрес метки перед директивой определяется правилом «Метки и выравнивание» ниже.
• Неявное выравнивание. Если счётчик адреса нечётен, перед каждой командой (включая псевдокоманды) и перед директивой .word ассемблер сам вставляет один нулевой байт. Поэтому команды и слова всегда лежат по чётным адресам, и вставлять .align 2 после нечётных данных не нужно. Директивы .byte, .ascii, .asciz, .space, .equ, .org счётчик не выравнивают.
• Метки и выравнивание. Метка привязывается к адресу следующего элемента, занимающего место: команды, .word, .byte, .ascii, .asciz, .space. Между меткой и этим элементом могут быть пустые строки, комментарии, .equ и другие метки. Если элемент требует выравнивания (команда или .word), метка получает адрес после вставки выравнивающего байта, то есть указывает на саму команду или слово, а не на байт заполнения. Метка перед .org и .align получает значение счётчика на момент определения.
• $ внутри команды или .word равен адресу после неявного выравнивания.
• Байты выравнивания входят в образ (значение 0) и показываются в листинге.
• Явный .align n нужен только для выравнивания на границу больше слова (4, 16 и так далее).
• Адрес любого байта вывода не должен выходить за 65535.
• Два вывода по одному адресу (в том числе после обратного .org) ошибка перекрытия.

        .org    $0000
        .byte   1, 2, 3         ; адреса 0, 1, 2; счётчик теперь 3 (нечётный)
tbl:    .word   $1234, tbl      ; байт заполнения по адресу 3, tbl = 4
msg:    .asciz  "Hi\n"          ; 4 байта (адреса 8..11), без выравнивания
buf:    .space  15              ; адреса 12..26, счётчик 27 (нечётный)
        NOP                     ; байт заполнения по адресу 27, NOP по адресу 28

10. Размер команд и подбор форм (нормативно)

Длина команды:

2 слова, если MOD ∈ {5, 6, 7} или (MOD = 3 и R2 = IP); иначе 1 слово.

Размер зависит от значений выражений только у двух групп:

1. #выр в LD, MOV, ALU, CMP, TEST: короткая (1 слово) или длинная (2 слова).
2. Цель-выражение у Jxx (JR или длинная относительная форма) и у CALL (MOD=1 или длинная относительная форма).

Остальное (сдвиги с #, LDZX, LDSX, TRAP, все регистровые и скобочные формы) имеет фиксированный размер, определяемый только синтаксисом.

Алгоритм

1. Разобрать файл в список элементов. Вычислить размеры фиксированных элементов.
2. Присвоить каждому элементу переменного размера состояние КОРОТКО.
3. Цикл:
   1. Вычислить адреса всех элементов и значения меток исходя из текущих состояний.
   2. Для каждого элемента в состоянии КОРОТКО проверить, умещается ли он при текущих значениях (константа 0..15; для Jxx смещение в −64..+63 слова, для CALL в −8..+7 слов; цель чётна). Если нет, перевести элемент в состояние ДЛИННО.
   3. Если хотя бы один элемент изменил состояние, повторить цикл.
4. Выполнить финальный проход: закодировать все элементы, проверить диапазоны (разд. 3), допустимость (разд. 8) и перекрытия.

Состояние ДЛИННО необратимо (переход обратно в КОРОТКО запрещён). Поэтому цикл завершается не более чем за N+1 итераций (N число элементов переменного размера). Результат детерминирован. Неопределённый символ ошибка, обнаруживаемая в финальном проходе.

Аргументы .org, .space, .align вычисляются один раз до цикла (они не зависят от меток). Значения .equ, зависящие от меток, пересчитываются на каждой итерации.

Байты неявного выравнивания и заполнение .align определяются текущим счётчиком адреса, поэтому пересчитываются на каждой итерации при вычислении адресов (шаг 3.1). На завершение цикла это не влияет: оно обеспечивается необратимостью перехода КОРОТКО → ДЛИННО.

11. Результат ассемблирования

Образ памяти это набор байтов с адресами 0..65535.

• base по умолчанию равен 0, так что образ загружается эмулятором без параметров: ./cpu16 prog.bin. Если выведены данные ниже base ошибка.
• Точка входа не задаётся: после сброса процессор начинает с адреса 0, поэтому код запуска должен лежать там.
• Порядок байт little-endian: младший байт слова по меньшему адресу.

Пример листинга:

0000  0000 0000          start:  LD      SP, #$FF00      ; (пример формата)

12. Диагностика

Формат: файл:строка: error: сообщение. Ассемблер должен сообщить обо всех найденных ошибках (не только о первой) и вернуть ненулевой код возврата, если хотя бы одна есть.

13. Короткие примеры

13.1. Вывод строки (порт консоли $FF20, см. 13.12)

        .equ    CONSOLE, $FF20
        .org    0
start:  LD      SP, #$FF00
        LD      R0, #msg
@next:  LDZX    R1, [R0++]
        CMP     R1, #0
        JZ      @done
        STB     [CONSOLE], R1
        JMP     @next
@done:  WFI
msg:    .asciz  "Hello!\n"

13.2. Сумма массива

        LD      R0, #table       ; указатель
        LD      R1, #5           ; счётчик
        LD      R2, #0           ; сумма
loop:   ADD     R2, [R0++]       ; сумма += *p++ (шаг 2)
        DEC     R1
        JNZ     loop
        WFI
table:  .word   10, 20, 30, 40, 50

13.3. Подпрограммы и сохранение LR

        LD      SP, #$FF00
        LD      R0, #7
        CALL    twice_plus_one
        WFI

twice_plus_one:
        PUSH    LR               ; вложенный вызов: сохранить LR
        ADD     R0, R0
        CALL    inc_r0
        POP     LR
        RET

inc_r0: INC     R0
        RET                      ; листовая подпрограмма: LR не сохраняем

13.4. 32-битное сложение

        ; R1:R0 += R3:R2
        ADD     R0, R2
        ADC     R1, R3

13.5. Беззнаковые и знаковые сравнения

        CMP     R0, R1
        JB      below            ; R0 < R1 как беззнаковые
        JL      less             ; R0 < R1 как знаковые
        JAE     above_or_equal   ; беззнаковое >=
        JGE     greater_or_equal ; знаковое >=

13.6. Копирование строки байтами

; R0 = источник, R1 = приёмник
copy:   LDZX    R2, [R0++]
        STB     [R1++], R2
        CMP     R2, #0
        JNZ     copy
        RET

13.7. Таблица переходов

        ; R0 = индекс 0..2
        ADD     R0, R0           ; индекс * 2
        JMP     [R0+table]       ; адрес берётся из слова table[R0]
table:  .word   case0, case1, case2

13.8. Спинлок на XCHB

acquire:
        LD      R1, #1
@try:   XCHB    [lock], R1       ; R1 = старое значение, lock = 1
        CMP     R1, #0
        JNZ     @try
        RET

release:
        LD      R1, #0
        STB     [lock], R1
        RET

lock:   .byte   0

13.9. Сдвиги и константы флагов

        .equ    IF, $08
        SHL     R0, #4
        ROR     R2, #8           ; обмен байтов
        OR      FLAGS, #IF       ; то же, что STI (1 слово)
        AND     FLAGS, #$0F & ~IF ; то же, что CLI: 1 слово, побочно OF=0
        AND     FLAGS, #~IF      ; CLI без побочного эффекта: ~$08 = $FFF7, 2 слова

        PUSH    FLAGS            ; критическая секция: сохранить IF и OF
        CLI
        ; ...
        POP     FLAGS            ; восстановить всё, включая OF

13.10. Прерывания: векторы и обработчик

        .org    0
        LD      SP, #$FF00
        STI
idle:   WFI
        JMP     idle

irq0:   PUSH    R0               ; обработчик обязан сам сохранить регистры
        LD      R0, [ticks]
        INC     R0
        ST      [ticks], R0
        POP     R0
        IRET                     ; восстанавливает флаги и IP
ticks:  .word   0
svc:    IRET                     ; обработчик программного вызова TRAP #9

        .org    $FF00            ; таблица векторов: 16 слов
        .word   irq0, 0, 0, 0, 0, 0, 0, 0     ; векторы 0..7: внешние IRQ
        .word   0, svc, 0, 0, 0, 0, 0, 0      ; вектор 8 ERRCMD, 9..15 программные

13.11. Относительная адресация (не зависит от места загрузки)

        LEA     R0, IP+(msg-$-4) ; R0 = адрес msg; $ адрес этой команды, +4 длина
        LD      R1, [IP+(val-$-4)]
        WFI
msg:    .asciz  "xy"             ; 3 байта: счётчик становится нечётным
val:    .word   $BEEF            ; выровнено автоматически, val чётный

13.12. Ввод с консоли

Порт консоли $FF20 (соглашение эмулятора и отладчика, не часть архитектуры процессора):

• запись байта выводит символ;
• чтение байта забирает следующий байт ввода или возвращает 0, если ввода нет; ожидания и регистра готовности нет;
• читать порт нужно байтовыми командами (LDZX, LDSX): чтение слова по $FF20 тоже забирает один байт ввода (младшая половина слова читается из порта);
• байт 0 во вводе неотличим от «ввода нет».

В эмуляторе cpu16 ввод берётся из stdin (./cpu16 prog.bin < input.txt), в браузерном отладчике — из панели консоли.

; эхо: копирует ввод в вывод до точки
loop:   LDZX    R1, [$FF20]      ; байт ввода или 0
        CMP     R1, #0
        JZ      loop             ; ввода пока нет
        STB     [$FF20], R1
        CMP     R1, #'.'
        JNZ     loop
        WFI

13.13. Печать числа в десятичном виде

        .equ    CONSOLE, $FF20
        .org    0
        LD      SP, #$FF00
        LD      R0, #40000
        CALL    print_dec        ; печатает 40000
        LD      R1, #10
        STB     [CONSOLE], R1
        WFI

; R0 - число без знака; R0, R1 и R2 портятся
print_dec:
        LD      R2, #0           ; счётчик цифр в стеке
@div:   LD      R1, R0
        REMU    R1, #10          ; очередная цифра (младшая)
        DIVU    R0, #10
        ADD     R1, #'0'
        PUSH    R1
        INC     R2
        CMP     R0, #0
        JNZ     @div
@out:   POP     R1               ; цифры из стека - от старшей к младшей
        STB     [CONSOLE], R1
        DEC     R2
        JNZ     @out
        RET

14. Примеры кодирования

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

Опкоды (старшие 5 бит слова):

15. Формальная грамматика (EBNF)

file        = { line } ;
line        = [ label ] [ statement ] [ comment ] newline ;
label       = ( ident | local ) ":" ;
local       = "@" ident ;
comment     = ";" { any char } ;
statement   = instruction | directive ;

instruction = mnemonic [ operand { "," operand } ] ;
operand     = reg
            | "#" expr
            | "[" memref "]"
            | reg ( "+" | "-" ) expr
            | expr ;                      (* голое выражение только у Jxx и CALL *)
memref      = reg [ "++" ]
            | "--" reg
            | reg ( "+" | "-" ) expr
            | expr ;

directive   = "." dname [ dargs ] ;
dargs       = expr { "," expr }                        (* .word, .byte, .org, .space, .align *)
            | string { "," string }                    (* .ascii, .asciz *)
            | ident "," expr                           (* .equ *)
            | string ;                                 (* .include *)

expr        = term { ( "|" | "^" | "&" | "<<" | ">>" | "+" | "-" ) term } ;   (* с приоритетами разд. 3 *)
term        = unary { ( "*" | "/" ) unary } ;
unary       = [ "+" | "-" | "~" ] primary ;
primary     = number | char | ident | local | "$" | "(" expr ")" | ( "lo" | "hi" ) "(" expr ")" ;

reg         = "R0".."R15" | "LR" | "SP" | "IP" | "FLAGS" ;

16. Что не входит в версию 1

Макросы, условная ассемблация, секции и компоновка объектных файлов, форматы вывода кроме плоского образа (Intel HEX можно добавить позже), предупреждения (все нарушения ошибки), символы в регистровой записи вида R+R.