I'm not sure if you want the C code for the function in question or not, so here it is on a separate post.

ATOM_TCB *tcbDequeuePriority (ATOM_TCB **tcb_queue_ptr, uint8_t priority)
{
ATOM_TCB *ret_ptr;

/* Parameter check */
if (tcb_queue_ptr == NULL)
{
/* Return NULL */
ret_ptr = NULL;
}
/* Check for an empty queue */
else if (*tcb_queue_ptr == NULL)
{
/* Return NULL */
ret_ptr = NULL;
}
/* Check if the list head priority is within our range */
else if ((*tcb_queue_ptr)->priority <= priority)
{
/* Remove the list head */
ret_ptr = *tcb_queue_ptr;
*tcb_queue_ptr = (*tcb_queue_ptr)->next_tcb;
if (*tcb_queue_ptr)
{
(*tcb_queue_ptr)->prev_tcb = NULL;
ret_ptr->next_tcb = NULL;
}
}
else
{
/* No higher priority ready threads found */
ret_ptr = NULL;
}

return (ret_ptr);
}

The structure ATOM_TCB is as follows:

typedef struct atom_tcb
{
/* Thread's current stack pointer. When a thread is scheduled
* out the architecture port can save*/
POINTER sp_save_ptr;

/* Thread priority (0-255) */
uint8_t priority;

/* Thread entry point and parameter */
void (*entry_point)(uint32_t);
uint32_t entry_param;

/* Queue pointers */
struct atom_tcb *prev_tcb; /* Previous TCB in doubly-linked TCB list */
struct atom_tcb *next_tcb; /* Next TCB in doubly-linked list */

/* Suspension data */
uint8_t suspended; /* TRUE if task is currently suspended */
uint8_t suspend_wake_status; /* Status returned to woken suspend calls */
ATOM_TIMER *suspend_timo_cb; /* Callback registered for suspension timeouts */

/* Details used if thread stack-checking is required */
#ifdef ATOM_STACK_CHECKING
POINTER stack_top; /* Pointer to top of stack allocation */
uint32_t stack_size; /* Size of stack allocation in bytes */
#endif

} ATOM_TCB;

I have a very similar problem with peephole optimisation.

In my case it seems to have lost the PUSH X and so tries to use the return address instead of the passed parameter (pointer).

int getline_noblock(char * buff, unsigned char maxlen)
{
    char * ptr;
    int c;
    
    ptr = buff;
...

produces this

              ; FUNCTION ?getline_noblock (BEGIN)
              ; Register-parameter buff (XW) is relocated (auto)
              ; Register-parameter maxlen (A) is relocated (auto)
              ; SOURCE LINE # 112 
0000 88                                PUSH   A
0001 5204                              SUB    SP,#004H
              ; SOURCE LINE # 117 
0003 1E06       F                      LDW    X,(006H,SP)   ; [ buff ]
0005 1F01       F                      LDW    (001H,SP),X   ; [ ptr ]
...

This significant line is at offset 0003 which is expecting buff (passed in X) to be on the stack. It should be reading buff, but actually reads the return address. This cause a crash later in the routine when it uses ptr for writing.

RCSTM8 COMPILER V2.40.11.327

I had a very similar problem.

In my case the problem was caused by calling a function with a pointer to a structure.
An extra byte was pushed onto the stack and then not popped before the function return.
I solved it by passing a pointer to a void and casting it to a pointer to the required structure.

Not very nice but I only had a few such functions so not a big problem for me at the moment.