Nearly all Win16 functions are exported as Pascal calling convention. The callee-clean convention saves three bytes at each call point, with a fixed overhead of two bytes per function. So if a function is called ten times, you save 3*10 = 30 bytes for the call points, and pay 2 bytes in the function itself, for a net savings of 28 bytes. It was also fractionally faster. On Win16, saving a few hundred bytes and a few cycles was a big deal.

Согла-       Порядок          Очистка           Расширение           Примечания
шение        передачи         стека             имени
вызова       аргументов

__cdecl      Справа           Аргументы из      К имени функции      Применяется 
             налево           стека удаляются   добавляется пре-     по умолчанию
                              вызывающей        фикс из символа      функциями
                              функцией.         подчеркивания:       C и C++
                              Только это сог-   например, _Foo
                              лашение поддер-  
                              живает перемен-  
                              ное число        
                              аргументов       
                              функций.         
                                               

__stdcall    Справа           Вызванная         К имени функции      Используется почти
             налево           функция сама      добавляется пре-     всеми системными
                              удаляет свои      фикс из символа      функциями; 
                              аргументы из      подчеркивания        Используется по
                              стека.            и суффикс из сим-    умолчанию внут-
                                                вола @, за которым   ренними функциями
                                                следует десятич-     Visual Basic
                                                ный размер списка
                                                аргументов в бай-
                                                тах: например,
                                                _Foo@12
                                               

__fastcall   Первые два       Вызванная         К имени функции      Поддерживается
             параметра        функция сама      добавляется пре-     только процессорами
             типа DWORD       удаляет свои      фикс из символа      с архитектурой Intel.
             передаются       аргументы из      @ и суффикс из       Это соглашение ис-
             в регистрах      стека.            этого же символа,    пользуется по умолча-
             ECX и EDX;                         за которым сле-      нию компиляторами
             Остальные                          дует десятичный      Borland Delphi.
             параметры                          размер списка 
             передаются                         аргументов в бай-
             справа налево.                     тах: например,
                                                @Foo@12

                                               
this         Справа налево.   Аргументы из      Нет.                 Автоматически приме-
(__thiscall) Параметр         стека удаляются                        няется к методам клас-
             this             вызывающей                             сов C++, пока вы не ука-
             передается       функцией.                              жете стандартное согла-
             в регистре                                              шение вызова. При 
             ECX.                                                    объявлении методов COM 
                                                                     используется стандартное
                                                                     соглашение вызова.
                                    
                                    
                                               
naked        Справа налево.   Аргументы из      Нет.                 Используется, когда
                              стека удаляются                        программисту нужно
                              вызывающей                             написать собственные
                              функцией.                              пролог и эпилог.

OE>>Согла-       Порядок          Очистка           Расширение           Примечания
OE>>шение        передачи         стека             имени
OE>>вызова       аргументов                        
OE>>

                                          

OE>>__stdcall    Справа           Вызванная         К имени функции      Используется почти
OE>>             налево          функция сама      добавляется пре-     всеми системными
OE>>             может            удаляет свои      фикс из символа      функциями; 
OE>>             наоборот - ?     аргументы из      подчеркивания        Используется по
OE>>                              стека.            и суффикс из сим-    умолчанию внут-
OE>>                                                вола @, за которым   ренними функциями
OE>>                                                следует десятич-     Visual Basic
OE>>                                                ный размер списка
OE>>                                                аргументов в бай-
OE>>                                                тах: например,
OE>>                                                _Foo@12
OE>>

__stdcall
Microsoft Specific

The __stdcall calling convention is used to call Win32 API functions. The callee cleans the stack, so the compiler makes vararg functions __cdecl. Functions that use this calling convention require a function prototype.


Argument-passing order Right to left.
Argument-passing convention By value, unless a pointer or reference type is passed.
Stack-maintenance responsibility Called function pops its own arguments from the stack.
Name-decoration convention An underscore (_) is prefixed to the name. The name is followed by the at sign (@) followed by the number of bytes (in decimal) in the argument list. Therefore, the function declared as int func( int a, double b ) is decorated as follows: _func@12
Case-translation convention None

The /Gz compiler option specifies __stdcall for all functions not explicitly declared with a different calling convention.

