Динамическая отправка методов, объявленных вне классов

Question

Я пытаюсь понять реализацию библиотеки, но способ, которым некоторые методы динамически связаны, меня озадачивает. Я знаю механизмы отправки при использовании объекта производного класса, но без объекта я не знаю, как это работает. Библиотека, которую я пытаюсь понять, это libitm от gcc.

Файл заголовка libitm.h объявляет все методы ABI как методы верхнего уровня без класса или структуры вокруг них. И для большинства из них я нашел уникальное определение, поэтому у меня нет вопросов о них, и я их опускаю здесь. Но следующая выдержка показывает объявление 70 методов, которые определяют меня.

typedef uint8_t _ITM_TYPE_U1; 
    typedef uint16_t _ITM_TYPE_U2; 
    typedef uint32_t _ITM_TYPE_U4; 
    typedef uint64_t _ITM_TYPE_U8; 
    typedef float _ITM_TYPE_F; 
    typedef double _ITM_TYPE_D; 
    typedef long double _ITM_TYPE_E; 
    typedef float _Complex _ITM_TYPE_CF; 
    typedef double _Complex _ITM_TYPE_CD; 
    typedef long double _Complex _ITM_TYPE_CE; 

    #define ITM_BARRIERS(T) \ 
     extern _ITM_TYPE_##T _ITM_R##T(const _ITM_TYPE_##T *) ITM_REGPARM; \ 
     extern _ITM_TYPE_##T _ITM_RaR##T(const _ITM_TYPE_##T *) ITM_REGPARM; \ 
     extern _ITM_TYPE_##T _ITM_RaW##T(const _ITM_TYPE_##T *) ITM_REGPARM; \ 
     extern _ITM_TYPE_##T _ITM_RfW##T(const _ITM_TYPE_##T *) ITM_REGPARM; \ 
     extern void _ITM_W##T (_ITM_TYPE_##T *, _ITM_TYPE_##T) ITM_REGPARM; \ 
     extern void _ITM_WaR##T (_ITM_TYPE_##T *, _ITM_TYPE_##T) ITM_REGPARM; \ 
     extern void _ITM_WaW##T (_ITM_TYPE_##T *, _ITM_TYPE_##T) ITM_REGPARM; 

    ITM_BARRIERS(U1) 
    ITM_BARRIERS(U2) 
    ITM_BARRIERS(U4) 
    ITM_BARRIERS(U8) 
    ITM_BARRIERS(F) 
    ITM_BARRIERS(D) 
    ITM_BARRIERS(E) 
    ITM_BARRIERS(CF) 
    ITM_BARRIERS(CD) 
    ITM_BARRIERS(CE) 

В файле dispatch.h на структуру abi_dispatch объявляется, который используется в качестве основы для конкретных рассылок ТМ-алгоритмов. В этой структуре объявления 70 методов, описанных выше, производятся как чистые виртуальные методы. Следующая выдержка показывает макроопределение для методов и структуры.

#define ITM_READ_M(T, LSMOD, M, M2)           \ 
    M _ITM_TYPE_##T ITM_REGPARM ITM_##LSMOD##T##M2 (const _ITM_TYPE_##T *ptr) \ 
    {                   \ 
    return load(ptr, abi_dispatch::LSMOD);         \ 
    } 

#define ITM_READ_M_PV(T, LSMOD, M, M2)          \ 
    M _ITM_TYPE_##T ITM_REGPARM ITM_##LSMOD##T##M2 (const _ITM_TYPE_##T *ptr) \ 
    = 0; 

#define ITM_WRITE_M(T, LSMOD, M, M2)       \ 
    M void ITM_REGPARM ITM_##LSMOD##T##M2 (_ITM_TYPE_##T *ptr, \ 
        _ITM_TYPE_##T val) \ 
    {               \ 
    store(ptr, val, abi_dispatch::LSMOD);     \ 
    } 

#define ITM_WRITE_M_PV(T, LSMOD, M, M2)      \ 
    M void ITM_REGPARM ITM_##LSMOD##T##M2 (_ITM_TYPE_##T *ptr, \ 
        _ITM_TYPE_##T val) \ 
    = 0; 

