Опять тупой вопрос:

Пустой мк не (ffff во флаш) стартует из RAM.
Сразу в HardFault. Момэнто море - сразу в море)
Обращение к невыравненому адресу вроде.
ЧоЗаНаХ?
F303 мк.

неровный доступ к памяти ?)))

#include <stdint.h>

/* --- Регистры ядра Cortex-M4 --- */
#define SCB_CFSR   (*(volatile uint32_t*)0xE000ED28)
#define SCB_HFSR   (*(volatile uint32_t*)0xE000ED2C)
#define SCB_MMFAR  (*(volatile uint32_t*)0xE000ED34)
#define SCB_BFAR   (*(volatile uint32_t*)0xE000ED38)
#define SCB_SHCSR  (*(volatile uint32_t*)0xE000ED24)

/* Биты CFSR */
#define CFSR_UFSR_UNALIGNED   (1u << 24)  /* невыровненный доступ */
#define CFSR_UFSR_INVSTATE    (1u << 17)  /* bad EPSR/Thumb bit */
#define CFSR_UFSR_INVPC       (1u << 18)  /* invalid PC load */
#define CFSR_MMFSR_IACCVIOL   (1u << 0)   /* instruction access violation */
#define CFSR_BFSR_PRECISERR   (1u << 1)   /* precise bus error */

/* Коды, которые кладём в «журнал» */
enum {
    DIAG_OK = 0,
    DIAG_BAD_MSP,        /* начальный SP вне RAM */
    DIAG_BAD_VECTOR,     /* Reset_Handler не в RAM/Flash */
    DIAG_NOT_THUMB,      /* адрес без бита Thumb */
    DIAG_RAM_NOT_READY,  /* не включена тактировка/доступ к SRAM */
    DIAG_UNALIGNED,      /* реально невыровненный доступ */
    DIAG_INVSTATE,
    DIAG_INVPC,
    DIAG_IACCVIOL,
    DIAG_BUSERR,
    DIAG_UNKNOWN
};

volatile uint32_t diag_code;     /* сюда пишем причину — смотрим в отладчике */
volatile uint32_t diag_addr;     /* проблемный адрес (BFAR/MMFAR) */
volatile uint32_t diag_cfsr;
volatile uint32_t diag_hfsr;

/* --- Проверка, что адрес лежит в SRAM F303 (0x20000000..0x2000A000) --- */
static inline int in_ram(uint32_t a) {
    return (a >= 0x20000000u) && (a < 0x2000A000u);
}

/* --- Проверка, что адрес лежит во Flash --- */
static inline int in_flash(uint32_t a) {
    return (a >= 0x08000000u) && (a < 0x08080000u);
}

/* Вызываем ПЕРВЫМ делом в Reset_Handler / main */
void diag_start(void)
{
    /* 1) Читаем текущий MSP и адрес, с которого стартовали */
    uint32_t msp, pc;
    __asm volatile ("mrs %0, msp" : "=r"(msp));
    __asm volatile ("mov %0, pc"  : "=r"(pc));

    /* На старте из RAM SP должен быть в RAM и кратен 8 (AAPCS) */
    if (!in_ram(msp) || (msp & 0x7u)) {
        diag_code = DIAG_BAD_MSP;
        diag_addr = msp;
        goto halt;
    }

    /* 2) Проверяем «векторную таблицу» по адресу 0x00000000.
       При BOOT=SRAM ядро читает SP/Reset из 0x00000000,
       но эта область может алиасить Flash или быть пустой. */
    {
        uint32_t vt_sp  = *(volatile uint32_t*)0x00000000u;
        uint32_t vt_rst = *(volatile uint32_t*)0x00000004u;

        if (!in_ram(vt_sp)) {              /* SP из вектора не в RAM */
            diag_code = DIAG_BAD_VECTOR;
            diag_addr = vt_sp;
            goto halt;
        }
        if (!(vt_rst & 1u)) {              /* нет Thumb-бита */
            diag_code = DIAG_NOT_THUMB;
            diag_addr = vt_rst;
            goto halt;
        }
        if (!(in_ram(vt_rst & ~1u) || in_flash(vt_rst & ~1u))) {
            diag_code = DIAG_BAD_VECTOR;
            diag_addr = vt_rst;
            goto halt;
        }
    }

    /* 3) Включаем отдельные обработчики, чтобы поймать UsageFault,
          а не получить «молча» HardFault */
    SCB_SHCSR |= (1u << 16);  /* USGFAULTENA */
    SCB_SHCSR |= (1u << 17);  /* BUSFAULTENA  */
    SCB_SHCSR |= (1u << 18);  /* MEMFAULTENA  */

    /* Сбрасываем флаги ошибок */
    SCB_CFSR = SCB_CFSR;
    SCB_HFSR = SCB_HFSR;

    diag_code = DIAG_OK;

    /* 4) Намеренно провоцируем невыровненный доступ,
          чтобы убедиться, что механизм ловит его и что
          именно он валит систему (в F303 UNALIGN_TRP обычно выкл,
          но LDM/STM всё равно упадут) */
    {
        volatile uint32_t buf[3] = {0x11111111, 0x22222222, 0x33333333};
        uint32_t *p = (uint32_t*)((uint8_t*)buf + 1); /* адрес +1 байт */

        /* Простое LDR с невыровненным адресом Cortex-M4 допускает,
           а вот LDM — нет. Поэтому делаем LDM через asm. */
        uint32_t r0, r1;
        __asm volatile (
            "ldmia %2, {%0, %1}"
            : "=r"(r0), "=r"(r1)
            : "r"(p)
            : "memory"
        );
        (void)r0; (void)r1;
    }

    diag_code = DIAG_OK;
    return;

halt:
    /* Зависаем — в отладчике смотрим diag_code/diag_addr */
    for (;;) { __asm volatile ("nop"); }
}