//! Конвертация заданного байта в его строково-шестнадцатиричное представление.
/*!
*    \param[in,out]        al        обрабатываемый байт
*
*    \retval    ah        строково-шестнадцатиричное представление старшей тетрады;
*    \retval    al        строково-шестнадцатиричное представление младшей тетрады.
*
*    \warning
*    ЭТО НЕТРИВИАЛЬНАЯ ФУНКЦИЯ.
*
*    Пролог и эпилог реализованы вручную с целью уменьшения накладных
*    расходов на вызов (часть стандартного пролога и эпилога
*    закомментирована с демонстрационной целью ).
*
*    Накладные расходы: ближний call.
*
*    На самом деле это не С++ функция, а скорее подпрограмма ассемблера.
*
*    \note
*    Обработка двух тетрад за раз ( дублирующийся код ) производится исключительно
*    с целью уменьшения накладных расходов (можно было вынести отдельно).
*/
void __declspec( naked ) cvtByte2strhex( void )
{
    __asm 
    { 
                // ----------  prolog
                //push    ebp                ; Save ebp
                //mov     ebp, esp           ; Set stack frame pointer
                //sub     esp, __LOCAL_SIZE

                mov        ah,    al

                // ----------  обработка первого символа
                shr        ah,    4 

                cmp        ah,    10
                jb            less_then_10_1
            
                add        ah,    'A' - 10
                jmp        next_1

    less_then_10_1:
                or            ah,    '0'

    next_1:
                // ----------  обработка второго символа
                and        al, 0x0F                    // обнуление старшей тетрады

                cmp        al,    10
                jb            less_then_10_2
            
                add        al,    'A' - 10
                jmp        next_2

    less_then_10_2:
                or            al,    '0'
    next_2:

                // ----------  epilog

                //mov         esp, ebp      ; Restore stack pointer
                //pop         ebp           ; Restore ebp
                ret                       ; Return from function
    }
}


//! Конвертация заданного слова содержащего строково-шестнадцатиричное значение в двоичное значение.
/*!
*    \param[in,out]        ax        обрабатываемое слово
*
*    \retval    al        двоичное значение.
*
*    \warning
*    ЭТО НЕТРИВИАЛЬНАЯ ФУНКЦИЯ.
*
*    Пролог и эпилог реализованы вручную с целью уменьшения накладных
*    расходов на вызов (часть стандартного пролога и эпилога
*    закомментирована с демонстрационной целью )
*
*    Накладные расходы: ближний call
*
*    На самом деле это не С++ функция, а скорее подпрограмма ассемблера.
*
*    \note
*    Обработка слова ( дублирующийся код ) производится исключительно
*    с целью уменьшения накладных расходов (можно было вынести отдельно).
*/
void __declspec( naked ) cvtstrhexword2byte( void )
{
    __asm
    { 
            // ----------  prolog
            //push    ebp                ; Save ebp
            //mov     ebp, esp           ; Set stack frame pointer
            //sub     esp, __LOCAL_SIZE

            // ----------  обработка первого символа
            cmp        al,    '9'
            jbe        only_digits1
            
            and        al,    0xDF        // Принудительное преобразование в UpperCase
            sub        al,    7

    only_digits1:
            sub        al,    '0'
            shl        al,    4

            // ----------  обработка второго символа
            cmp        ah,    '9'
            jbe        only_digits2

            and        ah,    0xDF        // Принудительное преобразование в UpperCase
            sub        ah,    7

    only_digits2:
            sub        ah,    '0'

            // ----------  получить в AL - сконвертированное значение байта
            or            al,    ah

        // ----------  epilog

        //mov         esp, ebp      ; Restore stack pointer
        //pop         ebp           ; Restore ebp
        ret                       ; Return from function
    }
}

//! Преобразование числового значения в строково-шестнадцатиричное.
/*!
*
*    \param[in]        sourceVal            конвертируемое значение;
*    \param[in,ou]    pDest                    буфер принимающий сконвертированное значение;
*    \param[in]        sizeOfSourceVal    размер конвертируемого значения.
*
*    \return    pDest
*
*    Данная реализация поддерживает преобразование числовых значений следующих типов:
*        - char;
*        - short;
*        - long.
*
*    \note
*    Значение третьего аргумента (\e sizeOfSourceVal) выводится автоматически.
*    Это крайне необходимо, поскольку я не нашел другого способа получения размера \e T.
*
*    \sa
*    cvtFromStrHex2Value()
*/
template< typename T >
    char* cvtValue2StrHex( const T& sourceVal, char* pDest, const size_t sizeOfSourceVal = sizeof( T ) )
    {
        __asm
        {
                push        ecx
                push        edx
                push        esi

                // EDX - исходное значение
                mov        ecx,    DWORD PTR sourceVal
                mov        edx,    [ecx]

                // ECX - переменная цикла, равна кол-ву байт источника
                mov        ecx,    sizeOfSourceVal

                // ESI - адрес результата
                mov        esi,    pDest

    main_loop:

                mov        al,    dl

                call        cvtByte2strhex

                //    ----------
                shr        edx,    8

                // HACK: инструкция mov - не изменяет флаг ZF
                dec        cx

                // ----------  сохранение результатов
                mov        [esi + ecx * 2 + 1],    al
                mov        [esi + ecx * 2],    ah

                jnz        main_loop

                pop        esi
                pop        edx
                pop        ecx

                mov        eax,    pDest
        }
    }

