CogVM source as per VMMaker.oscog-eem.3675/Balloon3D-Plugins-eem.24

Open code compiled code indexing in StackInterpreter>>stObject:at:[put:]
to eliminate the double check for compiledMethodFormat that
firstValidIndexOfIndexableObject:withFormat: implied.
Run InterpreterPrimitives>>primitive[String]At[Put] on the Smalltalk stack.

Together this significantly speeds up shape changing when the ClassBuilder
runs with MethodMassage (because at:[put:] for CompiledCode is not jitted).

Clean up the profiling code in the Cogit. In particular if (as it is by
default) the methodObject is being fetched for the prim trace log set
newMethod if required, avoiding fetching methodObject twice. Don't pass
the argument to ceTakeProfileSample:; instead have ceTakeProfileSample
access newMethod which will have been set.

When flushing the cache by selector (primitiveFlushCacheBySelector)
free any associated Open PIC and rebuild the OpenPIC list. This is
arguably over zealous, but otherwise relevant send sites are not
really unlinked.

Don't fetch callTargetFromReturnAddress: in ceSICMiss:, which with
cache flushing changes above results in an erroneous assert fail.

Add careful asserts for return from primitives in the Cogit. This pointed
to a bug in the SmartSyntaxPluginSimulator (see VMMaker.oscog-eem.3669).

Fix comment and variable names in ceStackOverflow:.

Fix warnings in method cache and prim log print routines.

Use methodReturnValue: in primitiveEnterCriticalSection.

Plugins:
Add stackMutableObjectValue: (that replaces the unused displayObject
in struct VirtualMachine) and use it to implement mutability checks
for at least the graphics plugins.

Remove some unnecessary remapOop:in: calls given that floatObjectOf:,
positive32BitIntegerObjectOf: and makePointwithxValue:yValue: do not fail.

Squeak3D:
Add mutability checking for the vertex array primitives.
Simplify mapVB:ofSize:into: given that floatObjectOf: never fails.

Author: eliotmiranda

platforms/Cross/plugins/BochsIA32Plugin/sqBochsIA32Plugin.cpp

@@ -163,6 +163,41 @@ resetSegmentRegisters(uintptr_t byteSize, uintptr_t minWriteMaxExecAddr)
 		return blidx == 0 ? 0 : SomethingLoggedError;
 	}
 
+	/*
+	 * Answer if a 64-bit performance counter is available, storing its value through
+	 * the pointer if so.
+	 * Answer an integer error code if and when something went awry (as specified above).
+	 */
+	long
+	performanceCounter64ofinto(void *cpu, uintptr_t *perfCounterp)
+	{
+		BX_CPU_C *anx86 = (BX_CPU_C *)cpu;
+
+		if (anx86 != &bx_cpu)
+			return BadCPUInstance;
+
+		*perfCounterp = anx86->timeStampCounter;
+
+		return 0;
+	}
+
+	/*
+	 * Answer zero if the 64-bit performance counter could be incremented by increment.
+	 * Answer an integer error code if and when something went awry (as specified above).
+	 */
+	long
+	incrementPerformanceCounter64ofby(void *cpu, uintptr_t increment)
+	{
+		BX_CPU_C *anx86 = (BX_CPU_C *)cpu;
+
+		if (anx86 != &bx_cpu)
+			return BadCPUInstance;
+
+		anx86->timeStampCounter += increment;
+
+		return 0;
+	}
+
 	/*
 	 * Currently a dummy for Bochs.
 	 */

platforms/Cross/plugins/BochsX64Plugin/sqBochsX64Plugin.cpp

@@ -193,6 +193,40 @@ resetSegmentRegisters(uintptr_t byteSize, uintptr_t minWriteMaxExecAddr)
 		return blidx == 0 ? 0 : SomethingLoggedError;
 	}
 
