Код запуска: что происходит от сброса до main()

Что делает ядро Cortex-M само

Сброс в архитектуре ARMv7-M описан псевдокодом TakeReset() (ARMv7-M ARM, B1.5.5). В переводе на обычный язык ядро после снятия сброса:

1. переходит в режим Thread с привилегиями и основным стеком (MSP), сбрасывает маски прерываний PRIMASK, FAULTMASK и BASEPRI;
2. если есть FPU — выключает доступ к нему: поля CP10 и CP11 регистра CPACR равны нулю;
3. читает слово по адресу таблицы векторов и записывает его в SP, обнулив два младших бита;
4. записывает в LR значение 0xFFFFFFFF — заведомо недопустимый адрес возврата;
5. читает слово по адресу таблицы + 4, младший бит кладёт в бит T регистра состояния, а на остальные биты переходит.

Адрес таблицы при сбросе — значение регистра VTOR. Архитектура оставляет его на усмотрение производителя: либо задаётся входами ядра, либо равен нулю (B3.2.5). У STM32 он нулевой, а по адресу 0 отображается память, выбранная выводами BOOT: обычно флеш-память с адреса 0x08000000. Поэтому таблица векторов прошивки стоит в самом начале флеш-памяти — это обеспечивает скрипт компоновщика правилом KEEP(*(.isr_vector)), о котором подробно в статье о скриптах компоновщика.

Из этого следует важная вещь: на Cortex-M указатель стека готов ещё до первой команды. Обработчик сброса может быть обычной функцией на C, которая сразу пользуется стеком. На AVR и многих других архитектурах стек сначала надо настроить командами.

Бит T заслуживает отдельного внимания. Cortex-M выполняет только команды Thumb, и любой адрес в таблице векторов, кроме слова 0, должен быть нечётным. Если там окажется чётное число, первая же команда обработчика вызовет INVSTATE UsageFault (B1.5.3). Если обработчик UsageFault выключен, ошибка эскалирует в HardFault (B1.5.1) — а после сброса он выключен всегда, пока программа сама его не включит, поэтому на практике такая ошибка почти всегда выглядит как HardFault. Компоновщик ставит этот бит сам, если символ помечен как функция Thumb; ошибка появляется в самописных таблицах на ассемблере, где адрес взят у метки данных.

Таблица векторов

Порядок слов в таблице задан номерами исключений (ARMv7-M ARM, табл. B1-4 и B1-5):

Номер внешнего прерывания — это IRQn из заголовка производителя. У STM32F103xB, например, USART1_IRQn = 37, значит адрес обработчика USART1 лежит по смещению 0x40 + 37 · 4 = 0xD4. Последнее прерывание этой линейки — USBWakeUp_IRQn = 42, всего в таблице 16 + 43 = 59 векторов.

В стартовом файле ST после последнего вектора есть ещё одно слово — BootRAM со значением 0xF108F85F по смещению 0x108, с комментарием «для загрузки из ОЗУ в устройствах средней плотности». Ядро его не читает как вектор; это особенность серии F1, переносить её в свои таблицы для других серий не нужно.

Слабые псевдонимы и Default_Handler

Все обработчики, кроме Reset_Handler, в стартовом файле объявлены слабыми псевдонимами одной функции:

  .weak HardFault_Handler
  .thumb_set HardFault_Handler,Default_Handler

Если в программе есть функция с тем же именем, компоновщик возьмёт её; если нет — вектор укажет на Default_Handler, который в шаблоне ST состоит из одной команды перехода на себя. Отсюда типичный симптом опечатки в имени обработчика: прерывание включено, флаг взводится, а программа «зависает». Остановив её отладчиком, видно, что она крутится в Default_Handler, а номер исключения подсказывает регистр IPSR (младшие 9 бит xPSR): вычтя 16, получаем IRQn. Подробнее о том, как не ошибиться с именем, — в статье о прерываниях STM32.

Таблица на C

Тот же механизм на C — массив указателей на функции, помещённый в секцию, которую скрипт компоновщика ставит в начало флеш-памяти:

#include <stdint.h>

typedef void (*vector_t)(void);

extern uint32_t _estack[];              /* top of stack, from the linker script */

void Reset_Handler(void);
void Default_Handler(void);

