Fix PM to account for named explicit operators, and unnamed explicit defs; redef 128!:9 for SR DIP; support IRS in 9:; use streaming store for large mvc(); make 0. comp array use intolerant code

HenryHRich · HenryHRich · commit f9f82ca47df7 · 2021-12-30T10:05:17.000-05:00
diff --git a/jsrc/af.c b/jsrc/af.c
@@ -185,8 +185,7 @@ DF1(jtfix){PROLOG(0005);A z;
  fauxblock(fauxself); A augself; fauxINT(augself,fauxself,2,0); IAV0(augself)[0]=IAV(self)[0]; IAV0(augself)[1]=(I)namelist;  // transfer value to writable block; install empty name array
  RZ(z=fixa(augself,AT(w)&VERB+ADV+CONJ?w:symbrdlock(w)));  // name comes from string a
  // Once a node has been fixed, it doesn't need to be looked at ever again.  This applies even if the node itself carries a name.  To indicate this
- // we set VFIX.  We only do so if the node has descendants (or a name).  We also turn off VNAMED, which is set in named explicit definitions (I don't
-  // understand why).  We can do this only if we are sure the entire tree was traversed, i. e. we were not just looking for implicit locatives or inverses.
- if(!(IAV(self)[0]&(FIXALOCSONLY|FIXALOCSONLYLOWEST|FIXASTOPATINV))&&AT(z)&VERB+ADV+CONJ){V*v=FAV(z); if(v->fgh[0]){v->flag|=VFIX+VNAMED; v->flag^=VNAMED;}}  // f is clear for anything in the pst
+ // we set VFIX.  We only do so if the node has descendants (or a name). We can do this only if we are sure the entire tree was traversed, i. e. we were not just looking for implicit locatives or inverses.
+ if(!(IAV(self)[0]&(FIXALOCSONLY|FIXALOCSONLYLOWEST|FIXASTOPATINV))&&AT(z)&VERB+ADV+CONJ){V*v=FAV(z); if(v->fgh[0]){v->flag|=VFIX;}}  // f is clear for anything in the pst
  EPILOG(z);
 }
diff --git a/jsrc/cx.c b/jsrc/cx.c
diff --git a/jsrc/dstop.c b/jsrc/dstop.c
@@ -42,8 +42,8 @@ B jtdbstop(J jt,DC d,I i){A a;B b,c=0,e;C nw[11],*s,*t,*u,*v;I md,n,p,q;
  }
  // if no single-step stop, try looking the line up in the stops table
  if(i==d->dcstop){d->dcstop=-2; R 0;}     /* not stopping if already stopped at the same place */