+	/*
+	 * Answer if a 64-bit performance counter is available, storing its value through
+	 * the pointer if so.
+	 */
+	long
+	performanceCounter64ofinto(void *cpu, uintptr_t *perfCounterp)
+	{
+		BX_CPU_C *anx64 = (BX_CPU_C *)cpu;
+
+		if (anx64 != &bx_cpu)
+			return BadCPUInstance;
+
+		*perfCounterp = anx64->timeStampCounter;
+
+		return 0;
+	}
+
+	/*
+	 * Answer zero if the 64-bit performance counter could be incremented by increment.
+	 * Answer an integer error code if and when something went awry (as specified above).
+	 */
+	long
+	incrementPerformanceCounter64ofby(void *cpu, uintptr_t increment)
+	{
+		BX_CPU_C *anx64 = (BX_CPU_C *)cpu;
+
+		if (anx64 != &bx_cpu)
+			return BadCPUInstance;
+
+		anx64->timeStampCounter += increment;
+
+		return 0;
+	}
+
 	/*
 	 * Currently a dummy for Bochs.
 	 */

platforms/Cross/plugins/GdbARMPlugin/sqGdbARMPlugin.c

@@ -23,7 +23,7 @@
 #include <armdefs.h>
 #include <armemu.h>
 
-ARMul_State*	lastCPU = NULL;
+ARMul_State	*lastCPU = NULL;
 
 // These two variables exist, in case there are library-functions which write to a stream.
 // In that case, we would write functions which print to that stream instead of stderr or similar
@@ -53,7 +53,7 @@ print_state(ARMul_State *state)
 		(state->prog32Sig == HIGHLOW ? "HIGHLOW" : "???")), state->Emulate);
 }
 
