class TUSART_Coding : public TUSART
{
    private:
        static OS_INTERRUPT void TXHandler(void); // 39 строка
        static OS_INTERRUPT void RXHandler(void); // 40 строка
...
};

OS_INTERRUPT interrupt(USART_RX_vect) TUSART_Coding::RXHandler(void)
{
    OS::TISRW_SS ISRW;
    Read_Next_Byte();
};

OS_INTERRUPT interrupt(USART_TX_vect) TUSART_Coding::TXHandler(void)
{
    OS::TISRW_SS ISRW;
    Write_Next_Byte();
};

OS_INTERRUPT interrupt(USART_RX_vect) TUSART_Coding::RXHandler(void) // Строка №284
{
    OS::TISRW_SS ISRW;
    Read_Next_Byte();
};

OS_INTERRUPT interrupt(USART_TX_vect) TUSART_Coding::TXHandler(void) // Строка №297
{
    OS::TISRW_SS ISRW;
    Write_Next_Byte();
};

# define    OS_INTERRUPT    extern "C" __attribute__((__signal__,__INTR_ATTRS))

#  define __INTR_ATTRS used, externally_visible

SIGNAL(SIG_UART_RECV)
{
    OS::TISRW_SS ISRW;
    Usart1.RXHandler();
}

.h:
ISR(USART_RXC_vect);
ISR(USART_UDRE_vect);

class uart_t
{
public:
    uart_t() {};
    ...
private:
    friend void USART_RXC_vect();
    friend void USART_UDRE_vect();
    void RXC_Handler();
    void UDRE_Handler();
    ...
}
.cpp:
inline void uart_t::RXC_Handler()
{
    ...
}

OS_INTERRUPT void USART_RXC_vect()
{
    OS::TISRW isr;
    UART.RXC_Handler();
}

define ISR_NOBLOCK    __attribute__((interrupt))

OS_INTERRUPT void INT0_vect(); // имя INT0_vect и подобные - в точности те, что даются макросу ISR() !!!

class foo
{
    friend void INT0_vect();

...

private:
   inline void isr_handler();
};

foo f;

OS_INTERRUPT  // уже не обязательно, но и не мешает
void INT0_vect()
{
    f.isr_handler();
}

SIGNAL(SIG_UART_RECV)
{
     OS::TISRW_SS ISRW;
     Usart1.RXHandler();
}

// foo.h
#include <avr/io.h>
#include <avr/interrupt.h>

SIGNAL(INT0_vect);
// примитивная наколка - после разворачивания SIGNAL это будет эквивалентно
//   extern "C" void INT0_vect(void) __attribute__ ((signal, __INTR_ATTRS));   void INT0_vect(void);
// второе объявление функции просто ничего не меняет

class foo_t
{
    friend void INT0_vect();
public:
    uint8_t get() { return tick; }
private:
    uint8_t tick;
    inline void isr_handler() { ++tick; }
};

// foo.cpp
#include "foo.h"
foo_t foo;

// а тут наконец-то определяем
SIGNAL(INT0_vect)
{
    foo.isr_handler();
}

// Timer.h
#include <avr/interrupt.h>
#define    OS_INTERRUPT    extern "C" __attribute__((__signal__,__INTR_ATTRS))

class Timer
{
public:
    Timer( ) { }
    ~Timer( ) { }

    void Dispatch( ) { }
    static void IRQHandler( ) asm( "__vector_10" ); // Или, не 10 ( взято "с потолка" ), в любом случае, меняя нумер можно
                                                                                 //  подставить куда угодно
};

// Timer.cpp
#include "Timer.h"

Timer timer;

//---------------------------------------------------------------
OS_INTERRUPT void Timer::IRQHandler(void)
{
    timer.Dispatch( );
}

$ nm Timer.o
00000150 t _GLOBAL__D_timer
00000138 t _GLOBAL__I_timer
000000d4 t _Z41__static_initialization_and_destruction_0ii
00000054 W _ZN5Timer8DispatchEv
00000000 W _ZN5TimerC1Ev
0000002a W _ZN5TimerD1Ev
0000003e a __SP_H__
0000003d a __SP_L__
0000003f a __SREG__
         U __do_clear_bss
         U __do_copy_data
         U __do_global_ctors
         U __do_global_dtors
00000000 a __tmp_reg__
0000007e T __vector_10       <===== Оно!
00000001 a __zero_reg__
00000000 B timer

Disassembly of section .text:

00000000 <__vectors>:
   0:   1b c0           rjmp    .+54           ; 0x38 <__dtors_end>
   2:   3f c0           rjmp    .+126          ; 0x82 <__bad_interrupt>
   4:   3e c0           rjmp    .+124          ; 0x82 <__bad_interrupt>
   6:   3d c0           rjmp    .+122          ; 0x82 <__bad_interrupt>
   8:   3c c0           rjmp    .+120          ; 0x82 <__bad_interrupt>
   a:   3b c0           rjmp    .+118          ; 0x82 <__bad_interrupt>
   c:   3a c0           rjmp    .+116          ; 0x82 <__bad_interrupt>
   e:   39 c0           rjmp    .+114          ; 0x82 <__bad_interrupt>
  10:   38 c0           rjmp    .+112          ; 0x82 <__bad_interrupt>
  12:   37 c0           rjmp    .+110          ; 0x82 <__bad_interrupt>
  14:   76 c0           rjmp    .+236          ; 0x102 <__vector_10>         <=== Оно!
  16:   35 c0           rjmp    .+106          ; 0x82 <__bad_interrupt>
  18:   34 c0           rjmp    .+104          ; 0x82 <__bad_interrupt>
  1a:   33 c0           rjmp    .+102          ; 0x82 <__bad_interrupt>
  1c:   32 c0           rjmp    .+100          ; 0x82 <__bad_interrupt>
  1e:   31 c0           rjmp    .+98           ; 0x82 <__bad_interrupt>
  20:   30 c0           rjmp    .+96           ; 0x82 <__bad_interrupt>
  22:   2f c0           rjmp    .+94           ; 0x82 <__bad_interrupt>
  24:   2e c0           rjmp    .+92           ; 0x82 <__bad_interrupt>
  26:   2d c0           rjmp    .+90           ; 0x82 <__bad_interrupt>
  28:   2c c0           rjmp    .+88           ; 0x82 <__bad_interrupt>
  2a:   2b c0           rjmp    .+86           ; 0x82 <__bad_interrupt>
  2c:   2a c0           rjmp    .+84           ; 0x82 <__bad_interrupt>
  2e:   29 c0           rjmp    .+82           ; 0x82 <__bad_interrupt>
  30:   28 c0           rjmp    .+80           ; 0x82 <__bad_interrupt>
  32:   27 c0           rjmp    .+78           ; 0x82 <__bad_interrupt>