#define CREATE_DISPATCH_METHODS_T(T, M, M2) \ 
    ITM_READ_M(T, R, M, M2)    \ 
    ITM_READ_M(T, RaR, M, M2)    \ 
    ITM_READ_M(T, RaW, M, M2)    \ 
    ITM_READ_M(T, RfW, M, M2)    \ 
    ITM_WRITE_M(T, W, M, M2)    \ 
    ITM_WRITE_M(T, WaR, M, M2)    \ 
    ITM_WRITE_M(T, WaW, M, M2) 
#define CREATE_DISPATCH_METHODS_T_PV(T, M, M2) \ 
    ITM_READ_M_PV(T, R, M, M2)    \ 
    ITM_READ_M_PV(T, RaR, M, M2)    \ 
    ITM_READ_M_PV(T, RaW, M, M2)    \ 
    ITM_READ_M_PV(T, RfW, M, M2)    \ 
    ITM_WRITE_M_PV(T, W, M, M2)    \ 
    ITM_WRITE_M_PV(T, WaR, M, M2)    \ 
    ITM_WRITE_M_PV(T, WaW, M, M2) 

#define CREATE_DISPATCH_METHODS(M, M2) \ 
    CREATE_DISPATCH_METHODS_T (U1, M, M2) \ 
    CREATE_DISPATCH_METHODS_T (U2, M, M2) \ 
    CREATE_DISPATCH_METHODS_T (U4, M, M2) \ 
    CREATE_DISPATCH_METHODS_T (U8, M, M2) \ 
    CREATE_DISPATCH_METHODS_T (F, M, M2) \ 
    CREATE_DISPATCH_METHODS_T (D, M, M2) \ 
    CREATE_DISPATCH_METHODS_T (E, M, M2) \ 
    CREATE_DISPATCH_METHODS_T (CF, M, M2) \ 
    CREATE_DISPATCH_METHODS_T (CD, M, M2) \ 
    CREATE_DISPATCH_METHODS_T (CE, M, M2) 
#define CREATE_DISPATCH_METHODS_PV(M, M2) \ 
    CREATE_DISPATCH_METHODS_T_PV (U1, M, M2) \ 
    CREATE_DISPATCH_METHODS_T_PV (U2, M, M2) \ 
    CREATE_DISPATCH_METHODS_T_PV (U4, M, M2) \ 
    CREATE_DISPATCH_METHODS_T_PV (U8, M, M2) \ 
    CREATE_DISPATCH_METHODS_T_PV (F, M, M2) \ 
    CREATE_DISPATCH_METHODS_T_PV (D, M, M2) \ 
    CREATE_DISPATCH_METHODS_T_PV (E, M, M2) \ 
    CREATE_DISPATCH_METHODS_T_PV (CF, M, M2) \ 
    CREATE_DISPATCH_METHODS_T_PV (CD, M, M2) \ 
    CREATE_DISPATCH_METHODS_T_PV (CE, M, M2) 

struct abi_dispatch 
{ 
public: 
    enum ls_modifier { NONTXNAL, R, RaR, RaW, RfW, W, WaR, WaW }; 

public: 
    CREATE_DISPATCH_METHODS_PV(virtual,) 
} 

Выведенные из abi_dispatch Структуры могут быть найдены, например, в method-ml или method-gl. Они используют CREATE_DISPATCH_METHODS (виртуальный) и указанный выше макрос для генерации 70 методов чтения/записи и сопоставления их для загрузки/хранения функций шаблона.

Мой большой вопрос: как система времени выполнения знает, какое определение метода (одно в методе-gl или методе-мл) должно использоваться при вызове одной из библиотечных функций? В определении методов чтения/записи не указан объект abi_dispatch. В локальном хранилище потоков есть объект abi-dispatch, но я не знаю, как это вписывается в это.

Благодарим за помощь.

Answer 1

Обнаружено недостающее звено.

Существует еще один макрос (CREATE_DISPATCH_FUNCTIONS), который определяет объявления функций 70 сверху и вызывает соответствующие методы в объекте отправки.