4字节未对齐写入地址

Question

I'm doing a port of the CHibiOS RTOS to the lm32 microprocessor.

I have a problem of misaligned memory address in the first line of code that I codified to setup a new thread. The other three lines already gave to me a similar problem when they tried to write to memory, but I solved it aligning the intctx and context struct putting __attribute__((packed)); .

The code is the following:

tp->p_ctx.sp = (struct intctx*)((uint32_t *)wsp + size - sizeof(struct intctx));
tp->p_ctx.sp->r1 = (uint32_t)arg;
tp->p_ctx.sp->r2 = (uint32_t)pf;
tp->p_ctx.sp->ra = (uint32_t)port_thread_start;

The structs are defined in a header file implemented by me:

struct intctx {
uint32_t r1;
uint32_t r2;
uint32_t r3;
uint32_t r4;
uint32_t r5;
uint32_t r6;
uint32_t r7;
uint32_t r8;
uint32_t r9;
uint32_t r10;
uint32_t r11;
uint32_t r12;
uint32_t r13;
uint32_t r14;
uint32_t r15;
uint32_t r16;
uint32_t r17;
uint32_t r18;
uint32_t r19;
uint32_t r20;
uint32_t r21;
uint32_t r22;
uint32_t r23;
uint32_t r24;
uint32_t r25;
uint32_t gp;
uint32_t fp;
uint32_t sp;
uint32_t ra;
uint32_t ea;
uint32_t ba;
} __attribute__((packed));

struct context {
struct intctx *sp;
} __attribute__((packed));

I used gdb to debug and when it try to execute the line:

tp->p_ctx.sp = (struct intctx*)((uint32_t *)wsp + size - sizeof(struct intctx)); 

It gives the following problem:

core: 4 byte misaligned write to address 0x107409 at 0x100b20

Program received signal SIGBUS, Bus error.
0x00000080 in ?? ()

Can anyone help me? Thank you.

---

The wsp is passed by reference as parameter of the function where these lines of code are. the wsp has the type void *: But this is a Thread * type, wsp point to the idle thread struct.

The line of code is implemented in the same function in other architectures that ChibiOS has support and I only did the same:

tp->p_ctx.sp =  (struct intctx*)((uint32_t *)wsp + size - sizeof(struct intctx));

This is the complete function:

Thread *chThdCreateI(void *wsp, size_t size,
                 tprio_t prio, tfunc_t pf, void *arg) {
/* Thread structure is laid out in the lower part of the thread workspace.*/
Thread *tp = wsp;

chDbgCheckClassI();

chDbgCheck((wsp != NULL) && (size >= THD_WA_SIZE(0)) &&
         (prio <= HIGHPRIO) && (pf != NULL),
         "chThdCreateI");
tp->p_ctx.sp =  (struct intctx*)((uint32_t *)wsp + size - sizeof(struct intctx));
tp->p_ctx.sp->r1 = (uint32_t)arg;
tp->p_ctx.sp->r2 = (uint32_t)pf;
tp->p_ctx.sp->ra = (uint32_t)port_thread_start;
//SETUP_CONTEXT(wsp, size, pf, arg);
return _thread_init(tp, prio);
}

Answer 1

What is the type of wsp? I'd suggest that an array of chars, or whatever else you're defining it as isn't required to be suitably aligned to store int32_t types. Consider how buses are conventionally aligned to retrieve int32_t values aligned in groups of 32 bits. Now consider what "bus error" might actually mean on the architecture level:

1. More than one fetch is required to retrieve the value (undesirable in terms of performance), or
2. Your program malfunctions (even worse)

On common Intel implementations, it uses the first option unless you or your debugger inject some assembly madness to your program (for example, see this wikipedia article ). In C, it's just plain undefined behaviour. Make sure wsp is suitably aligned to point at int32_t types. You can do this by ensuring that it points at one of these:

1. An int32_t variable, or
2. Any int32_t objects within an array, or:
3. A return value of malloc, calloc or realloc, or:
4. Any int32_t objects of "a malloc/calloc/realloc return value treated as a pointer to int32_t ".

I think you're confused in regards to pointer arithmetic. Which book are you reading?