PUBLIC _Z9AtomicIncPVh, _Z9AtomicDecPVh
PUBLIC _Z10AtomicSwapPVhj, _Z10AtomicSwapPVtj _Z10AtomicSwapPVjj
PUBLIC _Z13AtomicCmpSwapPVhjj, _Z13AtomicCmpSwapPVtjj, _Z13AtomicCmpSwapPVjjj

;uint AtomicInc(u8 volatile *);
_Z9AtomicIncPVh:
aInc8_01: LDREXB R3, [R0]
ADDS R1, R3, #1
STREXB R2, R1, [R0]
CMP R2, #0
BNE aInc8_01
MOV R0, R3
BX LR

;uint AtomicDec(u8 volatile *);
_Z9AtomicDecPVh:
aDec8_01: LDREXB R3, [R0]
SUBS R1, R3, #1
STREXB R2, R1, [R0]
CMP R2, #0
BNE aDec8_01
MOV R0, R3
BX LR

;АтомарнаЯ операциЯ "обмен" длЯ типа u8.
;uint AtomicSwap(u8 volatile *, uint);
_Z10AtomicSwapPVhj:
aSwap8_01: LDREXB R3, [R0]
STREXB R2, R1, [R0]
CMP R2, #0
BNE aSwap8_01
MOV R0, R3
BX LR

;АтомарнаЯ операциЯ "обмен" длЯ типа u16.
;uint AtomicSwap(u16 volatile *, uint);
_Z10AtomicSwapPVtj:
aSwap16_01: LDREXH R3, [R0]
STREXH R2, R1, [R0]
CMP R2, #0
BNE aSwap16_01
MOV R0, R3
BX LR

;АтомарнаЯ операциЯ "обмен" длЯ типа u32.
;u32 AtomicSwap(u32 volatile *, u32);
_Z10AtomicSwapPVjj:
aSwap32_01: LDREX R3, [R0]
STREX R2, R1, [R0]
CMP R2, #0
BNE aSwap32_01
MOV R0, R3
BX LR

;АтомарнаЯ операциЯ "сравнение и обмен" длЯ типа u8.
;uint AtomicCmpSwap(u8 volatile *ptr, uint newVal, uint cmpVal);
_Z13AtomicCmpSwapPVhjj:
aCmpSwap8_01: LDREXB R12, [R0]
CMP R12, R2
ITT EQ
STREXBEQ R3, R1, [R0]
CMPEQ R3, #1
BEQ aCmpSwap8_01
MOV R0, R12
BX LR

;АтомарнаЯ операциЯ "сравнение и обмен" длЯ типа u16.
;uint AtomicCmpSwap(u16 volatile *ptr, uint newVal, uint cmpVal);
_Z13AtomicCmpSwapPVtjj:
aCmpSwap16_01: LDREXH R12, [R0]
CMP R12, R2
ITT EQ
STREXHEQ R3, R1, [R0]
CMPEQ R3, #1
BEQ aCmpSwap16_01
MOV R0, R12
BX LR

;АтомарнаЯ операциЯ "сравнение и обмен" длЯ типа u32.
;u32 AtomicCmpSwap(u32 volatile *ptr, u32 newVal, u32 cmpVal);
_Z13AtomicCmpSwapPVjjj:
aCmpSwap32_01: LDREX R12, [R0]
CMP R12, R2
ITT EQ
STREXEQ R3, R1, [R0]
CMPEQ R3, #1
BEQ aCmpSwap32_01
MOV R0, R12
BX LR

uint AtomicInc(u8 volatile *);
uint AtomicDec(u8 volatile *);
uint AtomicSwap(u8 volatile *, uint);
uint AtomicSwap(u16 volatile *, uint);
u32  AtomicSwap(u32 volatile *, u32);
uint AtomicCmpSwap(u8 volatile *, uint newVal, uint cmpVal);
uint AtomicCmpSwap(u16 volatile *, uint newVal, uint cmpVal);
u32  AtomicCmpSwap(u32 volatile *, u32 newVal, u32 cmpVal);

; std::atomic<unsigned> lalala;
; unsigned to_test = 20;
; ........