- if(!(JT(jt,dbstops)))R 0; s=CAV(str0(JT(jt,dbstops))); sprintf(nw,FMTI,i);
- a=d->dca; n=d->dcm; t=NAV(a)->s; md=d->dcx&&d->dcy?2:1; 
+ if(!(JT(jt,dbstops)))R 0; s=CAV(str0(JT(jt,dbstops))); sprintf(nw,FMTI,i);  // s->stop strings, nw=character form of line#
+ a=d->dca; n=d->dcm; t=NAV(a)->s; md=d->dcx&&d->dcy?2:1;   // t->name we are looking for, n=its length, md=valence of call
  NOUNROLL while(s){
   NOUNROLL while(' '==*s)++s; if(b='~'==*s)++s; while(' '==*s)++s;
   u=strchr(s,'*'); v=strchr(s,' '); if(!v)break;; 
diff --git a/jsrc/dsusp.c b/jsrc/dsusp.c
@@ -211,7 +211,7 @@ A jtpee(J jt,A *queue,CW*ci,I err,I lk,DC c){A z=0;
  if(jt->jerr)z=0; R z;  // if we entered debug, the error may have been cleared.  If not, clear the result.  Return debug result, which is result to use or 0 to indicate jump
 }
 
-// parsex: parse an explicit defn line when the debugger is running
+// parsex: parse an explicit defn line when the debugger/pm is running
 /* w  - line to be parsed                           */
 /* lk - 1 iff locked function; _1 to signal noun error at beginning of sentence */
 /* ci - current row of control matrix               */
@@ -220,17 +220,18 @@ A jtpee(J jt,A *queue,CW*ci,I err,I lk,DC c){A z=0;
 
 A jtparsex(J jt,A* queue,I m,CW*ci,DC c){A z;B s;
  movesentencetosi(jt,queue,m,0);  // install sentence-to-be-executed for stop purposes
- if(s=dbstop(c,ci->source)){z=0; jsignal(EVSTOP);}
- else                      {z=PARSERVALUE(parsea(queue,m));     }
+ if(s=dbstop(c,ci->source)){z=0; jsignal(EVSTOP);
+ }else{  // cx adds a stack entry for PARSE, needed to get anonymous operators right
+  z=PARSERVALUE(parsea(queue,m));
+ }
  // If we hit a stop, or if we hit an error outside of try./catch., enter debug mode.  But if debug mode is off now, we must have just
  // executed 13!:0]0, and we should continue on outside of debug mode.  Error processing filled the current si line with the info from the parse
  if(!z&&jt->uflags.us.cx.cx_c.db){DC t=jt->sitop->dclnk; t->dcj=jt->sitop->dcj=jt->jerr; z=debug(); t->dcj=0;} //  d is PARSE type; set d->dcj=err#; d->dcn must remain # tokens
  R z;
 }
 
-A jtdbunquote(J jt,A a,A w,A self,L *stabent){A t,z;B s;DC d;V*sv;
+A jtdbunquote(J jt,A a,A w,A self,DC d){A t,z;B s;V*sv;
  sv=FAV(self); t=sv->fgh[0]; 
- RZ(d=deba(DCCALL,a,w,self)); d->dcn=(I)stabent;
  if(CCOLON==sv->id&&(sv->flag&VXOP||t&&NOUN&AT(t))){  // : and executable body: either OP (adv/conj now with noun operands) or m : n
   ras(self); z=a?dfs2(a,w,self):dfs1(w,self); fa(self);
  }else{                              /* tacit    */
@@ -248,7 +249,7 @@ A jtdbunquote(J jt,A a,A w,A self,L *stabent){A t,z;B s;DC d;V*sv;
   }
  }
  if(d->dcss)ssnext(d,d->dcss);  // if we step over/into on the last line of a function, we must stop on the next line of the caller
- debz();
+// obsolete  debz();
  R z;
 }    /* function call, debug version */
 
diff --git a/jsrc/j.c b/jsrc/j.c
@@ -57,7 +57,7 @@ I __attribute__((aligned(CACHELINESIZE))) validitymask[16]={-1, -1, 0, 0, -1, -1
 __attribute__((aligned(CACHELINESIZE))) I Bnum[22][8*(2-SY_64)] = {  // the numbers we keep at hand.  0 and 1 are B01, the rest INT; but the first 2 are integer forms of 0 and 1
 CBAIVAL(INT,0), CBAIVAL(INT,1),
 CBAIVAL(INT,-10), CBAIVAL(INT,-9), CBAIVAL(INT,-8), CBAIVAL(INT,-7), CBAIVAL(INT,-6), CBAIVAL(INT,-5), CBAIVAL(INT,-4), CBAIVAL(INT,-3), CBAIVAL(INT,-2), CBAIVAL(INT,-1), 
-CBAIVAL(B01,0), CBAIVAL(B01,1),
+CBAIVAL(B01,0), CBAIVAL(B01,1),  // these values must be padded with 0 so they can be used as an INT
 CBAIVAL(INT,2), CBAIVAL(INT,3), CBAIVAL(INT,4), CBAIVAL(INT,5), CBAIVAL(INT,6), CBAIVAL(INT,7), CBAIVAL(INT,8), CBAIVAL(INT,9)
 };
 
diff --git a/jsrc/j.h b/jsrc/j.h
@@ -759,7 +759,7 @@ extern unsigned int __cdecl _clearfp (void);
 #define FDEPINC(d)      {ASSERT(jt->fdepn>=jt->fdepi+(I4)(d),EVSTACK); jt->fdepi+=(I4)(d);}
 #define STACKVERIFY
 #endif
-#define FCONS(x)        fdef(0,CFCONS,VERB,jtnum1,jtnum2,0L,0L,(x),VFLAGNONE, RMAX,RMAX,RMAX)
+#define FCONS(x)        fdef(0,CFCONS,VERB,jtnum1,jtnum2,0L,0L,(x),VJTFLGOK1+VIRS1+VASGSAFE, RMAX,RMAX,RMAX)
 // fuzzy-equal is used for tolerant comparisons not related to jt->cct; for example testing whether x in x { y is an integer
 #define FUZZ            0.000000000000056843418860808015   // tolerance
 // FEQ/FIEQ are used in bcvt, where FUZZ may be set to 0 to ensure only exact values are demoted to lower precision
diff --git a/jsrc/je.h b/jsrc/je.h
@@ -600,7 +600,7 @@ extern DF2(jtbitwisechar);
 extern DF2(jtcharfn2);
 extern DF2(jtdeadband);
 extern DF2(jtunquote);
-extern A jtdbunquote(J,A,A,A,L*);
+extern A jtdbunquote(J,A,A,A,DC);
 extern DF2(jtdfs2);
 extern DF2(jteachl);
 extern DF2(jteachr);
diff --git a/jsrc/jt.h b/jsrc/jt.h
@@ -219,6 +219,7 @@ typedef struct JSTstruct {
  C baselocale[4];    // will be "base"
  UI4 baselocalehash;   // name hash for base locale
  A zpath;    // path 'z', used for all initial paths
+ I cachesizes[3];  // [0]: size of fastest cache  [1]: size of largest cache private to each core  [2]: size of largest cache shared by all cores
 // end of cache line 1
  A sbu;              /* SB data for each unique symbol                  */
  A p4792;            // pointer to p: i. 4792, filled in on first use
diff --git a/jsrc/jtype.h b/jsrc/jtype.h
@@ -1005,7 +1005,8 @@ typedef struct {
 #define VCEIL           (I)0x4000       /* function is >.@g                */
 #define VMOD            (I)0x8000        /* function is m&|@g               */
 #define VLOCK           (I)0x10000        /* function is locked              */
-#define VNAMED          (I)0x20000       /* named explicit defn             */
+// bit 17 free
+// obsolete #define VNAMED          (I)0x20000       /* named explicit defn         */
 #define VFIX            (I)0x40000       /* f. applied                      */
 #define VXOPRX          19
 #define VXOPR           ((I)1<<VXOPRX)       /* : defn with u. and x.           */
diff --git a/jsrc/p.c b/jsrc/p.c
@@ -283,7 +283,7 @@ void auditblock(J jt,A w, I nonrecurok, I virtok) {
 
 
 
-// Run parser, creating a new debug frame.  Explicit defs, which make other tests first, then go through jtparsea
+// Run parser, creating a new debug frame.  Explicit defs, which make other tests first, go through jtparsea except during debug/pm
 // the result has bit 0 set if final assignment
 // JT flags indicate whether call comes from ".
 F1(jtparse){F1PREFIP;A z;
diff --git a/jsrc/s.c b/jsrc/s.c
@@ -554,12 +554,10 @@ L* jtsymbis(J jt,A a,A w,A g){F2PREFIP;A x;I wn,wr;L*e;
  // g has the locale we are writing to
  anmf=AR(g);  // get rank-flags for the locale g
  if(!((I)jtinplace&JTASSIGNSYMNON0)){
- // we don't have e, look it up & check NAMED
+ // we don't have e, look it up
   RZ(e=g==jtlocal?probeislocal(a) : probeis(a,g));   // set e to symbol-table slot to use
-  // If the new value is a function created by n : m, this becomes a named function; if running a locked function, this is locked too.
-  // kludge  these flags are modified in the input area (w), which means they will be improperly set in the result of the
-  // assignment (ex: (nm =: 3 : '...') y).  There seems to be no ill effect, because VNAMED isn't used much.
-  if(unlikely(AT(w)&FUNC))if(likely(FAV(w)->fgh[0]!=0)){if(FAV(w)->id==CCOLON)FAV(w)->flag|=VNAMED; if(jt->glock)FAV(w)->flag|=VLOCK;}
+// obsolete   if(unlikely(AT(w)&FUNC))if(likely(FAV(w)->fgh[0]!=0)){if(FAV(w)->id==CCOLON)FAV(w)->flag|=VNAMED; if(jt->glock)FAV(w)->flag|=VLOCK;}
+  if(unlikely(jt->glock!=0))if(unlikely(AT(w)&FUNC))if(likely(FAV(w)->fgh[0]!=0)){FAV(w)->flag|=VLOCK;}  // fn created in locked function is also locked
  }
  // if we are writing to a non-local table, update the table's Bloom filter.
  if(unlikely((anmf&ARLOCALTABLE)==0)){BLOOMOR(g,BLOOMMASK(NAV(a)->hash));}
diff --git a/jsrc/sc.c b/jsrc/sc.c
@@ -143,18 +143,25 @@ valgone: ;
   if(unlikely(!(flgd0cp&2))){ACDECR(fs); if(unlikely(AC(fs)<=0)){ACINCR(fs); fa(fs);}}
  } else {
   // Extra processing is required.  Check each option individually
+  DC d=0;  // pointer to debug stack frame, if one is allocated
+  if(jt->uflags.us.cx.cx_us){  // debug or pm
+   // allocate debug stack frame if we are debugging OR PM'ing.  In PM, we need a way to get the name being executed in an operator
+   RZ(d=deba(DCCALL,flgd0cp&8?a:0,flgd0cp&8?w:a,fs)); d->dcn=(I)(flgd0cp&3?0:stabent);   // save last sym lookup as debug parm if it is valid (not cached or pseudoname)
+  }
+
   if(jt->uflags.us.cx.cx_c.pmctr)pmrecord(thisname,jt->global?LOCNAME(jt->global):0,-1L,flgd0cp&8?VAL2:VAL1);  // Record the call to the name, if perf monitoring on
   // If we are required to insert a marker for each call, do so (if it hasn't been done already).  But not for pseudo-named functions
   if(!(flgd0cp&1) && jt->uflags.us.uq.uq_c.bstkreqd && callstackx==jt->callstacknext){pushcallstack1d(CALLSTACKPOPLOCALE,jt->global);}  //  If cocurrent is about, make every call visible
   if(jt->uflags.us.cx.cx_c.db&&!(jt->glock||VLOCK&v->flag)&&jt->recurstate<RECSTATEPROMPT){  // The verb is locked if it is marked as locked, or if the script is locked; if recursive JDo, can't enter debug suspension so ignore debug
-   z=dbunquote(flgd0cp&8?a:0,flgd0cp&8?w:a,fs,flgd0cp&3?0:stabent);  // if debugging, go do that.  save last sym lookup as debug parm if it is valid (not cached or pseudoname)
+   z=dbunquote(flgd0cp&8?a:0,flgd0cp&8?w:a,fs,d);  // if debugging, go do that. 
   }else{
    if(unlikely(!(flgd0cp&2)))ACINCR(fs);  // protect the entity if not cached
    A s=jt->parserstackframe.sf; jt->parserstackframe.sf=fs; z=(*actionfn)((J)(((REPSGN(SGNIF(v->flag,(flgd0cp>>3)+VJTFLGOK1X)))|~JTFLAGMSK)&(I)jtinplace),a,w,fs); jt->parserstackframe.sf=s;
   if(unlikely(!(flgd0cp&2))){ACDECR(fs); if(unlikely(AC(fs)<=0)){ACINCR(fs); fa(fs);}}
   }
   if(jt->uflags.us.cx.cx_c.pmctr)pmrecord(thisname,jt->global?LOCNAME(jt->global):0,-2L,flgd0cp&8?VAL2:VAL1);  // record the return from call
   if(jt->uflags.us.uq.uq_c.spfreeneeded)spfree();   // if garbage collection required, do it
+  if(d)debz();  // release stack frame if allocated
  }
 #if !USECSTACK
  FDEPDEC(d);
@@ -279,7 +286,7 @@ F2(jtnamerefop){V*v;
 }    
 
 /* namerefop() is used by explicit defined operators when: */
-/* - debug is on                                           */
+// - debug is on or PM is on
 /* - operator arguments have been supplied                 */
 /* - function arguments have not yet been supplied         */
 // w is an anonymous entity that we want to give the name a to for debug purposes
diff --git a/jsrc/u.c b/jsrc/u.c
@@ -358,19 +358,33 @@ void mvc(I m,void*z,I n,void*w){
    }
    if(unlikely((m&=-SZI)==0))R; --m;  // account for bytes moved; return if we have moved all; keep m as count-1
   }
-  /* store 128-byte sections, first one being 0, 4, 8, or 12 Is. There could be 0 to do */
+  // store 128-byte sections, first one being 0, 4, 8, or 12 Is. There could be 0 to do
   UI n2=DUFFLPCT(m>>LGSZI,2);  /* # turns through duff loop */
   if(n2>0){
    UI backoff=DUFFBACKOFF(m>>LGSZI,2);
    z=(C*)z+(backoff+1)*NPAR*SZI;
-   switch(backoff){
-   do{ ;
-   case -1: _mm256_storeu_si256((__m256i*)z,wd);
-   case -2: _mm256_storeu_si256((__m256i*)((C*)z+1*NPAR*SZI),wd);
-   case -3: _mm256_storeu_si256((__m256i*)((C*)z+2*NPAR*SZI),wd);
-   case -4: _mm256_storeu_si256((__m256i*)((C*)z+3*NPAR*SZI),wd);
-   z=(C*)z+4*NPAR*SZI;
-   }while(--n2>0);
+   if(likely(m<L3CACHESIZE)){
+    // Normal case: not a huge copy
+    switch(backoff){
+    do{ ;
+    case -1: _mm256_storeu_si256((__m256i*)z,wd);
+    case -2: _mm256_storeu_si256((__m256i*)((C*)z+1*NPAR*SZI),wd);
+    case -3: _mm256_storeu_si256((__m256i*)((C*)z+2*NPAR*SZI),wd);
+    case -4: _mm256_storeu_si256((__m256i*)((C*)z+3*NPAR*SZI),wd);
+    z=(C*)z+4*NPAR*SZI;
+    }while(--n2>0);
+    }
+   }else{
+   // The copy length is bigger than L3 cache: use non-temporal stores to avoid excessive cache traffic
+    switch(backoff){
+    do{ ;
+    case -1: _mm256_stream_si256((__m256i*)z,wd);
+    case -2: _mm256_stream_si256((__m256i*)((C*)z+1*NPAR*SZI),wd);
+    case -3: _mm256_stream_si256((__m256i*)((C*)z+2*NPAR*SZI),wd);
+    case -4: _mm256_stream_si256((__m256i*)((C*)z+3*NPAR*SZI),wd);
+    z=(C*)z+4*NPAR*SZI;
+    }while(--n2>0);
+    }
    }
   }
   // copy last section, 1-4 Is. ll bits 00->4 bytes, 01->3 bytes, etc
diff --git a/jsrc/v.c b/jsrc/v.c
@@ -120,8 +120,29 @@ F1(jtjico1){A y,z;B b;D d,*v;I c,m,n;
  RETF(z);
 }
 
-// _9: to 9:, return the saved value.  These MUST NOT inplace because of a pun in the coding of comparison combination flags
-DF1(jtnum1){ARGCHK2(w,self); R FAV(self)->fgh[2];}
+// _9: to 9: and _:, return the saved value.
+// obsolete   These MUST NOT inplace because of a pun in the coding of comparison combination flags
+DF1(jtnum1){F1PREFIP;A z=0;
+ ARGCHK2(w,self); RANKT rank=(RANKT)jt->ranks; rank=rank>AR(w)?AR(w):rank; A a=FAV(self)->fgh[2];  // fetch value to store
+ if(rank==AR(w))R a;  // at infinite rank, just return the value
+ // rank given, must replicate the value.  if rank 0, we can do it inplace
+ I natoms;  // number of atoms to allocate
+ I akl=bplg(AT(a)), wkl=bplg(AT(w));  // sizes of atoms
+ if(rank==0){
+  natoms=AN(w);  // result has same # atoms as input
+  if(ASGNINPLACESGN(SGNIF((I)jtinplace,JTINPLACEWX)&-(AT(w)&B01+INT+FL)&~((AT(w)&B01+INT+FL)-(AT(a)&B01+INT+FL)),w)){  // inplaceable, and direct numeric and type of a is not bigger than that of w
+   // inplace: we will cast the atom of a to the (never smaller) size of w.  This is OK because a is never a bigger type
+   z=w; akl=wkl;
+ }else{
+  // not inplace: count the atoms of the result
+  PROD(natoms,AR(w)-rank,AS(w));  // # atoms in result: 1 per cell
+  wkl=akl;  // we will allocate with the type of a, so use that length
+ }
+ if(!z)GA(z,AT(a),natoms,AR(w)-rank,AS(w)+rank);}  // allocate result if not inplace
+ // We now have the result area, with the right type.  Fill it
+ mvc(natoms<<wkl,voidAV(z),1LL<<akl,voidAV(a));
+ R z;
+}
 DF2(jtnum2){ARGCHK3(a,w,self); R FAV(self)->fgh[2];}
 
 F2(jtfromr  ){ARGCHK2(a,w); A z; R IRS2(a,w,0, RMAX,1L,jtfrom  ,z);} // no agreement check because left rank is infinite - no frame  {"_ 1
diff --git a/jsrc/vcomp.c b/jsrc/vcomp.c
@@ -97,7 +97,7 @@ AHDR2(name,B,D,D){ \
  if(jt->cct!=1.0){ \
   cct=_mm256_broadcast_sd(&jt->cct); \
   if(n-1==0){ \
-   /* vector-to-vector, no repetitions */ \
+   /* vector op vector, no repetitions */ \
    endmask = _mm256_loadu_si256((__m256i*)(validitymask+((-m)&(NPAR-1))));  /* mask for 00=1111, 01=1000, 10=1100, 11=1110 */ \
    DQ((m-1)>>LGNPAR, \
      u=_mm256_loadu_pd(x);v=_mm256_loadu_pd(y); \
@@ -112,7 +112,8 @@ AHDR2(name,B,D,D){ \
    STOREBYTES(z,VALIDBOOLEAN&_mm256_movemask_epi8(_mm256_castpd_si256(eq)),((-m)&(NPAR-1))+NPAR);  /* could just overstore */ \
   }else{ \
    if(n-1<0){n=~n; \
-    /* atom+vector */ \
+    /* atom op vector */ \
+    if(m==1 && *x==0.0)goto name##av0;  /* if comparing against 0, switch to intolerant */ \
     endmask = _mm256_loadu_si256((__m256i*)(validitymask+((-n)&(NPAR-1)))); \
     DQ(m, u=_mm256_broadcast_sd(x); ++x; \
       ctop=_mm256_mul_pd(u,cct); \
@@ -128,7 +129,8 @@ AHDR2(name,B,D,D){ \
       STOREBYTES(z,VALIDBOOLEAN&_mm256_movemask_epi8(_mm256_castpd_si256(eq)),((-n)&(NPAR-1))+NPAR);  /* could just overstore */ \
       y+=((n-1)&(NPAR-1))+1; z+=((n-1)&(NPAR-1))+1;) \
    }else{ \
-    /* vector+atom */ \
+    /* vector op atom */ \
+    if(m==1 && *y==0.0)goto name##va0;  /* if comparing against 0, switch to intolerant */ \
     endmask = _mm256_loadu_si256((__m256i*)(validitymask+((-n)&(NPAR-1)))); \
     DQ(m, v=_mm256_broadcast_sd(y); ++y; \
       ctop=_mm256_mul_pd(v,cct); \
@@ -147,7 +149,7 @@ AHDR2(name,B,D,D){ \
   } \
  }else{ \
   if(n-1==0){ \
-   /* vector-to-vector, no repetitions */ \
+   /* vector op!.0 vector, no repetitions */ \
    endmask = _mm256_loadu_si256((__m256i*)(validitymask+((-m)&(NPAR-1))));  /* mask for 00=1111, 01=1000, 10=1100, 11=1110 */ \
    DQ((m-1)>>LGNPAR, \
      u=_mm256_loadu_pd(x);v=_mm256_loadu_pd(y); \
@@ -160,7 +162,7 @@ AHDR2(name,B,D,D){ \
    STOREBYTES(z,VALIDBOOLEAN&_mm256_movemask_epi8(_mm256_castpd_si256(eq)),((-m)&(NPAR-1))+NPAR);  /* could just overstore */ \
   }else{ \
    if(n-1<0){n=~n; \
-    /* atom+vector */ \
+    name##av0: /* atom op!.0 vector */ \
     endmask = _mm256_loadu_si256((__m256i*)(validitymask+((-n)&(NPAR-1)))); \
     DQ(m,; u=_mm256_broadcast_sd(x); ++x; \
       DQ((n-1)>>LGNPAR, \
@@ -173,7 +175,7 @@ AHDR2(name,B,D,D){ \
       STOREBYTES(z,VALIDBOOLEAN&_mm256_movemask_epi8(_mm256_castpd_si256(eq)),((-n)&(NPAR-1))+NPAR);  /* could just overstore */ \
       y+=((n-1)&(NPAR-1))+1; z+=((n-1)&(NPAR-1))+1;) \
    }else{ \
-    /* vector+atom */ \
+    name##va0: /* vector op!.0atom */ \
     endmask = _mm256_loadu_si256((__m256i*)(validitymask+((-n)&(NPAR-1)))); \
     DQ(m, v=_mm256_broadcast_sd(y); ++y; \
       DQ((n-1)>>LGNPAR, \
diff --git a/jsrc/vfrom.c b/jsrc/vfrom.c
diff --git a/jsrc/xt.c b/jsrc/xt.c
diff --git a/test/g520.ijs b/test/g520.ijs
diff --git a/test/g6x.ijs b/test/g6x.ijs
diff --git a/version.txt b/version.txt
