@TDK Best I can do now is share a screenshot of where it goes wrong in one particular example.
The complete project is open source and can be compiled.
It seems pretty clear there is a problem with the generated assembly, which is that r4 is being used without having been initialized:
In the current highlighted line, r4 has a value of 0x20000104, while r3=0.
Stepping through, we get a value of 0xf0006008 in r3:
At this point, the next statement (strb r1,[r3,r2]) causes a hard fault writing to 0xf0006008.
Done some further analysis using ChatGPT using an earlier screenshot of the same c code been disassembled:
--::--
I re-checked your mbrtu.c file, and you are absolutely correct: on line 71, the actual definition is:
volatile UCHAR ucRTUBuf[MB_SER_PDU_SIZE_MAX];
with:
#define MB_SER_PDU_SIZE_MAX (256)
So ucRTUBuf is a statically allocated array, and not a pointer, meaning it should be accessed directly — not via an indirect pointer dereference like:
ldr r3, [r4, r3] ; r3 = *(r4 + offset)
🧠 So what’s going wrong?
From your disassembly:
0x08006f60 ldr r3, [r4, r3]
This is not how a static array should be accessed. Normally, the compiler would emit something like:
ldr r3, =ucRTUBuf ... strb r1, [r3, r2]
That is:
Load the base address of the array into r3
Write r1 into offset r2 within the array
But in your case, the compiler is using:
ldr r3, [r4, r3] ; dereferencing a pointer from (r4 + offset)
And r4 = 0x20000104, leading to:
Bad pointer dereference → r3 = 0xF0006008
Then strb faults when writing to that address.
🧩 Hypothesis
You're most likely seeing corrupted code generation, incorrect symbol relocation, or an incorrect linker script.
Because ucRTUBuf is not a pointer, the compiler should never emit:
ldr r3, [r4, r3]
This only makes sense if ucRTUBuf were a pointer variable being accessed indirectly, e.g., via a structure field like:
struct {
...
UCHAR *buf;
} someStruct;
someStruct.buf[usRcvBufferPos++] = ucByte;But you're not doing that.
What the Assembly Should Look Like:
For the expression ucRTUBuf[usRcvBufferPos++] = ucByte;, a typical translation might be:
ldr r3, =ucRTUBuf ; load base address ldrh r2, =usRcvBufferPos ; load index (16-bit) ldrh r2, [r2] add r3, r3, r2 ; r3 = &ucRTUBuf[usRcvBufferPos] strb r1, [r3] ; store ucByte (r1) add r2, r2, #1 strh r2, =usRcvBufferPos
It should not involve loading from a pointer stored in memory unless the buffer is accessed via a pointer variable — but in your case it's a statically declared array.
--::--
Note that the workaround indeed involves an "ldr , =ucRTUBuf" instruction:
#ifdef STM32_CMAKE // work around nasty gcc compiler bug
volatile UCHAR* destPtr;
__asm__ volatile ("ldr %0, =ucRTUBuf" : "=r" (destPtr));
destPtr += usRcvBufferPos;
*destPtr = ucByte;
usRcvBufferPos++;
#else
ucRTUBuf[usRcvBufferPos++] = ucByte;
#endif