/* Weak aliases: a handler defined elsewhere overrides the default one. */
void NMI_Handler(void)       __attribute__((weak, alias("Default_Handler")));
void HardFault_Handler(void) __attribute__((weak, alias("Default_Handler")));
void SysTick_Handler(void)   __attribute__((weak, alias("Default_Handler")));
void USART1_IRQHandler(void) __attribute__((weak, alias("Default_Handler")));

__attribute__((section(".isr_vector"), used))
const vector_t g_vectors[16 + 43] = {
    [0]       = (vector_t)(uintptr_t)_estack,   /* initial MSP */
    [1]       = Reset_Handler,
    [2]       = NMI_Handler,
    [3]       = HardFault_Handler,
    [15]      = SysTick_Handler,
    [16 + 37] = USART1_IRQHandler,             /* USART1_IRQn = 37 */
    /* the remaining entries must also point to handlers, not stay zero */
};

void Default_Handler(void)
{
    for (;;) { }
}

Назначенные инициализаторы [16 + 37] = (C99 и C11, 6.7.9) избавляют от подсчёта позиций, но оставляют нулями незаполненные слова. Ноль — чётный адрес, и прерывание с таким вектором закончится HardFault, поэтому в настоящей таблице заполняют все позиции, хотя бы Default_Handler. Атрибут used не даёт компилятору выбросить массив, на который нет ссылок, а KEEP в скрипте компоновщика защищает секцию от --gc-sections. Преобразование адреса _estack в указатель на функцию формально выходит за рамки стандарта C, но GCC его выполняет как ожидается; ST в своих файлах обходит вопрос, записывая таблицу на ассемблере директивами .word.

Reset_Handler в стартовом файле ST

Обработчик сброса из шаблона startup_stm32f103xb.s (cmsis-device-f1, коммит c8e9a4a) по шагам:

Символы _sidata, _sdata, _edata, _sbss, _ebss и _estack определяет скрипт компоновщика. _sidata — адрес хранения (LMA) начальных значений во флеш-памяти, _sdata и _edata — границы секции .data в ОЗУ (VMA). Разница между этими адресами — главная причина, по которой код запуска вообще нужен: начальные значения переменных обязаны пережить выключение питания, а сами переменные должны быть в ОЗУ. Подробнее о двух адресах секции — в статье о файлах прошивки и в глоссарии: VMA и LMA, секция .bss.

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

В шаблоне для STM32F411 (cmsis-device-f4, коммит 9192c7b) перед вызовом SystemInit стоит ещё одна команда — ldr sp, =_estack. Ядро уже загрузило SP из таблицы, но запись нужна, когда в Reset_Handler попадают не через сброс: например, загрузчик или отладчик просто передаёт управление на его адрес, не трогая стек.

Почему SystemInit не должна трогать глобальные переменные

SystemInit вызывается до копирования .data и обнуления .bss. Всё, что она запишет в глобальную переменную, будет затёрто на следующих шагах, а всё, что прочитает, — мусор. Шаблоны ST это соблюдают: SystemInit() для F1 при определённом USER_VECT_TAB_ADDRESS только записывает адрес таблицы в SCB->VTOR, а без этого макроса не делает ничего, кроме настройки внешней памяти на старших моделях. Переменная SystemCoreClock объявлена с начальным значением 8000000 — частотой внутреннего генератора HSI — и получает его как раз при копировании .data. Тактирование от кварца и PLL настраивают уже в main(): в проектах CubeMX это функция SystemClock_Config(), а частоты и делители удобно посчитать в инструменте «Тактирование STM32».

Если в SystemInit всё же нужно что-то запомнить — например, флаги причины сброса из RCC->CSR, — переменную кладут в секцию без инициализации (.noinit), которую код запуска не трогает. Как её завести в скрипте компоновщика, показано в статье о скриптах компоновщика.

FPU на Cortex-M4 и M7

После сброса FPU выключен: TakeReset() обнуляет поля CP10 и CP11 регистра CPACR. Любая команда с плавающей точкой в таком состоянии вызывает UsageFault, который при выключенном обработчике UsageFault превращается в HardFault. Поэтому включение FPU — одна из немногих вещей, которые обязаны случиться до main(), ведь компилятор с -mfloat-abi=hard может применить регистры FPU в любой функции, даже в коде запуска библиотеки.

