static void dc_callvm_argLongLong_ppc32_sysv(DCCallVM* in_self, DClonglong L)
{
DCint* p = (DCint*) &L;
DCCallVM_ppc32* self = (DCCallVM_ppc32*)in_self;
/* fillup integer register file */
if (self->mIntRegs < 7)
{
/* next free integer register is even (r0, r2, r3) ? */
/* if not, skip one integer */
if (self->mIntRegs & 1) self->mIntRegs++;
self->mRegData.mIntData[self->mIntRegs++] = p[0];
self->mRegData.mIntData[self->mIntRegs++] = p[1];
}
/* OR push onto stack */
else
{
/* in case, mIntRegs == 7, set it to 8 */
self->mIntRegs = 8;
/* align stack to 8 byte boundary */
dcVecResize(&self->mVecHead , ( dcVecSize(&self->mVecHead) + 7 ) & (-8UL) );
/* push data */
dcVecAppend(&self->mVecHead,&L,sizeof(DClonglong));
}
}
static void dc_callvm_argFloat_mips_o32(DCCallVM* in_self, DCfloat x)
{
DCCallVM_mips_o32* self = (DCCallVM_mips_o32*)in_self;
dcVecAppend(&self->mVecHead, &x, sizeof(DCfloat) );
if (self->mArgCount < 2) {
/*
call kernel
mips:
lwc1 $f12, 4($5) <--- byte offset 4
lwc1 $f13, 0($5)
lwc1 $f14, 12($5) <--- byte offset 12
lwc1 $f15, 8($5)
mipsel:
lwc1 $f12, 0($5) <--- byte offset 4
lwc1 $f13, 4($5)
lwc1 $f14, 8($5) <--- byte offset 12
lwc1 $f15, 12($5)
*/
#if defined(__MIPSEL__)
/* index 0 and 2 */
self->mRegData.floats[self->mArgCount*2] = x;
#else
/* index 1 and 3 */
self->mRegData.floats[self->mArgCount*2+1] = x;
#endif
}
self->mArgCount++;
}
static void dc_callvm_argFloat_mips_o32(DCCallVM* in_self, DCfloat x)
{
DCCallVM_mips_o32* self = (DCCallVM_mips_o32*)in_self;
dcVecAppend(&self->mVecHead, &x, sizeof(DCfloat) );
if (self->mArgCount < 2) {
#if defined(DC__Endian_LITTLE)
self->mRegData.u[self->mArgCount].f[0] = x;
#else
self->mRegData.u[self->mArgCount].f[1] = x;
#endif
#if 0
self->mRegData.u[self->mArgCount].f[1] = x;
call kernel
mips:
lwc1 $f12, 4($5) <--- byte offset 4
lwc1 $f13, 0($5)
lwc1 $f14, 12($5) <--- byte offset 12
lwc1 $f15, 8($5)
mipsel:
lwc1 $f12, 0($5) <--- byte offset 4
lwc1 $f13, 4($5)
lwc1 $f14, 8($5) <--- byte offset 12
lwc1 $f15, 12($5)
#if defined(DC__Endian_LITTLE)
/* index 0 and 2 */
self->mRegData.floats[self->mArgCount*2] = x;
#else
/* index 1 and 3 */
self->mRegData.floats[self->mArgCount*2+1] = x;
#endif
#endif
}
static void dc_callvm_argDouble_arm32_thumb_eabi(DCCallVM* in_self, DCdouble x)
{
DCCallVM_arm32_thumb* self = (DCCallVM_arm32_thumb*)in_self;
/* 64 bit values need to be aligned on 8 byte boundaries */
dcVecSkip(&self->mVecHead, dcVecSize(&self->mVecHead) & 4);
dcVecAppend(&self->mVecHead, &x, sizeof(DCdouble));
}
static void dc_callvm_argPointer_x64(DCCallVM* in_self, DCpointer x)
{
DCCallVM_x64* self = (DCCallVM_x64*)in_self;
if(self->mRegCount.i < numIntRegs)
*(DCpointer*)&self->mRegData.i[self->mRegCount.i++] = x;
else
dcVecAppend(&self->mVecHead, &x, sizeof(DCpointer));
}
static void dc_callvm_argDouble_x64(DCCallVM* in_self, DCdouble x)
{
DCCallVM_x64* self = (DCCallVM_x64*)in_self;
if(self->mRegCount.f < numFloatRegs)
self->mRegData.f[self->mRegCount.f++] = x;
else
dcVecAppend(&self->mVecHead, &x, sizeof(DCdouble));
}
static void dc_callvm_argFloat_mips_eabi(DCCallVM* in_self, DCfloat x)
{
DCCallVM_mips_eabi* self = (DCCallVM_mips_eabi*)in_self;
if (self->mSingleRegs < 8) {
self->mRegData.mSingleData[self->mSingleRegs++] = x;
} else {
dcVecAppend(&self->mVecHead, &x, sizeof(DCfloat) );
}
}
static void dc_callvm_argInt_mips_eabi(DCCallVM* in_self, DCint i)
{
DCCallVM_mips_eabi* self = (DCCallVM_mips_eabi*)in_self;
/* fillup integer register file */
if (self->mIntRegs < 8)
self->mRegData.mIntData[self->mIntRegs++] = i;
else
dcVecAppend(&self->mVecHead, &i, sizeof(DCint));
}
static void dc_callvm_argLongLong_mips_n64(DCCallVM* in_self, DClonglong Lv)
{
DCCallVM_mips_n64* self = (DCCallVM_mips_n64*)in_self;
/* fillup integer register file */
if (self->mRegCount < 8)
self->mRegData.mIntData[self->mRegCount++] = Lv;
else
dcVecAppend(&self->mVecHead, &Lv, sizeof(DClonglong));
}
static void dc_callvm_argInt_ppc32_darwin(DCCallVM* in_self, DCint i)
{
DCCallVM_ppc32* self = (DCCallVM_ppc32*)in_self;
/* fillup integer register file */
if (self->mIntRegs < 8)
self->mRegData.mIntData[self->mIntRegs++] = i;
/* AND push onto stack */
dcVecAppend(&self->mVecHead,&i,sizeof(DCint));
}
static void dc_callvm_argLongLong_mips_o32(DCCallVM* in_self, DClonglong Lv)
{
DCCallVM_mips_o32* self = (DCCallVM_mips_o32*)in_self;
/* 64-bit values need to be aligned on 8 byte boundaries */
dcVecSkip(&self->mVecHead, dcVecSize(&self->mVecHead) & 4);
dcVecAppend(&self->mVecHead, &Lv, sizeof(DClonglong));
self->mArgCount += 1;
}
static void dc_callvm_argLongLong_x64(DCCallVM* in_self, DClonglong x)
{
/* A long long always has 64 bits on the supported x64 platforms (lp64 on unix and llp64 on windows). */
DCCallVM_x64* self = (DCCallVM_x64*)in_self;
if(self->mRegCount.i < numIntRegs)
self->mRegData.i[self->mRegCount.i++] = x;
else
dcVecAppend(&self->mVecHead, &x, sizeof(DClonglong));
}
static void dc_callvm_argInt_x86_win32_fast_gnu(DCCallVM* in_self, DCint x)
{
DCCallVM_x86* self = (DCCallVM_x86*) in_self;
if (self->mIntRegs < 2) {
*( (int*) dcVecAt(&self->mVecHead, sizeof(DCint) * self->mIntRegs ) ) = x;
++( self->mIntRegs );
} else
dcVecAppend(&self->mVecHead, &x, sizeof(DCint) );
}
static void dc_callvm_argStruct_x64(DCCallVM* in_self, DCstruct* s, DCpointer x)
{
DCCallVM_x64* self = (DCCallVM_x64*)in_self;
dcVecAppend(&self->mVecHead, x, s->size);
/*printf("dc_callvm_argStruct_x64 size = %d\n", (int)s->size);@@@*/
if (s->size <= 64)
dcArgStructUnroll(in_self, s, x);
/*else@@@*/
/* dcVecAppend(&self->mVecHead, &x, sizeof(DCpointer));@@@*/
}
static void a_double(DCCallVM* in_p, DCdouble x)
{
DCCallVM_arm64* p = (DCCallVM_arm64*)in_p;
if (p->f < 8) {
p->u.D[ p->f ] = x;
p->f++;
} else {
dcVecAppend(&p->mVecHead, &x, sizeof(DCdouble));
}
}
static void dc_callvm_argDouble_mips_o32(DCCallVM* in_self, DCdouble x)
{
DCCallVM_mips_o32* self = (DCCallVM_mips_o32*)in_self;
/* 64-bit values need to be aligned on 8 byte boundaries */
dcVecSkip(&self->mVecHead, dcVecSize(&self->mVecHead) & 4);
dcVecAppend(&self->mVecHead, &x, sizeof(DCdouble) );
if (self->mArgCount < 2)
self->mRegData.doubles[self->mArgCount] = x;
self->mArgCount++;
}
static void dc_callvm_argLongLong_sparc64(DCCallVM* in_self, DClonglong x)
{
DCCallVM_sparc64* self = (DCCallVM_sparc64*)in_self;
if (self->mIntRegs < IREGS) {
* ( (DClonglong*) ( dcVecAt(&self->mVecHead, (self->mIntRegs++)*8) ) ) = x;
} else {
dcVecAppend(&self->mVecHead, &x, sizeof(DClonglong));
}
if (self->mFloatRegs < FREGS) self->mFloatRegs++;
}
static void a_i64(DCCallVM* in_self, DClonglong x)
{
DCCallVM_arm64* p = (DCCallVM_arm64*)in_self;
if (p->i < 8) {
p->I[p->i] = x;
p->i++;
} else {
dcVecAppend(&p->mVecHead, &x, sizeof(DClonglong));
}
}
static void a_int(DCCallVM* in_self, DCint x)
{
DCCallVM_arm32_armhf* p = (DCCallVM_arm32_armhf*)in_self;
if (p->i < 16) {
* (DCint*) dcVecAt(&p->mVecHead, p->i) = x;
p->i += 4;
} else {
dcVecAppend(&p->mVecHead, &x, sizeof(DCint));
}
}
static void dc_callvm_argDouble_mips_n64(DCCallVM* in_self, DCdouble x)
{
DCCallVM_mips_n64* self = (DCCallVM_mips_n64*)in_self;
if (self->mRegCount < 8) {
self->mRegData.mUseDouble |= 1<<( self->mRegCount );
self->mRegData.mFloatData[self->mRegCount++].d = x;
} else {
dcVecAppend(&self->mVecHead, &x, sizeof(DCdouble) );
}
}
static void dc_callvm_argFloat_mips_n64(DCCallVM* in_self, DCfloat x)
{
DCCallVM_mips_n64* self = (DCCallVM_mips_n64*)in_self;
if (self->mRegCount < 8) {
/*self->mRegData.mFloatData[self->mRegCount++].d = (DCdouble) x;*/
self->mRegData.mFloatData[self->mRegCount++].f = x;
} else {
dcVecAppend(&self->mVecHead, &x, sizeof(DCfloat) );
dcVecSkip(&self->mVecHead, sizeof(DCfloat) );
}
}
static void a_float(DCCallVM* in_p, DCfloat x)
{
DCCallVM_arm64* p = (DCCallVM_arm64*)in_p;
if (p->f < 8) {
p->u.S[ p->f << 1 ] = x;
p->f++;
} else {
dcVecAppend(&p->mVecHead, &x, sizeof(DCfloat));
dcVecSkip(&p->mVecHead, 4); /* align to 8-bytes */
}
}
static void dc_callvm_argFloat_ppc32_sysv(DCCallVM* in_self, DCfloat f)
{
DCCallVM_ppc32* self = (DCCallVM_ppc32*)in_self;
/* Put as float register (casted to double) */
if (self->mFloatRegs < 8)
self->mRegData.mFloatData[self->mFloatRegs++] = (DCdouble) (f);
else /* OR put float on stack */
dcVecAppend(&self->mVecHead, &f, sizeof(DCfloat));
}
static void dc_callvm_argDouble_sparc64(DCCallVM* in_self, DCdouble x)
{
DCCallVM_sparc64* self = (DCCallVM_sparc64*)in_self;
if (self->mFloatRegs < FREGS) {
* ((double*)dcVecAt(&self->mVecHead,(IREGS+(self->mFloatRegs++))*8)) = x;
}
if (self->mIntRegs < IREGS) {
self->mIntRegs++;
} else {
dcVecAppend(&self->mVecHead, &x, sizeof(DCdouble));
}
}
static void dc_callvm_argDouble_ppc32_sysv(DCCallVM* in_self, DCdouble d)
{
DCCallVM_ppc32* self = (DCCallVM_ppc32*)in_self;
if (self->mFloatRegs < 8)
self->mRegData.mFloatData[self->mFloatRegs++] = d;
else /* OR push data on stack */
{
/* align stack to 8 byte boundary */
dcVecResize(&self->mVecHead , ( dcVecSize(&self->mVecHead) + 7UL ) & -8UL );
/* AND push data */
dcVecAppend(&self->mVecHead,(DCpointer) &d,sizeof(DCdouble));
}
}
static void dc_callvm_argLongLong_ppc64_ellipsis(DCCallVM* in_self, DClonglong L)
{
DCCallVM_ppc64* self = (DCCallVM_ppc64*)in_self;
if (dcVecSize(&self->mVecHead) == 0)
dcVecSkip(&self->mVecHead,(sizeof(DClonglong))*(self->mIntRegs));
if (self->mIntRegs < 8)
self->mRegData.mIntData[self->mIntRegs++] = L;
/* push on stack */
dcVecAppend(&self->mVecHead,&L,sizeof(DClonglong));
}
static void a_float(DCCallVM* in_p, DCfloat x)
{
DCCallVM_arm32_armhf* p = (DCCallVM_arm32_armhf*)in_p;
if (p->s < 16) {
p->S[p->s++] = x;
if (p->d < p->s) {
p->d = (p->s+1) & ~(1U);
} else {
p->s = p->d;
}
} else {
dcVecAppend(&p->mVecHead, &x, sizeof(DCfloat));
}
}
static void a_longlong(DCCallVM* in_self, DClonglong x)
{
DCCallVM_arm32_armhf* p = (DCCallVM_arm32_armhf*)in_self;
p->i = (p->i+4) & -8;
if (p->i < 16) {
* (DClonglong*) dcVecAt(&p->mVecHead, p->i) = x;
p->i += 8;
} else {
/* 64 bit values need to be aligned on 8 byte boundaries */
dcVecSkip(&p->mVecHead, dcVecSize(&p->mVecHead) & 4);
dcVecAppend(&p->mVecHead, &x, sizeof(DClonglong));
}
}
static void dc_callvm_argDouble_ppc32_darwin(DCCallVM* in_self, DCdouble d)
{
DCCallVM_ppc32* self = (DCCallVM_ppc32*)in_self;
if (self->mFloatRegs < 13) {
self->mRegData.mFloatData[self->mFloatRegs++] = d;
/* skip two integer register file entries */
if (self->mIntRegs < 8)
self->mRegData.mIntData[self->mIntRegs++] = ( (DCint*) &d )[0];
if (self->mIntRegs < 8)
self->mRegData.mIntData[self->mIntRegs++] = ( (DCint*) &d )[1];
}
/* push on stack */
dcVecAppend(&self->mVecHead, &d, sizeof(DCdouble));
}
static void dc_callvm_argFloat_ppc32_darwin(DCCallVM* in_self, DCfloat f)
{
DCCallVM_ppc32* self = (DCCallVM_ppc32*)in_self;
if (self->mFloatRegs < 13) {
self->mRegData.mFloatData[self->mFloatRegs++] = (DCdouble) (f);
}
/* AND skip one integer register file entry (write in - for ellipsis calls) */
if (self->mIntRegs < 8)
self->mRegData.mIntData[self->mIntRegs++] = *( (DCint*) &f );
/* AND push on stack */
dcVecAppend(&self->mVecHead, &f, sizeof(DCfloat));
}