void maxfilt_centered_double_inplace( double *a, int len, int support )
{ static double **U = NULL;
static size_t maxUbytes = 0;
size_t maxU,maxR;
unsigned int iUf,iUb,iRf,iRb;
static double *R = NULL;
static size_t maxRbytes = 0;
double *e;
int off = support;
int c = support/2+1;
double this,last;
assert(support > 2);
U = request_storage_pow2items(U,&maxUbytes,sizeof(double*), 2*support , "maxfilt_centered_double_inplace");
maxU = maxUbytes / sizeof(double*) - 1;
iUf = maxU/2-1;
iUb = maxU/2;
R = request_storage_pow2items(R,&maxRbytes,sizeof(double), 2*(off-c), "maxfilt_centered_double_inplace");
maxR = maxRbytes / sizeof(double) - 1;
iRf=-1;
iRb=0;
//The middle (support entirely in interval)
last = *a;
for( e=a+1; e < a+len; e++ )
{ this = *e;
if( e-a >= c )
pushf(R) = isempty(U) ? last : *peekf(U);
if( e-a >= off )
e[-off] = popb(R);
//progress("iRf:%5d\tiUf:%5d\tiUb:%5d\tsz:%5d\n",iRf,iUf,iUb,iUf-iUb+1);
if( this > last )
{ while( !isempty(U) )
{ if( this <= *peekb(U) )
{ if( e-off == peekf(U) )
popf_noassign(U);
break;
}
if( !isempty(U) )
popb_noassign(U);
}
} else
{ pushb(U) = e-1;
if( (e-off) == peekf(U) )
popf_noassign(U);
}
last = this;
}
//The end
for( ; e <= a+len+c; e++ )
{ pushf(R) = isempty(U) ? e[-1] : *peekf(U);
e[-off] = popb(R);
pushb(U) = e-1;
if( (e-off) == peekf(U) )
popf_noassign(U);
}
}
void SeniorVMHandle::exit()
{
pcode->v_push_register(T_RET);
pushf();
pushad();
db(HANDLE.ret.handle);
}
void read(matrice *a)
{
int n, m, i, j;
a->n = 0;
a->lin = NULL;
a->col = NULL;
a->x = NULL;
scanf("%d %d", &n, &m);
a->l = n;
a->c = m;
a->n = 0;
for (i = 0; i < n; ++ i)
for (j = 0; j < m; ++ j)
{
float t;
scanf("%f", &t);
if (t != 0)
{
a->n+=1;
a->x = pushf(a->x, t, a->n);
a->lin = pushi(a->lin, i, a->n);
a->col = pushi(a->col, j, a->n);
}
}
}
static void
uparse(char *m)
{
char *p=m;
if (!p[0] || (p[1]!=' ' && p[1]!=0)) {
pmsg:
if (ch==0) return;
m+=strspn(m, " ");
if (!*m) return;
pushf(ch, PFMT, nick, m);
sndf("PRIVMSG %s :%s", chl[ch].name, m);
return;
}
switch (*p) {
case 'j': /* Join channels. */
p+=1+(p[1]==' ');
p=strtok(p, " ");
while (p) {
if (chadd(p)<0) break;
sndf("JOIN %s", p);
p=strtok(0, " ");
}
tredraw();
return;
case 'l': /* Leave channels. */
p+=1+(p[1]==' ');
if (!*p) {
if (ch==0) return; /* Cannot leave server window. */
strcat(p, chl[ch].name);
}
p=strtok(p, " ");
while (p) {
if (chdel(p))
sndf("PART %s", p);
p=strtok(0, " ");
}
tredraw();
return;
case 'm': /* Private message. */
m=p+1+(p[1]==' ');
if (!(p=strchr(m, ' '))) return;
*p++ = 0;
sndf("PRIVMSG %s :%s", m, p);
return;
case 'r': /* Send raw. */
if (p[1])
sndf("%s", &p[2]);
return;
case 'q': /* Quit. */
quit=1;
return;
default: /* Send on current channel. */
goto pmsg;
}
}
// --- ref_cas_with_check
// Write barriered compare of Rcmp with memory, if equal set memory to Rval. Set
// flags dependent on success. Returns relpc of where NPE info should be added.
// NB on failure Rcmp contains the value from memory, this will be poisoned and
// not lvb-ed. ie. you shouldn't use this value.
int C1_MacroAssembler::ref_cas_with_check(RInOuts, Register Rbase, Register Rcmp, Register Rtmp0, Register Rtmp1,
RKeepIns, Register Rindex, int off, int scale, Register Rval,
CodeEmitInfo *info) {
assert0( Rcmp == RAX );
Label checked, strip;
#ifdef ASSERT
verify_oop(Rval, MacroAssembler::OopVerify_Store);
verify_oop(Rcmp, MacroAssembler::OopVerify_Move);
if (RefPoisoning) move8(Rtmp1,Rval); // Save Rval
#endif
null_chk( Rval,strip ); // NULLs are always safe to store
pre_write_barrier_compiled(RInOuts::a, Rtmp0, Rtmp1,
RKeepIns::a, Rbase, off, Rindex, scale, Rval,
info);
#ifdef ASSERT
if (RefPoisoning) {
mov8 (Rtmp1,Rval); // Save Rval again as it will have been squashed by the barrier
always_poison(Rval); // Must store poisoned ref
}
#endif // ASSERT
bind(strip);
verify_not_null_oop(Rbase, MacroAssembler::OopVerify_StoreBase);
cvta2va(Rbase);
#ifdef ASSERT
if (RefPoisoning) {
poison(Rcmp); // Compared register must also be posioned
}
#endif // ASSERT
bind(checked);
int npe_relpc = rel_pc();
#ifdef ASSERT
// check the value to be cas-ed is an oop, npe on this rather than the store
if (should_verify_oop(MacroAssembler::OopVerify_OverWrittenField))
npe_relpc = verify_oop (Rbase, off, Rindex, scale, MacroAssembler::OopVerify_OverWrittenField);
#endif
if (Rindex == noreg) locked()->cas8 (Rbase, off, Rval);
else locked()->cas8 (Rbase, off, Rindex, scale, Rval);
#ifdef ASSERT
pushf();
if (RefPoisoning) {
mov8 (Rval,Rtmp1); // Restore unpoisoned Rval
unpoison(Rcmp); // Compared register must also be unposioned
}
verify_oop(Rval, MacroAssembler::OopVerify_Move);
verify_oop(Rcmp, MacroAssembler::OopVerify_Move);
popf();
#endif
return npe_relpc;
}
void pushvar(stack * st, var variable)
{
if(variable.type == 0)
{
pushi(st, variable.value.literalI);
}
else if(variable.type == 1)
{
pushf(st, variable.value.literalF);
}
else if(variable.type == 2)
{
pushs(st, variable.value.literalS);
}
else
{
printf("Unknown variable type, cannot push.\n");
exit(4);
}
}
static void
scmd(char *usr, char *cmd, char *par, char *data)
{
int s;
char *pm=strtok(par, " ");
if (!usr) usr="******";
else {
char *bang=strchr(usr, '!');
if (bang)
*bang=0;
}
if (!strcmp(cmd, "PRIVMSG")) {
if (!pm || !data) return;
pushf(chfind(pm), PFMT, usr, data);
} else if (!strcmp(cmd, "PING")) {
sndf("PONG :%s", data?data:"(null)");
} else if (!strcmp(cmd, "PART")) {
if (!pm) return;
pushf(chfind(pm), "-!- %s has left %s", usr, pm);
} else if (!strcmp(cmd, "JOIN")) {
if (!pm) return;
pushf(chfind(pm), "-!- %s has joined %s", usr, pm);
} else if (!strcmp(cmd, "470")) { /* Channel forwarding. */
char *ch=strtok(0, " "), *fch=strtok(0, " ");
if (!ch || !fch || !(s=chfind(ch))) return;
chl[s].name[0] = 0;
strncat(chl[s].name, fch, ChanLen-1);
tdrawbar();
} else if (!strcmp(cmd, "471") || !strcmp(cmd, "473")
|| !strcmp(cmd, "474") || !strcmp(cmd, "475")) { /* Join error. */
if ((pm=strtok(0, " "))) {
chdel(pm);
pushf(0, "-!- Cannot join channel %s (%s)", pm, cmd);
tredraw();
}
} else if (!strcmp(cmd, "QUIT")) { /* Commands we don't care about. */
return;
} else if (!strcmp(cmd, "NOTICE") || !strcmp(cmd, "375")
|| !strcmp(cmd, "372") || !strcmp(cmd, "376")) {
pushf(0, "%s", data?data:"");
} else
pushf(0, "%s - %s %s", cmd, par, data?data:"(null)");
}
extern VOID far ClkInter_( VOID )
{
pushf();
ClkInter();
popf();
}
/*
* macro - the work horse..
*/
static void
macro(void)
{
char token[MAXTOK+1];
int t, l;
ndptr p;
int nlpar;
cycle {
t = gpbc();
if (t == '_' || isalpha(t)) {
p = inspect(t, token);
if (p != nil)
putback(l = gpbc());
if (p == nil || (l != LPAREN &&
(p->type & NEEDARGS) != 0))
outputstr(token);
else {
/*
* real thing.. First build a call frame:
*/
pushf(fp); /* previous call frm */
pushf(p->type); /* type of the call */
pushf(0); /* parenthesis level */
fp = sp; /* new frame pointer */
/*
* now push the string arguments:
*/
pushs1(p->defn); /* defn string */
pushs1(p->name); /* macro name */
pushs(ep); /* start next..*/
if (l != LPAREN && PARLEV == 0) {
/* no bracks */
chrsave(EOS);
if ((uintptr_t)sp == STACKMAX)
errx(1, "internal stack overflow");
eval((const char **) mstack+fp+1, 2,
CALTYP);
ep = PREVEP; /* flush strspace */
sp = PREVSP; /* previous sp.. */
fp = PREVFP; /* rewind stack...*/
}
}
} else if (t == EOF) {
if (sp > -1) {
warnx( "unexpected end of input, unclosed parenthesis:");
dump_stack(paren, PARLEV);
exit(1);
}
if (ilevel <= 0)
break; /* all done thanks.. */
release_input(infile+ilevel--);
free(inname[ilevel+1]);
bufbase = bbase[ilevel];
emitline();
continue;
}
/*
* non-alpha token possibly seen..
* [the order of else if .. stmts is important.]
*/
else if (LOOK_AHEAD(t,lquote)) { /* strip quotes */
nlpar = 0;
record(quotes, nlpar++);
/*
* Opening quote: scan forward until matching
* closing quote has been found.
*/
do {
l = gpbc();
if (LOOK_AHEAD(l,rquote)) {
if (--nlpar > 0)
outputstr(rquote);
} else if (LOOK_AHEAD(l,lquote)) {
record(quotes, nlpar++);
outputstr(lquote);
} else if (l == EOF) {
if (nlpar == 1)
warnx("unclosed quote:");
else
warnx("%d unclosed quotes:", nlpar);
dump_stack(quotes, nlpar);
exit(1);
} else {
if (nlpar > 0) {
if (sp < 0)
putc(l, active);
else
CHRSAVE(l);
}
}
}
while (nlpar != 0);
}
else if (sp < 0 && LOOK_AHEAD(t, scommt)) {
fputs(scommt, active);
for(;;) {
t = gpbc();
if (LOOK_AHEAD(t, ecommt)) {
fputs(ecommt, active);
break;
}
if (t == EOF)
break;
putc(t, active);
}
}
else if (sp < 0) { /* not in a macro at all */
putc(t, active); /* output directly.. */
}
else switch(t) {
case LPAREN:
if (PARLEV > 0)
chrsave(t);
while (isspace(l = gpbc()))
; /* skip blank, tab, nl.. */
putback(l);
record(paren, PARLEV++);
break;
case RPAREN:
if (--PARLEV > 0)
chrsave(t);
else { /* end of argument list */
chrsave(EOS);
if ((uintptr_t)sp == STACKMAX)
errx(1, "internal stack overflow");
eval((const char **) mstack+fp+1, sp-fp,
CALTYP);
ep = PREVEP; /* flush strspace */
sp = PREVSP; /* previous sp.. */
fp = PREVFP; /* rewind stack...*/
}
break;
case COMMA:
if (PARLEV == 1) {
chrsave(EOS); /* new argument */
while (isspace(l = gpbc()))
;
putback(l);
pushs(ep);
} else
chrsave(t);
break;
default:
if (LOOK_AHEAD(t, scommt)) {
char *pc;
for (pc = scommt; *pc; pc++)
chrsave(*pc);
for(;;) {
t = gpbc();
if (LOOK_AHEAD(t, ecommt)) {
for (pc = ecommt; *pc; pc++)
chrsave(*pc);
break;
}
if (t == EOF)
break;
CHRSAVE(t);
}
} else
CHRSAVE(t); /* stack the char */
break;
}
}
}
/*
* macro - the work horse..
*/
static void
macro(void)
{
char token[MAXTOK+1];
int t, l;
ndptr p;
int nlpar;
cycle {
t = gpbc();
if (LOOK_AHEAD(t,lquote)) { /* strip quotes */
nlpar = 0;
record(quotes, nlpar++);
/*
* Opening quote: scan forward until matching
* closing quote has been found.
*/
do {
l = gpbc();
if (LOOK_AHEAD(l,rquote)) {
if (--nlpar > 0)
outputstr(rquote);
} else if (LOOK_AHEAD(l,lquote)) {
record(quotes, nlpar++);
outputstr(lquote);
} else if (l == EOF) {
if (nlpar == 1)
warnx("unclosed quote:");
else
warnx("%d unclosed quotes:", nlpar);
dump_stack(quotes, nlpar);
exit(1);
} else {
if (nlpar > 0) {
if (sp < 0)
reallyputchar(l);
else
CHRSAVE(l);
}
}
}
while (nlpar != 0);
} else if (sp < 0 && LOOK_AHEAD(t, scommt)) {
reallyoutputstr(scommt);
for(;;) {
t = gpbc();
if (LOOK_AHEAD(t, ecommt)) {
reallyoutputstr(ecommt);
break;
}
if (t == EOF)
break;
reallyputchar(t);
}
} else if (t == '_' || isalpha(t)) {
p = inspect(t, token);
if (p != NULL)
pushback(l = gpbc());
if (p == NULL || (l != LPAREN &&
(macro_getdef(p)->type & NEEDARGS) != 0))
outputstr(token);
else {
/*
* real thing.. First build a call frame:
*/
pushf(fp); /* previous call frm */
pushf(macro_getdef(p)->type); /* type of the call */
pushf(is_traced(p));
pushf(0); /* parenthesis level */
fp = sp; /* new frame pointer */
/*
* now push the string arguments:
*/
pushs1(macro_getdef(p)->defn); /* defn string */
pushs1((char *)macro_name(p)); /* macro name */
pushs(ep); /* start next..*/
if (l != LPAREN && PARLEV == 0) {
/* no bracks */
chrsave(EOS);
if (sp == (int)STACKMAX)
errx(1, "internal stack overflow");
eval((const char **) mstack+fp+1, 2,
CALTYP, TRACESTATUS);
ep = PREVEP; /* flush strspace */
sp = PREVSP; /* previous sp.. */
fp = PREVFP; /* rewind stack...*/
}
}
} else if (t == EOF) {
if (!mimic_gnu /* you can puke right there */
&& sp > -1 && ilevel <= 0) {
warnx( "unexpected end of input, unclosed parenthesis:");
dump_stack(paren, PARLEV);
exit(1);
}
if (ilevel <= 0)
break; /* all done thanks.. */
release_input(infile+ilevel--);
emit_synchline();
bufbase = bbase[ilevel];
continue;
} else if (sp < 0) { /* not in a macro at all */
reallyputchar(t); /* output directly.. */
}
else switch(t) {
case LPAREN:
if (PARLEV > 0)
chrsave(t);
while (isspace(l = gpbc())) /* skip blank, tab, nl.. */
if (PARLEV > 0)
chrsave(l);
pushback(l);
record(paren, PARLEV++);
break;
case RPAREN:
if (--PARLEV > 0)
chrsave(t);
else { /* end of argument list */
chrsave(EOS);
if (sp == (int)STACKMAX)
errx(1, "internal stack overflow");
eval((const char **) mstack+fp+1, sp-fp,
CALTYP, TRACESTATUS);
ep = PREVEP; /* flush strspace */
sp = PREVSP; /* previous sp.. */
fp = PREVFP; /* rewind stack...*/
}
break;
case COMMA:
if (PARLEV == 1) {
chrsave(EOS); /* new argument */
while (isspace(l = gpbc()))
;
pushback(l);
pushs(ep);
} else
chrsave(t);
break;
default:
if (LOOK_AHEAD(t, scommt)) {
char *cp;
for (cp = scommt; *cp; cp++)
chrsave(*cp);
for(;;) {
t = gpbc();
if (LOOK_AHEAD(t, ecommt)) {
for (cp = ecommt; *cp; cp++)
chrsave(*cp);
break;
}
if (t == EOF)
break;
CHRSAVE(t);
}
} else
CHRSAVE(t); /* stack the char */
break;
}
}
}
void ExecFrame::execute_ops(int num)
{
int opcode, param;
floatval fa,fb;
int ia, ib, ifor, iparam, ijmp;
//char opfor,pfor;
Vec2 *v1,*v2;
Vec2 v;
VMInterface* obj;
ExecFrame* frame;
CodeObj* cobj;
while(num-- != 0)
{
opcode = (int)code->code[iptr++];
param = (int)code->code[iptr++];
//std::cout << opcode << ':' << param << std::endl;
switch(opcode) {
case OPC_EXIT:
iptr-=2;
return;
case OPC_VMCALL:
cobj = (CodeObj*)popp();
ia = popi();
frame = new ExecFrame(cobj);
frame->restart();
if (param > 0) move(param, frame);
frame->execute();
if (ia > 0) frame->move(ia, this);
delete frame;
break;
case OPC_CONSTF:
pushf(code->conarray_f[param]);
break;
case OPC_CONSTI:
pushi(code->conarray_i[param]);
break;
case OPC_CONSTV:
pushv(code->conarray_v[param]);
break;
case OPC_CONSTP:
pushp(code->conarray_p[param]);
break;
case OPC_PUSHVARF:
pushf(vararray_f[param]);
break;
case OPC_PUSHVARI:
pushi(vararray_i[param]);
break;
case OPC_PUSHVARV:
pushv(vararray_v[param]);
break;
case OPC_PUSHVARP:
pushp(vararray_p[param]);
break;
case OPC_POP:
top -= param;
break;
case OPC_SETVARF:
vararray_f[param] = popf();
break;
case OPC_SETVARI:
vararray_i[param] = popi();
break;
case OPC_SETVARV:
fb = popf();
fa = popf();
vararray_v[param].set(fa,fb);
break;
case OPC_SETVARP:
vararray_p[param] = popp();
break;
case OPC_GETPROP:
obj = (VMInterface*)popp();
obj->VM_GetProp(this, param);
break;
case OPC_SETPROP:
obj = (VMInterface*)popp();
obj->VM_SetProp(this, param);
break;
case OPC_METCALL:
obj = (VMInterface*)popp();
obj->VM_MetCall(this, param);
break;
case OPC_GETPROPV:
v1 = (Vec2*)popp();
v1->VM_GetProp(this, param);
break;
case OPC_SETPROPV:
v1 = (Vec2*)popp();
v1->VM_SetProp(this, param);
break;
case OPC_METCALLV:
v1 = (Vec2*)popp();
v1->VM_MetCall(this, param);
break;
case OPC_JUMP:
iptr += param*2;
break;
case OPC_IFJUMP:
ia = popi();
if (ia == 0) iptr += param*2;
break;
case OPC_INITFOR:
ib = popi();
ia = popi();
++iptr;
iparam = code->code[iptr++];
ijmp = iptr;
for(ifor=ia;ifor<ib;++ifor)
{
iptr = ijmp;
vararray_i[param] = ifor;
execute_ops(iparam);
/*for(iptr=ijmp;iptr<ijmp+iparam*2;++iptr)
{
opfor = code->code[iptr];
pfor = code->code[++iptr];
if (opfor == OPC_EXIT)
{
--iptr;
return;
}
execute_op(opfor, pfor);
}*/
}
break;
case OPC_LOOP:
; // TODO
break;
case OPC_I2F:
// this will break is floatval uses doubles !!
/* ia = *((int*)top);
*((floatval*)top) = (float)ia;*/
ia = popi();
pushf((floatval)ia);
break;
case OPC_F2I:
/*fa = *((floatval*)top);
*((int*)top) = (int)fa;*/
fa = popf();
pushi((int)fa);
break;
case OPC_VEC2P:
fb = popf();
fa = popf();
v1 = vectemp + (vecidx % 5);
++vecidx;
v1->set(fa,fb);
pushp(v1);
break;
case OPC_P2VEC:
v1 = popv();
pushv(*v1);
break;
case OPC_LASTVEC:
v1 = vectemp + ((vecidx-1)%5);
pushv(*v1);
break;
// --------------------------------------------------
// -------------------- OPERATORS -------------------
// --------------------------------------------------
case OPC_OP_ADDFF:
fa = popf();
*(((floatval*)top)-1) += fa;
break;
case OPC_OP_ADDII:
ia = popi();
*(((int*)top)-1) += ia;
break;
case OPC_OP_ADDVV:
v2 = popv();
v1 = popv();
v.set(*v1);
v.add(*v2);
pushv(v);
break;
case OPC_OP_ANDBB:
ib = popi();
ia = popi();
pushi(ia & ib);
break;
case OPC_OP_DIVFF:
fa = popf();
*(((floatval*)top)-1) /= fa;
break;
case OPC_OP_DIVII:
ia = popi();
*(((int*)top)-1) /= ia;
break;
case OPC_OP_DIVVF:
fa = popf();
v1 = (Vec2*)popp();
v.set(*v1);
v.div(fa);
pushv(v);
break;
case OPC_OP_EQFF:
fb = popf();
fa = popf();
pushi((int)(fa == fb));
break;
case OPC_OP_EQII:
ib = popi();
ia = popi();
pushi((int)(ia == ib));
break;
case OPC_OP_EQVV:
v2 = popv();
v1 = popv();
pushi((int)(ia == ib));
break;
case OPC_OP_GEFF:
fb = popf();
fa = popf();
pushi((int)(fa >= fb));
break;
case OPC_OP_GEII:
ib = popi();
ia = popi();
pushi((int)(ia >= ib));
break;
case OPC_OP_GTFF:
fb = popf();
fa = popf();
pushi((int)(fa > fb));
break;
case OPC_OP_GTII:
ib = popi();
ia = popi();
pushi((int)(ia > ib));
break;
case OPC_OP_LEFF:
fb = popf();
fa = popf();
pushi((int)(fa <= fb));
break;
case OPC_OP_LEII:
ib = popi();
ia = popi();
pushi((int)(ia <= ib));
break;
case OPC_OP_LTFF:
fb = popf();
fa = popf();
pushi((int)(fa < fb));
break;
case OPC_OP_LTII:
ib = popi();
ia = popi();
pushi((int)(ia < ib));
break;
case OPC_OP_MULFF:
fa = popf();
*(((floatval*)top)-1) *= fa;
break;
case OPC_OP_MULII:
ia = popi();
*(((int*)top)-1) *= ia;
break;
case OPC_OP_MULVF:
fa = popf();
v1 = popv();
v.set(*v1);
v.mul(fa);
pushv(v);
break;
case OPC_OP_NEFF:
fb = popf();
fa = popf();
pushi((int)(fa != fb));
break;
case OPC_OP_NEGF:
*(((floatval*)top)-1) = -(*((floatval*)top));
break;
case OPC_OP_NEGI:
*(((int*)top)-1) = -(*((int*)top));
break;
case OPC_OP_NEGV:
v1 = popv();
v.set(-v1->x, -v1->y);
pushv(v);
break;
case OPC_OP_NEII:
ib = popi();
ia = popi();
pushi((int)(ia != ib));
break;
case OPC_OP_NEVV:
v2 = popv();
v1 = popv();
pushi((int)(ia != ib));
break;
case OPC_OP_NOTBB:
; // TODO
break;
case OPC_OP_ORBB:
; // TODO
break;
case OPC_OP_SUBFF:
fa = popf();
*(((floatval*)top)-1) -= fa;
break;
case OPC_OP_SUBII:
ia = popi();
*(((int*)top)-1) -= ia;
break;
case OPC_OP_SUBVV:
v2 = (Vec2*)popp();
v1 = (Vec2*)popp();
v.set(*v1);
v.sub(*v2);
pushv(v);
break;
case OPC_OP_XORBB:
; // TODO
break;
}
}
}
double_buffer( InfoStruct *recInfo, float *leadSnds[], float *lagSnds[], float *locations, float *azimuths, float *rove, float *scalesLead, float *scalesLag, float *attensLead, int nSignal )
{
FILE *fptr;
long seekpos = 0;
float preloadScale = .2;
int i, j;
char OutFNA [MAX_FILENAME_LEN];
char OutFNB [MAX_FILENAME_LEN];
float temp;
int record = recInfo->record;
int cnt = 1;
unsigned int DEC_FACT = recInfo->decimateFactor;
unsigned int SignalPlayFlag = 0;
unsigned int signalScale = 0, Signalcnt = 0, readflag = 0;
unsigned int MAX_SIGNAL_JITTER = recInfo->max_signal_jitter;
unsigned int NUM_CARRIERS_TO_ROVE = recInfo->num_carriers;
unsigned int rove_id;
unsigned int TRIALS_TO_SHOW = 3;
long NPTS = recInfo->buf_pts;
/* just for plotting PDR trace in real time */
long DEC_PTS = ceil(NPTS / pow(2, DEC_FACT));
long ONSET = ceil(recInfo->sound_onset / pow(2, DEC_FACT));
long NPTS_totalplay = recInfo->nptsTotalPlay;
long templ;
long buffer_cnt=0;
float HAB_LOC = recInfo->hab_loc;
int src[3];
float sf[3];
div_t div_result;
int loc;
/* Display output variables: */
int t0,t1, n;
float elapsed_time;
float rem_time;
int min;
float sec, cntdown;
char str[100] = { '\0' };
float pdrBuffer[DEFAULT_PTS];
int len;
float xy[2];
/* select SS1 output */
int ss_id, out_port;
srand( (unsigned)time( NULL ) );
/* setup session info display */
len = ceil(NPTS * (SRATE/1E3));
// was commented out - put back in on Sep 14, 2009
if (record)
{
play0_record0(recInfo->outFN1, recInfo->outFN2);
remove(recInfo->outFN1);
remove(recInfo->outFN2);
//remove(recInfo->AD_FN);
}
// end comment out
if(!S2init(0, INIT_SECONDARY, 20000))
mexErrMsgTxt("S2init failed");
if(!APlock(200, 0))
{
S2close();
mexErrMsgTxt("APLock failed");
}
if(!XBlock(200, 0))
{
APunlock(0);
S2close();
mexErrMsgTxt("XBlock failed");
}
trash();
dropall();
// set up buffers
allot16( PLAY_SPEC, 10);
allot16( CHA_SEQ, 10);
allot16( BUF_A1, NPTS);
allot16( BUF_A2, NPTS);
allot16( CHB_SEQ, 10);
allot16( BUF_B1, NPTS);
allot16( BUF_B2, NPTS);
// play specification list
dpush(10);
value(0);
make(0,CHA_SEQ);
make(1,CHB_SEQ);
make(2,0);
qpop16(PLAY_SPEC);
// playsequence for ChanA
dpush(10);
value(0);
make(0,BUF_A1);
make(1,1);
make(2,BUF_A2);
make(3,1);
make(4,0);
qpop16(CHA_SEQ);
// playsequence for ChanB
dpush(10);
value(0);
make(0,BUF_B1);
make(1,1);
make(2,BUF_B2);
make(3,1);
make(4,0);
qpop16(CHB_SEQ);
if (record) // record eye signal
{
// set up buffers
allot16( REC_SPEC, 10);
allot16( RECCHA_SEQ, 10);
allot16( RECBUF_A1, NPTS);
allot16( RECBUF_A2, NPTS);
allot16( RECCHB_SEQ, 10);
allot16( RECBUF_B1, NPTS);
allot16( RECBUF_B2, NPTS);
temp = ceil(NPTS / pow(2, DEC_FACT));
allot16( DECBUF_A, temp);
allot16( DECBUF_B, temp);
// record specification list
dpush(10);
value(0);
make(0,RECCHA_SEQ);
make(1,RECCHB_SEQ);
make(2,0);
qpop16(REC_SPEC);
// recordsequence for ChanA
dpush(10);
value(0);
make(0,RECBUF_A1);
make(1,1);
make(2,RECBUF_A2);
make(3,1);
make(4,0);
qpop16(RECCHA_SEQ);
// recordsequence for ChanB
dpush(10);
value(0);
make(0,RECBUF_B1);
make(1,1);
make(2,RECBUF_B2);
make(3,1);
make(4,0);
qpop16(RECCHB_SEQ);
}
// allot and load buffers for LEAD SOUNDS
for( j=0; j<NUM_CARRIERS_TO_ROVE; j++ ) {
allotf( BUF_LEAD(j), NPTS);
pushf(leadSnds[j], NPTS);
qpopf(BUF_LEAD(j));
}
// allot and load buffers for LAG SOUNDS
for( j=0; j<NUM_CARRIERS_TO_ROVE; j++ ) {
allotf( BUF_LAG(j), NPTS);
pushf(lagSnds[j], NPTS);
qpopf(BUF_LAG(j));
}
// setup PD1
PD1clear(1);
PD1srate(1,SRATE);
PD1npts(1,-1);
PD1resetDSP(1,0xFFF);
dropall();
PD1clrsched(1);
PD1nstrms(1, 2, record*2);
PD1addsimp(1, IREG[0], DAC[0]);
PD1specIB (1, IB[0], IREG[0]);
PD1addsimp(1, IREG[1], DAC[1]);
PD1specIB (1, IB[1], IREG[1]);
if (record)
{
PD1specOB (1, OB[1], ADC[1]);
PD1specOB (1, OB[0], ADC[0]);
}
PF1freq(1,12000,0);
PF1freq(2,12000,0);
dropall();
/* set LED thresholds */
PD1setIO(1,0.01,9.99,0.01,9.99);
/* setup signal switchers */
/* SWITCH BETWEEN 8 LAG SPEAKERS (Nos. 2, 3, 4, ... 9) */
/* (NOTE: Speaker #1 is reserved for the lead sound) */
SS1clear(1); /* left SS1 (LAG) */
SS1mode(1, QUAD_2_1); /* inputs 1, 3, 5, 7 => outputs A,B,C,D */
SS1select(1,0,1); /* Default Lag Output is A (Hab Location) */
// set attenuation
PA4atten(1,0); /* lead channel */
PA4atten(2,0); /* lag ch */
// ready,set,go!!
dropall();
// nothing to chanA (LEAD)
dpush(NPTS);
value(0);
qpop16(BUF_A1);
dpush(NPTS);
value(0);
qpop16(BUF_A2);
// nothing to chanB (LAG)
dpush(NPTS);
value(0);
qpop16(BUF_B1);
dpush(NPTS);
value(0);
qpop16(BUF_B2);
seqplay(PLAY_SPEC);
if (record)
seqrecord(REC_SPEC);
PD1arm (1);
pfireall();
PD1go (1);
do
{
do{}while (playseg(1)==BUF_A1); // wait for #1 buffers to finish
t0 = clock();
SignalPlayFlag = 0;
if(signalScale >0)
{
readflag = 1;
}
else if(readflag)
{
readflag = 0;
SignalPlayFlag = 1;
}
/* count down to next test trial */
cntdown = (recInfo->ISI - cnt)*(NPTS*SRATE/1E6);
for(i=0; i<(recInfo->n_trials - Signalcnt); i++) {
if(locations[Signalcnt+i]!=HAB_LOC)
break;
cntdown += (recInfo->ISI+1)*(NPTS*SRATE/1E6);
}
/* display session info */
elapsed_time = seekpos*(SRATE/1E6);
div_result = div( elapsed_time, 60 );
min = div_result.quot; sec = elapsed_time - (60*min);
memset(str,'\0',sizeof(str));
n=sprintf(str,"session.elapsed_time(1)=%i; session.elapsed_time(2)=%.3f;",min,sec);
mexEvalString(str);
rem_time = NPTS_totalplay*(SRATE/1E6) - elapsed_time;
div_result = div( rem_time, 60 );
min = div_result.quot; sec = rem_time - (60*min);
memset(str,'\0',sizeof(str));
n=sprintf(str,"session.rem_time(1)=%i; session.rem_time(2)=%.3f;",min,sec);
mexEvalString(str);
div_result = div( cntdown, 60 );
min = div_result.quot; sec = cntdown - (60*min);
memset(str,'\0',sizeof(str));
n=sprintf(str,"session.next_test_trial(1)=%i; session.next_test_trial(2)=%.3f;",min,sec);
mexEvalString(str);
mexEvalString("sessionPlots('Update Session Info');");
// re-loading #1 playbuffers
// LEAD to chanA LAG to chanB
dropall();
if (cnt==recInfo->ISI)
{
// Jitter trial presentation
if (MAX_SIGNAL_JITTER > 0)
{
cnt = ( rand() % (2*MAX_SIGNAL_JITTER+1) ) - MAX_SIGNAL_JITTER; // gives a range of +/- MAX_SIGNAL_JITTER
} else
{
cnt = 0;
}
loc = locations[Signalcnt];
/* location series indicates lag speaker # (2, 3, 4, ... 9) */
// set attenuation
PA4atten(1,attensLead[loc-2]); /* lead channel */
PA4atten(2,0); /* lag ch */
SS1clear(1); SS1clear(2);
if (loc < 6) {
ss_id = 1; /* use left SS1 */
out_port = loc - 2; /* decrement by 2 for output selection */
}
else {
ss_id = 2; /* use right SS1 */
out_port = loc - 6; /* decrement by 6 for output selection */
}
SS1mode(ss_id, QUAD_2_1); /* inputs 1, 3, 5, 7 => outputs A,B,C,D */
SS1select(ss_id,out_port,1); /* Chan B (LAG) location ( speakers A...D = 0...3 ) */
/* plot a marker on trial sequence plot */
memset(str,'\0',sizeof(str));
n=sprintf(str,"session.trialcnt=%i; session.trialval=%10.1f;sessionPlots('Update Trial Plot');",Signalcnt+1,azimuths[loc-1]);
mexEvalString(str);
rove_id = rove[Signalcnt ++] - 1; /* decrement by 1 for C indexing */
signalScale=scalesLead[loc-2];
qpushf(BUF_LEAD(rove_id));
scale(signalScale); /* always scale with first speaker scaling value */
qpop16(BUF_A1);
signalScale=scalesLag[loc-2];
qpushf(BUF_LAG(rove_id));
scale(signalScale); /* decrement by 1 to get appropriate speaker scale value */
qpop16(BUF_B1);
}
else
{
signalScale = 0;
cnt++;
dpush(NPTS);
value(0);
qpop16(BUF_A1);
dpush(NPTS);
value(0);
qpop16(BUF_B1);
}
if(record)
{ // downloading #1 recordbuffers
qpush16 (RECBUF_A1);
decimate (DEC_FACT);
make(0, SignalPlayFlag);
make(1, loc);
qpop16 (DECBUF_A);
dama2disk16 (DECBUF_A, recInfo->outFN1, 1);
qpush16 (RECBUF_B1);
decimate (DEC_FACT);
// plot PDR trace
qdup();
popf(pdrBuffer);
// store last buffer in matlab variable for plotting
for(i=0; i<DEC_PTS; i++) {
memset(str,'\0',sizeof(str));
n=sprintf(str,"session.last_buffer(%i+1)= %.5f;",i,pdrBuffer[i]);
mexEvalString(str);
}
if(SignalPlayFlag) {
if(locations[Signalcnt-1]==HAB_LOC) {
mexEvalString("session.test_flag=1;");
}
else {
mexEvalString("session.test_flag=Inf;");
}
}
else {
mexEvalString("session.test_flag=0;");
}
// tell sessionPlots to update trace
mexEvalString("sessionPlots('Update Trace Plot');");
make(0, SignalPlayFlag);
make(1, loc);
qpop16 (DECBUF_B);
dama2disk16 (DECBUF_B, recInfo->outFN2, 1);
dropall ();
}
/* processing time */
t1=clock();
memset(str,'\0',sizeof(str));
n = sprintf(str,"session.proc_time = [session.proc_time %.3f];",((float) (t1-t0))/CLOCKS_PER_SEC);
mexEvalString(str);
mexEvalString("sessionPlots('Update Session Info');");
seekpos += NPTS;
if(seekpos < NPTS_totalplay)
{
// wait for #2 buffers to finish
do{}while (playseg(1)==BUF_A2); // wait for #2 buffers to finish
t0=clock();
SignalPlayFlag = 0;
if(signalScale >0)
{
readflag = 1;
}
else if(readflag)
{
readflag = 0;
SignalPlayFlag = 1;
}
/* count down to next test trial */
cntdown = (recInfo->ISI - cnt)*(NPTS*SRATE/1E6);
for(i=0; i<(recInfo->n_trials - Signalcnt); i++) {
if(locations[Signalcnt+i]!=HAB_LOC)
break;
cntdown += (recInfo->ISI+1)*(NPTS*SRATE/1E6);
}
/* display session info */
elapsed_time = seekpos*(SRATE/1E6);
div_result = div( elapsed_time, 60 );
min = div_result.quot; sec = elapsed_time - (60*min);
memset(str,'\0',sizeof(str));
n=sprintf(str,"session.elapsed_time(1)=%i; session.elapsed_time(2)=%.3f;",min,sec);
mexEvalString(str);
rem_time = NPTS_totalplay*(SRATE/1E6) - elapsed_time;
div_result = div( rem_time, 60 );
min = div_result.quot; sec = rem_time - (60*min);
memset(str,'\0',sizeof(str));
n=sprintf(str,"session.rem_time(1)=%i; session.rem_time(2)=%.3f;",min,sec);
mexEvalString(str);
div_result = div( cntdown, 60 );
min = div_result.quot; sec = cntdown - (60*min);
memset(str,'\0',sizeof(str));
n=sprintf(str,"session.next_test_trial(1)=%i; session.next_test_trial(2)=%.3f;",min,sec);
mexEvalString(str);
mexEvalString("sessionPlots('Update Session Info');");
// reload #2 playbuffers LEAD to chanA LAG to chanB
dropall();
if (cnt==recInfo->ISI)
{
if (MAX_SIGNAL_JITTER > 0)
{
cnt = ( rand() % (2*MAX_SIGNAL_JITTER+1) ) - MAX_SIGNAL_JITTER; // gives a range of +/- MAX_SIGNAL_JITTER
} else
{
cnt = 0;
}
loc = locations[Signalcnt];
/* location series indicates lag speaker # (2, 3, 4, ... 9) */
// set attenuation
PA4atten(1,attensLead[loc-2]); /* lead channel */
PA4atten(2,0); /* lag ch */
SS1clear(1); SS1clear(2);
if (loc < 6) {
ss_id = 1; /* use left SS1 */
out_port = loc - 2; /* decrement by 2 for output selection */
}
else {
ss_id = 2; /* use right SS1 */
out_port = loc - 6; /* decrement by 6 for output selection */
}
SS1mode(ss_id, QUAD_2_1); /* inputs 1, 3, 5, 7 => outputs A,B,C,D */
SS1select(ss_id,out_port,1); /* Chan B (LAG) location ( speakers A...D = 0...3 ) */
/* plot a marker on trial sequence plot */
memset(str,'\0',sizeof(str));
n=sprintf(str,"session.trialcnt=%i; session.trialval=%10.1f;sessionPlots('Update Trial Plot');",Signalcnt+1,azimuths[loc-1]);
mexEvalString(str);
rove_id = rove[Signalcnt ++] - 1; /* decrement by 1 for C indexing */
signalScale=scalesLead[loc-2];
qpushf(BUF_LEAD(rove_id));
scale(signalScale); /* always scale with first speaker scaling value */
qpop16(BUF_A2);
signalScale=scalesLag[loc-2];
qpushf(BUF_LAG(rove_id));
scale(signalScale); /* decrement by 1 to get appropriate speaker scale value */
qpop16(BUF_B2);
}
else
{
signalScale = 0;
cnt++;
dpush(NPTS);
value(0);;
qpop16(BUF_A2);
dpush(NPTS);
value(0);
qpop16(BUF_B2);
}
if (record)
{ // download #2 recordbuffers
qpush16 (RECBUF_A2);
decimate (DEC_FACT);
make(0,SignalPlayFlag);
make(1,loc);
qpop16 (DECBUF_A);
dama2disk16 (DECBUF_A, recInfo->outFN1, 1);
qpush16 (RECBUF_B2);
decimate (DEC_FACT);
// plot PDR trace
qdup();
popf(pdrBuffer);
// store last buffer in matlab variable for plotting
for(i=0; i<DEC_PTS; i++) {
memset(str,'\0',sizeof(str));
n=sprintf(str,"session.last_buffer(%i+1)= %.5f;",i,pdrBuffer[i]);
mexEvalString(str);
}
if(SignalPlayFlag) {
if(locations[Signalcnt-1]==HAB_LOC) {
mexEvalString("session.test_flag=1;");
}
else {
mexEvalString("session.test_flag=Inf;");
}
}
else {
mexEvalString("session.test_flag=0;");
}
// tell sessionPlots to update trace
mexEvalString("sessionPlots('Update Trace Plot');");
make(0,SignalPlayFlag);
make(1,loc);
qpop16 (DECBUF_B);
dama2disk16 (DECBUF_B, recInfo->outFN2, 1);
dropall ();
}
if (playseg(1) !=BUF_A1)
{
PD1stop(1);
mexPrintf("got to %d percent of the way\n",seekpos/NPTS_totalplay);
mexErrMsgTxt(" APcard too slow? or outFNs incorrect?");
}
/* processing time */
t1=clock();
memset(str,'\0',sizeof(str));
n = sprintf(str,"session.proc_time = [session.proc_time %.3f];",((float) (t1-t0))/CLOCKS_PER_SEC);
mexEvalString(str);
mexEvalString("sessionPlots('Update Session Info');");
seekpos += NPTS;
}
if (Signalcnt > nSignal)
Signalcnt = 0;
} while(seekpos < NPTS_totalplay);
do{}while (playseg(1)==BUF_A1); /* wait for last 2 buffers to finish */
do{}while (playseg(1)==BUF_A2);
PA4mute(1);
PA4mute(2);
PD1stop(1);
PD1clrIO(1);
PD1clear(1);
mexEvalString("sessionPlots('Finish Session');");
trash();
dropall();
APunlock(0);
XBunlock(0);
S2close();
}
address generate_getPsrInfo() {
// Flags to test CPU type.
const uint32_t HS_EFL_AC = 0x40000;
const uint32_t HS_EFL_ID = 0x200000;
// Values for when we don't have a CPUID instruction.
const int CPU_FAMILY_SHIFT = 8;
const uint32_t CPU_FAMILY_386 = (3 << CPU_FAMILY_SHIFT);
const uint32_t CPU_FAMILY_486 = (4 << CPU_FAMILY_SHIFT);
Label detect_486, cpu486, detect_586, std_cpuid1, std_cpuid4;
Label sef_cpuid, ext_cpuid, ext_cpuid1, ext_cpuid5, ext_cpuid7, done;
StubCodeMark mark(this, "VM_Version", "getPsrInfo_stub");
# define __ _masm->
address start = __ pc();
//
// void getPsrInfo(VM_Version::CpuidInfo* cpuid_info);
//
// LP64: rcx and rdx are first and second argument registers on windows
__ push(rbp);
#ifdef _LP64
__ mov(rbp, c_rarg0); // cpuid_info address
#else
__ movptr(rbp, Address(rsp, 8)); // cpuid_info address
#endif
__ push(rbx);
__ push(rsi);
__ pushf(); // preserve rbx, and flags
__ pop(rax);
__ push(rax);
__ mov(rcx, rax);
//
// if we are unable to change the AC flag, we have a 386
//
__ xorl(rax, HS_EFL_AC);
__ push(rax);
__ popf();
__ pushf();
__ pop(rax);
__ cmpptr(rax, rcx);
__ jccb(Assembler::notEqual, detect_486);
__ movl(rax, CPU_FAMILY_386);
__ movl(Address(rbp, in_bytes(VM_Version::std_cpuid1_offset())), rax);
__ jmp(done);
//
// If we are unable to change the ID flag, we have a 486 which does
// not support the "cpuid" instruction.
//
__ bind(detect_486);
__ mov(rax, rcx);
__ xorl(rax, HS_EFL_ID);
__ push(rax);
__ popf();
__ pushf();
__ pop(rax);
__ cmpptr(rcx, rax);
__ jccb(Assembler::notEqual, detect_586);
__ bind(cpu486);
__ movl(rax, CPU_FAMILY_486);
__ movl(Address(rbp, in_bytes(VM_Version::std_cpuid1_offset())), rax);
__ jmp(done);
//
// At this point, we have a chip which supports the "cpuid" instruction
//
__ bind(detect_586);
__ xorl(rax, rax);
__ cpuid();
__ orl(rax, rax);
__ jcc(Assembler::equal, cpu486); // if cpuid doesn't support an input
// value of at least 1, we give up and
// assume a 486
__ lea(rsi, Address(rbp, in_bytes(VM_Version::std_cpuid0_offset())));
__ movl(Address(rsi, 0), rax);
__ movl(Address(rsi, 4), rbx);
__ movl(Address(rsi, 8), rcx);
__ movl(Address(rsi,12), rdx);
__ cmpl(rax, 0xa); // Is cpuid(0xB) supported?
__ jccb(Assembler::belowEqual, std_cpuid4);
//
// cpuid(0xB) Processor Topology
//
__ movl(rax, 0xb);
__ xorl(rcx, rcx); // Threads level
__ cpuid();
__ lea(rsi, Address(rbp, in_bytes(VM_Version::tpl_cpuidB0_offset())));
__ movl(Address(rsi, 0), rax);
__ movl(Address(rsi, 4), rbx);
__ movl(Address(rsi, 8), rcx);
__ movl(Address(rsi,12), rdx);
__ movl(rax, 0xb);
__ movl(rcx, 1); // Cores level
__ cpuid();
__ push(rax);
__ andl(rax, 0x1f); // Determine if valid topology level
__ orl(rax, rbx); // eax[4:0] | ebx[0:15] == 0 indicates invalid level
__ andl(rax, 0xffff);
__ pop(rax);
__ jccb(Assembler::equal, std_cpuid4);
__ lea(rsi, Address(rbp, in_bytes(VM_Version::tpl_cpuidB1_offset())));
__ movl(Address(rsi, 0), rax);
__ movl(Address(rsi, 4), rbx);
__ movl(Address(rsi, 8), rcx);
__ movl(Address(rsi,12), rdx);
__ movl(rax, 0xb);
__ movl(rcx, 2); // Packages level
__ cpuid();
__ push(rax);
__ andl(rax, 0x1f); // Determine if valid topology level
__ orl(rax, rbx); // eax[4:0] | ebx[0:15] == 0 indicates invalid level
__ andl(rax, 0xffff);
__ pop(rax);
__ jccb(Assembler::equal, std_cpuid4);
__ lea(rsi, Address(rbp, in_bytes(VM_Version::tpl_cpuidB2_offset())));
__ movl(Address(rsi, 0), rax);
__ movl(Address(rsi, 4), rbx);
__ movl(Address(rsi, 8), rcx);
__ movl(Address(rsi,12), rdx);
//
// cpuid(0x4) Deterministic cache params
//
__ bind(std_cpuid4);
__ movl(rax, 4);
__ cmpl(rax, Address(rbp, in_bytes(VM_Version::std_cpuid0_offset()))); // Is cpuid(0x4) supported?
__ jccb(Assembler::greater, std_cpuid1);
__ xorl(rcx, rcx); // L1 cache
__ cpuid();
__ push(rax);
__ andl(rax, 0x1f); // Determine if valid cache parameters used
__ orl(rax, rax); // eax[4:0] == 0 indicates invalid cache
__ pop(rax);
__ jccb(Assembler::equal, std_cpuid1);
__ lea(rsi, Address(rbp, in_bytes(VM_Version::dcp_cpuid4_offset())));
__ movl(Address(rsi, 0), rax);
__ movl(Address(rsi, 4), rbx);
__ movl(Address(rsi, 8), rcx);
__ movl(Address(rsi,12), rdx);
//
// Standard cpuid(0x1)
//
__ bind(std_cpuid1);
__ movl(rax, 1);
__ cpuid();
__ lea(rsi, Address(rbp, in_bytes(VM_Version::std_cpuid1_offset())));
__ movl(Address(rsi, 0), rax);
__ movl(Address(rsi, 4), rbx);
__ movl(Address(rsi, 8), rcx);
__ movl(Address(rsi,12), rdx);
//
// Check if OS has enabled XGETBV instruction to access XCR0
// (OSXSAVE feature flag) and CPU supports AVX
//
__ andl(rcx, 0x18000000);
__ cmpl(rcx, 0x18000000);
__ jccb(Assembler::notEqual, sef_cpuid);
//
// XCR0, XFEATURE_ENABLED_MASK register
//
__ xorl(rcx, rcx); // zero for XCR0 register
__ xgetbv();
__ lea(rsi, Address(rbp, in_bytes(VM_Version::xem_xcr0_offset())));
__ movl(Address(rsi, 0), rax);
__ movl(Address(rsi, 4), rdx);
//
// cpuid(0x7) Structured Extended Features
//
__ bind(sef_cpuid);
__ movl(rax, 7);
__ cmpl(rax, Address(rbp, in_bytes(VM_Version::std_cpuid0_offset()))); // Is cpuid(0x7) supported?
__ jccb(Assembler::greater, ext_cpuid);
__ xorl(rcx, rcx);
__ cpuid();
__ lea(rsi, Address(rbp, in_bytes(VM_Version::sef_cpuid7_offset())));
__ movl(Address(rsi, 0), rax);
__ movl(Address(rsi, 4), rbx);
//
// Extended cpuid(0x80000000)
//
__ bind(ext_cpuid);
__ movl(rax, 0x80000000);
__ cpuid();
__ cmpl(rax, 0x80000000); // Is cpuid(0x80000001) supported?
__ jcc(Assembler::belowEqual, done);
__ cmpl(rax, 0x80000004); // Is cpuid(0x80000005) supported?
__ jccb(Assembler::belowEqual, ext_cpuid1);
__ cmpl(rax, 0x80000006); // Is cpuid(0x80000007) supported?
__ jccb(Assembler::belowEqual, ext_cpuid5);
__ cmpl(rax, 0x80000007); // Is cpuid(0x80000008) supported?
__ jccb(Assembler::belowEqual, ext_cpuid7);
//
// Extended cpuid(0x80000008)
//
__ movl(rax, 0x80000008);
__ cpuid();
__ lea(rsi, Address(rbp, in_bytes(VM_Version::ext_cpuid8_offset())));
__ movl(Address(rsi, 0), rax);
__ movl(Address(rsi, 4), rbx);
__ movl(Address(rsi, 8), rcx);
__ movl(Address(rsi,12), rdx);
//
// Extended cpuid(0x80000007)
//
__ bind(ext_cpuid7);
__ movl(rax, 0x80000007);
__ cpuid();
__ lea(rsi, Address(rbp, in_bytes(VM_Version::ext_cpuid7_offset())));
__ movl(Address(rsi, 0), rax);
__ movl(Address(rsi, 4), rbx);
__ movl(Address(rsi, 8), rcx);
__ movl(Address(rsi,12), rdx);
//
// Extended cpuid(0x80000005)
//
__ bind(ext_cpuid5);
__ movl(rax, 0x80000005);
__ cpuid();
__ lea(rsi, Address(rbp, in_bytes(VM_Version::ext_cpuid5_offset())));
__ movl(Address(rsi, 0), rax);
__ movl(Address(rsi, 4), rbx);
__ movl(Address(rsi, 8), rcx);
__ movl(Address(rsi,12), rdx);
//
// Extended cpuid(0x80000001)
//
__ bind(ext_cpuid1);
__ movl(rax, 0x80000001);
__ cpuid();
__ lea(rsi, Address(rbp, in_bytes(VM_Version::ext_cpuid1_offset())));
__ movl(Address(rsi, 0), rax);
__ movl(Address(rsi, 4), rbx);
__ movl(Address(rsi, 8), rcx);
__ movl(Address(rsi,12), rdx);
//
// return
//
__ bind(done);
__ popf();
__ pop(rsi);
__ pop(rbx);
__ pop(rbp);
__ ret(0);
# undef __
return start;
};