В шаблоне ST для F4 это делает SystemInit:

#if (__FPU_PRESENT == 1) && (__FPU_USED == 1)
    SCB->CPACR |= ((3UL << 10*2) | (3UL << 11*2));  /* set CP10 and CP11 Full Access */
#endif

Это те же биты 20–23 регистра CPACR по адресу 0xE000ED88, что и в примере из руководства Cortex-M4 (DUI 0553B, 4.6.6). В руководстве после записи стоят барьеры DSB и ISB: первый дожидается завершения записи, второй сбрасывает конвейер, чтобы следующие команды выполнялись уже с включённым FPU. В своём коде запуска на C это выглядит так:

SCB->CPACR |= (0xFUL << 20);    /* CP10 and CP11: full access */
__DSB();
__ISB();

Reset_Handler на C

Тот же порядок действий без ассемблера. Символы скрипта компоновщика — это адреса без значений (GNU ld, Source Code Reference), поэтому их объявляют массивами и берут только адрес:

#include <stddef.h>
#include <stdint.h>

extern uint32_t _sidata[];          /* LMA of .data in flash */
extern uint32_t _sdata[], _edata[]; /* VMA of .data in RAM */
extern uint32_t _sbss[], _ebss[];

void SystemInit(void);
void __libc_init_array(void);
int main(void);

void Reset_Handler(void)
{
    SystemInit();                   /* must not use .data or .bss */

    size_t n = (size_t)((uintptr_t)_edata - (uintptr_t)_sdata) / sizeof(uint32_t);
    for (size_t i = 0; i < n; i++)
        _sdata[i] = _sidata[i];

    n = (size_t)((uintptr_t)_ebss - (uintptr_t)_sbss) / sizeof(uint32_t);
    for (size_t i = 0; i < n; i++)
        _sbss[i] = 0u;

    __libc_init_array();            /* static constructors (newlib) */
    (void)main();

    for (;;) { }                    /* main() must not return */
}

Несколько замечаний к этому коду.

• Длина через uintptr_t. Сравнивать указатели &_sdata < &_edata на разные объекты стандарт C не разрешает (6.5.8), хотя GCC такой код компилирует. Разность целых адресов — честная операция.
• Цикл может стать вызовом memset. С -O2 GCC включает -ftree-loop-distribute-patterns, который превращает цикл обнуления в вызов memset. В коде запуска это не страшно — memset из библиотеки не пользуется .data, — но если вы пишете свою memset, компилятор может превратить её тело в вызов самой себя. Для такого файла задают -fno-tree-loop-distribute-patterns.
• Нельзя возвращаться из main(). LR при входе в Reset_Handler равен 0xFFFFFFFF, возвращаться некуда. Стартовый файл ST после bl main выполняет bx lr, то есть результат возврата из main() там не определён; бесконечный цикл после вызова делает поведение предсказуемым.
• Без стандартного кода запуска. Если свой Reset_Handler полностью заменяет стартовый файл, его убирают из проекта, а компоновщику передают -nostartfiles, чтобы не подключались стандартные файлы запуска инструментария.

Перенос таблицы векторов: VTOR

Когда в начале флеш-памяти стоит загрузчик, приложение собирают с другого адреса, например 0x08004000, а таблицу векторов приложения нужно показать ядру. Для этого есть регистр VTOR (Vector Table Offset Register) по адресу 0xE000ED08, в CMSIS — SCB->VTOR. Поле TBLOFF занимает биты 31:7, младшие биты адреса всегда нулевые.

Выравнивание — частая ошибка. Архитектура требует, чтобы адрес таблицы был кратен степени двойки, не меньшей размера таблицы, и минимум 128 байтам (ARMv7-M ARM, B1.5.3). Руководство Cortex-M3 формулирует то же через слова: минимум 32 слова, хватает на 16 прерываний, а для 21 прерывания таблица занимает 37 слов, и граница — 64 слова (DUI 0552A, 4.3.4).

Адрес 0x08004000 кратен 256 и подходит. А 0x08004080 в поле TBLOFF записать можно, но он выровнен только на 128 байт, а таблица STM32F103xB занимает 236; такое размещение архитектура запрещает, и где ядро станет искать векторы старших прерываний, не определено.