-void*
+void *
 newCPU()
 {
 	if (lastCPU == NULL) ARMul_EmulateInit();
@@ -70,7 +70,7 @@ long
 resetCPU(void *cpu)
 {
 	unsigned int i, j;
-	ARMul_State *state = (ARMul_State*) cpu;
+	ARMul_State *state = (ARMul_State *)cpu;
 	// test whether the supplied instance is an ARMul type?
 
 	gdblog_index = 0;
@@ -95,7 +95,7 @@ resetCPU(void *cpu)
 // See comments in platforms/Cross/plugins/ProcessorSimulatorPlugin.h
 static inline long
 runOnCPU(ARMul_State *cpu, void *memory,
-		uintptr_t byteSize, uintptr_t minAddr, uintptr_t minWriteMaxExecAddr, ARMword (*runOrStep)(ARMul_State*))
+		uintptr_t byteSize, uintptr_t minAddr, uintptr_t minWriteMaxExecAddr, ARMword (*runOrStep)(ARMul_State *))
 {
 	assert(lastCPU == cpu);
 
@@ -150,6 +150,37 @@ runCPUInSizeMinAddressReadWrite(void *cpu, void *memory,
 	return runOnCPU(cpu, memory, byteSize, minAddr, minWriteMaxExecAddr, ARMul_DoProg);
 }
 
+/*
+ * Answer if a 64-bit performance counter is available, storing its value through
+ * the pointer if so.
+ */
+long
+performanceCounter64ofinto(void *cpup, uintptr_t *perfCounterp)
+{
+	ARMul_State *cpu = cpup;
+
+	if (lastCPU != cpu)
+		return BadCPUInstance;
+
+	return UnsupportedOperationError;
+}
+
+/*
+ * Answer zero if the 64-bit performance counter could be incremented by increment.
+ * Answer an integer error code if and when something went awry (as specified above).
+ */
+long
+incrementPerformanceCounter64ofby(void *cpup, uintptr_t increment)
+{
+	ARMul_State *cpu = cpup;
+
+	if (lastCPU != cpu)
+		return BadCPUInstance;
+
+	// rather than fail just ignore it. It allows the image to increment the clock without a platform test
+	return 0;
+}
+
 /*
  * Currently a dummy for ARM Processor Alien.
  */
@@ -168,10 +199,11 @@ gdb_log_printf(void *stream, const char *format, ...)
 	int n;
 	va_start(arg,format);
 
-	if (stream == NULL){
-		n = vsnprintf((char*) (&gdb_log) + gdblog_index, LOGSIZE-gdblog_index, format, arg);
+	if (!stream) {
+		n = vsnprintf((char *)(&gdb_log) + gdblog_index, LOGSIZE-gdblog_index, format, arg);
 		gdblog_index = gdblog_index + n;
-	} else {
+	}
+	else {
 		vfprintf(stream, format, arg);
 	}
 	return 0;

platforms/Cross/plugins/GdbARMv8Plugin/sqGdbARMv8Plugin.c

@@ -151,6 +151,40 @@ runCPUInSizeMinAddressReadWrite(void *cpu, void *memory,
 	return runOnCPU(cpu, memory, byteSize, minAddr, minWriteMaxExecAddr, run);
 }
 
+/*
+ * Answer if a 64-bit performance counter is available, storing its value through
+ * the pointer if so.
+ */
+long
+performanceCounter64ofinto(void *cpup, uintptr_t *perfCounterp)
+{
+	sim_cpu *cpu = cpup;
+
+	if (lastCPU != cpu)
+		return BadCPUInstance;
+
+	*perfCounterp = cpu->cntvct;
+
+	return 0;
+}
+
+/*
+ * Answer zero if the 64-bit performance counter could be incremented by increment.
+ * Answer an integer error code if and when something went awry (as specified above).
+ */
+long
+incrementPerformanceCounter64ofby(void *cpup, uintptr_t increment)
+{
+	sim_cpu *cpu = cpup;
+
+	if (lastCPU != cpu)
+		return BadCPUInstance;
+
+	cpu->cntvct += increment;
+
+	return 0;
+}
+
 /*
  * Currently a dummy for ARM Processor Alien.
  */

platforms/Cross/plugins/ProcessorSimulatorPlugin.h

@@ -101,3 +101,16 @@ extern void storeIntegerRegisterStateOfinto(void *cpu, WordType *registerState);
  * produces duplicate symbols so use this large hammer, setMinAddresses.
  */
 extern void setMinAddresses(uintptr_t mra, uintptr_t mwa);
+
+/*
+ * Answer zero if a 64-bit performance counter is available, storing its value
+ * through the pointer if so.
+ * Answer an integer error code if and when something went awry (as specified above).
+ */
+extern long performanceCounter64ofinto(void *cpu, uintptr_t *perfCounterp);
+
+/*
+ * Answer zero if the 64-bit performance counter could be incremented by increment.
+ * Answer an integer error code if and when something went awry (as specified above).
+ */
+extern long incrementPerformanceCounter64ofby(void *cpu, uintptr_t increment);

platforms/Cross/vm/sqVirtualMachine.c

@@ -90,7 +90,7 @@ struct VirtualMachine* sqGetInterpreterProxy(void)
 	VM->pushInteger = pushInteger;
 	VM->stackFloatValue = stackFloatValue;
 	VM->stackIntegerValue = stackIntegerValue;
-	VM->stackObjectValue = stackObjectValue;
+	VM->stackObjectValue = stackObjectValue; // N.B. see stackMutableObjectValue below
 	VM->stackValue = stackValue;
 
 	/* InterpreterProxy methodsFor: 'object access' */
@@ -156,7 +156,11 @@ struct VirtualMachine* sqGetInterpreterProxy(void)
 # else
 	VM->characterTable = characterTable;
 # endif
+#if OLD_FOR_REFERENCE
 	VM->displayObject = displayObject;
+#else
+	VM->stackMutableObjectValue = stackMutableObjectValue; // cf stackObjectValue above
+#endif
 	VM->falseObject = falseObject;
 	VM->nilObject = nilObject;
 	VM->trueObject = trueObject;

platforms/Cross/vm/sqVirtualMachine.h

@@ -123,7 +123,11 @@ typedef struct VirtualMachine {
 	/* InterpreterProxy methodsFor: 'special objects' */
 
 	sqInt (*characterTable)(void);
-	sqInt (*displayObject)(void);
+#if OLD_FOR_REFERENCE
+	sqInt (*displayObject)(void); // repurposed
+#else /* since there is no legacy plugin problem back to 3.8 we repurpose... */
+	sqInt  (*stackMutableObjectValue)(sqInt offset);
+#endif
 	sqInt (*falseObject)(void);
 	sqInt (*nilObject)(void);
 	sqInt (*trueObject)(void);
@@ -397,6 +401,7 @@ sqInt  pushInteger(sqInt integerValue);
 double stackFloatValue(sqInt offset);
 sqInt  stackIntegerValue(sqInt offset);
 sqInt  stackObjectValue(sqInt offset);
+sqInt  stackMutableObjectValue(sqInt offset);
 sqInt  stackValue(sqInt offset);
 
 /*** variables ***/
@@ -463,6 +468,9 @@ sqInt isOopMutable(sqInt oop);
 sqInt isOopImmutable(sqInt oop);
 
 /* InterpreterProxy methodsFor: 'converting' */
+// N.B. there is no booleanObjectOf because testing a boolean and answering either
+// trueObject() or falseObject() is faster than passing an argument to a function
+// that does the same.
 sqInt  booleanValueOf(sqInt obj);
 sqInt  checkedIntegerValueOf(sqInt intOop);
 sqInt  floatObjectOf(double aFloat);

platforms/minheadless/unix/sqUnixHeartbeat.c

@@ -171,11 +171,26 @@ ioHighResClock(void)
 {
   /* return the value of the high performance counter */
   sqLong value = 0;
-#if defined(__GNUC__) && (defined(i386) || defined(__i386) || defined(__i386__)  \
-			|| defined(x86_64) || defined(__x86_64) || defined (__x86_64__))
+
+#if (defined(__GNUC__) || defined(__SUNPRO_C)) && (defined(i386) || defined(__i386) || defined(__i386__))
     __asm__ __volatile__ ("rdtsc" : "=A"(value));
+#elif (defined(__GNUC__) || defined(__SUNPRO_C)) && (defined(x86_64) || defined(__x86_64) || defined (__x86_64__))
+    __asm__ __volatile__ ("rdtsc\n\t"			// Returns the time in EDX:EAX.
+						"shl $32, %%rdx\n\t"	// Shift the upper bits left.
+						"or %%rdx, %0"			// 'Or' in the lower bits.
+						: "=a" (value)
+						: 
+						: "rdx");
+#elif defined(__ARM_ARCH_ISA_A64) || defined(__arm64__) || defined(__aarch64__) || defined(ARM64)
+    // would prefer to use PMCCNTR_EL0 but at least macOS makes it illegal
+    __asm__ __volatile__ ("MRS  %0, CNTVCT_EL0" : "=r"(value));
 #elif defined(__arm__) && (defined(__ARM_ARCH_6__) || defined(__ARM_ARCH_7A__))
 	/* tpr - do nothing for now; needs input from eliot to decide further */
+	/* Tim, not sure I have input beyond:
+		Is there a 64-bit clock on ARM?  If so, access it here :-)
+	 */
+#elif defined(__riscv64__)
+  	__asm__ __volatile__ ("rdcycle a0" : "=r"(value));
 #else
 # error "no high res clock defined"
 #endif

platforms/unix/vm/sqUnixHeartbeat.c

@@ -182,6 +182,7 @@ ioHighResClock(void)
 						: 
 						: "rdx");
 #elif defined(__ARM_ARCH_ISA_A64) || defined(__arm64__) || defined(__aarch64__) || defined(ARM64)
+    // would prefer to use PMCCNTR_EL0 but at least macOS makes it illegal
     __asm__ __volatile__ ("MRS  %0, CNTVCT_EL0" : "=r"(value));
 #elif defined(__arm__) && (defined(__ARM_ARCH_6__) || defined(__ARM_ARCH_7A__))
 	/* tpr - do nothing for now; needs input from eliot to decide further */

platforms/unix/vm/sqUnixITimerHeartbeat.c

@@ -170,15 +170,16 @@ ioHighResClock(void)
 						: "=a" (value)
 						: 
 						: "rdx");
-#elif defined(__arm64__) || defined(__aarch64__) || defined(ARM64)
-    __asm__ __volatile__ ("MRS  X0, CNTVCT_EL0");
+#elif defined(__ARM_ARCH_ISA_A64) || defined(__arm64__) || defined(__aarch64__) || defined(ARM64)
+    // would prefer to use PMCCNTR_EL0 but at least macOS makes it illegal
+    __asm__ __volatile__ ("MRS  %0, CNTVCT_EL0" : "=r"(value));
 #elif defined(__arm__) && (defined(__ARM_ARCH_6__) || defined(__ARM_ARCH_7A__))
 	/* tpr - do nothing for now; needs input from eliot to decide further */
 	/* Tim, not sure I have input beyond:
 		Is there a 64-bit clock on ARM?  If so, access it here :-)
 	 */
 #elif defined(__riscv64__)
-       __asm__ __volatile__ ("rdcycle a0" : "=r"(value));
+  	__asm__ __volatile__ ("rdcycle a0" : "=r"(value));
 #else
 # error "no high res clock defined"
 #endif