From 7f2279b64921a2c3e159ad4653391a295cca36b6 Mon Sep 17 00:00:00 2001 From: Henry Rich Date: Fri, 10 Jan 2025 18:39:13 -0500 Subject: [PATCH] gcc compile errors --- jsrc/va2.c | 18 +++++++++++------- 1 file changed, 11 insertions(+), 7 deletions(-) diff --git a/jsrc/va2.c b/jsrc/va2.c index 3314a59c2..2a2090c2a 100644 --- a/jsrc/va2.c +++ b/jsrc/va2.c @@ -44,24 +44,24 @@ static NOINLINE I intforD(J jt, D d){D q;I z; // noinline because it uses so ma // we know that AN=1 in a and w, which are FL/INT/B01 types. af is larger arg rank (=rank of result) // obsolete I awip=2*SGNTO0(AC(a))+SGNTO0(AC(w)); awip=(awip&(I)jtinplace)+4*((I)jtinplace&3); // abandoned flags from aw; make (assignable),(inplaceable) flags // obsolete z=jtssingleton(jt,a,w,af+((I)FAV(self)->lu2.lc<>INTX)+(wt>>INTX))<<20)); // create portmanteau parm reg -A INLINE jtssingleton(J jt,A a,A w,I af,I at, I wt,A self){ +static A INLINE jtssingleton(J jt,A a,A w,I af,I at, I wt,A self){ // obsolete A INLINE jtssingleton(J jt, A a,A w,I ipcaserank){A z;I aiv;void *zv; I awip=2*SGNTO0(AC(a))+SGNTO0(AC(w)); // collect inplaceable status for a and w I opcode=(I)FAV(self)->lu2.lc; // fetch operation# void *av=voidAV(a), *wv=voidAV(w); // point to the argument values - FPREFIP(I); I zomb=2*(a==jt->zombieval)+(w==jt->zombieval); // save jt as an I, clear low bits, see if either arg is + I jtinplace=(I)jt; jt=(J)(intptr_t)((I)jt&~JTFLAGMSK); I zomb=2*(a==jt->zombieval)+(w==jt->zombieval); // save jt as an I, clear low bits, see if either arg is being assigned I caseno=(opcode&0x7f)-VA2CBW1111; caseno=caseno<0?0:caseno; caseno=SSINGCASE(caseno,SSINGENC(at,wt)); // case # for eventual switch. Lump all Booleans at 0 A z=0; void *zv; // pointer to result location // if the operation is a rank-0 comparison that can return num[result], don't bother with inplacing. Inplacing would be // a potential gain if the result can itself be inplaced, but it is a certain loser when deciding where the result is if((opcode>>7)>af)goto nozv; // true if 0x80 (comparison op) and af=0 - awip&=jtinplace; z=awip&JTINPLACEA?a:z; z=awip&JTINPLACEW?w:z; // block is contextually inplaceable and inplaceable by count= abandoned. Give priority to w // While z is settling, see if we can inplace an assignment. That is always a good idea, though rare - if(unlikely(zomb&jtinplace)){ // one of the args is being reassigned + if(unlikely(zomb&=jtinplace)){ // one of the args is being reassigned if(likely((AFLAG(jt->zombieval)&AFVIRTUAL+AFUNINCORPABLE)+(af^AR(jt->zombieval))==0)){z=jt->zombieval; goto getzv;} // mustn't modify VIRTUAL or INCORPABLE, and reassigned value must have the higher rank // obsolete if(likely(af==AR(jt->zombieval))){z=jt->zombieval; goto getzv;} // the // obsolete } } +// obsolete awip&=jtinplace; z=awip&JTINPLACEA?a:z; z=awip&JTINPLACEW?w:z; // block is contextually inplaceable and inplaceable by count= abandoned. Give priority to w #if 0 // obsolete // if the operation is a rank-0 comparison that can return num[result], don't bother with inplacing. Inplacing would be // a potential gain if the result can itself be inplaced, but it is a certain loser when deciding where the result is @@ -70,7 +70,7 @@ A INLINE jtssingleton(J jt,A a,A w,I af,I at, I wt,A self){ // see if the block is inplaceable in the ordinary way - start loading the z value if it is // obsolete z=(AC(a)&SGNIF(ipcaserank,24+JTINPLACEAX))<0?a:z; z=(AC(w)&SGNIF(ipcaserank,24+JTINPLACEWX))<0?w:z; // block is contextually inplaceable z=ipcaserank&0x20000?a:z; z=ipcaserank&0x10000?w:z; // block is contextually inplaceable. Give priority to w - // While z is settling, see if we can inplace an assignment. That is always a good idea, though rare + // While z is settling, see if we can inplace an assignment. That is always a good idea (since it results in IP assignment), though rare // obsolete if(unlikely(((B)(a==jt->zombieval)&((B)(ipcaserank>>(24+JTINPLACEAX))))+((B)(w==jt->zombieval)&((B)(ipcaserank>>(24+JTINPLACEWX)))))){ if(unlikely((2*(a==jt->zombieval)+(w==jt->zombieval))&(ipcaserank>>18))){ if(likely(!(AFLAG(jt->zombieval)&AFVIRTUAL+AFUNINCORPABLE))){ @@ -79,8 +79,12 @@ A INLINE jtssingleton(J jt,A a,A w,I af,I at, I wt,A self){ } #endif // obsolete if(z&&likely(!(AFLAG(z)&AFUNINCORPABLE+AFRO)))if(likely(af==AR(z)))goto getzv; // not disallowed and correct rank, take it - if(z&&likely((AFLAG(z)&AFUNINCORPABLE+AFRO)+(af^AR(z))==0))goto getzv; // not disallowed and correct rank, inplace to it - // no inplacing, allocate the result, usually an atom. If not atom, make the shape all 1s + // See if we can inplace. We let some chances get away because they aren't worth testing for. There are two main possibilities: assignment (checked above) + // and abandoned arg (checked presently). If either passes, it must further be not VIRTUAL if assigned (lest it overwrite the backer of a virtual x/y arg) + // and not AFRO if bare; and never UNINCORPABLE since we may change the type and we don't want callers to bear the burden of checking that. It is possible that + // one arg would be inplaceable as an assignment and the other as abandoned, but we pick one and live with it. + if(awip&=jtinplace){z=awip&JTINPLACEW?w:a; if(likely((AFLAG(z)&AFUNINCORPABLE+AFRO)+(af^AR(z))==0))goto getzv;} // block is abandoned inplaceable; not disallowed and correct rank, inplace to it + // fall through: no inplacing, allocate the result, usually an atom. If not atom, make the shape all 1s if(likely(af==0)){GAT0(z,FL,1,0); zv=voidAV0(z);}else{GATV1(z,FL,1,af); zv=voidAV(z);} // not voidAVn so that af is not needed goto nozv; getzv:; // here when we are operating inplace on z