Yet they have the concept of calling conventions, which is the same thing, just more limited.

Custom calling convention is needed for connecting assembly language and hll language properly. Just the need to push variables to stack (when you could just pass them in registers) kind of defeats the point of writing some function in assembly.

Pseudocode:

Code:

func do_something([eax] int par1, [ecx] int par2) : [eax] int res {
    res = par1 + par2
}    

If you specify that some registers are trashed by this function, they will be saved before entering the function and restored after this function (or maybe this register just wouldn't be used outside for some time, for 5 or more function calls in a row). If some registers are marked as preserved, they will be saved on entering the function (or somewhere in the middle), and restored at exiting it (or somewhere in the middle).

Ideally it will be the compiler who will decide a proper calling convention. But register allocation is a complex problem, probably only solvable by trial and error, and benchmarks.

GLOBAL(boolean)
jpeg_fill_bit_buffer (bitread_working_state *state,
                      register bit_buf_type get_buffer, register int bits_left,
                      int nbits)    

@DimonSoft In fastcall you can use only 3 registers, while you potentially can use all 7 for passing data (esp still used for stack).

Look at "register" keyword. This does what I hope this does?

#include <stdio.h>

void test_reg(register int i) {
        i = 2;
}

int main() {
        int i = 1;
        printf("%i\n", i);
        test_reg(i);
        printf("%i\n", i);
        getchar();
}

//output:
//1
//1    

BTW fastcall passes only 2 parameters in registers: ecx and edx. eax is not used and neither preserved.

The 3 parameters (eax, ecx, edx) is a GCC-specific custom calling convention (by custom I mean that it doesn't even have a name, you have to use regparm(3) attribute AFAIK, or it does it automatically if it determines all callers of the function (LTO or if it's with static linkage)).