В шаблоне ST перенос включают макросами: раскомментировать USER_VECT_TAB_ADDRESS и задать VECT_TAB_OFFSET в system_stm32f1xx.c, тогда SystemInit() запишет SCB->VTOR = VECT_TAB_BASE_ADDRESS | VECT_TAB_OFFSET. В шаблоне для F4 запись в VTOR выполняется всегда, без макроса — значением FLASH_BASE.

Сам переход из загрузчика в приложение выглядит так:

#include "stm32f1xx.h"

#define APP_BASE 0x08004000u

typedef void (*entry_t)(void);

void jump_to_app(void)
{
    const uint32_t *app = (const uint32_t *)APP_BASE;
    uint32_t sp    = app[0];                    /* initial MSP of the application */
    entry_t  entry = (entry_t)app[1];           /* its Reset_Handler, bit 0 set */

    __disable_irq();
    SysTick->CTRL = 0;                          /* stop the bootloader's tick */
    for (uint32_t i = 0; i < 8; i++) {
        NVIC->ICER[i] = 0xFFFFFFFFu;            /* disable all IRQs */
        NVIC->ICPR[i] = 0xFFFFFFFFu;            /* clear pending ones */
    }
    SCB->ICSR = SCB_ICSR_PENDSTCLR_Msk;         /* SysTick is not in NVIC: clear it here */
    SCB->VTOR = APP_BASE;
    __set_MSP(sp);
    entry();                                    /* PRIMASK stays 1: the app enables IRQs */
}

Перед прыжком загрузчик выключает всё, что включал сам: SysTick, прерывания периферии, по возможности возвращает тактирование к состоянию после сброса. Иначе первое же прерывание от его таймера придёт в приложение, где обработчика нет или он ждёт другого. SysTick — системное исключение, а не прерывание NVIC: регистры ICER и ICPR его не касаются, и уже взведённый запрос SysTick снимают битом PENDSTCLR регистра ICSR (ARMv7-M ARM, B1.5.1).

Прерывания перед entry() загрузчик не разрешает. Иначе любой запрос, который успеет появиться между __enable_irq() и первыми командами приложения, будет обслужен по таблице приложения, когда оно ещё не настроило ни стек, ни переменные, ни периферию для этого обработчика. Обратная сторона: после такого перехода PRIMASK остаётся равным 1, а не 0, как после настоящего сброса (B1.5.5). Приложение, которое полагается на состояние после сброса и само прерывания нигде не разрешает, останется с запрещёнными прерываниями. Поэтому приложение, рассчитанное на запуск из загрузчика, само вызывает __enable_irq() после своей инициализации, и это нужно оговорить в описании интерфейса между загрузчиком и приложением. Приложение, в свою очередь, не должно рассчитывать на то, что периферия в состоянии после сброса. Как устроены встроенный загрузчик и выбор области загрузки у STM32 — в статье о загрузчике и прошивке STM32.

AVR: код запуска avr-libc

У AVR нет аппаратной загрузки указателя стека из таблицы: по адресу 0 стоит обычная команда перехода на код запуска. В ATmega328P 26 векторов по два слова — команда JMP (DS40002061B, табл. 12-6): сброс по адресу 0x0000, внешнее прерывание INT0 — 0x0002 и так далее до SPM READY — 0x0032. Адреса в даташите — номера слов флеш-памяти, в байтах они вдвое больше. В avr-libc размер таблицы задан как _VECTORS_SIZE (26 * 4), то есть 104 байта.

Нумерация векторов в даташите и в avr-libc отличается на единицу: в таблице 12-6 приём USART — вектор 19, а в <avr/iom328p.h> — USART_RX_vect = _VECTOR(18), потому что avr-libc считает сброс нулевым вектором. Это нужно помнить, когда вектор ищут по номеру в листинге.

Секции .init0–.init9

Код запуска avr-libc разбит на секции .init0….init9, которые компоновщик выкладывает подряд, и выполнение проходит их одну за другой без вызовов и возвратов (sections.dox):

Код из .init4 компилятор подключает только при необходимости: если в программе нет инициализированных переменных, копирования не будет. После exit() выполняются секции .fini9….fini0, и последняя запрещает прерывания и останавливает программу в бесконечном цикле.

