Replace assembly code responsible for doing generic C calls

[SanderMertens]

The file db_cdecl_x86.s contains assembly code that is capable of generically invoking subroutines without knowing their signature at compile-time. This is something that is not possible in C, hence the need for assembly (you can't manipulate the stack directly in C). Note that this is a problem only in C and C++.

The assembly however makes it very hard to port the code other platforms / architectures / compilers. To encourage porting the code to other platforms the dependency on assembly code must be removed.

An alternative approach is to wrap the calls in an interface that is mandated by the language binding. Consider the following C-function:

db_uint32 multiply(db_uint32 a, db_uint32 b) {
    return a + b;
}

Suppose that now a script run by the virtual machine wants to call this function. Since the virtual machine doesn't know this function and doesn't know its signature it cannot call the function directly. However, when this function would be wrapped into a mandated interface:

db_void __multiply(void *args, void *result) {
    *(db_uint32*)result = 
        multiply(*(db_uint32*)args, *(db_uint32*)((intptr_t)args + sizeof(db_uint32)));
}

... the function could be generically called from anywhere even when the callee signature is not known by the caller. This approach is likely to be faster than the assembly approach since the assembly had to figure out based on metadata how to call the function, while this approach hard-codes the mapping to a generic interface.

The only downside of this approach is that wrapper functions have to be created and executable footprint is increased by a little bit. Wrapper functions can be generated though so this wouldn't be visible for a user.

The wrapper function pointer will be stored in the "impl" field of the function.

[SanderMertens]

The wrapper generation will happen in the C interface generator since this generator also generates the procedure bodies. Since it is undesirable that the wrapper methods "clutter" the interface implementation files they will be stored in a separate file called *__wrapper.c.

The interface implementations are currently already "cluttered" with functions that are generated for calling virtual methods. It would make sense to also store these method implementations in *__wrapper.c.

[SanderMertens]

This issue is solved now that dependent issue #21 is fixed.