Linux/MSP430FR2422: MSP430-GCC 6.1.0.0 optimization compiler error: interrupt handler calls another interrupt handler using normal calling convention

I was able to replicate that but when I specified the vector used::

__attribute__((interrupt(TIMER0_A0_VECTOR))) void fn_11()

The problem vanished.

Why would you change the interrupt vectors while servicing an interrupt? I can't imagine that.

In any case, if things are so dynamic that you can't tell what code you want to execute until the interrupt happens, have the ISR call the appropriate code via a pointer to a function.

Peter,
I don't think you are understanding my approach.
The code at the interrupt vector itself does not change.
I am NOT manipulating the vector itself, as David Schultz had proposed.

The instruction at the vector is merely a branch whose destination address changes based on a RAM variable.
There is no difference between this and the state variable you are proposing, except this solution does not require a costly switch or if statement.
The RAM variable simply stores the next function to call on the next interrupt.
And when you look at the assembler, you will see that this is the most effective approach.
This is established practice for me on the G2553 with an older compiler.

 It's just that the newer compiler for the FR2422 is generating erroneous code, which should be addressed by Mitto.

-Dave

Hi Dave,

Since the way you make use of interrupt functions is quite uncommon, I wanted to get your opinion on how we may extend the optimization of identical interrupt functions.

If your two identical interrupt functions were folded by creating an alias (instead of by creating a wrapper, which is what is happening at the moment), might that cause any problems for your program?

Using the code snippet from your original post as an example, the proposed behaviour would be roughly equivalent to this:

__attribute((interrupt)) 
void fn_11(){ 
 TX_INV_MARK += u.tx.offset_fix; 
 TX_BIT_DOWN_IRQ = u.tx.bit_down_irq; 
} 

__attribute((interrupt,alias("fn_11"))) 
void fn_08(); 

So GCC would detect that the interrupt functions are equivalent and alias them, so they would have the same address. 

Does your program require these interrupt functions with identical contents to have different addresses? Would this proposal cause any issues?

Thanks.

P.S. In the next release we have simply disabled "identical code folding" for interrupt functions, but we are continuing to investigate this possibility of aliasing them for a future release.