/* --- Обработчики: перехватываем всё и записываем причину --- */
void UsageFault_Handler(void)
{
    diag_cfsr = SCB_CFSR;
    diag_hfsr = SCB_HFSR;
    diag_addr = SCB_MMFAR ? SCB_MMFAR : SCB_BFAR;

    if (diag_cfsr & CFSR_UFSR_UNALIGNED) diag_code = DIAG_UNALIGNED;
    else if (diag_cfsr & CFSR_UFSR_INVSTATE) diag_code = DIAG_INVSTATE;
    else if (diag_cfsr & CFSR_UFSR_INVPC)    diag_code = DIAG_INVPC;
    else                                     diag_code = DIAG_UNKNOWN;

    for (;;) { __asm volatile ("nop"); }
}

void BusFault_Handler(void)
{
    diag_cfsr = SCB_CFSR;
    diag_hfsr = SCB_HFSR;
    diag_addr = SCB_BFAR;
    diag_code = (SCB_CFSR & CFSR_BFSR_PRECISERR) ? DIAG_BUSERR : DIAG_UNKNOWN;
    for (;;) { __asm volatile ("nop"); }
}

void MemManage_Handler(void)
{
    diag_cfsr = SCB_CFSR;
    diag_hfsr = SCB_HFSR;
    diag_addr = SCB_MMFAR;
    diag_code = (SCB_CFSR & CFSR_MMFSR_IACCVIOL) ? DIAG_IACCVIOL : DIAG_UNKNOWN;
    for (;;) { __asm volatile ("nop"); }
}

void HardFault_Handler(void)
{
    /* Сюда попадём, если что-то не поймали выше.
       Читаем CFSR/HFSR — там будет намёк. */
    diag_cfsr = SCB_CFSR;
    diag_hfsr = SCB_HFSR;
    diag_addr = SCB_BFAR ? SCB_BFAR : SCB_MMFAR;

    if (diag_cfsr & CFSR_UFSR_UNALIGNED) diag_code = DIAG_UNALIGNED;
    else if (diag_cfsr & CFSR_UFSR_INVSTATE) diag_code = DIAG_INVSTATE;
    else if (diag_cfsr & CFSR_UFSR_INVPC)    diag_code = DIAG_INVPC;
    else if (diag_cfsr & CFSR_MMFSR_IACCVIOL) diag_code = DIAG_IACCVIOL;
    else if (diag_cfsr & CFSR_BFSR_PRECISERR) diag_code = DIAG_BUSERR;
    else                                      diag_code = DIAG_UNKNOWN;

    for (;;) { __asm volatile ("nop"); }
}

все равно никто не ответит наверное, по этому сразу код от ии скину)))

Естепственно. Такими компетенциями в етой песочнице обладают, ну, возможно, дривер, бездисковый и ммм.
Код твой приколен, но на стадии старта - только асм. С там не будет работать.
Причина мне ясна, просто не знал, что ядра стартуют по разному)

Для начала стереть всю память.

Написал же - ffff во флашь.
Он по другому не стирается, erase не в 0000 а в фффф стирает)))

А что в нем должно “стартануть”, если в нем FF во флеше??

Старт со стандартного загрузчика в ОЗУ.
Странно, а может и нет, но 1, 3 и 4 серии стартуют вообще по разному.

У меня как то на плате пины boot через раз контачили, мк с ума сходил.

Я не совсем понимаю смысл этого пина (boot) и логику его работы.
Если сможешь внятно объяснить мне = буду очень рад.
От себя скажу одно: вне зависимости от состояния boot пина и прочих пинов, кроме питания (3,3В) - если свободны ДВА SWD = запущу процентов на 90.

на плате МК есть пины boot0 и к ней обычно перемычка или кнопка, когда то давно когда я часто использовал для загрузки dfu
в один прекрасный момент МК стал загружаться через раз - оказалось что пины чипа оторвались от платы, пришлось пропаять и все заработало.

Я к тому, чтоб проверить все ли правильно подключено и правильные ли уровни на пинах boot0 и boot1.

а логику работы boot0 boot1 читать в ДШ, там четко прописано что и откуда стартует.

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

Это просто развлечение, не более. Запустить мк на плате не выпаивая ничего. Только питание с отладочный интерфейс)