simx86: stop using e_querymark to stop codegen (except prejit)

Only stop if
1. there's a jump op generated, or
2. we're in single step mode (SINGLEBLOCK or TF), or
3. we encounter a compatible block we can jump into
other code is going to be invalidated in DoClose(), we're just
going to bulldoze over it here.

SPEC_PREJIT should avoid overwriting, but instead of using a gap,
I let it give up, by not calling Close() and resetting CurrIMeta,
thereby throwing away the prejitted code, instead of generating
an early tailcode.

Author: bartoldeman

src/base/emu-i386/simx86/interp.c

@@ -98,44 +98,42 @@ static TNode *DoClose(unsigned int PC, unsigned int Interp_LONG_CS, int mode,
 		int flags)
 {
 	unsigned int P0 = InstrMeta[0].npc;
-	TNode *G, *nextG = NULL;
+	TNode *G, *nextG;
+	int linknext;
 
-	assert(CurrIMeta >= 0);
-	/* If the code doesn't terminate with a jump/loop instruction
-	 * it still lacks the tail code; add it here */
-	IMeta *GL = &InstrMeta[CurrIMeta];
-	if (GL->gen[GL->ngen-1].op < JMP_TAILCODE) {
-		/* almost always we get here because e_querymark() in
-		   interp_post() found code. If there is no overlap
-		   and the node is compatible we can generate a jump
-		   to it and link as well */
-		nextG = FindTree(PC);
-		if (nextG && nextG->mode == mode &&
-		    nextG->cs == Interp_LONG_CS)
-			JMPGen(JMP_LINK, mode, PC);
-		else
-			JMPGen(JMP_TAILCODE, mode, PC);
-	}
-
-	assert(PC > P0);
+	assert(CurrIMeta >= 0 && PC > P0);
 	if (e_querymark(P0, PC - P0)) {
+	    /* with SPEC_PREJIT give up if we'd overwrite
+	       existing code */
+	    if (flags & F_SPRJ) {
+	        CurrIMeta = -1;
+		return NULL;
+	    }
 	    InvalidateNodeRange(P0, PC - P0, NULL);
 	    if (!e_querymprotrange_full(P0, PC - P0)) {
 		unsigned int abeg, aend;
 
 		/* in case of prejit, the page content could
 		 * be altered, so we better re-jit */
-		if (flags & (F_PREJ | F_SPRJ))
+		if (flags & F_PREJ) {
+			CurrIMeta = -1;
 			return NULL;
+		}
 		abeg = P0 & _PAGE_MASK;
 		aend = PC & _PAGE_MASK;
 		/* re-populate cache */
 		for (; abeg <= aend; abeg += PAGE_SIZE)
 			Fetch(abeg);
 	    }
 	}
+
+	IMeta *GL = &InstrMeta[CurrIMeta];
+	linknext = GL->gen[GL->ngen-1].op == JMP_LINK && !(flags & F_SPRJ);
 	G = Close(PC, Interp_LONG_CS, mode, flags);
-	if (nextG)
+	if (linknext &&
+	    (nextG = FindTree(PC)) &&
+	    nextG->mode == mode &&
+	    nextG->cs == Interp_LONG_CS)
 		NodeLinker(G, nextG);
 	return G;
 }
@@ -464,23 +462,13 @@ static unsigned int FindExecCode(unsigned int PC)
 			else if (debug_level('e')>2)
 				e_printf("** Found compiled code at %08x\n",PC);
 		}
