void dc_callvm_mode_ppc32(DCCallVM* in_self, DCint mode)
{
DCCallVM_ppc32* self = (DCCallVM_ppc32*) in_self;
DCCallVM_vt* vt;
switch(mode) {
case DC_CALL_C_PPC32_OSX:
#if defined(DC__ABI_Darwin)
case DC_CALL_C_DEFAULT:
case DC_CALL_C_ELLIPSIS:
#endif
vt = &gVT_ppc32_darwin;
break;
case DC_CALL_C_PPC32_SYSV:
#if defined(DC__ABI_SysV)
case DC_CALL_C_DEFAULT:
case DC_CALL_C_ELLIPSIS:
#endif
vt = &gVT_ppc32_sysv;
break;
default:
self->mInterface.mError = DC_ERROR_UNSUPPORTED_MODE;
return;
}
dc_callvm_base_init(&self->mInterface, vt);
dcReset(in_self);
}
void dc_callvm_mode_ppc64(DCCallVM* in_self, DCint mode)
{
DCCallVM_ppc64* self = (DCCallVM_ppc64*) in_self;
DCCallVM_vt* vt;
switch(mode) {
case DC_CALL_C_PPC64:
case DC_CALL_C_DEFAULT:
case DC_CALL_C_ELLIPSIS:
#if DC__ABI_PPC64_ELF_V == 2
vt = &gVT_ppc64;
break;
case DC_CALL_C_ELLIPSIS_VARARGS:
vt = &gVT_ppc64_ellipsis;
break;
#else
case DC_CALL_C_ELLIPSIS_VARARGS:
vt = &gVT_ppc64;
break;
#endif
case DC_CALL_SYS_DEFAULT:
case DC_CALL_SYS_PPC64:
vt = &gVT_ppc64_syscall;
break;
default:
self->mInterface.mError = DC_ERROR_UNSUPPORTED_MODE;
return;
}
dc_callvm_base_init(&self->mInterface, vt);
}
static DCCallVM* dc_callvm_new_arm32_thumb(DCCallVM_vt* vt, DCsize size)
{
/* Store at least 16 bytes (4 words) for internal spill area. Assembly code depends on it. */
DCCallVM_arm32_thumb* self = (DCCallVM_arm32_thumb*)dcAllocMem(sizeof(DCCallVM_arm32_thumb)+size+16);
dc_callvm_base_init(&self->mInterface, vt);
dcVecInit(&self->mVecHead, size);
return (DCCallVM*)self;
}
static DCCallVM* dc_callvm_new_mips_o32(DCCallVM_vt* vt, DCsize size)
{
DCCallVM_mips_o32* self = (DCCallVM_mips_o32*)dcAllocMem(sizeof(DCCallVM_mips_o32)+size);
dc_callvm_base_init(&self->mInterface, vt);
dcVecInit(&self->mVecHead, size);
dc_callvm_reset_mips_o32( (DCCallVM*) self );
return (DCCallVM*)self;
}
/* the six output registers %o0-%o5 are always loaded, thus we need to ensure the argument buffer has space for at least 24 bytes. */
static DCCallVM* dc_callvm_new_sparc(DCCallVM_vt* vt, DCsize size)
{
size=DC_MAX(size,sizeof(void*)*(6+1));
DCCallVM_sparc* self = (DCCallVM_sparc*) dcAllocMem(sizeof(DCCallVM_sparc)+size);
dc_callvm_base_init(&self->mInterface, vt);
dcVecInit(&self->mVecHead,size);
return (DCCallVM*)self;
}
/* the six output registers %o0-%o5 are always loaded, thus we need to ensure the argument buffer has space for at least 24 bytes. */
static DCCallVM* dc_callvm_new_sparc64(DCCallVM_vt* vt, DCsize size)
{
DCCallVM_sparc64* self = (DCCallVM_sparc64*) dcAllocMem(sizeof(DCCallVM_sparc64)+DHEAD+size);
dc_callvm_base_init(&self->mInterface, vt);
dcVecInit(&self->mVecHead,DHEAD+size);
dc_callvm_reset_sparc64(&self->mInterface);
return (DCCallVM*)self;
}
static DCCallVM* dc_callvm_new_x86(DCCallVM_vt* vt, DCsize size)
{
DCCallVM_x86* self = (DCCallVM_x86*) dcAllocMem( sizeof(DCCallVM_x86)+size );
dc_callvm_base_init(&self->mInterface, vt);
self->mIntRegs = 0;
dcVecInit(&self->mVecHead, size);
return (DCCallVM*) self;
}
static DCCallVM* dc_callvm_new_arm32_armhf(DCCallVM_vt* vt, DCsize size)
{
/* Store at least 16 bytes (4 words) for internal spill area. Assembly code depends on it. */
DCCallVM_arm32_armhf* p = (DCCallVM_arm32_armhf*)dcAllocMem(sizeof(DCCallVM_arm32_armhf)+size+16);
dc_callvm_base_init(&p->mInterface, vt);
dcVecInit(&p->mVecHead, size);
p->i = 0;
p->s = 0;
p->d = 0;
return (DCCallVM*)p;
}
static DCCallVM* dc_callvm_new_arm64(DCCallVM_vt* vt, DCsize size)
{
DCCallVM_arm64* p = (DCCallVM_arm64*) dcAllocMem(size);
dc_callvm_base_init(&p->mInterface, vt);
dcVecInit(&p->mVecHead, size);
p->i = 0;
p->f = 0;
return (DCCallVM*)p;
}
static DCCallVM* dc_callvm_new_x64(DCCallVM_vt* vt, DCsize size)
{
DCCallVM_x64* self = (DCCallVM_x64*)dcAllocMem(sizeof(DCCallVM_x64)+size);
dc_callvm_base_init(&self->mInterface, vt);
/* Since we store register parameters in DCCallVM_x64 directly, adjust the stack size. */
size -= sizeof(DCRegData_x64);
size = (((signed long)size) < 0) ? 0 : size;
self->mRegCount.i = self->mRegCount.f = 0;
dcVecInit(&self->mVecHead, size);
return (DCCallVM*)self;
}
/* mode: only a single mode available currently. */
static void dc_callvm_mode_mips_eabi(DCCallVM* in_self, DCint mode)
{
DCCallVM_mips_eabi* self = (DCCallVM_mips_eabi*)in_self;
DCCallVM_vt* vt;
switch(mode) {
case DC_CALL_C_DEFAULT:
case DC_CALL_C_MIPS32_EABI:
case DC_CALL_C_ELLIPSIS:
case DC_CALL_C_ELLIPSIS_VARARGS:
vt = &gVT_mips_eabi;
break;
default:
self->mInterface.mError = DC_ERROR_UNSUPPORTED_MODE;
return;
}
dc_callvm_base_init(&self->mInterface, vt);
}
static void mode(DCCallVM* in_self, DCint mode)
{
DCCallVM_arm32_armhf* self = (DCCallVM_arm32_armhf*)in_self;
DCCallVM_vt* vt;
switch(mode) {
case DC_CALL_C_DEFAULT:
case DC_CALL_C_ARM_ARMHF:
vt = &vt_armhf;
break;
case DC_CALL_C_ELLIPSIS:
case DC_CALL_C_ELLIPSIS_VARARGS:
vt = &vt_armhf_ellipsis;
break;
default:
self->mInterface.mError = DC_ERROR_UNSUPPORTED_MODE;
return;
}
dc_callvm_base_init(&self->mInterface, vt);
}
void dc_callvm_mode_x86(DCCallVM* in_self, DCint mode)
{
DCCallVM_x86* self = (DCCallVM_x86*)in_self;
DCCallVM_vt* vt;
switch(mode) {
case DC_CALL_C_DEFAULT:
case DC_CALL_C_ELLIPSIS:
case DC_CALL_C_ELLIPSIS_VARARGS:
/* Plan9 (and forks) have their own calling convention (and no support for foreign ones). */
#if defined(DC_PLAN9)
case DC_CALL_C_X86_PLAN9: vt = &gVT_x86_plan9; break;
#else
case DC_CALL_C_X86_CDECL: vt = &gVT_x86_cdecl; break;
case DC_CALL_C_X86_WIN32_STD: vt = &gVT_x86_win32_std; break;
case DC_CALL_C_X86_WIN32_FAST_MS: vt = &gVT_x86_win32_fast_ms; break;
case DC_CALL_C_X86_WIN32_THIS_MS: vt = &gVT_x86_win32_this_ms; break;
case DC_CALL_C_X86_WIN32_FAST_GNU: vt = &gVT_x86_win32_fast_gnu; break;
case DC_CALL_C_X86_WIN32_THIS_GNU: vt = &gVT_x86_cdecl; break;
case DC_CALL_SYS_DEFAULT:
# if defined DC_UNIX
# if defined DC__OS_Linux
vt = &gVT_x86_sys_int80h_linux; break;
# else
vt = &gVT_x86_sys_int80h_bsd; break;
# endif
# else
self->mInterface.mError = DC_ERROR_UNSUPPORTED_MODE; return;
# endif
case DC_CALL_SYS_X86_INT80H_LINUX: vt = &gVT_x86_sys_int80h_linux; break;
case DC_CALL_SYS_X86_INT80H_BSD: vt = &gVT_x86_sys_int80h_bsd; break;
#endif
default:
self->mInterface.mError = DC_ERROR_UNSUPPORTED_MODE;
return;
}
dc_callvm_base_init(&self->mInterface, vt);
}