//! Преобразование  строково-шестнадцатиричного значения в двоичное.
/*!
*    \param[in]            pSourse                буфер содержащий конвертируемое значение;
*    \param[in,out]        destVal                двоичное(сконвертированное) значение;
*    \param[in]            sizeOfDestVal        размер двоичного(сконвертированного) значения.
*
*    \return    destVal
*
*    Данная реализация поддерживает преобразование в значения следующих типов:
*        - char;
*        - short;
*        - long.
*
*    \note
*    Регистр символов - значения не имеет.
*
*    \warning
*    Функция не производит проверки на правильность значений:
*    в случае наличия в строке символа не принадлежащего
*    диапазону '0'-'9' && 'A'-'F' - последствия не определены.
*
*    \note
*    Значение третьего аргумента (\e sizeOfDestVal) выводится автоматически.
*    Это крайне необходимо, поскольку я не нашел другого способа получения размера \e T.
*
*    \sa
*    cvtValue2StrHex()
*/
template< typename T >
    T& cvtFromStrHex2Value( const char* pSourse, T& destVal, const size_t sizeOfDestVal = sizeof( T ) )
    {
        __asm
        {
                // Сохраняем регистры
                push        ecx
                push        edx
                push        esi

                // ECX - переменная цикла, равна кол-ву байт результата
                mov        ecx,    sizeOfDestVal

                // EDX - адрес результата
                mov        edx,    DWORD PTR destVal        

                // ESI - адрес обрабатываемого символа
                mov        esi,    pSourse
        main_loop:
                
                // ----------  сдвиг результата на 8 бит, в зависимости от типа результата
                cmp        sizeOfDestVal, 1
                jne        dest_not_char

                shl        BYTE PTR [edx], 8            // результат типа 'char'
                jmp        after_shift_dest

        dest_not_char:
                cmp        sizeOfDestVal, 2
                jne        dest_not_short

                shl        WORD PTR [edx], 8            // результат типа 'short'
                jmp        after_shift_dest

        dest_not_short:
                shl        DWORD PTR [edx], 8        // результат типа 'long'

        after_shift_dest:

                // ----------  загрузить в AX обрабатываемое слово
                mov        ax,    [ esi ]    
                add        si,    2

                call cvtstrhexword2byte

                // ----------  накопление результата
                or            BYTE PTR [edx],al

                loop        main_loop

                // Поместить в EAX destVal
                mov        eax, edx

                // Восстанавливаем регистры
                pop        esi
                pop        edx
                pop        ecx

        }
}

Такое вообще нигде кроме MSDN не прочитаешь

А тема naked всплыла из-за:

__declspec ИМХО можно встретить только в дешевых книжках аля "Visual C++ за 15 дней", но такое лучше не читать...

OE>>>>Согла-       Порядок          Очистка           Расширение           Примечания
OE>>>>шение        передачи         стека             имени
OE>>>>вызова       аргументов                        
OE>>>>

                                          

OE>>>>__stdcall    Справа           Вызванная         К имени функции      Используется почти
OE>>>>             налево          функция сама      добавляется пре-     всеми системными
OE>>>>             может            удаляет свои      фикс из символа      функциями; 
OE>>>>             наоборот - ?     аргументы из      подчеркивания        Используется по
OE>>>>                              стека.            и суффикс из сим-    умолчанию внут-
OE>>>>                                                вола @, за которым   ренними функциями
OE>>>>                                                следует десятич-     Visual Basic
OE>>>>                                                ный размер списка
OE>>>>                                                аргументов в бай-
OE>>>>                                                тах: например,
OE>>>>                                                _Foo@12
OE>>>>

The __pascal, __fortran, and __syscall calling conventions are no longer supported.

Pascal (__pascal)
Pascal does not support functions with a variable number of parameters, so it can use the callee-clean convention. Parameters are pushed from left to right, because, well, it seemed the natural thing to do.