-		else if (e_querymark(PC, 1)) {
-			/* slow path */
-			InvalidateNodeRange(PC, 1, NULL);
-		}
 		/* future proofing: _Interp86() can't fail now in non-prejit mode
 		   but if it ever does, retry */
 		while (!G) {
 			if (CEmuStat & (CeS_PREJIT_RM | CeS_PREJIT_PM)) {
 				TheCPU.err = EXCP_GOBACK;
 				return PC;
 			}
-#if 0
-			/* this obviously can't happen with current code, but
-			 * slows down execution under debug a lot */
-			if (debug_level('e') && e_querymark(PC, 1))
-				error("simx86: code nodes clashed at %x\n", PC);
-#endif
 			if (debug_level('e')>=9)
 				dbug_printf("\n%s",e_print_regs(LONG_CS));
 			PC = _Interp86(PC, LONG_CS, TheCPU.cs, TheCPU.mode, 0);
@@ -557,27 +545,46 @@ void Interp86(void)
     TheCPU.eip = PC - LONG_CS;
 }
 
-/* safety gap should be definitely longer than 1 instruction to not
- * overwrite something unintentionally */
-#define SAFE_PRJ_GAP 16
-
 static int interp_post(unsigned int PC, unsigned int Interp_LONG_CS,
 		       const int mode, int flags)
 {
-		int ret = 0;
-		int gap = (flags & F_SPRJ) ? SAFE_PRJ_GAP : 1;
-		assert (CurrIMeta>=0);
+	TNode *nextG;
+	assert (CurrIMeta>=0);
+	InstrMeta[0].flags |= flags;
 
+	IMeta *GL = &InstrMeta[CurrIMeta];
+	if (GL->gen[GL->ngen-1].op >= JMP_TAILCODE)
+		return 1;
+
+#ifndef SINGLEBLOCK
+        if (mode & MSSTP) {
+		assert(mode & MTRAP);
+#endif
+		/* The code doesn't terminate with a jump/loop instruction
+		 * it still lacks the tail code; add it here */
+		JMPGen(JMP_TAILCODE, mode, PC);
+		return 1;
 #ifndef SINGLEBLOCK
-		IMeta *GL = &InstrMeta[CurrIMeta];
-		if ((mode & MSSTP) ||
-		    GL->gen[GL->ngen-1].op >= JMP_TAILCODE ||
-		    e_querymark(PC, gap))
+	}
+
+	/* if we encounter a compatible block, we can jump and link to
+	   it without needing to overwrite it */
+	if ((nextG = FindTree(PC)) &&
+	    nextG->mode == mode &&
+	    nextG->cs == Interp_LONG_CS) {
+		JMPGen(JMP_LINK, mode, PC);
+		return 1;
+	}
 #endif
-			ret = 1;
-		InstrMeta[0].flags |= flags;
 
-		return ret;
+#ifdef SPEC_PREJIT
+	/* let SPEC_PREJIT give up via DoClose if it overwrites */
+	if ((flags & F_SPRJ) && e_querymark(PC-1, 1))
+		return 1;
+#endif
+
+	/* else we continue interpreting code */
+	return 0;
 }
 
 static void sprj_deep(TNode *G, unsigned PC, unsigned int Interp_LONG_CS,
@@ -589,9 +596,9 @@ static void sprj_deep(TNode *G, unsigned PC, unsigned int Interp_LONG_CS,
 	while (G->clink_t.link && !(G->flags & F_LJMP)) {
 		TNode *oldG = G;
 		PC = G->clink_t.target;
-		if (e_querymark(PC, SAFE_PRJ_GAP)) break;
 		PC = _Interp86(PC, Interp_LONG_CS, ocs, basemode, flags);
 		G = DoClose(PC, Interp_LONG_CS, basemode, flags);
+		if (!G) break;
 		i++;
 		NodesPrejitted++;
 		NodeLinker(oldG, G);
@@ -2791,7 +2798,7 @@ static void prejit_run(TNode *G)
     ds = e_emu_disasm(EMU_BASE32(PC),basemode&MBIGCS,ocs);
     e_printf("prejit at  %s\n", ds);
   }
-  if (e_querymark(PC, SAFE_PRJ_GAP))
+  if (e_querymark(PC, 1))
     return;
 #if PROFILE
   SpecPrejits++;