Указатель стека у ATmega328P и так равен RAMEND сразу после сброса (DS40002061B, 7.5), но код запуска записывает его снова: в программу можно попасть и прыжком на адрес 0, а не только через сброс.

Свой код до инициализации переменных

Классический пример — сторожевой таймер. После сброса от него он остаётся включённым, по документации avr-libc — с самым коротким периодом, около 15 мс (в даташите это 2048 тактов генератора 128 кГц, типично 16 мс), и если код запуска с копированием большой секции .data и конструкторами работает дольше, микроконтроллер будет перезапускаться бесконечно. Поэтому его выключают в .init3 — после настройки __zero_reg__ и стека, но до инициализации переменных. Пример из документации <avr/wdt.h>:

#include <stdint.h>
#include <avr/io.h>
#include <avr/wdt.h>

uint8_t mcusr_mirror __attribute__((section(".noinit")));

__attribute__((used, unused, naked, section(".init3")))
static void get_mcusr(void)
{
    mcusr_mirror = MCUSR;   /* keep the reset cause for main() */
    MCUSR = 0;              /* WDRF must be cleared before WDE can be */
    wdt_disable();
}

Атрибут naked убирает пролог и эпилог: функция не вызывается, а выполняется «на проходе» между .init2 и .init4, и команда возврата в ней была бы ошибкой. used не даёт компилятору выбросить функцию, на которую никто не ссылается. Переменная лежит в .noinit, иначе код из .init4 обнулил бы её сразу после записи. Как устроен сторожевой таймер и где его сбрасывать — в статье о сторожевых таймерах.

Непредусмотренное прерывание на AVR

Неиспользуемые векторы avr-libc направляет на __bad_interrupt, а тот — на __vector_default, который по умолчанию равен __vectors, то есть адресу 0. Прерывание, для которого забыли написать обработчик (или ошиблись в имени вектора), перезапускает программу. Это не аппаратный сброс: регистры периферии сохраняют настройки, флаги в MCUSR не меняются, и программа стартует в непривычном окружении. Определив свой обработчик ISR(BADISR_vect), такие случаи можно ловить явно. Как выглядит этот путь на уровне регистров, разобрано в уроке о таймерах и прерываниях курса «AVR с нуля».

Что делать до main(), а что в main()

Хорошее правило — в коде запуска только то, без чего не может работать C:

• до main(): указатель стека, .data, .bss, конструкторы, FPU на Cortex-M4F и M7, отключение сторожевого таймера на AVR после сброса от него, внешняя память, если в ней лежат переменные;
• в main(): тактирование от кварца и PLL, задержки ожидания флеш-памяти, периферия, прерывания.

Причина простая: в main() работают все механизмы языка, отладчик останавливается на первой строке, а ошибку видно в обычном коде. Ошибка в коде запуска выглядит как «программа не доходит до main» и ищется пошаговым выполнением ассемблера. Готовые последовательности инициализации тактирования и периферии собирают инструменты «Инициализация STM32» и «Инициализация AVR».

Типичные ошибки

• Чтение глобальной переменной в SystemInit или в .init3 — значение ещё не скопировано. Нужные там переменные кладут в .noinit.
• Чётный адрес в таблице векторов — HardFault при первом же исключении; обычно это пропущенная позиция в таблице на C или метка данных в таблице на ассемблере.
• Опечатка в имени обработчика — вектор остаётся на Default_Handler (STM32) или __bad_interrupt (AVR): зависание или тихий перезапуск.
• Неверное выравнивание VTOR после загрузчика — приложение получает векторы не из своей таблицы. Адрес таблицы кратен степени двойки не меньше её размера.
• FPU не включён на Cortex-M4F — HardFault на первой команде с плавающей точкой, иногда в библиотечной функции задолго до main().
• .data без AT> FLASH в скрипте компоновщика — секция есть, а начальных значений в прошивке нет. Проверяется по map-файлу: у .data должны различаться VMA и LMA.
• Возврат из main() — на Cortex-M переход по LR = 0xFFFFFFFF или по случайному значению, на AVR — остановка в .fini0 с запрещёнными прерываниями.
• Долгий код до main() при включённом сторожевом таймере — бесконечные перезапуски после первого же сброса от него.