/*
* Check and cast arguments for builtins.
*/
static int
acnt(NODE *a, int narg, TWORD *tp)
{
NODE *q;
TWORD t;
if (a == NIL)
return narg;
for (; a->n_op == CM; a = a->n_left, narg--) {
if (tp == NULL)
continue;
q = a->n_right;
t = ctype(tp[narg-1]);
if (q->n_type == t)
continue;
a->n_right = ccast(q, t, 0, NULL, 0);
}
/* Last arg is ugly to deal with */
if (narg == 1 && tp != NULL && a->n_type != tp[0]) {
q = talloc();
*q = *a;
q = ccast(q, ctype(tp[0]), 0, NULL, 0);
*a = *q;
nfree(q);
}
return narg != 1;
}
int main() {
myclass a("a");
mybase base("base");
std::cout << "== nocast" << std::endl;
nocast(&a);
// nocast(&base); <- Does not compile
std::cout << "== ccast" << std::endl;
ccast(&a);
ccast(&base); // XXX actually works!
std::cout << "== staticcast" << std::endl;
staticcast(&a);
staticcast(&base); // XXX actually works!
std::cout << "== dynamiccast" << std::endl;
dynamiccast(&a);
dynamiccast(&base);
}
static void
addreg(NODE *p)
{
TWORD t;
NODE *q;
int sz, r;
sz = tsize(p->n_type, p->n_df, p->n_ap)/SZCHAR;
sz = (sz + 3) >> 2; /* sz in regs */
if ((regcvt+sz) > rparg) {
regcvt = rparg;
return;
}
if (sz > 2)
uerror("cannot put struct in 3 regs (yet)");
if (sz == 2)
r = regcvt == 0 ? AXDX : DXCX;
else
r = regcvt == 0 ? AX : regcvt == 1 ? DX : CX;
if (p->n_op == FUNARG) {
/* at most 2 regs */
if (p->n_type < INT) {
p->n_left = ccast(p->n_left, INT, 0, 0, 0);
p->n_type = INT;
}
p->n_op = ASSIGN;
p->n_right = p->n_left;
} else if (p->n_op == STARG) {
/* convert to ptr, put in reg */
q = p->n_left;
t = sz == 2 ? LONGLONG : INT;
q = cast(q, INCREF(t), 0);
q = buildtree(UMUL, q, NIL);
p->n_op = ASSIGN;
p->n_type = t;
p->n_right = q;
} else
cerror("addreg");
p->n_left = block(REG, 0, 0, p->n_type, 0, 0);
regno(p->n_left) = r;
regcvt += sz;
}
NODE *
amd64_builtin_va_arg(NODE *f, NODE *a, TWORD t)
{
NODE *ap, *r, *dp;
ap = a->n_left;
dp = a->n_right;
if (dp->n_type <= ULONGLONG || ISPTR(dp->n_type) ||
dp->n_type == FLOAT || dp->n_type == DOUBLE) {
/* type might be in general register */
if (dp->n_type == FLOAT || dp->n_type == DOUBLE) {
f->n_sp = lookup(fpnext, SNORMAL);
varneeds |= NEED_FPNEXT;
} else {
f->n_sp = lookup(gpnext, SNORMAL);
varneeds |= NEED_GPNEXT;
}
f->n_type = f->n_sp->stype = INCREF(dp->n_type) + (FTN-PTR);
f->n_ap = dp->n_ap;
f->n_df = /* dp->n_df */ NULL;
f = clocal(f);
r = buildtree(CALL, f, ccopy(ap));
} else if (ISSOU(dp->n_type) || dp->n_type == LDOUBLE) {
/* put a reference directly to the stack */
int sz = tsize(dp->n_type, dp->n_df, dp->n_ap);
int al = talign(dp->n_type, dp->n_ap);
if (al < ALLONG)
al = ALLONG;
if (sz <= SZLONG*2 && al == ALLONG) {
if (sz <= SZLONG) {
f->n_sp = lookup(_1regref, SNORMAL);
varneeds |= NEED_1REGREF;
} else {
f->n_sp = lookup(_2regref, SNORMAL);
varneeds |= NEED_2REGREF;
}
f->n_type = f->n_sp->stype;
f = clocal(f);
r = buildtree(CALL, f, ccopy(ap));
r = ccast(r, INCREF(dp->n_type), 0, dp->n_df, dp->n_ap);
r = buildtree(UMUL, r, NIL);
} else {
f->n_sp = lookup(memref, SNORMAL);
varneeds |= NEED_MEMREF;
f->n_type = f->n_sp->stype;
f = clocal(f);
SETOFF(sz, al);
r = buildtree(CALL, f,
buildtree(CM, ccopy(ap), bcon(sz/SZCHAR)));
r = ccast(r, INCREF(dp->n_type), 0, dp->n_df, dp->n_ap);
r = buildtree(UMUL, r, NIL);
}
} else {
uerror("amd64_builtin_va_arg not supported type");
goto bad;
}
tfree(a);
return r;
bad:
uerror("bad argument to __builtin_va_arg");
return bcon(0);
}
virtual double Run(CVectorBratAlgorithmParam& args) override
{
double result;
return processCall( PyObject_CallMethod( m_instance, ccast( "Run" ),ccast( "(O)"), createPyArguments( args ) ), result );
}
virtual std::string GetOutputUnit() const override
{
std::string result;
return processCall( PyObject_CallMethod( m_instance, ccast( "GetOutputUnit" ), nullptr ), result );
}
virtual std::string GetInputParamUnit(uint32_t indexParam) const override
{
std::string result;
return processCall( PyObject_CallMethod( m_instance, ccast( "GetInputParamUnit" ), ccast( "(i)" ), indexParam ), result );
}
virtual CBratAlgorithmParam::bratAlgoParamTypeVal GetInputParamFormat(uint32_t indexParam) const override
{
uint32_t result;
return (CBratAlgorithmParam::bratAlgoParamTypeVal)
processCall( PyObject_CallMethod( m_instance, ccast( "GetInputParamFormat" ), ccast( "(i)" ), indexParam ), result );
}
virtual uint32_t GetNumInputParam() const override
{
uint32_t result;
return processCall( PyObject_CallMethod( m_instance, ccast( "GetNumInputParam" ), nullptr ), result );
}
virtual std::string GetDescription() const override
{
std::string result;
return processCall( PyObject_CallMethod( m_instance, ccast( "GetDescription" ), nullptr ), result );
}