; lalala = 10;
8000a8a:    f3bf 8f5f     dmb    sy
8000a8e:    4a0d          ldr    r2, [pc, #52]; (8000ac4 <main+0x3c>)
8000a90:    210a          movs    r1, #10
8000a92:    6011          str    r1, [r2, #0]
8000a94:    f3bf 8f5f     dmb    sy

; lalala.compare_exchange_strong(to_test, 10);
8000a98:    4b0b          ldr    r3, [pc, #44]; (8000ac8 <main+0x40>)
8000a9a:    681c          ldr    r4, [r3, #0]
8000a9c:    f3bf 8f5f     dmb    sy
8000aa0:    e852 0f00     ldrex    r0, [r2]
8000aa4:    42a0          cmp    r0, r4
8000aa6:    d104          bne.n    8000ab2 <main+0x2a>
8000aa8:    e842 1e00     strex    lr, r1, [r2]
8000aac:    f1be 0f00     cmp.w    lr, #0
8000ab0:    d1f6          bne.n    8000aa0 <main+0x18>
8000ab2:    f3bf 8f5f     dmb    sy
8000ab6:    bf18          it    ne
8000ab8:    6018          strne    r0, [r3, #0]

#include <stdint.h>
#include "stm32_lib/stm32l1xx/hl_gpio.hpp"
#include "stm32_lib/stm32l1xx/hl_adc.hpp"
#include "stm32_lib/stm32l1xx/hl_rcc.hpp"

using namespace hl;

typedef PA8 LedPin;

static void init_led()
{
    PA::clock_on();
    PA::reset();
    LedPin::conf_out_push_pull();
    LedPin::off();
}

static void adc_init()
{
    rcc_enable_hsi();
    ADC_<1>::clock_on();
    ADC_<1>::reset();
    ADC_<1>::set_regular_len(1);
    ADC_<1>::set_regular_channel_pos(1, 0);
    ADC_<1>::enable_eoc_interrupt();
    ADC_<1>::enable();
    NVIC_EnableIRQ(ADC1_IRQn);
}

static void led_on(bool value)
{
    LedPin::set_out(value);
}

// Нулевой тест. Между LDREXW и STREXW почти ничего нету
// Монитор НЕ отлавливает нарушение
static void test0()
{
    volatile uint32_t var = 0;
    __LDREXW(&var);
    bool res = __STREXW(10, &var) == 0;
    led_on(res);
}

// Изменение памяти при помощи STR
// Монитор НЕ отлавливает нарушение
static void test1()
{
    volatile uint32_t var = 0;
    __LDREXW(&var);
    var = 20;
    bool res = __STREXW(10, &var) == 0;
    led_on(res);
}

// Изменение одного участка памяти при помощи STREX
// Монитор отлавливает нарушение
static void test2()
{
    volatile uint32_t var = 0;
    __LDREXW(&var);
    __STREXW(20, &var);
    bool res = __STREXW(10, &var) == 0;
    led_on(res);
}

// Изменение разных участков памяти при помощи STREX
// Монитор отлавливает нарушение
static void test3()
{
    volatile uint32_t var = 0;
    volatile uint32_t var2 = 0;
    __LDREXW(&var);
    __STREXW(20, &var2);
    bool res = __STREXW(10, &var) == 0;
    led_on(res);
}

// Прерывание между LDREX и STREX
// Монитор отлавливает нарушение
// volatile bool interrupt_executed = false;
static void test4()
{
    volatile uint32_t var = 0;
    __LDREXW(&var);

    // Вот таким вот нехитрым образом добиваемся прерывания ))
    ADC_<1>::start_regular_conversion();
    ADC_<1>::start_regular_conversion();
    ADC_<1>::start_regular_conversion();
    ADC_<1>::start_regular_conversion();
    ADC_<1>::start_regular_conversion();
    ADC_<1>::start_regular_conversion();
    ADC_<1>::start_regular_conversion();
    ADC_<1>::start_regular_conversion();
    ADC_<1>::start_regular_conversion();
    ADC_<1>::start_regular_conversion();
    ADC_<1>::start_regular_conversion();
    ADC_<1>::start_regular_conversion();
    ADC_<1>::start_regular_conversion();
    ADC_<1>::start_regular_conversion();
    ADC_<1>::start_regular_conversion();
    ADC_<1>::start_regular_conversion();
    ADC_<1>::start_regular_conversion();
    ADC_<1>::start_regular_conversion();
    ADC_<1>::start_regular_conversion();
    ADC_<1>::start_regular_conversion();
    ADC_<1>::start_regular_conversion();
    ADC_<1>::start_regular_conversion();
    // Тут прерывание точно произошло, т.к. мы работаем на частоте 2 МГц, а АЦП на 16 Мгц

    // Это осталось от предыдущего теста:
    // while (!interrupt_executed) {}

    bool res = __STREXW(10, &var) == 0;
    led_on(res);
}

extern "C" void ADC1_IRQHandler()
{
//    interrupt_executed = true;
    ADC_<1>::clear_eoc_flag();
}

int main()
{
    init_led();
    adc_init();
//    test0();
//    test1();
//    test2();
//    test3();
    test4();
}

static void test4()
{
    volatile uint32_t var = 0;
    __LDREXW(&var);

    ADC_<1>::start_regular_conversion();
    while (!interrupt_executed) {}

    bool res = __STREXW(10, &var) == 0;
    led_on(res);
}

extern "C" void ADC1_IRQHandler()
{
    interrupt_executed = true;
    ADC_<1>::clear_eoc_flag();
}

for (;;) {}

bool res = __STREXW(10, &var) == 0;

SCB->ICSR = SCB_ICSR_PENDSVSET_Msk;