[Vm-dev] [commit] r2337 - OSCogVM SimpleStackBasedCogit as per VMMaker-oscog.41.

[commits at squeakvm.org]

Author: eliot
Date: 2011-01-01 12:18:49 -0800 (Sat, 01 Jan 2011)
New Revision: 2337

Modified:
   branches/Cog/cygwinbuild/HowToBuild
   branches/Cog/image/VMMaker-Squeak4.1.changes
   branches/Cog/image/VMMaker-Squeak4.1.image
   branches/Cog/image/Workspace.text
   branches/Cog/src/vm/cogit.c
   branches/Cog/src/vm/cogit.h
   branches/Cog/src/vm/cointerp.c
   branches/Cog/src/vm/gcc3x-cointerp.c
Log:
OSCogVM SimpleStackBasedCogit as per VMMaker-oscog.41.
Fix a bug with bytecode to pc mapping being confused by frameless
blocks which caused a crash when converting an interpreter
activation of Cogit class>>generatorTableFrom: to machine code.

Fix SimpleStackBasedCogit compilation by ifdeffing out the body of
enterRegisterArgCogMethod:at:receiver: and addding dummy
registerMaskFor:... defs.

Fix an assert for objects-as-methods in activateInterpreterMethod...


Modified: branches/Cog/cygwinbuild/HowToBuild
===================================================================
--- branches/Cog/cygwinbuild/HowToBuild	2010-12-31 19:27:35 UTC (rev 2336)
+++ branches/Cog/cygwinbuild/HowToBuild	2011-01-01 20:18:49 UTC (rev 2337)
@@ -31,7 +31,10 @@
    cygwinbuild/build/vm folder (make sure you copy Croquet.map along with it)
 
 3a. The cygwin makefile supports building three VM configurations, product,
-    assert and debug, building product by default.  The configurations are
+    assert and debug, building product by default.  To build a configuration
+	simply type make configuration, e.g.
+		make assert
+	The configurations are
 	product: stripped  & unstripped production VMs optimized at -O2 in
 		build/vm/Croquet.exe
 		build/vm/CroquetUnstripped.exe

Modified: branches/Cog/image/VMMaker-Squeak4.1.changes
===================================================================
--- branches/Cog/image/VMMaker-Squeak4.1.changes	2010-12-31 19:27:35 UTC (rev 2336)
+++ branches/Cog/image/VMMaker-Squeak4.1.changes	2011-01-01 20:18:49 UTC (rev 2337)
@@ -150426,4 +150426,1134 @@
 		platformDir: (FileDirectory default / '../platforms') fullName
 		excluding:#(BrokenPlugin SlangTestPlugin TestOSAPlugin
 					FFIPlugin ReentrantARMFFIPlugin ReentrantFFIPlugin ReentrantPPCBEFFIPlugin
-					NewsqueakIA32ABIPlugin NewsqueakIA32ABIPluginAttic)!
\ No newline at end of file
+					NewsqueakIA32ABIPlugin NewsqueakIA32ABIPluginAttic)!
+
+----STARTUP----{31 December 2010 . 6:42:49 pm} as /Users/eliot/Cog/oscog/Cog.squeakvm.org/image/VMMaker-Squeak4.1.image!
+
+
+'From Squeak4.1 of 17 April 2010 [latest update: #9957] on 31 December 2010 at 12:58:22 pm'!
+!CoInterpreter methodsFor: 'trampolines' stamp: 'eem 12/31/2010 11:46' prior: 34481786!
+activateInterpreterMethodFromMachineCode
+	"Execute an interpreted method from machine code.  We assume (require) that newMethod
+	 messageSelector, primitiveFunctionPointer and argumentCount have been set in the caller.
+	 Once evaluated either continue in the interpreter via a jongjmp or in machine code via an
+	 enilopmart (a form of longjmp - a stinking rose by any other name)."
+	<inline: false>
+	cogit assertCStackWellAligned.
+	self assert: (self validInstructionPointer: self stackTop inFrame: framePointer).
+	instructionPointer := self popStack.
+	primitiveFunctionPointer ~= 0
+		ifTrue:
+			[primitiveFunctionPointer = #primitiveInvokeObjectAsMethod asSymbol
+				ifTrue: [self assert: (self isOopCompiledMethod: newMethod) not]
+				ifFalse: [self assert: ((self isOopCompiledMethod: newMethod)
+									  and: [(self primitiveIndexOf: newMethod) ~= 0])].
+			 "Invoke an interpreter primitive (because the method is to be interpreted or has not yet been
+			  compiled).  This is very similar to invoking an interpreter primitive from a compiled primitive
+			  (see e.g. SimpleStackBasedCogit>>compileInterpreterPrimitive:).  Cut back the stack pointer
+			  (done above) to skip the return address and invoke the function.  On return if it has succeeded
+			  simply continue otherwise restore the stackPointer, collect the pc and interpret.  Note that
+			  frame building primitives such as primitiveClosureValue, primitiveEvaluateMethod et al will not
+			  return but will instead jump into either machine code or longjmp back to the interpreter."
+			"Assign stackPage headFP so we can tell if the primitive built a frame.  We can't simply save
+			 the framePointer since e.g. assignment to contexts (via primitiveInstVarAt:put:) can change the
+			 framePointer.  But context assignments will change both the framePointer and stackPage headFP."
+			 stackPage headFP: framePointer.
+			 self isPrimitiveFunctionPointerAnIndex
+				ifTrue:
+					[self externalQuickPrimitiveResponse.
+					 primFailCode := 0]
+				ifFalse:
+					[self slowPrimitiveResponse].
+			self successful ifTrue:
+				[self return: self popStack toExecutive: false
+				 "NOTREACHED"]]
+		ifFalse:
+			[self assert: ((self primitiveIndexOf: newMethod) = 0
+						or: [(self functionPointerFor: (self primitiveIndexOf: newMethod) inClass: objectMemory nilObject) = 0])].
+	"if not primitive, or primitive failed, activate the method and reenter the interpreter"
+	self activateNewMethod.
+	self siglong: reenterInterpreter jmp: ReturnToInterpreter.
+	"NOTREACHED"
+	^nil! !
+!CoInterpreter methodsFor: 'enilopmarts' stamp: 'eem 12/30/2010 19:42' prior: 34626310!
+enterRegisterArgCogMethod: cogMethod at: entryOffset receiver: rcvr
+	"convert
+	 		rcvr	base
+			arg(s)
+			retpc	<- sp
+	 to
+			retpc	base
+			entrypc
+			rcvr
+			arg(s)	<- sp
+	 and then enter at either the checked or the unchecked entry-point."
+	<var: #cogMethod type: #'CogMethod *'>
+	self cppIf: cogit numRegArgs > 0
+		ifTrue:
+			[self assert: (cogit numRegArgs > 0 and: [cogit numRegArgs <= 2]).
+			 cogMethod cmNumArgs = 2 ifTrue:
+				[self stackValue: 3 put: self stackTop. "retpc"
+				 self push: (self stackValue: 1). "last arg"
+				 self stackValue: 1 put: (self stackValue: 3). "first arg"
+				 self stackValue: 2 put: rcvr.
+				 self stackValue: 3 put: cogMethod asInteger + entryOffset.
+				 cogit ceEnterCogCodePopReceiverArg1Arg0Regs
+				"NOTREACHED"].
+			 cogMethod cmNumArgs = 1 ifTrue:
+				[self stackValue: 2 put: self stackTop. "retpc"
+				 self push: (self stackValue: 1). "arg"
+				 self stackValue: 1 put: rcvr.
+				 self stackValue: 2 put: cogMethod asInteger + entryOffset.
+				 cogit ceEnterCogCodePopReceiverArg0Regs
+				"NOTREACHED"].
+			 self assert: cogMethod cmNumArgs = 0.
+			 self stackValue: 1 put: self stackTop. "retpc"
+			 self stackValue: 0 put: cogMethod asInteger + entryOffset.
+			 self push: rcvr.
+			 cogit ceEnterCogCodePopReceiverReg
+			 "NOTREACHED"]
+		ifFalse:
+			[self assert: false]! !
+!Cogit methodsFor: 'method map' stamp: 'eem 12/31/2010 12:50' prior: 35234297!
+mapFor: cogMethod bcpc: startbcpc performUntil: functionSymbol arg: arg
+	"Machine-code <-> bytecode pc mapping support.  Evaluate functionSymbol
+	 for each mcpc, bcpc pair in the map until the function returns non-zero,
+	 answering that result, or 0 if it fails to."
+	<api>
+	<var: #cogMethod type: #'CogBlockMethod *'>
+	<var: #functionSymbol declareC: 'sqInt (*functionSymbol)(char annotation, char *mcpc, sqInt bcpc, void *arg)'>
+	<var: #arg type: #'void *'>
+	| isInBlock mcpc bcpc endbcpc map mapByte firstTime homeMethod aMethodObj |
+	<var: #descriptor type: #'BytecodeDescriptor *'>
+	<var: #homeMethod type: #'CogMethod *'>
+	cogMethod cmType = CMMethod
+		ifTrue:
+			[isInBlock := false.
+			 mcpc := cogMethod asInteger + cmNoCheckEntryOffset.
+			 homeMethod := self cCoerceSimple: cogMethod to: #'CogMethod *'.
+			 self assert: startbcpc = (coInterpreter startPCOfMethodHeader: homeMethod methodHeader).
+			 map := self findMapLocationForMcpc: mcpc inMethod: homeMethod.
+			 self flag: 'I see crashes here or below but don''t see quite how the VM asks for and gets answered 0 here.'.
+			 self assert: map ~= 0.
+			 map = 0 ifTrue: [^0].
+			 self assert: ((coInterpreter byteAt: map) >> AnnotationShift = IsMethodReference
+						 or: [(coInterpreter byteAt: map) >> AnnotationShift = IsRelativeCall
+						 or: [(coInterpreter byteAt: map) >> AnnotationShift = IsDisplacementX2N]])]
+		ifFalse:
+			[isInBlock := true.
+			 mcpc := cogMethod asInteger + (self sizeof: CogBlockMethod).
+			 homeMethod := self cogHomeMethod: cogMethod.
+			 map := self findMapLocationForMcpc: mcpc inMethod: homeMethod.
+			 self flag: 'I see crashes here or above but don''t see quite how the VM asks for and gets answered 0 here.'.
+			 self assert: map ~= 0.
+			 map = 0 ifTrue: [^0].
+			 self assert: ((coInterpreter byteAt: map) >> AnnotationShift = HasBytecodePC "fiducial"
+						 or: [(coInterpreter byteAt: map) >> AnnotationShift = IsDisplacementX2N]).
+			 [(coInterpreter byteAt: map) >> AnnotationShift ~= HasBytecodePC] whileTrue:
+				[map := map - 1].
+			 map := map - 1]. "skip fiducial"
+	bcpc := startbcpc.
+	aMethodObj := homeMethod methodObject.
+	endbcpc := (objectMemory byteSizeOf: aMethodObj) - 1.
+	self assert: (bcpc >= (coInterpreter startPCOfMethod: aMethodObj)
+				and: [bcpc <= endbcpc]).
+	firstTime := true.
+	[(mapByte := objectMemory byteAt: map) ~= MapEnd] whileTrue:
+		[| annotation bcpcArg result descriptor numBytes |
+		 mapByte >= FirstAnnotation
+			ifTrue:
+				[annotation := mapByte >> AnnotationShift.
+				mcpc := mcpc + (mapByte bitAnd: DisplacementMask).
+				(annotation = HasBytecodePC or: [annotation = IsSendCall])
+					ifTrue:
+						[| byte |
+						bcpcArg := bcpc.
+						byte := objectMemory fetchByte: bcpc ofObject: aMethodObj.
+						descriptor := self generatorAt: byte.
+						numBytes := descriptor numBytes.
+						 (bcpc = startbcpc
+						  and: [descriptor isMapped
+						  and: [firstTime]])
+							ifTrue:
+								["horrible special case for frame-building accessors in contexts, e.g.
+								  MethodContext>>method.  In this case the first bytecode is mapped
+								  and so counts twice, once for the stackCheckOffset and once for itself."
+								 firstTime := false]
+							ifFalse:
+								[bcpc := self nextBytecodePCFor: descriptor at: bcpc byte0: byte in: aMethodObj.
+								 bcpc := self nextBytecodePCInMapAfter: bcpc
+											in: aMethodObj
+											inBlock: isInBlock
+											upTo: endbcpc].
+						 self assert: bcpcArg ~= 0]
+					ifFalse: [bcpcArg := numBytes := 0].
+				 result := self perform: functionSymbol
+								with: annotation
+								with: (self cCoerceSimple: mcpc to: #'char *')
+								with: bcpcArg + numBytes
+								with: arg.
+				 result ~= 0 ifTrue:
+					[^result]]
+			ifFalse:
+				[mcpc := mcpc + (mapByte >= DisplacementX2N
+									ifTrue: [mapByte - DisplacementX2N << AnnotationShift]
+									ifFalse: [mapByte])].
+		 map := map - 1].
+	^0! !
+!Cogit methodsFor: 'disassembly' stamp: 'eem 12/30/2010 20:00' prior: 35411760!
+printMethodHeader: cogMethod on: aStream
+	<doNotGenerate>
+	self cCode: ''
+		inSmalltalk:
+			[cogMethod isInteger ifTrue:
+				[^self printMethodHeader: (coInterpreter cogMethodSurrogateAt: cogMethod) on: aStream]].
+	aStream ensureCr.
+	cogMethod asInteger printOn: aStream base: 16.
+	aStream crtab; nextPutAll: (cogMethod cmType ~= CMBlock ifTrue: ['objhdr: '] ifFalse: ['homemth: ']).
+	cogMethod objectHeader printOn: aStream base: 16.
+	aStream
+		crtab; nextPutAll: 'nArgs: ';	print: cogMethod cmNumArgs;
+		tab;    nextPutAll: 'type: ';	print: cogMethod cmType.
+	cogMethod cmType ~= CMBlock ifTrue:
+		[aStream crtab; nextPutAll: 'blksiz: '.
+		cogMethod blockSize printOn: aStream base: 16.
+		aStream crtab; nextPutAll: 'method: '.
+		cogMethod methodObject printOn: aStream base: 16.
+		aStream crtab; nextPutAll: 'mthhdr: '.
+		cogMethod methodHeader printOn: aStream base: 16.
+		aStream crtab; nextPutAll: 'selctr: '.
+		cogMethod selector printOn: aStream base: 16.
+		(coInterpreter lookupAddress: cogMethod selector) ifNotNil:
+			[:string| aStream nextPut: $=; nextPutAll: string].
+		aStream crtab; nextPutAll: 'blkentry: '.
+		cogMethod blockEntryOffset printOn: aStream base: 16.
+		cogMethod blockEntryOffset ~= 0 ifTrue:
+			[aStream nextPutAll: ' => '.
+			 cogMethod asInteger + cogMethod blockEntryOffset printOn: aStream base: 16]].
+	cogMethod cmType = CMClosedPIC
+		ifTrue:
+			[aStream crtab; nextPutAll: 'cPICNumCases: '.
+			 cogMethod cPICNumCases printOn: aStream base: 16.]
+		ifFalse:
+			[aStream crtab; nextPutAll: 'stackCheckOffset: '.
+			 cogMethod stackCheckOffset printOn: aStream base: 16.
+			 cogMethod stackCheckOffset > 0 ifTrue:
+				[aStream nextPut: $/.
+				 cogMethod asInteger + cogMethod stackCheckOffset printOn: aStream base: 16]].
+	aStream cr; flush! !
+!CurrentImageCoInterpreterFacade methodsFor: 'labels' stamp: 'eem 12/31/2010 12:11' prior: 35523752!
+lookupAddress: address
+	^(objectMap
+		keyAtValue: address
+		ifAbsent:
+			[variables
+				keyAtValue: address
+				ifAbsent: [^nil]]) asString! !
+!SimpleStackBasedCogit methodsFor: 'simulation stack' stamp: 'eem 12/30/2010 19:57'!
+registerMaskFor: reg
+	"Dummy implementation for CogFooCompiler>callerSavedRegisterMask
+	 which doesn't get pruned due to Slang limitations."
+	^0! !
+!SimpleStackBasedCogit methodsFor: 'simulation stack' stamp: 'eem 12/30/2010 19:57'!
+registerMaskFor: reg and: reg2
+	"Dummy implementation for CogFooCompiler>callerSavedRegisterMask
+	 which doesn't get pruned due to Slang limitations."
+	^0! !
+!SimpleStackBasedCogit methodsFor: 'simulation stack' stamp: 'eem 12/30/2010 19:57'!
+registerMaskFor: reg1 and: reg2 and: reg3
+	"Dummy implementation for CogFooCompiler>callerSavedRegisterMask
+	 which doesn't get pruned due to Slang limitations."
+	^0! !
+
+SimpleStackBasedCogit subclass: #StackToRegisterMappingCogit
+	instanceVariableNames: 'callerSavedRegMask methodOrBlockNumTemps regArgsHaveBeenPushed simSelf simStack simStackPtr simSpillBase optStatus ceEnterCogCodePopReceiverArg0Regs ceEnterCogCodePopReceiverArg1Arg0Regs methodAbortTrampolines picAbortTrampolines picMissTrampolines ceEnter0ArgsPIC ceEnter1ArgsPIC ceEnter2ArgsPIC debugStackPointers debugFixupBreaks debugBytecodePointers realCEEnterCogCodePopReceiverArg0Regs realCEEnterCogCodePopReceiverArg1Arg0Regs deadCode'
+	classVariableNames: ''
+	poolDictionaries: 'CogCompilationConstants VMMethodCacheConstants VMObjectIndices VMStackFrameOffsets'
+	category: 'VMMaker-JIT'!
+!StackToRegisterMappingCogit commentStamp: 'eem 12/19/2010 18:12' prior: 38899170!
+StackToRegisterMappingCogit is an optimizing code generator that eliminates a lot of stack operations and inlines some special selector arithmetic.  It does so by a simple stack-to-register mapping scheme based on deferring the generation of code to produce operands until operand-consuming operations.  The operations that consume operands are sends, stores and returns.
+
+See methods in the class-side documentation protocol for more detail.
+
+Instance Variables
+	callerSavedRegMask:							<Integer>
+	ceEnter0ArgsPIC:								<Integer>
+	ceEnter1ArgsPIC:								<Integer>
+	ceEnter2ArgsPIC:								<Integer>
+	ceEnterCogCodePopReceiverArg0Regs:		<Integer>
+	ceEnterCogCodePopReceiverArg1Arg0Regs:	<Integer>
+	debugBytecodePointers:						<Set of Integer>
+	debugFixupBreaks:								<Set of Integer>
+	debugStackPointers:							<CArrayAccessor of (Integer|nil)>
+	methodAbortTrampolines:						<CArrayAccessor of Integer>
+	methodOrBlockNumTemps:						<Integer>
+	optStatus:										<Integer>
+	picAbortTrampolines:							<CArrayAccessor of Integer>
+	picMissTrampolines:							<CArrayAccessor of Integer>
+	realCEEnterCogCodePopReceiverArg0Regs:		<Integer>
+	realCEEnterCogCodePopReceiverArg1Arg0Regs:	<Integer>
+	regArgsHaveBeenPushed:						<Boolean>
+	simSelf:											<CogSimStackEntry>
+	simSpillBase:									<Integer>
+	simStack:										<CArrayAccessor of CogSimStackEntry>
+	simStackPtr:									<Integer>
+	traceSimStack:									<Integer>
+
+callerSavedRegMask
+	- the bitmask of the ABI's caller-saved registers
+
+ceEnter0ArgsPIC ceEnter1ArgsPIC ceEnter2ArgsPIC
+	- the trampoline for entering an N-arg PIC
+
+ceEnterCogCodePopReceiverArg0Regs ceEnterCogCodePopReceiverArg1Arg0Regs
+	- teh trampoline for entering a method with N register args
+	
+debugBytecodePointers
+	- a Set of bytecode pcs for setting breakpoints (simulation only)
+
+debugFixupBreaks
+	- a Set of fixup indices for setting breakpoints (simulation only)
+
+debugStackPointers
+	- an Array of stack depths for each bytecode for code verification
+
+methodAbortTrampolines
+	- a CArrayAccessor of abort trampolines for 0, 1, 2 and N args
+
+methodOrBlockNumTemps
+	- the number of method or block temps (including args) in the current compilation unit (method or block)
+
+optStatus
+	- the variable used to track the status of ReceiverResultReg for avoiding reloading that register with self between adjacent inst var accesses
+
+picAbortTrampolines
+	- a CArrayAccessor of abort trampolines for 0, 1, 2 and N args
+
+picMissTrampolines
+	- a CArrayAccessor of abort trampolines for 0, 1, 2 and N args
+
+realCEEnterCogCodePopReceiverArg0Regs realCEEnterCogCodePopReceiverArg1Arg0Regs
+	- the real trampolines for ebtering machine code with N reg args when in the Debug regime
+
+regArgsHaveBeenPushed
+	- whether the register args have been pushed before frame build (e.g. when an interpreter primitive is called)
+
+simSelf
+	- the simulation stack entry representing self in the current compilation unit
+
+simSpillBase
+	- the variable tracking how much of the simulation stack has been spilled to the real stack
+
+simStack
+	- the simulation stack itself
+
+simStackPtr
+	- the pointer to the top of the simulation stack
+!
+]style[(819 14 2308),cblack;,!
+!StackToRegisterMappingCogit methodsFor: 'compile abstract instructions' stamp: 'eem 12/30/2010 16:15' prior: 38815078!
+compileAbstractInstructionsFrom: start through: end
+	"Loop over bytecodes, dispatching to the generator for each bytecode, handling fixups in due course."
+	| nextOpcodeIndex descriptor fixup result |
+	<var: #descriptor type: #'BytecodeDescriptor *'>
+	<var: #fixup type: #'BytecodeFixup *'>
+	self traceSimStack.
+	bytecodePointer := start.
+	descriptor := nil.
+	deadCode := false.
+	[self cCode: '' inSmalltalk:
+		[(debugBytecodePointers includes: bytecodePointer) ifTrue: [self halt]].
+	fixup := self fixupAt: bytecodePointer - initialPC.
+	fixup targetInstruction asUnsignedInteger > 0
+		ifTrue:
+			[deadCode := false.
+	 		 fixup targetInstruction asUnsignedInteger >= 2 ifTrue:
+				[self merge: fixup afterReturn: (descriptor notNil and: [descriptor isReturn])]]
+		ifFalse: "If there's no fixup following a return there's no jump to that code and it is dead."
+			[(descriptor notNil and: [descriptor isReturn]) ifTrue:
+				[deadCode := true]].
+	 self cCode: '' inSmalltalk:
+		[deadCode ifFalse:
+			[self assert: simStackPtr + (needsFrame
+										ifTrue: [0]
+										ifFalse: [methodOrBlockNumArgs + 1])
+						= (self debugStackPointerFor: bytecodePointer)]].
+	 byte0 := objectMemory fetchByte: bytecodePointer ofObject: methodObj.
+	 descriptor := self generatorAt: byte0.
+	 descriptor numBytes > 1 ifTrue:
+		[byte1 := objectMemory fetchByte: bytecodePointer + 1 ofObject: methodObj.
+		 descriptor numBytes > 2 ifTrue:
+			[byte2 := objectMemory fetchByte: bytecodePointer + 2 ofObject: methodObj.
+			 descriptor numBytes > 3 ifTrue:
+				[byte3 := objectMemory fetchByte: bytecodePointer + 3 ofObject: methodObj.
+				 descriptor numBytes > 4 ifTrue:
+					[self notYetImplemented]]]].
+	 nextOpcodeIndex := opcodeIndex.
+	 result := deadCode
+				ifTrue: "insert nops for dead code that is mapped so that bc to mc mapping is not many to one"
+					[(descriptor isMapped
+					  or: [inBlock and: [descriptor isMappedInBlock]]) ifTrue:
+						[self annotateBytecode: self Nop].
+						0]
+				ifFalse:
+					[self perform: descriptor generator].
+	 self traceDescriptor: descriptor; traceSimStack.
+	 (fixup targetInstruction asUnsignedInteger between: 1 and: 2) ifTrue:
+		["There is a fixup for this bytecode.  It must point to the first generated
+		   instruction for this bytecode.  If there isn't one we need to add a label."
+		 opcodeIndex = nextOpcodeIndex ifTrue:
+			[self Label].
+		 fixup targetInstruction: (self abstractInstructionAt: nextOpcodeIndex)].
+	 bytecodePointer := self nextBytecodePCFor: descriptor at: bytecodePointer byte0: byte0 in: methodObj.
+	 result = 0 and: [bytecodePointer <= end]] whileTrue.
+	^result! !
+!StackToRegisterMappingCogit methodsFor: 'bytecode generators' stamp: 'eem 12/30/2010 16:22' prior: 38854414!
+genSpecialSelectorEqualsEquals
+	| argReg rcvrReg nextPC postBranchPC targetBytecodePC branchBytecode primDescriptor branchDescriptor jumpEqual jumpNotEqual resultReg |
+	<var: #primDescriptor type: #'BytecodeDescriptor *'>
+	<var: #branchDescriptor type: #'BytecodeDescriptor *'>
+	<var: #jumpEqual type: #'AbstractInstruction *'>
+	<var: #jumpNotEqual type: #'AbstractInstruction *'>
+	self ssPop: 2.
+	resultReg := self availableRegisterOrNil.
+	resultReg ifNil:
+		[self ssAllocateRequiredReg: (resultReg := Arg1Reg)].
+	self ssPush: 2.
+	(self ssTop type = SSConstant
+	 and: [self ssTop spilled not]) "if spilled we must generate a real pop"
+		ifTrue:
+			[(self ssValue: 1) type = SSRegister
+				ifTrue: [rcvrReg := (self ssValue: 1) register]
+				ifFalse:
+					[(self ssValue: 1) popToReg: (rcvrReg := resultReg)].
+			(objectRepresentation shouldAnnotateObjectReference: self ssTop constant)
+				ifTrue: [self annotate: (self CmpCw: self ssTop constant R: rcvrReg)
+							objRef: self ssTop constant]
+				ifFalse: [self CmpCq: self ssTop constant R: rcvrReg].
+			self ssPop: 1]
+		ifFalse:
+			[argReg := self ssStorePop: true toPreferredReg: TempReg.
+			 rcvrReg := argReg = resultReg
+							ifTrue: [TempReg]
+							ifFalse: [resultReg].
+			self ssTop popToReg: rcvrReg.
+			self CmpR: argReg R: rcvrReg].
+	self ssPop: 1; ssPushRegister: resultReg.
+	primDescriptor := self generatorAt: byte0.
+	nextPC := bytecodePointer + primDescriptor numBytes.
+	branchBytecode := objectMemory fetchByte: nextPC ofObject: methodObj.
+	branchDescriptor := self generatorAt: branchBytecode.
+	(branchDescriptor isBranchTrue
+	 or: [branchDescriptor isBranchFalse])
+		ifTrue:
+			[self ssFlushTo: simStackPtr - 1.
+			 targetBytecodePC := nextPC
+								+ branchDescriptor numBytes
+								+ (self spanFor: branchDescriptor at: nextPC byte0: branchBytecode in: methodObj).
+			 postBranchPC := nextPC + branchDescriptor numBytes.
+			 (self fixupAt: nextPC - initialPC) targetInstruction = 0 ifTrue: "The next instruction is dead.  we can skip it."
+				[deadCode := true.
+				 self ssPop: 1. "the conditional branch bytecodes pop the item tested from the stack."
+				 self ensureFixupAt: targetBytecodePC - initialPC.
+				 self ensureFixupAt: postBranchPC - initialPC].
+			 self gen: (branchDescriptor isBranchTrue
+						ifTrue: [JumpZero]
+						ifFalse: [JumpNonZero])
+				operand: (self ensureNonMergeFixupAt: targetBytecodePC - initialPC) asUnsignedInteger.
+			 self Jump: (self ensureNonMergeFixupAt: postBranchPC - initialPC)]
+		ifFalse:
+			[jumpNotEqual := self JumpNonZero: 0.
+			 self annotate: (self MoveCw: objectMemory trueObject R: resultReg)
+				objRef: objectMemory trueObject.
+			 jumpEqual := self Jump: 0.
+			 jumpNotEqual jmpTarget: (self annotate: (self MoveCw: objectMemory falseObject R: resultReg)
+											objRef: objectMemory falseObject).
+			 jumpEqual jmpTarget: self Label].
+	resultReg == ReceiverResultReg ifTrue:
+		[optStatus isReceiverResultRegLive: false].
+	^0! !
+
+----End fileIn of /Users/eliot/Cog/methods.st----!
+
+----STARTUP----{31 December 2010 . 7:05:55 pm} as /Users/eliot/Cog/oscog/Cog.squeakvm.org/image/VMMaker-Squeak4.1.image!
+
+
+'From Squeak4.1 of 17 April 2010 [latest update: #9957] on 31 December 2010 at 7:05:24 pm'!
+!CoInterpreter methodsFor: 'trampolines' stamp: 'eem 12/31/2010 19:03' prior: 34481786!
+activateInterpreterMethodFromMachineCode
+	"Execute an interpreted method from machine code.  We assume (require) that newMethod
+	 messageSelector, primitiveFunctionPointer and argumentCount have been set in the caller.
+	 Once evaluated either continue in the interpreter via a jongjmp or in machine code via an
+	 enilopmart (a form of longjmp - a stinking rose by any other name)."
+	<inline: false>
+	cogit assertCStackWellAligned.
+	self assert: (self validInstructionPointer: self stackTop inFrame: framePointer).
+	instructionPointer := self popStack.
+	primitiveFunctionPointer ~= 0
+		ifTrue:
+			[primitiveFunctionPointer = #primitiveInvokeObjectAsMethod asSymbol
+				ifTrue: [self assert: (objectMemory isOopCompiledMethod: newMethod) not]
+				ifFalse: [self assert: ((objectMemory isOopCompiledMethod: newMethod)
+									  and: [(self primitiveIndexOf: newMethod) ~= 0])].
+			 "Invoke an interpreter primitive (because the method is to be interpreted or has not yet been
+			  compiled).  This is very similar to invoking an interpreter primitive from a compiled primitive
+			  (see e.g. SimpleStackBasedCogit>>compileInterpreterPrimitive:).  Cut back the stack pointer
+			  (done above) to skip the return address and invoke the function.  On return if it has succeeded
+			  simply continue otherwise restore the stackPointer, collect the pc and interpret.  Note that
+			  frame building primitives such as primitiveClosureValue, primitiveEvaluateMethod et al will not
+			  return but will instead jump into either machine code or longjmp back to the interpreter."
+			"Assign stackPage headFP so we can tell if the primitive built a frame.  We can't simply save
+			 the framePointer since e.g. assignment to contexts (via primitiveInstVarAt:put:) can change the
+			 framePointer.  But context assignments will change both the framePointer and stackPage headFP."
+			 stackPage headFP: framePointer.
+			 self isPrimitiveFunctionPointerAnIndex
+				ifTrue:
+					[self externalQuickPrimitiveResponse.
+					 primFailCode := 0]
+				ifFalse:
+					[self slowPrimitiveResponse].
+			self successful ifTrue:
+				[self return: self popStack toExecutive: false
+				 "NOTREACHED"]]
+		ifFalse:
+			[self assert: ((self primitiveIndexOf: newMethod) = 0
+						or: [(self functionPointerFor: (self primitiveIndexOf: newMethod) inClass: objectMemory nilObject) = 0])].
+	"if not primitive, or primitive failed, activate the method and reenter the interpreter"
+	self activateNewMethod.
+	self siglong: reenterInterpreter jmp: ReturnToInterpreter.
+	"NOTREACHED"
+	^nil! !
+!CoInterpreter methodsFor: 'enilopmarts' stamp: 'eem 12/30/2010 19:42' prior: 34626310!
+enterRegisterArgCogMethod: cogMethod at: entryOffset receiver: rcvr
+	"convert
+	 		rcvr	base
+			arg(s)
+			retpc	<- sp
+	 to
+			retpc	base
+			entrypc
+			rcvr
+			arg(s)	<- sp
+	 and then enter at either the checked or the unchecked entry-point."
+	<var: #cogMethod type: #'CogMethod *'>
+	self cppIf: cogit numRegArgs > 0
+		ifTrue:
+			[self assert: (cogit numRegArgs > 0 and: [cogit numRegArgs <= 2]).
+			 cogMethod cmNumArgs = 2 ifTrue:
+				[self stackValue: 3 put: self stackTop. "retpc"
+				 self push: (self stackValue: 1). "last arg"
+				 self stackValue: 1 put: (self stackValue: 3). "first arg"
+				 self stackValue: 2 put: rcvr.
+				 self stackValue: 3 put: cogMethod asInteger + entryOffset.
+				 cogit ceEnterCogCodePopReceiverArg1Arg0Regs
+				"NOTREACHED"].
+			 cogMethod cmNumArgs = 1 ifTrue:
+				[self stackValue: 2 put: self stackTop. "retpc"
+				 self push: (self stackValue: 1). "arg"
+				 self stackValue: 1 put: rcvr.
+				 self stackValue: 2 put: cogMethod asInteger + entryOffset.
+				 cogit ceEnterCogCodePopReceiverArg0Regs
+				"NOTREACHED"].
+			 self assert: cogMethod cmNumArgs = 0.
+			 self stackValue: 1 put: self stackTop. "retpc"
+			 self stackValue: 0 put: cogMethod asInteger + entryOffset.
+			 self push: rcvr.
+			 cogit ceEnterCogCodePopReceiverReg
+			 "NOTREACHED"]
+		ifFalse:
+			[self assert: false]! !
+!Cogit methodsFor: 'method map' stamp: 'eem 12/31/2010 14:54' prior: 35226074!
+bytecodePCFor: mcpc startBcpc: startbcpc in: cogMethod
+	"Answer the zero-relative bytecode pc matching the machine code pc argument in
+	 cogMethod, given the start of the bytecodes for cogMethod's block or method object."
+	<api>
+	<var: #cogMethod type: #'CogBlockMethod *'>
+	"All map entries for bytecodes (sends, mustBeBooleans et al) map to the following
+	 bytecode except the first bytecode (stackCheckOffset).  So special case that here."
+	mcpc = (cogMethod stackCheckOffset = 0
+				ifTrue: [cogMethod asInteger + (self sizeof: CogBlockMethod)]
+				ifFalse: [cogMethod asInteger + cogMethod stackCheckOffset]) ifTrue:
+		[^startbcpc].
+	^self
+		mapFor: cogMethod
+		bcpc: startbcpc
+		performUntil: #find:Mcpc:Bcpc:MatchingMcpc: asSymbol
+		arg: (self cCoerceSimple: mcpc to: #'void *')! !
+!Cogit methodsFor: 'method map' stamp: 'eem 12/31/2010 14:10' prior: 35229086!
+findBlockMethodWithStartMcpc: blockEntryPC bcpc: startBcpc
+	<returnTypeC: #usqInt>
+	| cogBlockMethod startMcpc |
+	<var: #cogBlockMethod type: #'CogBlockMethod *'>
+	cogBlockMethod := self cCoerceSimple: blockEntryPC - (self sizeof: CogBlockMethod)
+								   to: #'CogBlockMethod *'.
+	startMcpc := cogBlockMethod stackCheckOffset = 0
+					ifTrue: [cogBlockMethod] "frameless block method"
+					ifFalse: [cogBlockMethod asUnsignedInteger + cogBlockMethod stackCheckOffset].
+	(self bytecodePCFor: startMcpc startBcpc: startBcpc in: cogBlockMethod) = startBcpc ifTrue:
+		[^cogBlockMethod asUnsignedInteger].
+	^0 "keep scanning..."! !
+!Cogit methodsFor: 'method map' stamp: 'eem 12/31/2010 14:09' prior: 35231138!
+findMethodForStartBcpc: startbcpc inHomeMethod: cogMethod
+	<api>
+	<var: #cogMethod type: #'CogMethod *'>
+	<returnTypeC: #'CogBlockMethod *'>
+	"Find the CMMethod or CMBlock that has zero-relative startbcpc as its first bytecode pc.
+	 As this is for cannot resume processing and/or conversion to machine-code on backward
+	 branch, it doesn't have to be fast.  Enumerate block returns and map to bytecode pcs."
+	self assert: cogMethod cmType = CMMethod.
+	startbcpc = (coInterpreter startPCOfMethodHeader: cogMethod methodHeader) ifTrue:
+		[^self cCoerceSimple: cogMethod to: #'CogBlockMethod *'].
+	self assert: cogMethod blockEntryOffset ~= 0.
+	^self cCoerceSimple: (self blockDispatchTargetsFor: cogMethod
+								perform: #findBlockMethodWithStartMcpc:bcpc: asSymbol
+								arg: startbcpc)
+		to: #'CogBlockMethod *'! !
+!Cogit methodsFor: 'method map' stamp: 'eem 12/31/2010 14:25' prior: 35234297!
+mapFor: cogMethod bcpc: startbcpc performUntil: functionSymbol arg: arg
+	"Machine-code <-> bytecode pc mapping support.  Evaluate functionSymbol
+	 for each mcpc, bcpc pair in the map until the function returns non-zero,
+	 answering that result, or 0 if it fails to."
+	<api>
+	<var: #cogMethod type: #'CogBlockMethod *'>
+	<var: #functionSymbol declareC: 'sqInt (*functionSymbol)(char annotation, char *mcpc, sqInt bcpc, void *arg)'>
+	<var: #arg type: #'void *'>
+	| isInBlock mcpc bcpc endbcpc map mapByte firstTime homeMethod aMethodObj |
+	<var: #descriptor type: #'BytecodeDescriptor *'>
+	<var: #homeMethod type: #'CogMethod *'>
+	cogMethod cmType = CMMethod
+		ifTrue:
+			[isInBlock := false.
+			 mcpc := cogMethod asInteger + cmNoCheckEntryOffset.
+			 homeMethod := self cCoerceSimple: cogMethod to: #'CogMethod *'.
+			 self assert: startbcpc = (coInterpreter startPCOfMethodHeader: homeMethod methodHeader).
+			 map := self findMapLocationForMcpc: mcpc inMethod: homeMethod.
+			 self assert: map ~= 0.
+			 map = 0 ifTrue: [^0].
+			 self assert: ((coInterpreter byteAt: map) >> AnnotationShift = IsMethodReference
+						 or: [(coInterpreter byteAt: map) >> AnnotationShift = IsRelativeCall
+						 or: [(coInterpreter byteAt: map) >> AnnotationShift = IsDisplacementX2N]])]
+		ifFalse:
+			[isInBlock := true.
+			 mcpc := cogMethod asInteger + (self sizeof: CogBlockMethod).
+			 homeMethod := self cogHomeMethod: cogMethod.
+			 map := self findMapLocationForMcpc: mcpc inMethod: homeMethod.
+			 self assert: map ~= 0.
+			 map = 0 ifTrue: [^0].
+			 self assert: ((coInterpreter byteAt: map) >> AnnotationShift = HasBytecodePC "fiducial"
+						 or: [(coInterpreter byteAt: map) >> AnnotationShift = IsDisplacementX2N]).
+			 [(coInterpreter byteAt: map) >> AnnotationShift ~= HasBytecodePC] whileTrue:
+				[map := map - 1].
+			 map := map - 1]. "skip fiducial"
+	bcpc := startbcpc.
+	aMethodObj := homeMethod methodObject.
+	endbcpc := (objectMemory byteSizeOf: aMethodObj) - 1.
+	self assert: (bcpc >= (coInterpreter startPCOfMethod: aMethodObj)
+				and: [bcpc <= endbcpc]).
+	firstTime := true.
+	[(mapByte := objectMemory byteAt: map) ~= MapEnd] whileTrue:
+		[| annotation bcpcArg result descriptor numBytes |
+		 mapByte >= FirstAnnotation
+			ifTrue:
+				[annotation := mapByte >> AnnotationShift.
+				mcpc := mcpc + (mapByte bitAnd: DisplacementMask).
+				(annotation = HasBytecodePC or: [annotation = IsSendCall])
+					ifTrue:
+						[| byte |
+						bcpcArg := bcpc.
+						byte := objectMemory fetchByte: bcpc ofObject: aMethodObj.
+						descriptor := self generatorAt: byte.
+						numBytes := descriptor numBytes.
+						 (bcpc = startbcpc
+						  and: [descriptor isMapped
+						  and: [firstTime]])
+							ifTrue:
+								["horrible special case for frame-building accessors in contexts, e.g.
+								  MethodContext>>method.  In this case the first bytecode is mapped
+								  and so counts twice, once for the stackCheckOffset and once for itself."
+								 firstTime := false]
+							ifFalse:
+								[bcpc := self nextBytecodePCFor: descriptor at: bcpc byte0: byte in: aMethodObj.
+								 bcpc := self nextBytecodePCInMapAfter: bcpc
+											in: aMethodObj
+											inBlock: isInBlock
+											upTo: endbcpc].
+						 self assert: bcpcArg ~= 0]
+					ifFalse: [bcpcArg := numBytes := 0].
+				 result := self perform: functionSymbol
+								with: annotation
+								with: (self cCoerceSimple: mcpc to: #'char *')
+								with: bcpcArg + numBytes
+								with: arg.
+				 result ~= 0 ifTrue:
+					[^result]]
+			ifFalse:
+				[mcpc := mcpc + (mapByte >= DisplacementX2N
+									ifTrue: [mapByte - DisplacementX2N << AnnotationShift]
+									ifFalse: [mapByte])].
+		 map := map - 1].
+	^0! !
+!Cogit methodsFor: 'disassembly' stamp: 'eem 12/30/2010 20:00' prior: 35411760!
+printMethodHeader: cogMethod on: aStream
+	<doNotGenerate>
+	self cCode: ''
+		inSmalltalk:
+			[cogMethod isInteger ifTrue:
+				[^self printMethodHeader: (coInterpreter cogMethodSurrogateAt: cogMethod) on: aStream]].
+	aStream ensureCr.
+	cogMethod asInteger printOn: aStream base: 16.
+	aStream crtab; nextPutAll: (cogMethod cmType ~= CMBlock ifTrue: ['objhdr: '] ifFalse: ['homemth: ']).
+	cogMethod objectHeader printOn: aStream base: 16.
+	aStream
+		crtab; nextPutAll: 'nArgs: ';	print: cogMethod cmNumArgs;
+		tab;    nextPutAll: 'type: ';	print: cogMethod cmType.
+	cogMethod cmType ~= CMBlock ifTrue:
+		[aStream crtab; nextPutAll: 'blksiz: '.
+		cogMethod blockSize printOn: aStream base: 16.
+		aStream crtab; nextPutAll: 'method: '.
+		cogMethod methodObject printOn: aStream base: 16.
+		aStream crtab; nextPutAll: 'mthhdr: '.
+		cogMethod methodHeader printOn: aStream base: 16.
+		aStream crtab; nextPutAll: 'selctr: '.
+		cogMethod selector printOn: aStream base: 16.
+		(coInterpreter lookupAddress: cogMethod selector) ifNotNil:
+			[:string| aStream nextPut: $=; nextPutAll: string].
+		aStream crtab; nextPutAll: 'blkentry: '.
+		cogMethod blockEntryOffset printOn: aStream base: 16.
+		cogMethod blockEntryOffset ~= 0 ifTrue:
+			[aStream nextPutAll: ' => '.
+			 cogMethod asInteger + cogMethod blockEntryOffset printOn: aStream base: 16]].
+	cogMethod cmType = CMClosedPIC
+		ifTrue:
+			[aStream crtab; nextPutAll: 'cPICNumCases: '.
+			 cogMethod cPICNumCases printOn: aStream base: 16.]
+		ifFalse:
+			[aStream crtab; nextPutAll: 'stackCheckOffset: '.
+			 cogMethod stackCheckOffset printOn: aStream base: 16.
+			 cogMethod stackCheckOffset > 0 ifTrue:
+				[aStream nextPut: $/.
+				 cogMethod asInteger + cogMethod stackCheckOffset printOn: aStream base: 16]].
+	aStream cr; flush! !
+!CurrentImageCoInterpreterFacade methodsFor: 'labels' stamp: 'eem 12/31/2010 12:11' prior: 35523752!
+lookupAddress: address
+	^(objectMap
+		keyAtValue: address
+		ifAbsent:
+			[variables
+				keyAtValue: address
+				ifAbsent: [^nil]]) asString! !
+!SimpleStackBasedCogit methodsFor: 'compile abstract instructions' stamp: 'eem 12/31/2010 14:32' prior: 37974309!
+compileBlockFramelessEntry: blockStart
+	"Make sure ReceiverResultReg holds the receiver, loaded from the closure,
+	 which is what is initially in ReceiverResultReg.  We must annotate the first
+	 instruction so that findMethodForStartBcpc:inHomeMethod: can function.
+	 We need two annotations because the first is a fiducial."
+	<var: #blockStart type: #'BlockStart *'>
+	self annotateBytecode: blockStart entryLabel.
+	self annotateBytecode: blockStart entryLabel.
+	objectRepresentation
+		genLoadSlot: ClosureOuterContextIndex
+			sourceReg: ReceiverResultReg
+				destReg: TempReg;
+		genLoadSlot: ReceiverIndex
+			sourceReg: TempReg
+				destReg: ReceiverResultReg! !
+!SimpleStackBasedCogit methodsFor: 'simulation stack' stamp: 'eem 12/30/2010 19:57'!
+registerMaskFor: reg
+	"Dummy implementation for CogFooCompiler>callerSavedRegisterMask
+	 which doesn't get pruned due to Slang limitations."
+	^0! !
+!SimpleStackBasedCogit methodsFor: 'simulation stack' stamp: 'eem 12/30/2010 19:57'!
+registerMaskFor: reg and: reg2
+	"Dummy implementation for CogFooCompiler>callerSavedRegisterMask
+	 which doesn't get pruned due to Slang limitations."
+	^0! !
+!SimpleStackBasedCogit methodsFor: 'simulation stack' stamp: 'eem 12/30/2010 19:57'!
+registerMaskFor: reg1 and: reg2 and: reg3
+	"Dummy implementation for CogFooCompiler>callerSavedRegisterMask
+	 which doesn't get pruned due to Slang limitations."
+	^0! !
+
+SimpleStackBasedCogit subclass: #StackToRegisterMappingCogit
+	instanceVariableNames: 'callerSavedRegMask methodOrBlockNumTemps regArgsHaveBeenPushed simSelf simStack simStackPtr simSpillBase optStatus ceEnterCogCodePopReceiverArg0Regs ceEnterCogCodePopReceiverArg1Arg0Regs methodAbortTrampolines picAbortTrampolines picMissTrampolines ceEnter0ArgsPIC ceEnter1ArgsPIC ceEnter2ArgsPIC debugStackPointers debugFixupBreaks debugBytecodePointers realCEEnterCogCodePopReceiverArg0Regs realCEEnterCogCodePopReceiverArg1Arg0Regs deadCode'
+	classVariableNames: ''
+	poolDictionaries: 'CogCompilationConstants VMMethodCacheConstants VMObjectIndices VMStackFrameOffsets'
+	category: 'VMMaker-JIT'!
+!StackToRegisterMappingCogit commentStamp: 'eem 12/19/2010 18:12' prior: 38899170!
+StackToRegisterMappingCogit is an optimizing code generator that eliminates a lot of stack operations and inlines some special selector arithmetic.  It does so by a simple stack-to-register mapping scheme based on deferring the generation of code to produce operands until operand-consuming operations.  The operations that consume operands are sends, stores and returns.
+
+See methods in the class-side documentation protocol for more detail.
+
+Instance Variables
+	callerSavedRegMask:							<Integer>
+	ceEnter0ArgsPIC:								<Integer>
+	ceEnter1ArgsPIC:								<Integer>
+	ceEnter2ArgsPIC:								<Integer>
+	ceEnterCogCodePopReceiverArg0Regs:		<Integer>
+	ceEnterCogCodePopReceiverArg1Arg0Regs:	<Integer>
+	debugBytecodePointers:						<Set of Integer>
+	debugFixupBreaks:								<Set of Integer>
+	debugStackPointers:							<CArrayAccessor of (Integer|nil)>
+	methodAbortTrampolines:						<CArrayAccessor of Integer>
+	methodOrBlockNumTemps:						<Integer>
+	optStatus:										<Integer>
+	picAbortTrampolines:							<CArrayAccessor of Integer>
+	picMissTrampolines:							<CArrayAccessor of Integer>
+	realCEEnterCogCodePopReceiverArg0Regs:		<Integer>
+	realCEEnterCogCodePopReceiverArg1Arg0Regs:	<Integer>
+	regArgsHaveBeenPushed:						<Boolean>
+	simSelf:											<CogSimStackEntry>
+	simSpillBase:									<Integer>
+	simStack:										<CArrayAccessor of CogSimStackEntry>
+	simStackPtr:									<Integer>
+	traceSimStack:									<Integer>
+
+callerSavedRegMask
+	- the bitmask of the ABI's caller-saved registers
+
+ceEnter0ArgsPIC ceEnter1ArgsPIC ceEnter2ArgsPIC
+	- the trampoline for entering an N-arg PIC
+
+ceEnterCogCodePopReceiverArg0Regs ceEnterCogCodePopReceiverArg1Arg0Regs
+	- teh trampoline for entering a method with N register args
+	
+debugBytecodePointers
+	- a Set of bytecode pcs for setting breakpoints (simulation only)
+
+debugFixupBreaks
+	- a Set of fixup indices for setting breakpoints (simulation only)
+
+debugStackPointers
+	- an Array of stack depths for each bytecode for code verification
+
+methodAbortTrampolines
+	- a CArrayAccessor of abort trampolines for 0, 1, 2 and N args
+
+methodOrBlockNumTemps
+	- the number of method or block temps (including args) in the current compilation unit (method or block)
+
+optStatus
+	- the variable used to track the status of ReceiverResultReg for avoiding reloading that register with self between adjacent inst var accesses
+
+picAbortTrampolines
+	- a CArrayAccessor of abort trampolines for 0, 1, 2 and N args
+
+picMissTrampolines
+	- a CArrayAccessor of abort trampolines for 0, 1, 2 and N args
+
+realCEEnterCogCodePopReceiverArg0Regs realCEEnterCogCodePopReceiverArg1Arg0Regs
+	- the real trampolines for ebtering machine code with N reg args when in the Debug regime
+
+regArgsHaveBeenPushed
+	- whether the register args have been pushed before frame build (e.g. when an interpreter primitive is called)
+
+simSelf
+	- the simulation stack entry representing self in the current compilation unit
+
+simSpillBase
+	- the variable tracking how much of the simulation stack has been spilled to the real stack
+
+simStack
+	- the simulation stack itself
+
+simStackPtr
+	- the pointer to the top of the simulation stack
+!
+]style[(819 14 2308),cblack;,!
+!StackToRegisterMappingCogit methodsFor: 'compile abstract instructions' stamp: 'eem 12/30/2010 16:15' prior: 38815078!
+compileAbstractInstructionsFrom: start through: end
+	"Loop over bytecodes, dispatching to the generator for each bytecode, handling fixups in due course."
+	| nextOpcodeIndex descriptor fixup result |
+	<var: #descriptor type: #'BytecodeDescriptor *'>
+	<var: #fixup type: #'BytecodeFixup *'>
+	self traceSimStack.
+	bytecodePointer := start.
+	descriptor := nil.
+	deadCode := false.
+	[self cCode: '' inSmalltalk:
+		[(debugBytecodePointers includes: bytecodePointer) ifTrue: [self halt]].
+	fixup := self fixupAt: bytecodePointer - initialPC.
+	fixup targetInstruction asUnsignedInteger > 0
+		ifTrue:
+			[deadCode := false.
+	 		 fixup targetInstruction asUnsignedInteger >= 2 ifTrue:
+				[self merge: fixup afterReturn: (descriptor notNil and: [descriptor isReturn])]]
+		ifFalse: "If there's no fixup following a return there's no jump to that code and it is dead."
+			[(descriptor notNil and: [descriptor isReturn]) ifTrue:
+				[deadCode := true]].
+	 self cCode: '' inSmalltalk:
+		[deadCode ifFalse:
+			[self assert: simStackPtr + (needsFrame
+										ifTrue: [0]
+										ifFalse: [methodOrBlockNumArgs + 1])
+						= (self debugStackPointerFor: bytecodePointer)]].
+	 byte0 := objectMemory fetchByte: bytecodePointer ofObject: methodObj.
+	 descriptor := self generatorAt: byte0.
+	 descriptor numBytes > 1 ifTrue:
+		[byte1 := objectMemory fetchByte: bytecodePointer + 1 ofObject: methodObj.
+		 descriptor numBytes > 2 ifTrue:
+			[byte2 := objectMemory fetchByte: bytecodePointer + 2 ofObject: methodObj.
+			 descriptor numBytes > 3 ifTrue:
+				[byte3 := objectMemory fetchByte: bytecodePointer + 3 ofObject: methodObj.
+				 descriptor numBytes > 4 ifTrue:
+					[self notYetImplemented]]]].
+	 nextOpcodeIndex := opcodeIndex.
+	 result := deadCode
+				ifTrue: "insert nops for dead code that is mapped so that bc to mc mapping is not many to one"
+					[(descriptor isMapped
+					  or: [inBlock and: [descriptor isMappedInBlock]]) ifTrue:
+						[self annotateBytecode: self Nop].
+						0]
+				ifFalse:
+					[self perform: descriptor generator].
+	 self traceDescriptor: descriptor; traceSimStack.
+	 (fixup targetInstruction asUnsignedInteger between: 1 and: 2) ifTrue:
+		["There is a fixup for this bytecode.  It must point to the first generated
+		   instruction for this bytecode.  If there isn't one we need to add a label."
+		 opcodeIndex = nextOpcodeIndex ifTrue:
+			[self Label].
+		 fixup targetInstruction: (self abstractInstructionAt: nextOpcodeIndex)].
+	 bytecodePointer := self nextBytecodePCFor: descriptor at: bytecodePointer byte0: byte0 in: methodObj.
+	 result = 0 and: [bytecodePointer <= end]] whileTrue.
+	^result! !
+!StackToRegisterMappingCogit methodsFor: 'bytecode generators' stamp: 'eem 12/30/2010 16:22' prior: 38854414!
+genSpecialSelectorEqualsEquals
+	| argReg rcvrReg nextPC postBranchPC targetBytecodePC branchBytecode primDescriptor branchDescriptor jumpEqual jumpNotEqual resultReg |
+	<var: #primDescriptor type: #'BytecodeDescriptor *'>
+	<var: #branchDescriptor type: #'BytecodeDescriptor *'>
+	<var: #jumpEqual type: #'AbstractInstruction *'>
+	<var: #jumpNotEqual type: #'AbstractInstruction *'>
+	self ssPop: 2.
+	resultReg := self availableRegisterOrNil.
+	resultReg ifNil:
+		[self ssAllocateRequiredReg: (resultReg := Arg1Reg)].
+	self ssPush: 2.
+	(self ssTop type = SSConstant
+	 and: [self ssTop spilled not]) "if spilled we must generate a real pop"
+		ifTrue:
+			[(self ssValue: 1) type = SSRegister
+				ifTrue: [rcvrReg := (self ssValue: 1) register]
+				ifFalse:
+					[(self ssValue: 1) popToReg: (rcvrReg := resultReg)].
+			(objectRepresentation shouldAnnotateObjectReference: self ssTop constant)
+				ifTrue: [self annotate: (self CmpCw: self ssTop constant R: rcvrReg)
+							objRef: self ssTop constant]
+				ifFalse: [self CmpCq: self ssTop constant R: rcvrReg].
+			self ssPop: 1]
+		ifFalse:
+			[argReg := self ssStorePop: true toPreferredReg: TempReg.
+			 rcvrReg := argReg = resultReg
+							ifTrue: [TempReg]
+							ifFalse: [resultReg].
+			self ssTop popToReg: rcvrReg.
+			self CmpR: argReg R: rcvrReg].
+	self ssPop: 1; ssPushRegister: resultReg.
+	primDescriptor := self generatorAt: byte0.
+	nextPC := bytecodePointer + primDescriptor numBytes.
+	branchBytecode := objectMemory fetchByte: nextPC ofObject: methodObj.
+	branchDescriptor := self generatorAt: branchBytecode.
+	(branchDescriptor isBranchTrue
+	 or: [branchDescriptor isBranchFalse])
+		ifTrue:
+			[self ssFlushTo: simStackPtr - 1.
+			 targetBytecodePC := nextPC
+								+ branchDescriptor numBytes
+								+ (self spanFor: branchDescriptor at: nextPC byte0: branchBytecode in: methodObj).
+			 postBranchPC := nextPC + branchDescriptor numBytes.
+			 (self fixupAt: nextPC - initialPC) targetInstruction = 0 ifTrue: "The next instruction is dead.  we can skip it."
+				[deadCode := true.
+				 self ssPop: 1. "the conditional branch bytecodes pop the item tested from the stack."
+				 self ensureFixupAt: targetBytecodePC - initialPC.
+				 self ensureFixupAt: postBranchPC - initialPC].
+			 self gen: (branchDescriptor isBranchTrue
+						ifTrue: [JumpZero]
+						ifFalse: [JumpNonZero])
+				operand: (self ensureNonMergeFixupAt: targetBytecodePC - initialPC) asUnsignedInteger.
+			 self Jump: (self ensureNonMergeFixupAt: postBranchPC - initialPC)]
+		ifFalse:
+			[jumpNotEqual := self JumpNonZero: 0.
+			 self annotate: (self MoveCw: objectMemory trueObject R: resultReg)
+				objRef: objectMemory trueObject.
+			 jumpEqual := self Jump: 0.
+			 jumpNotEqual jmpTarget: (self annotate: (self MoveCw: objectMemory falseObject R: resultReg)
+											objRef: objectMemory falseObject).
+			 jumpEqual jmpTarget: self Label].
+	resultReg == ReceiverResultReg ifTrue:
+		[optStatus isReceiverResultRegLive: false].
+	^0! !
+
+----End fileIn of /Users/eliot/Cog/methods.st----!
+
+----QUIT----{31 December 2010 . 7:07:01 pm} VMMaker-Squeak4.1.image priorSource: 6053307!
+
+----STARTUP----{31 December 2010 . 7:12:03 pm} as /Users/eliot/Cog/oscog/Cog.squeakvm.org/image/VMMaker-Squeak4.1.image!
+
+
+SimpleStackBasedCogit initializeBytecodeTableForClosureV3!
+
+StackToRegisterMappingCogit initializeBytecodeTableForClosureV3!
+
+----QUIT/NOSAVE----{31 December 2010 . 7:13:08 pm} VMMaker-Squeak4.1.image priorSource: 6098879!
+
+----STARTUP----{31 December 2010 . 7:14:09 pm} as /Users/eliot/Cog/oscog/Cog.squeakvm.org/image/VMMaker-Squeak4.1.image!
+
+
+StackToRegisterMappingCogit initializeBytecodeTableForClosureV3!
+
+StackToRegisterMappingCogit initializeBytecodeTableForClosureV3!
+
+StackToRegisterMappingCogit initializeBytecodeTableForClosureV3!
+
+StackToRegisterMappingCogit initializeBytecodeTableForClosureV3!
+
+StackToRegisterMappingCogit initializeBytecodeTableForClosureV3!
+
+StackToRegisterMappingCogit initializeBytecodeTableForClosureV3!
+
+----QUIT/NOSAVE----{31 December 2010 . 7:15:30 pm} VMMaker-Squeak4.1.image priorSource: 6098879!
+
+----STARTUP----{31 December 2010 . 7:15:37 pm} as /Users/eliot/Cog/oscog/Cog.squeakvm.org/image/VMMaker-Squeak4.1.image!
+
+
+----QUIT/NOSAVE----{31 December 2010 . 7:16:07 pm} VMMaker-Squeak4.1.image priorSource: 6098879!
+
+----STARTUP----{31 December 2010 . 7:21:40 pm} as /Users/eliot/Cog/oscog/Cog.squeakvm.org/image/VMMaker-Squeak4.1.image!
+
+!Gnuifier methodsFor: 'as yet unclassified' stamp: 'eem 12/31/2010 19:18' prior: 35891606!
+gnuifyFrom: inFileStream to: outFileStream
+
+"convert interp.c to use GNU features"
+
+	| inData beforeInterpret inInterpret inInterpretVars beforePrimitiveResponse inPrimitiveResponse |
+
+	inData := inFileStream upToEnd withSqueakLineEndings.
+	inFileStream close.
+
+	"print a header"
+	outFileStream
+		nextPutAll: '/* This file has been post-processed for GNU C */';
+		cr; cr; cr.
+
+	beforeInterpret := true.    "whether we are before the beginning of interpret()"
+	inInterpret := false.     "whether we are in the middle of interpret"
+	inInterpretVars := false.    "whether we are in the variables of interpret"
+	beforePrimitiveResponse := true.  "whether we are before the beginning of primitiveResponse()"
+	inPrimitiveResponse := false.   "whether we are inside of primitiveResponse"
+	'Gnuifying'
+		displayProgressAt: Sensor cursorPoint
+		from: 1 to: (inData occurrencesOf: Character cr)
+		during:
+			[:bar | | lineNumber |
+			lineNumber := 0.
+			inData linesDo:
+				[ :inLine | | outLine extraOutLine |
+				bar value: (lineNumber := lineNumber + 1).
+				outLine := inLine. 	"print out one line for each input line; by default, print out the line that was input, but some rules modify it"
+				extraOutLine := nil.   "occasionally print a second output line..."
+				beforeInterpret ifTrue: [
+					(inLine = '#include "sq.h"') ifTrue: [
+						outLine := '#include "sqGnu.h"'. ].
+					(inLine beginsWith: 'interpret(void)') ifTrue: [
+						"reached the beginning of interpret"
+						beforeInterpret := false.
+						inInterpret := true.
+						inInterpretVars := true. ] ]
+				ifFalse: [
+				inInterpretVars ifTrue: [
+					(inLine findString: 'register struct foo * foo = &fum;') > 0 ifTrue: [
+						outLine := 'register struct foo * foo FOO_REG = &fum;' ].
+					(inLine findString: ' localIP;') > 0 ifTrue: [
+						outLine := '    char* localIP IP_REG;' ].
+					(inLine findString: ' localFP;') > 0 ifTrue: [
+						outLine := '    char* localFP FP_REG;' ].
+					(inLine findString: ' localSP;') > 0 ifTrue: [
+						outLine := '    char* localSP SP_REG;' ].
+					(inLine findString: ' currentBytecode;') > 0 ifTrue: [
+						outLine := '    sqInt currentBytecode CB_REG;' ].
+					inLine isEmpty ifTrue: [
+						"reached end of variables"
+						inInterpretVars := false.
+						outLine := '    JUMP_TABLE;'.
+						extraOutLine := inLine ] ]
+				ifFalse: [
+				inInterpret ifTrue: [
+					"working inside interpret(); translate the switch statement"
+					(inLine beginsWith: '		case ') ifTrue: [
+						| caseLabel |
+						caseLabel := (inLine findTokens: '	 :') second.
+						outLine := '		CASE(', caseLabel, ')' ].
+					inLine = '			break;' ifTrue: [
+						outLine := '			BREAK;' ].
+					inLine = '}' ifTrue: [
+						"all finished with interpret()"
+						inInterpret := false. ] ]
+				ifFalse: [
+				beforePrimitiveResponse ifTrue: [
+					(inLine beginsWith: 'primitiveResponse(') ifTrue: [
+						"into primitiveResponse we go"
+						beforePrimitiveResponse := false.
+						inPrimitiveResponse := true.
+						extraOutLine := '    PRIM_TABLE;'.  ] ]
+				ifFalse: [
+				inPrimitiveResponse ifTrue: [
+					(inLine = '	switch (primitiveIndex) {') ifTrue: [
+						extraOutLine := outLine.
+						outLine := '	PRIM_DISPATCH;' ].
+					(inLine = '	switch (GIV(primitiveIndex)) {') ifTrue: [
+						extraOutLine := outLine.
+						outLine := '	PRIM_DISPATCH;' ].
+					(inLine beginsWith: '	case ') ifTrue: [
+						| caseLabel |
+						caseLabel := (inLine findTokens: '	 :') second.
+						outLine := '	CASE(', caseLabel, ')' ].
+					inLine = '}' ifTrue: [
+						inPrimitiveResponse := false ] ].
+				] ] ] ].
+
+				outFileStream nextPutAll: outLine; cr.
+				extraOutLine ifNotNil: [
+					outFileStream nextPutAll: extraOutLine; cr ]]].
+
+	outFileStream close! !
+
+----QUIT----{31 December 2010 . 7:22:49 pm} VMMaker-Squeak4.1.image priorSource: 6098879!
+
+----STARTUP----{1 January 2011 . 11:54:57 am} as /Users/eliot/Cog/oscog/Cog.squeakvm.org/image/VMMaker-Squeak4.1.image!
+
+
+----QUIT/NOSAVE----{1 January 2011 . 11:56:43 am} VMMaker-Squeak4.1.image priorSource: 6104104!
+
+----STARTUP----{1 January 2011 . 11:57:04 am} as /Users/eliot/Cog/oscog/Cog.squeakvm.org/image/VMMaker-Squeak4.1.image!
+
+
+| user pw |
+Utilities setAuthorInitials.
+user := UIManager default request: 'Repository user name'.
+pw := UIManager default requestPassword: 'Monticello password'.
+MCHttpRepository allSubInstancesDo: [ : rep |
+	rep user: user;
+	password: pw ].
+user = 'anon' ifTrue: [MCFileBasedRepository flushAllCaches]!
+
+"VMMaker"!
+
+| user pw |
+Utilities setAuthorInitials.
+user := UIManager default request: 'Repository user name'.
+pw := UIManager default requestPassword: 'Monticello password'.
+MCHttpRepository allSubInstancesDo: [ : rep |
+	rep user: user;
+	password: pw ].
+user = 'anon' ifTrue: [MCFileBasedRepository flushAllCaches]!
+
+----QUIT----{1 January 2011 . 12:01:07 pm} VMMaker-Squeak4.1.image priorSource: 6104104!
+
+----STARTUP----{1 January 2011 . 12:05:11 pm} as /Users/eliot/Cog/oscog/Cog.squeakvm.org/image/VMMaker-Squeak4.1.image!
+
+
+----QUIT/NOSAVE----{1 January 2011 . 12:13:36 pm} VMMaker-Squeak4.1.image priorSource: 6105162!
+
+----STARTUP----{1 January 2011 . 12:14:25 pm} as /Users/eliot/Cog/oscog/Cog.squeakvm.org/image/VMMaker-Squeak4.1.image!
+
+
+----QUIT/NOSAVE----{1 January 2011 . 12:15:18 pm} VMMaker-Squeak4.1.image priorSource: 6105162!
\ No newline at end of file

Modified: branches/Cog/image/VMMaker-Squeak4.1.image
===================================================================
(Binary files differ)

Modified: branches/Cog/image/Workspace.text
===================================================================
--- branches/Cog/image/Workspace.text	2010-12-31 19:27:35 UTC (rev 2336)
+++ branches/Cog/image/Workspace.text	2011-01-01 20:18:49 UTC (rev 2337)
@@ -4,10 +4,15 @@
 x86 platforms:
 	(VMMaker
 		generate: CoInterpreter
+		and: (Smalltalk
+				at: ([:choices| choices at: (UIManager default chooseFrom: choices)
+				ifAbsent: [^self]]
+					value: #(SimpleStackBasedCogit StackToRegisterMappingCogit)))
 		to: (FileDirectory default / '../src') fullName
 		platformDir: (FileDirectory default / '../platforms') fullName
-		excluding:#(BrokenPlugin IA32ABIPluginSimulator SlangTestPlugin TestOSAPlugin
-					FFIPlugin ReentrantARMFFIPlugin ReentrantFFIPlugin ReentrantPPCBEFFIPlugin))
+		excluding:#(BrokenPlugin SlangTestPlugin TestOSAPlugin
+					FFIPlugin ReentrantARMFFIPlugin ReentrantFFIPlugin ReentrantPPCBEFFIPlugin
+					NewsqueakIA32ABIPlugin NewsqueakIA32ABIPluginAttic))
 other platforms:
 	 (VMMaker
 		generate: StackInterpreter
Modified: branches/Cog/src/vm/cogit.c
===================================================================
--- branches/Cog/src/vm/cogit.c	2010-12-31 19:27:35 UTC (rev 2336)
+++ branches/Cog/src/vm/cogit.c	2011-01-01 20:18:49 UTC (rev 2337)
@@ -1,9 +1,9 @@
 /* Automatically generated by
-	CCodeGenerator VMMaker-oscog.40 uuid: 637db40c-33c6-4263-816e-1b8cc19e3c99
+	CCodeGenerator VMMaker-oscog.41 uuid: 096b8a29-e7e8-4cbf-b29c-0f096abbdd5c
    from
-	StackToRegisterMappingCogit VMMaker-oscog.40 uuid: 637db40c-33c6-4263-816e-1b8cc19e3c99
+	SimpleStackBasedCogit VMMaker-oscog.41 uuid: 096b8a29-e7e8-4cbf-b29c-0f096abbdd5c
  */
-static char __buildInfo[] = "StackToRegisterMappingCogit VMMaker-oscog.40 uuid: 637db40c-33c6-4263-816e-1b8cc19e3c99 " __DATE__ ;
+static char __buildInfo[] = "SimpleStackBasedCogit VMMaker-oscog.41 uuid: 096b8a29-e7e8-4cbf-b29c-0f096abbdd5c " __DATE__ ;
 char *__cogitBuildInfo = __buildInfo;
 
 
@@ -83,6 +83,14 @@
 
 
 typedef struct {
+	AbstractInstruction *targetInstruction;
+	sqInt	instructionIndex;
+ } BytecodeFixup;
+
+#define CogBytecodeFixup BytecodeFixup
+
+
+typedef struct {
 	sqInt	annotation;
 	AbstractInstruction *instruction;
  } InstructionAnnotation;
@@ -99,35 +107,7 @@
 #define CogPrimitiveDescriptor PrimitiveDescriptor
 
 
-typedef struct {
-	AbstractInstruction *targetInstruction;
-	sqInt	instructionIndex;
-	sqInt	simStackPtr;
-	sqInt	simSpillBase;
-	sqInt	mergeBase;
-	sqInt	optStatus;
- } BytecodeFixup;
 
-#define CogSSBytecodeFixup BytecodeFixup
-
-
-typedef struct {
-	char	type;
-	char	spilled;
-	sqInt	registerr;
-	sqInt	offset;
-	sqInt	constant;
-	sqInt	bcptr;
- } CogSimStackEntry;
-
-
-typedef struct {
-	sqInt	isReceiverResultRegLive;
-	CogSimStackEntry *ssEntry;
- } CogSSOptStatus;
-
-
-
 /*** Constants ***/
 #define AddCqR 82
 #define AddCwR 89
@@ -143,7 +123,6 @@
 #define ArithmeticShiftRightCqR 68
 #define ArithmeticShiftRightRR 69
 #define BaseHeaderSize 4
-#define BytesPerOop 4
 #define BytesPerWord 4
 #define Call 8
 #define CDQ 102
@@ -164,7 +143,6 @@
 #define CmpCwR 88
 #define CmpRdRd 95
 #define CmpRR 74
-#define ConstZero 1
 #define ConvertRRd 101
 #define CPUID 105
 #define Debug DEBUGVM
@@ -198,8 +176,6 @@
 #define FoxMFReceiver -12
 #define FoxThisContext -8
 #define FPReg -1
-#define GPRegMax -3
-#define GPRegMin -8
 #define HasBytecodePC 5
 #define HashBitsOffset 17
 #define HashMaskUnshifted 0xFFF
@@ -292,7 +268,7 @@
 #define NegateR 67
 #define Nop 7
 #define NumSendTrampolines 4
-#define NumTrampolines 50
+#define NumTrampolines 38
 #define OrCqR 85
 #define OrRR 78
 #define PopR 62
@@ -318,10 +294,6 @@
 #define SizeMask 0xFC
 #define SPReg -2
 #define SqrtRd 100
-#define SSBaseOffset 1
-#define SSConstant 2
-#define SSRegister 3
-#define SSSpill 4
 #define StackPointerIndex 2
 #define SubCqR 83
 #define SubCwR 90
@@ -376,7 +348,6 @@
 static AbstractInstruction * annotateobjRef(AbstractInstruction *abstractInstruction, sqInt anOop);
 static AbstractInstruction * annotatewith(AbstractInstruction *abstractInstruction, sqInt annotationFlag);
 static void assertSaneJumpTarget(void *jumpTarget);
-static sqInt availableRegisterOrNil(void);
 static sqInt blockCodeSize(unsigned char byteZero, unsigned char byteOne, unsigned char byteTwo, unsigned char byteThree);
 static sqInt blockDispatchTargetsForperformarg(CogMethod *cogMethod, usqInt (*binaryFunction)(sqInt mcpc, sqInt arg), sqInt arg);
 sqInt bytecodePCForstartBcpcin(sqInt mcpc, sqInt startbcpc, CogBlockMethod *cogMethod);
@@ -529,13 +500,8 @@
 static sqInt doubleExtendedDoAnythingBytecode(void);
 static sqInt duplicateTopBytecode(void);
 static BytecodeFixup * ensureFixupAt(sqInt targetIndex);
-static BytecodeFixup * ensureNonMergeFixupAt(sqInt targetIndex);
-static void ensureReceiverResultRegContainsSelf(void);
-static void ensureSpilledAtfrom(CogSimStackEntry * self_in_ensureSpilledAtfrom, sqInt baseOffset, sqInt baseRegister);
 void enterCogCodePopReceiver(void);
 void enterCogCodePopReceiverAndClassRegs(void);
-void enterCogCodePopReceiverArg0Regs(void);
-void enterCogCodePopReceiverArg1Arg0Regs(void);
 static sqInt extendedPushBytecode(void);
 static sqInt extendedStoreAndPopBytecode(void);
 static sqInt extendedStoreBytecode(void);
@@ -564,10 +530,8 @@
 static sqInt genDoubleArithmeticpreOpCheck(sqInt arithmeticOperator, AbstractInstruction *(*preOpCheckOrNil)(int rcvrReg, int argReg));
 static sqInt genDoubleComparisoninvert(AbstractInstruction *(*jumpOpcodeGenerator)(void *), sqInt invertComparison);
 static AbstractInstruction * genDoubleFailIfZeroArgRcvrarg(sqInt rcvrReg, sqInt argReg);
-static void (*genEnilopmartForandandcalled(sqInt regArg1, sqInt regArg2, sqInt regArg3, char *trampolineName))(void) ;
 static void (*genEnilopmartForandcalled(sqInt regArg1, sqInt regArg2, char *trampolineName))(void) ;
 static void (*genEnilopmartForcalled(sqInt regArg, char *trampolineName))(void) ;
-static void (*genEnterPICEnilopmartNumArgs(sqInt numArgs))(void) ;
 static sqInt genExtendedSendBytecode(void);
 static sqInt genExtendedSuperBytecode(void);
 static sqInt genExternalizePointersForPrimitiveCall(void);
@@ -625,16 +589,13 @@
 static sqInt genLongJumpIfTrue(void);
 static sqInt genLongUnconditionalBackwardJump(void);
 static sqInt genLongUnconditionalForwardJump(void);
-static sqInt genMarshalledSendSupernumArgs(sqInt selector, sqInt numArgs);
-static sqInt genMarshalledSendnumArgs(sqInt selector, sqInt numArgs);
-static sqInt genMethodAbortTrampolineFor(sqInt numArgs);
+static sqInt genMethodAbortTrampoline(void);
 static void genMulRR(AbstractInstruction * self_in_genMulRR, sqInt regSource, sqInt regDest);
 static sqInt genMustBeBooleanTrampolineForcalled(sqInt boolean, char *trampolineName);
 static sqInt genNonLocalReturnTrampoline(void);
 static sqInt genPassConstasArgument(AbstractInstruction * self_in_genPassConstasArgument, sqInt constant, sqInt zeroRelativeArgIndex);
 static sqInt genPassRegasArgument(AbstractInstruction * self_in_genPassRegasArgument, sqInt abstractRegister, sqInt zeroRelativeArgIndex);
-static sqInt genPICAbortTrampolineFor(sqInt numArgs);
-static sqInt genPICMissTrampolineFor(sqInt numArgs);
+static sqInt genPICAbortTrampoline(void);
 static sqInt genPopStackBytecode(void);
 static sqInt genPrimitiveAdd(void);
 static sqInt genPrimitiveAsFloat(void);
@@ -689,9 +650,6 @@
 static sqInt genPushReceiverBytecode(void);
 static sqInt genPushReceiverVariableBytecode(void);
 static sqInt genPushReceiverVariable(sqInt index);
-static void genPushRegisterArgs(void);
-static void genPushRegisterArgsForAbortMissNumArgs(sqInt numArgs);
-static void genPushRegisterArgsForNumArgs(sqInt numArgs);
 static sqInt genPushRemoteTempLongBytecode(void);
 static sqInt genPushTemporaryVariableBytecode(void);
 static sqInt genPushTemporaryVariable(sqInt index);
@@ -717,24 +675,19 @@
 static sqInt genSendLiteralSelector1ArgBytecode(void);
 static sqInt genSendLiteralSelector2ArgsBytecode(void);
 static sqInt genSendSupernumArgs(sqInt selector, sqInt numArgs);
-static sqInt genSendTrampolineFornumArgscalledargargargarg(void *aRoutine, sqInt numArgs, char *aString, sqInt regOrConst0, sqInt regOrConst1, sqInt regOrConst2, sqInt regOrConst3);
 static sqInt genSendnumArgs(sqInt selector, sqInt numArgs);
 static sqInt genSetSmallIntegerTagsIn(sqInt scratchReg);
 static sqInt genShiftAwaySmallIntegerTagsInScratchReg(sqInt scratchReg);
 static sqInt genShortJumpIfFalse(void);
 static sqInt genShortUnconditionalJump(void);
 static sqInt genSmallIntegerComparison(sqInt jumpOpcode);
-static sqInt genSpecialSelectorArithmetic(void);
 static sqInt genSpecialSelectorClass(void);
-static sqInt genSpecialSelectorComparison(void);
 static sqInt genSpecialSelectorEqualsEquals(void);
 static sqInt genSpecialSelectorSend(void);
-static sqInt genSSPushSlotreg(sqInt index, sqInt baseReg);
 static sqInt genStoreAndPopReceiverVariableBytecode(void);
 static sqInt genStoreAndPopRemoteTempLongBytecode(void);
 static sqInt genStoreAndPopTemporaryVariableBytecode(void);
 static sqInt genStoreCheckTrampoline(void);
-static sqInt genStoreImmediateInSourceRegslotIndexdestReg(sqInt sourceReg, sqInt index, sqInt destReg);
 static sqInt genStorePopLiteralVariable(sqInt popBoolean, sqInt litVarIndex);
 static sqInt genStorePopMaybeContextReceiverVariable(sqInt popBoolean, sqInt slotIndex);
 static sqInt genStorePopReceiverVariable(sqInt popBoolean, sqInt slotIndex);
@@ -746,6 +699,8 @@
 static AbstractInstruction * genSubstituteReturnAddress(AbstractInstruction * self_in_genSubstituteReturnAddress, sqInt retpc);
 static sqInt genTrampolineForcalled(void *aRoutine, char *aString);
 static sqInt genTrampolineForcalledarg(void *aRoutine, char *aString, sqInt regOrConst0);
+static sqInt genTrampolineForcalledargarg(void *aRoutine, char *aString, sqInt regOrConst0, sqInt regOrConst1);
+static sqInt genTrampolineForcalledargargargarg(void *aRoutine, char *aString, sqInt regOrConst0, sqInt regOrConst1, sqInt regOrConst2, sqInt regOrConst3);
 static sqInt genTrampolineForcalledargargargresult(void *aRoutine, char *aString, sqInt regOrConst0, sqInt regOrConst1, sqInt regOrConst2, sqInt resultReg);
 static sqInt genTrampolineForcalledargargresult(void *aRoutine, char *aString, sqInt regOrConst0, sqInt regOrConst1, sqInt resultReg);
 static sqInt genTrampolineForcalledargresult(void *aRoutine, char *aString, sqInt regOrConst0, sqInt resultReg);
@@ -771,14 +726,11 @@
 static BytecodeFixup * initializeFixupAt(sqInt targetIndex);
 static sqInt initialMethodUsageCount(void);
 static sqInt initialOpenPICUsageCount(void);
-static void initSimStackForFramefulMethod(sqInt startpc);
-static void initSimStackForFramelessMethod(sqInt startpc);
 static sqInt inlineCacheTagAt(AbstractInstruction * self_in_inlineCacheTagAt, sqInt callSiteReturnAddress);
 static sqInt inlineCacheTagForInstance(sqInt oop);
 static sqInt inlineCacheTagIsYoung(sqInt cacheTag);
 static sqInt instructionSizeAt(AbstractInstruction * self_in_instructionSizeAt, sqInt pc);
 sqInt interpretOffset(void);
-static sqInt inverseBranchFor(sqInt opcode);
 static sqInt isAFixup(AbstractInstruction * self_in_isAFixup, void *fixupOrAddress);
 static sqInt isAnInstruction(AbstractInstruction * self_in_isAnInstruction, void *addressOrInstruction);
 static sqInt isBigEndian(AbstractInstruction * self_in_isBigEndian);
@@ -789,7 +741,6 @@
 static sqInt isPCDependent(AbstractInstruction * self_in_isPCDependent);
 static sqInt isQuick(AbstractInstruction * self_in_isQuick, unsigned long operand);
 sqInt isSendReturnPC(sqInt retpc);
-static sqInt isSmallIntegerTagNonZero(void);
 static AbstractInstruction * gJumpAboveOrEqual(void *jumpTarget);
 static AbstractInstruction * gJumpAbove(void *jumpTarget);
 static AbstractInstruction * gJumpBelow(void *jumpTarget);
@@ -805,7 +756,6 @@
 static AbstractInstruction * gJumpLong(void *jumpTarget);
 static AbstractInstruction * gJumpNegative(void *jumpTarget);
 static AbstractInstruction * gJumpNonZero(void *jumpTarget);
-static AbstractInstruction * gJumpNoOverflow(void *jumpTarget);
 static AbstractInstruction * gJumpOverflow(void *jumpTarget);
 static AbstractInstruction * JumpRT(sqInt callTarget);
 static AbstractInstruction * gJumpR(sqInt reg);
@@ -827,7 +777,6 @@
 static sqInt leafCallStackPointerDelta(AbstractInstruction * self_in_leafCallStackPointerDelta);
 void linkSendAtintocheckedreceiver(sqInt callSiteReturnAddress, CogMethod *sendingMethod, CogMethod *targetMethod, sqInt checked, sqInt receiver);
 static sqInt literalBeforeFollowingAddress(AbstractInstruction * self_in_literalBeforeFollowingAddress, sqInt followingAddress);
-static sqInt liveRegisters(void);
 static sqInt loadLiteralByteSize(AbstractInstruction * self_in_loadLiteralByteSize);
 static sqInt longBranchDistance(unsigned char byteZero, unsigned char byteOne);
 static sqInt longForwardBranchDistance(unsigned char byteZero, unsigned char byteOne);
@@ -867,14 +816,11 @@
 void markMethodAndReferents(CogBlockMethod *aCogMethod);
 static void markYoungObjectsIn(CogMethod *cogMethod);
 static sqInt markYoungObjectspcmethod(sqInt annotation, char *mcpc, sqInt cogMethod);
-static void marshallSendArguments(sqInt numArgs);
 usqInt maxCogMethodAddress(void);
 static sqInt maybeFreeCogMethodDoesntLookKosher(CogMethod *cogMethod);
 static void maybeGenerateCheckFeatures(void);
 static void maybeGenerateICacheFlush(void);
 sqInt mcPCForstartBcpcin(sqInt bcpc, sqInt startbcpc, CogBlockMethod *cogMethod);
-static void mergeAtfrom(CogSimStackEntry * self_in_mergeAtfrom, sqInt baseOffset, sqInt baseRegister);
-static void mergeafterReturn(BytecodeFixup *fixup, sqInt mergeFollowsReturn);
 static sqInt methodAbortTrampolineFor(sqInt numArgs);
 static CogMethod * methodAfter(CogMethod *cogMethod);
 CogMethod * methodFor(void *address);
@@ -882,7 +828,6 @@
 sqInt mnuOffset(void);
 static sqInt modRMRO(AbstractInstruction * self_in_modRMRO, sqInt mod, sqInt regMode, sqInt regOpcode);
 static AbstractInstruction * gNegateR(sqInt reg);
-static AbstractInstruction * gNop(void);
 static sqInt nextBytecodePCForatbyte0in(BytecodeDescriptor *descriptor, sqInt pc, sqInt opcodeByte, sqInt aMethodObj);
 static sqInt nextBytecodePCInMapAfterininBlockupTo(sqInt startbcpc, sqInt methodObject, sqInt isInBlock, sqInt endpc);
 static sqInt noCogMethodsMaximallyMarked(void);
@@ -907,7 +852,6 @@
 sqInt pcisWithinMethod(char *address, CogMethod *cogMethod);
 static sqInt picAbortTrampolineFor(sqInt numArgs);
 static void planCompaction(void);
-static void popToReg(CogSimStackEntry * self_in_popToReg, sqInt reg);
 static PrimitiveDescriptor * primitiveGeneratorOrNil(void);
 void printCogMethodFor(void *address);
 void printCogMethods(void);
@@ -922,10 +866,7 @@
 void recordCallOffsetInof(CogMethod *cogMethod, void *callLabelArg);
 static void recordGeneratedRunTimeaddress(char *aString, sqInt address);
 sqInt recordPrimTraceFunc(void);
-static sqInt registerMask(CogSimStackEntry * self_in_registerMask);
-static sqInt registerMaskFor(sqInt reg);
 static sqInt registerMaskForandand(sqInt reg1, sqInt reg2, sqInt reg3);
-static sqInt registerOrNil(CogSimStackEntry * self_in_registerOrNil);
 static void relocateAndPruneYoungReferrers(void);
 static void relocateCallBeforeReturnPCby(AbstractInstruction * self_in_relocateCallBeforeReturnPCby, sqInt retpc, sqInt delta);
 static void relocateCallsAndSelfReferencesInMethod(CogMethod *cogMethod);
@@ -965,31 +906,10 @@
 static sqInt sizePCDependentInstructionAt(AbstractInstruction * self_in_sizePCDependentInstructionAt, sqInt eventualAbsoluteAddress);
 static sqInt slotOffsetOfInstVarIndex(sqInt index);
 static sqInt spanForatbyte0in(BytecodeDescriptor *descriptor, sqInt pc, sqInt opcodeByte, sqInt aMethodObj);
-static void ssAllocateCallReg(sqInt requiredReg1);
-static void ssAllocateCallRegand(sqInt requiredReg1, sqInt requiredReg2);
-static sqInt ssAllocatePreferredReg(sqInt preferredReg);
-static void ssAllocateRequiredRegMaskupThrough(sqInt requiredRegsMask, sqInt stackPtr);
-static void ssAllocateRequiredReg(sqInt requiredReg);
-static void ssAllocateRequiredRegand(sqInt requiredReg1, sqInt requiredReg2);
-static void ssAllocateRequiredRegupThrough(sqInt requiredReg, sqInt stackPtr);
-static void ssFlushTo(sqInt index);
-static void ssFlushUpThroughReceiverVariable(sqInt slotIndex);
-static void ssFlushUpThroughTemporaryVariable(sqInt tempIndex);
-static void ssPop(sqInt n);
-static sqInt ssPushBaseoffset(sqInt reg, sqInt offset);
-static sqInt ssPushConstant(sqInt literal);
-static sqInt ssPushDesc(CogSimStackEntry simStackEntry);
-static sqInt ssPushRegister(sqInt reg);
-static void ssPush(sqInt n);
-static sqInt ssStorePoptoPreferredReg(sqInt popBoolean, sqInt preferredReg);
-static CogSimStackEntry * ssTop(void);
-static CogSimStackEntry ssTopDescriptor(void);
-static CogSimStackEntry * ssValue(sqInt n);
 static sqInt stackBytesForNumArgs(AbstractInstruction * self_in_stackBytesForNumArgs, sqInt numArgs);
 sqInt stackPageHeadroomBytes(void);
 static sqInt stackPageInterruptHeadroomBytes(AbstractInstruction * self_in_stackPageInterruptHeadroomBytes);
 static void storeLiteralbeforeFollowingAddress(AbstractInstruction * self_in_storeLiteralbeforeFollowingAddress, sqInt literal, sqInt followingAddress);
-static void storeToReg(CogSimStackEntry * self_in_storeToReg, sqInt reg);
 static sqInt sib(AbstractInstruction * self_in_sib, sqInt scale, sqInt indexReg, sqInt baseReg);
 sqInt traceLinkedSendOffset(void);
 static char * trampolineNamenumArgs(char *routinePrefix, sqInt numArgs);
@@ -1036,7 +956,6 @@
 static sqInt bytecodePointer;
 void * CFramePointer;
 void * CStackPointer;
-static sqInt callerSavedRegMask;
 sqInt ceBaseFrameReturnTrampoline;
 sqInt ceCannotResumeTrampoline;
 void (*ceCaptureCStackPointers)(void);
@@ -1045,12 +964,7 @@
 static sqInt ceClosureCopyTrampoline;
 static sqInt ceCPICMissTrampoline;
 static sqInt ceCreateNewArrayTrampoline;
-void (*ceEnter0ArgsPIC)(void);
-void (*ceEnter1ArgsPIC)(void);
-void (*ceEnter2ArgsPIC)(void);
 void (*ceEnterCogCodePopReceiverAndClassRegs)(void);
-void (*ceEnterCogCodePopReceiverArg0Regs)(void);
-void (*ceEnterCogCodePopReceiverArg1Arg0Regs)(void);
 void (*ceEnterCogCodePopReceiverReg)(void);
 static sqInt ceFetchContextInstVarTrampoline;
 static void (*ceFlushICache)(unsigned long from, unsigned long to);
@@ -1083,7 +997,6 @@
 static sqInt cPICCaseSize;
 static sqInt cPICEndSize;
 static const int cStackAlignment = STACK_ALIGN_BYTES;
-static sqInt debugFixupBreaks;
 unsigned long debugPrimCallStackOffset;
 static AbstractInstruction * endCPICCase0;
 static AbstractInstruction * endCPICCase1;
@@ -1098,22 +1011,22 @@
 static sqInt firstSend;
 static BytecodeFixup * fixups;
 static BytecodeDescriptor generatorTable[256] = {
-	{ genPushReceiverVariableBytecode, (sqInt (*)(unsigned char,...))0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
-	{ genPushReceiverVariableBytecode, (sqInt (*)(unsigned char,...))0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
-	{ genPushReceiverVariableBytecode, (sqInt (*)(unsigned char,...))0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
-	{ genPushReceiverVariableBytecode, (sqInt (*)(unsigned char,...))0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
-	{ genPushReceiverVariableBytecode, (sqInt (*)(unsigned char,...))0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
-	{ genPushReceiverVariableBytecode, (sqInt (*)(unsigned char,...))0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
-	{ genPushReceiverVariableBytecode, (sqInt (*)(unsigned char,...))0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
-	{ genPushReceiverVariableBytecode, (sqInt (*)(unsigned char,...))0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
-	{ genPushReceiverVariableBytecode, (sqInt (*)(unsigned char,...))0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
-	{ genPushReceiverVariableBytecode, (sqInt (*)(unsigned char,...))0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
-	{ genPushReceiverVariableBytecode, (sqInt (*)(unsigned char,...))0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
-	{ genPushReceiverVariableBytecode, (sqInt (*)(unsigned char,...))0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
-	{ genPushReceiverVariableBytecode, (sqInt (*)(unsigned char,...))0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
-	{ genPushReceiverVariableBytecode, (sqInt (*)(unsigned char,...))0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
-	{ genPushReceiverVariableBytecode, (sqInt (*)(unsigned char,...))0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
-	{ genPushReceiverVariableBytecode, (sqInt (*)(unsigned char,...))0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
+	{ genPushReceiverVariableBytecode, (sqInt (*)(unsigned char,...))0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0 },
+	{ genPushReceiverVariableBytecode, (sqInt (*)(unsigned char,...))0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0 },
+	{ genPushReceiverVariableBytecode, (sqInt (*)(unsigned char,...))0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0 },
+	{ genPushReceiverVariableBytecode, (sqInt (*)(unsigned char,...))0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0 },
+	{ genPushReceiverVariableBytecode, (sqInt (*)(unsigned char,...))0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0 },
+	{ genPushReceiverVariableBytecode, (sqInt (*)(unsigned char,...))0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0 },
+	{ genPushReceiverVariableBytecode, (sqInt (*)(unsigned char,...))0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0 },
+	{ genPushReceiverVariableBytecode, (sqInt (*)(unsigned char,...))0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0 },
+	{ genPushReceiverVariableBytecode, (sqInt (*)(unsigned char,...))0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0 },
+	{ genPushReceiverVariableBytecode, (sqInt (*)(unsigned char,...))0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0 },
+	{ genPushReceiverVariableBytecode, (sqInt (*)(unsigned char,...))0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0 },
+	{ genPushReceiverVariableBytecode, (sqInt (*)(unsigned char,...))0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0 },
+	{ genPushReceiverVariableBytecode, (sqInt (*)(unsigned char,...))0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0 },
+	{ genPushReceiverVariableBytecode, (sqInt (*)(unsigned char,...))0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0 },
+	{ genPushReceiverVariableBytecode, (sqInt (*)(unsigned char,...))0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0 },
+	{ genPushReceiverVariableBytecode, (sqInt (*)(unsigned char,...))0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0 },
 	{ genPushTemporaryVariableBytecode, (sqInt (*)(unsigned char,...))0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0 },
 	{ genPushTemporaryVariableBytecode, (sqInt (*)(unsigned char,...))0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0 },
 	{ genPushTemporaryVariableBytecode, (sqInt (*)(unsigned char,...))0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0 },
@@ -1210,7 +1123,7 @@
 	{ genStoreAndPopTemporaryVariableBytecode, (sqInt (*)(unsigned char,...))0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0 },
 	{ genStoreAndPopTemporaryVariableBytecode, (sqInt (*)(unsigned char,...))0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0 },
 	{ genStoreAndPopTemporaryVariableBytecode, (sqInt (*)(unsigned char,...))0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0 },
-	{ genPushReceiverBytecode, (sqInt (*)(unsigned char,...))0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
+	{ genPushReceiverBytecode, (sqInt (*)(unsigned char,...))0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0 },
 	{ genPushConstantTrueBytecode, (sqInt (*)(unsigned char,...))0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
 	{ genPushConstantFalseBytecode, (sqInt (*)(unsigned char,...))0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
 	{ genPushConstantNilBytecode, (sqInt (*)(unsigned char,...))0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
@@ -1274,28 +1187,28 @@
 	{ genLongJumpIfFalse, (sqInt (*)(unsigned char,...))longForwardBranchDistance, 0, 0, 2, 1, 1, 1, 0, 0, 1, 0, 0, 1, 0 },
 	{ genLongJumpIfFalse, (sqInt (*)(unsigned char,...))longForwardBranchDistance, 0, 0, 2, 1, 1, 1, 0, 0, 1, 0, 0, 1, 0 },
 	{ genLongJumpIfFalse, (sqInt (*)(unsigned char,...))longForwardBranchDistance, 0, 0, 2, 1, 1, 1, 0, 0, 1, 0, 0, 1, 0 },
-	{ genSpecialSelectorArithmetic, (sqInt (*)(unsigned char,...))0, 0, 75, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0 },
-	{ genSpecialSelectorArithmetic, (sqInt (*)(unsigned char,...))0, 0, 76, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0 },
-	{ genSpecialSelectorComparison, (sqInt (*)(unsigned char,...))0, 0, 23, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0 },
-	{ genSpecialSelectorComparison, (sqInt (*)(unsigned char,...))0, 0, 25, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0 },
-	{ genSpecialSelectorComparison, (sqInt (*)(unsigned char,...))0, 0, 26, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0 },
-	{ genSpecialSelectorComparison, (sqInt (*)(unsigned char,...))0, 0, 24, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0 },
-	{ genSpecialSelectorComparison, (sqInt (*)(unsigned char,...))0, 0, 15, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0 },
-	{ genSpecialSelectorComparison, (sqInt (*)(unsigned char,...))0, 0, 16, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0 },
 	{ genSpecialSelectorSend, (sqInt (*)(unsigned char,...))0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0 },
 	{ genSpecialSelectorSend, (sqInt (*)(unsigned char,...))0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0 },
 	{ genSpecialSelectorSend, (sqInt (*)(unsigned char,...))0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0 },
 	{ genSpecialSelectorSend, (sqInt (*)(unsigned char,...))0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0 },
 	{ genSpecialSelectorSend, (sqInt (*)(unsigned char,...))0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0 },
 	{ genSpecialSelectorSend, (sqInt (*)(unsigned char,...))0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0 },
-	{ genSpecialSelectorArithmetic, (sqInt (*)(unsigned char,...))0, 0, 77, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0 },
-	{ genSpecialSelectorArithmetic, (sqInt (*)(unsigned char,...))0, 0, 78, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0 },
 	{ genSpecialSelectorSend, (sqInt (*)(unsigned char,...))0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0 },
 	{ genSpecialSelectorSend, (sqInt (*)(unsigned char,...))0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0 },
 	{ genSpecialSelectorSend, (sqInt (*)(unsigned char,...))0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0 },
 	{ genSpecialSelectorSend, (sqInt (*)(unsigned char,...))0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0 },
 	{ genSpecialSelectorSend, (sqInt (*)(unsigned char,...))0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0 },
 	{ genSpecialSelectorSend, (sqInt (*)(unsigned char,...))0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0 },
+	{ genSpecialSelectorSend, (sqInt (*)(unsigned char,...))0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0 },
+	{ genSpecialSelectorSend, (sqInt (*)(unsigned char,...))0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0 },
+	{ genSpecialSelectorSend, (sqInt (*)(unsigned char,...))0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0 },
+	{ genSpecialSelectorSend, (sqInt (*)(unsigned char,...))0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0 },
+	{ genSpecialSelectorSend, (sqInt (*)(unsigned char,...))0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0 },
+	{ genSpecialSelectorSend, (sqInt (*)(unsigned char,...))0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0 },
+	{ genSpecialSelectorSend, (sqInt (*)(unsigned char,...))0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0 },
+	{ genSpecialSelectorSend, (sqInt (*)(unsigned char,...))0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0 },
+	{ genSpecialSelectorSend, (sqInt (*)(unsigned char,...))0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0 },
+	{ genSpecialSelectorSend, (sqInt (*)(unsigned char,...))0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0 },
 	{ genSpecialSelectorEqualsEquals, (sqInt (*)(unsigned char,...))0, -1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
 	{ genSpecialSelectorClass, (sqInt (*)(unsigned char,...))0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
 	{ genSpecialSelectorSend, (sqInt (*)(unsigned char,...))0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0 },
@@ -1364,12 +1277,10 @@
 static sqInt lastSend;
 static usqInt limitAddress;
 static CogBlockMethod * maxMethodBefore;
-static sqInt methodAbortTrampolines[4];
 static sqInt methodBytesFreedSinceLastCompaction;
 static AbstractInstruction *methodLabel = &aMethodLabel;
 static sqInt methodObj;
 static sqInt methodOrBlockNumArgs;
-static sqInt methodOrBlockNumTemps;
 static sqInt methodZoneBase;
 static sqInt missOffset;
 static AbstractInstruction * mnuCall;
@@ -1381,9 +1292,6 @@
 static sqInt opcodeIndex;
 static CogMethod *openPICList = 0;
 static sqInt openPICSize;
-static CogSSOptStatus optStatus;
-static sqInt picAbortTrampolines[4];
-static sqInt picMissTrampolines[4];
 static void (*postCompileHook)(CogMethod *, void *);
 static AbstractInstruction * primInvokeLabel;
 static PrimitiveDescriptor primitiveGeneratorTable[MaxCompiledPrimitiveIndex+1] = {
@@ -1613,16 +1521,9 @@
 };
 static sqInt primitiveIndex;
 void (*realCEEnterCogCodePopReceiverAndClassRegs)(void);
-void (*realCEEnterCogCodePopReceiverArg0Regs)(void);
-void (*realCEEnterCogCodePopReceiverArg1Arg0Regs)(void);
 void (*realCEEnterCogCodePopReceiverReg)(void);
-static sqInt regArgsHaveBeenPushed;
 static AbstractInstruction * sendMissCall;
 static sqInt sendTrampolines[NumSendTrampolines];
-static CogSimStackEntry simSelf;
-static sqInt simSpillBase;
-static CogSimStackEntry simStack[256];
-static sqInt simStackPtr;
 static AbstractInstruction * stackCheckLabel;
 static AbstractInstruction * stackOverflowCall;
 static sqInt superSendTrampolines[NumSendTrampolines];
@@ -1675,7 +1576,7 @@
 #define noCheckEntryOffset() cmNoCheckEntryOffset
 #define noContextSwitchBlockEntryOffset() blockNoContextSwitchOffset
 #define notYetImplemented() warning("not yet implemented")
-#define numRegArgs() 1
+#define numRegArgs() 0
 #define printNum(n) printf("%ld", (long) n)
 #define printOnTrace() (traceLinkedSends & 8)
 #define print(aString) printf(aString)
@@ -1685,12 +1586,7 @@
 #define reportError(n) warning("compilation error")
 #define setCFramePointer(theFP) (CFramePointer = (void *)(theFP))
 #define setCStackPointer(theSP) (CStackPointer = (void *)(theSP))
-#define simStackAt(index) (simStack + (index))
-#define traceDescriptor(ign) 0
-#define traceFixup(ign) 0
 #define traceMapbyteatfor(ig,no,re,d) 0
-#define traceMerge(ign) 0
-#define traceSimStack() 0
 #define tryLockVMOwner() (ceTryLockVMOwner() != 0)
 #define typeEtAlWord(cm) (((long *)(cm))[1])
 #define unlockVMOwner() ceUnlockVMOwner()
@@ -2036,30 +1932,6 @@
 }
 
 static sqInt
-availableRegisterOrNil(void)
-{
-    sqInt liveRegs;
-
-	liveRegs = liveRegisters();
-	if (!(liveRegs & (registerMaskFor(Arg1Reg)))) {
-		return Arg1Reg;
-	}
-	if (!(liveRegs & (registerMaskFor(Arg0Reg)))) {
-		return Arg0Reg;
-	}
-	if (!(liveRegs & (registerMaskFor(SendNumArgsReg)))) {
-		return SendNumArgsReg;
-	}
-	if (!(liveRegs & (registerMaskFor(ClassReg)))) {
-		return ClassReg;
-	}
-	if (!(liveRegs & (registerMaskFor(ReceiverResultReg)))) {
-		return ReceiverResultReg;
-	}
-	return null;
-}
-
-static sqInt
 blockCodeSize(unsigned char byteZero, unsigned char byteOne, unsigned char byteTwo, unsigned char byteThree)
 {
 	return (byteTwo * 256) + byteThree;
@@ -2113,7 +1985,9 @@
 sqInt
 bytecodePCForstartBcpcin(sqInt mcpc, sqInt startbcpc, CogBlockMethod *cogMethod)
 {
-	if (mcpc == ((((sqInt)cogMethod)) + ((cogMethod->stackCheckOffset)))) {
+	if (mcpc == ((((cogMethod->stackCheckOffset)) == 0
+	? (((sqInt)cogMethod)) + (sizeof(CogBlockMethod))
+	: (((sqInt)cogMethod)) + ((cogMethod->stackCheckOffset))))) {
 		return startbcpc;
 	}
 	return mapForbcpcperformUntilarg(cogMethod, startbcpc, findMcpcBcpcMatchingMcpc, ((void *) mcpc));
@@ -3123,34 +2997,13 @@
 static sqInt
 compileAbstractInstructionsFromthrough(sqInt start, sqInt end)
 {
-    sqInt deadCode;
-    sqInt debugBytecodePointers;
     BytecodeDescriptor *descriptor;
     BytecodeFixup *fixup;
     sqInt nextOpcodeIndex;
     sqInt result;
 
-	traceSimStack();
 	bytecodePointer = start;
-	descriptor = null;
-	deadCode = 0;
 	do {
-		;
-		fixup = fixupAt(bytecodePointer - initialPC);
-		if ((((usqInt)((fixup->targetInstruction)))) > 0) {
-			deadCode = 0;
-			if ((((usqInt)((fixup->targetInstruction)))) >= 2) {
-				mergeafterReturn(fixup, (descriptor != null)
-				 && ((descriptor->isReturn)));
-			}
-		}
-		else {
-			if ((descriptor != null)
-			 && ((descriptor->isReturn))) {
-				deadCode = 1;
-			}
-		}
-		;
 		byte0 = fetchByteofObject(bytecodePointer, methodObj);
 		descriptor = generatorAt(byte0);
 		if (((descriptor->numBytes)) > 1) {
@@ -3166,16 +3019,9 @@
 			}
 		}
 		nextOpcodeIndex = opcodeIndex;
-		result = (deadCode
-			? (((descriptor->isMapped))
- || (inBlock
- && ((descriptor->isMappedInBlock)))
-	? annotateBytecode(gNop())
-	: 0),0
-			: ((descriptor->generator))());
-		traceDescriptor(descriptor);
-		traceSimStack();
-		if ((((((usqInt)((fixup->targetInstruction)))) >= 1) && ((((usqInt)((fixup->targetInstruction)))) <= 2))) {
+		result = ((descriptor->generator))();
+		fixup = fixupAt(bytecodePointer - initialPC);
+		if (((fixup->targetInstruction)) != 0) {
 			if (opcodeIndex == nextOpcodeIndex) {
 				gLabel();
 			}
@@ -3272,18 +3118,12 @@
 	sp->	Nth temp
 	Avoid use of SendNumArgsReg which is the flag determining whether
 	context switch is allowed on stack-overflow. */
-/*	Build a frame for a block activation. See CoInterpreter
-	class>>initializeFrameIndices. Override to push the register receiver and
-	register arguments, if any, and to correctly
-	initialize the explicitly nilled/pushed temp entries (they are /not/ of
-	type constant nil). */
 
 static void
 compileBlockFrameBuild(BlockStart *blockStart)
 {
     AbstractInstruction * cascade0;
     sqInt i;
-    sqInt ign;
 
 	annotateBytecode(gLabel());
 	gPushR(FPReg);
@@ -3304,33 +3144,19 @@
 	gCmpRR(TempReg, SPReg);
 	gJumpBelow(stackOverflowCall);
 	(blockStart->stackCheckLabel = annotateBytecode(gLabel()));
-	methodOrBlockNumTemps = (((blockStart->numArgs)) + ((blockStart->numCopied))) + ((blockStart->numInitialNils));
-	initSimStackForFramefulMethod((blockStart->startpc));
-	if (((blockStart->numInitialNils)) > 0) {
-		if (((blockStart->numInitialNils)) > 1) {
-			annotateobjRef(gMoveCwR(nilObject(), TempReg), nilObject());
-			for (ign = 1; ign <= ((blockStart->numInitialNils)); ign += 1) {
-				gPushR(TempReg);
-			}
-		}
-		else {
-			annotateobjRef(gPushCw(nilObject()), nilObject());
-		}
-		methodOrBlockNumTemps = ((blockStart->numArgs)) + ((blockStart->numCopied));
-	}
 }
 
 
-/*	Make sure ReceiverResultReg holds the receiver, loaded from
-	the closure, which is what is initially in ReceiverResultReg */
-/*	Make sure ReceiverResultReg holds the receiver, loaded from
-	the closure, which is what is initially in ReceiverResultReg */
+/*	Make sure ReceiverResultReg holds the receiver, loaded from the closure,
+	which is what is initially in ReceiverResultReg. We must annotate the
+	first instruction so that findMethodForStartBcpc:inHomeMethod: can
+	function. We need two annotations because the first is a fiducial. */
 
 static void
 compileBlockFramelessEntry(BlockStart *blockStart)
 {
-	methodOrBlockNumTemps = ((blockStart->numArgs)) + ((blockStart->numCopied));
-	initSimStackForFramelessMethod((blockStart->startpc));
+	annotateBytecode((blockStart->entryLabel));
+	annotateBytecode((blockStart->entryLabel));
 	genLoadSlotsourceRegdestReg(ClosureOuterContextIndex, ReceiverResultReg, TempReg);
 	genLoadSlotsourceRegdestReg(ReceiverIndex, TempReg, ReceiverResultReg);
 }
@@ -3369,14 +3195,11 @@
 static CogMethod *
 compileCogMethod(sqInt selector)
 {
-    sqInt debugStackPointers;
     sqInt extra;
     sqInt numBlocks;
     sqInt numBytecodes;
     sqInt result;
 
-	methodOrBlockNumTemps = tempCountOf(methodObj);
-	;
 	hasYoungReferent = (isYoung(methodObj))
 	 || (isYoung(selector));
 	methodOrBlockNumArgs = argumentCountOf(methodObj);
@@ -3497,9 +3320,6 @@
 	Ensure SendNumArgsReg is set early on (incidentally to nilObj) because
 	it is the flag determining whether context switch is allowed on
 	stack-overflow.  */
-/*	Build a frame for a CogMethod activation. See CoInterpreter
-	class>>initializeFrameIndices. Override to push the register receiver and
-	register arguments, if any. */
 
 static void
 compileFrameBuild(void)
@@ -3508,13 +3328,8 @@
     AbstractInstruction *jumpSkip;
 
 	if (!(needsFrame)) {
-		initSimStackForFramelessMethod(initialPC);
 		return;
 	}
-	genPushRegisterArgs();
-	if (!(needsFrame)) {
-		return;
-	}
 	gPushR(FPReg);
 	gMoveRR(SPReg, FPReg);
 	addDependent(methodLabel, annotateMethodRef(gPushCw(((sqInt)methodLabel))));
@@ -3541,7 +3356,6 @@
 		jmpTarget(jumpSkip, stackCheckLabel = gLabel());
 	}
 	annotateBytecode(stackCheckLabel);
-	initSimStackForFramefulMethod(initialPC);
 }
 
 
@@ -3698,14 +3512,12 @@
 
 
 /*	Compile the abstract instructions for the entire method. */
-/*	Compile the abstract instructions for a method. */
 
 static sqInt
 compileMethod(void)
 {
     sqInt result;
 
-	regArgsHaveBeenPushed = 0;
 	compileProlog();
 	compileEntry();
 	if (((result = compilePrimitive())) < 0) {
@@ -3747,7 +3559,7 @@
 	while (compiledBlocksCount < blockCount) {
 		blockStart = blockStartAt(compiledBlocksCount);
 		compileBlockEntry(blockStart);
-		if (((result = compileAbstractInstructionsFromthrough(((blockStart->startpc)) + ((blockStart->numInitialNils)), (((blockStart->startpc)) + ((blockStart->span))) - 1))) < 0) {
+		if (((result = compileAbstractInstructionsFromthrough((blockStart->startpc), (((blockStart->startpc)) + ((blockStart->span))) - 1))) < 0) {
 			return result;
 		}
 		compiledBlocksCount += 1;
@@ -3780,7 +3592,7 @@
 
 /*	Compile the code for an open PIC. Perform a probe of the first-level
 	method lookup cache followed by a call of ceSendFromOpenPIC: if the probe
-	fails. Override to push the register args when calling ceSendFromOpenPIC: */
+	fails.  */
 
 static void
 compileOpenPICnumArgs(sqInt selector, sqInt numArgs)
@@ -3842,7 +3654,6 @@
 	gCmpRR(SendNumArgsReg, TempReg);
 	gJumpZero(itsAHit);
 	jmpTarget(jumpSelectorMiss, gLabel());
-	genPushRegisterArgsForNumArgs(numArgs);
 	genSaveStackPointers();
 	genLoadCStackPointers();
 	addDependent(methodLabel, annotateMethodRef(gMoveCwR(((sqInt)methodLabel), SendNumArgsReg)));
@@ -6140,7 +5951,7 @@
 static sqInt
 cPICMissTrampolineFor(sqInt numArgs)
 {
-	return picMissTrampolines[((numArgs < ((numRegArgs()) + 1)) ? numArgs : ((numRegArgs()) + 1))];
+	return ceCPICMissTrampoline;
 }
 
 static sqInt
@@ -6532,10 +6343,9 @@
 static sqInt
 duplicateTopBytecode(void)
 {
-    CogSimStackEntry desc;
-
-	desc = ssTopDescriptor();
-	return ssPushDesc(desc);
+	gMoveMwrR(0, SPReg, TempReg);
+	gPushR(TempReg);
+	return 0;
 }
 
 
@@ -6550,93 +6360,13 @@
     BytecodeFixup *fixup;
 
 	fixup = fixupAt(targetIndex);
-	traceFixup(fixup);
-	;
-	if ((((usqInt)((fixup->targetInstruction)))) <= 1) {
-		(fixup->targetInstruction = ((AbstractInstruction *) 2));
-		(fixup->simStackPtr = simStackPtr);
-	}
-	else {
-		if (((fixup->simStackPtr)) <= -2) {
-			(fixup->simStackPtr = simStackPtr);
-		}
-		else {
-			assert(((fixup->simStackPtr)) == simStackPtr);
-		}
-	}
-	return fixup;
-}
-
-
-/*	Make sure there's a flagged fixup at the targetIndex (pc relative to first
-	pc) in fixups.
-	Initially a fixup's target is just a flag. Later on it is replaced with a
-	proper instruction. */
-
-static BytecodeFixup *
-ensureNonMergeFixupAt(sqInt targetIndex)
-{
-    BytecodeFixup *fixup;
-
-	fixup = fixupAt(targetIndex);
 	if (((fixup->targetInstruction)) == 0) {
 		(fixup->targetInstruction = ((AbstractInstruction *) 1));
 	}
-	;
 	return fixup;
 }
 
-static void
-ensureReceiverResultRegContainsSelf(void)
-{
-	if (needsFrame) {
-		if (!(((optStatus.isReceiverResultRegLive))
-			 && (((optStatus.ssEntry)) == ((&simSelf))))) {
-			ssAllocateRequiredReg(ReceiverResultReg);
-			storeToReg((&simSelf), ReceiverResultReg);
-		}
-		(optStatus.isReceiverResultRegLive = 1);
-		(optStatus.ssEntry = (&simSelf));
-	}
-	else {
-		assert((((simSelf.type)) == SSRegister)
-		 && (((simSelf.registerr)) == ReceiverResultReg));
-		assert(((optStatus.isReceiverResultRegLive))
-		 && (((optStatus.ssEntry)) == ((&simSelf))));
-	}
-}
 
-static void
-ensureSpilledAtfrom(CogSimStackEntry * self_in_ensureSpilledAtfrom, sqInt baseOffset, sqInt baseRegister)
-{
-	if ((self_in_ensureSpilledAtfrom->spilled)) {
-		if (((self_in_ensureSpilledAtfrom->type)) == SSSpill) {
-			assert((((self_in_ensureSpilledAtfrom->offset)) == baseOffset)
-			 && (((self_in_ensureSpilledAtfrom->registerr)) == baseRegister));
-			return;
-		}
-	}
-	assert(((self_in_ensureSpilledAtfrom->type)) != SSSpill);
-	if (((self_in_ensureSpilledAtfrom->type)) == SSConstant) {
-		annotateobjRef(gPushCw((self_in_ensureSpilledAtfrom->constant)), (self_in_ensureSpilledAtfrom->constant));
-	}
-	else {
-		if (((self_in_ensureSpilledAtfrom->type)) == SSBaseOffset) {
-			gMoveMwrR((self_in_ensureSpilledAtfrom->offset), (self_in_ensureSpilledAtfrom->registerr), TempReg);
-			gPushR(TempReg);
-		}
-		else {
-			assert(((self_in_ensureSpilledAtfrom->type)) == SSRegister);
-			gPushR((self_in_ensureSpilledAtfrom->registerr));
-		}
-		(self_in_ensureSpilledAtfrom->type) = SSSpill;
-		(self_in_ensureSpilledAtfrom->offset) = baseOffset;
-		(self_in_ensureSpilledAtfrom->registerr) = baseRegister;
-	}
-	(self_in_ensureSpilledAtfrom->spilled) = 1;
-}
-
-
 /*	This is a static version of ceEnterCogCodePopReceiverReg
 	for break-pointing when debugging in C. */
 /*	(and this exists only to reference Debug) */
@@ -6664,34 +6394,6 @@
 	realCEEnterCogCodePopReceiverAndClassRegs();
 }
 
-
-/*	This is a static version of ceEnterCogCodePopReceiverArg0Regs
-	for break-pointing when debugging in C. */
-/*	(and this exists only to reference Debug) */
-
-void
-enterCogCodePopReceiverArg0Regs(void)
-{
-	if (!(Debug)) {
-		error("what??");
-	}
-	realCEEnterCogCodePopReceiverArg0Regs();
-}
-
-
-/*	This is a static version of ceEnterCogCodePopReceiverArg1Arg0Regs
-	for break-pointing when debugging in C. */
-/*	(and this exists only to reference Debug) */
-
-void
-enterCogCodePopReceiverArg1Arg0Regs(void)
-{
-	if (!(Debug)) {
-		error("what??");
-	}
-	realCEEnterCogCodePopReceiverArg1Arg0Regs();
-}
-
 static sqInt
 extendedPushBytecode(void)
 {
@@ -6842,11 +6544,13 @@
 findBlockMethodWithStartMcpcbcpc(sqInt blockEntryPC, sqInt startBcpc)
 {
     CogBlockMethod *cogBlockMethod;
-    sqInt stackCheckMcpc;
+    sqInt startMcpc;
 
 	cogBlockMethod = ((CogBlockMethod *) (blockEntryPC - (sizeof(CogBlockMethod))));
-	stackCheckMcpc = (((usqInt)cogBlockMethod)) + ((cogBlockMethod->stackCheckOffset));
-	if ((bytecodePCForstartBcpcin(stackCheckMcpc, startBcpc, cogBlockMethod)) == startBcpc) {
+	startMcpc = (((cogBlockMethod->stackCheckOffset)) == 0
+		? cogBlockMethod
+		: (((usqInt)cogBlockMethod)) + ((cogBlockMethod->stackCheckOffset)));
+	if ((bytecodePCForstartBcpcin(startMcpc, startBcpc, cogBlockMethod)) == startBcpc) {
 		return ((usqInt)cogBlockMethod);
 	}
 	return 0;
@@ -6899,8 +6603,10 @@
 
 /*	Find the CMMethod or CMBlock that has zero-relative startbcpc as its first
 	bytecode pc.
-	As this is for cannot resme processing it doesn't have to be fast.
-	Enumerate block returns and map to bytecode pcs */
+	As this is for cannot resume processing and/or conversion to machine-code
+	on backward
+	branch, it doesn't have to be fast. Enumerate block returns and map to
+	bytecode pcs. */
 
 CogBlockMethod *
 findMethodForStartBcpcinHomeMethod(sqInt startbcpc, CogMethod *cogMethod)
@@ -7229,27 +6935,29 @@
 }
 
 
-/*	Receiver and arg in registers.
-	Stack looks like
+/*	Stack looks like
+	receiver (also in ResultReceiverReg)
+	arg
 	return address */
 
 static sqInt
 genDoubleArithmeticpreOpCheck(sqInt arithmeticOperator, AbstractInstruction *(*preOpCheckOrNil)(int rcvrReg, int argReg))
 {
     AbstractInstruction *doOp;
+    AbstractInstruction *fail;
     AbstractInstruction *jumpFailAlloc;
     AbstractInstruction *jumpFailCheck;
     AbstractInstruction *jumpFailClass;
     AbstractInstruction *jumpSmallInt;
 
-	gMoveRR(Arg0Reg, TempReg);
+	gMoveMwrR(BytesPerWord, SPReg, TempReg);
 	genGetDoubleValueOfinto(ReceiverResultReg, DPFPReg0);
-	gMoveRR(Arg0Reg, ClassReg);
+	gMoveRR(TempReg, ClassReg);
 	jumpSmallInt = genJumpSmallIntegerInScratchReg(TempReg);
-	genGetCompactClassIndexNonIntOfinto(Arg0Reg, SendNumArgsReg);
+	genGetCompactClassIndexNonIntOfinto(ClassReg, SendNumArgsReg);
 	gCmpCqR(classFloatCompactIndex(), SendNumArgsReg);
 	jumpFailClass = gJumpNonZero(0);
-	genGetDoubleValueOfinto(Arg0Reg, DPFPReg1);
+	genGetDoubleValueOfinto(ClassReg, DPFPReg1);
 	doOp = gLabel();
 	if (preOpCheckOrNil == null) {
 		null;
@@ -7260,30 +6968,29 @@
 	genoperandoperand(arithmeticOperator, DPFPReg1, DPFPReg0);
 	jumpFailAlloc = genAllocFloatValueintoscratchRegscratchReg(DPFPReg0, SendNumArgsReg, ClassReg, TempReg);
 	gMoveRR(SendNumArgsReg, ReceiverResultReg);
-	gRetN(0);
-	assert(methodOrBlockNumArgs <= (numRegArgs()));
-	jmpTarget(jumpFailClass, gLabel());
-	if (preOpCheckOrNil == null) {
-		null;
-	}
-	else {
-		jmpTarget(jumpFailCheck, getJmpTarget(jumpFailClass));
-	}
-	genPushRegisterArgsForNumArgs(methodOrBlockNumArgs);
-	jumpFailClass = gJump(0);
+	flag("currently caller pushes result");
+	gRetN(BytesPerWord * 2);
 	jmpTarget(jumpSmallInt, gLabel());
 	genConvertSmallIntegerToIntegerInScratchReg(ClassReg);
 	gConvertRRd(ClassReg, DPFPReg1);
 	gJump(doOp);
 	jmpTarget(jumpFailAlloc, gLabel());
 	compileInterpreterPrimitive(functionPointerForCompiledMethodprimitiveIndex(methodObj, primitiveIndex));
+	fail = gLabel();
 	jmpTarget(jumpFailClass, gLabel());
+	if (preOpCheckOrNil == null) {
+		null;
+	}
+	else {
+		jmpTarget(jumpFailCheck, fail);
+	}
 	return 0;
 }
 
 
-/*	Receiver and arg in registers.
-	Stack looks like
+/*	Stack looks like
+	receiver (also in ResultReceiverReg)
+	arg
 	return address */
 
 static sqInt
@@ -7294,13 +7001,14 @@
     AbstractInstruction *jumpFail;
     AbstractInstruction *jumpSmallInt;
 
-	gMoveRR(Arg0Reg, TempReg);
+	gMoveMwrR(BytesPerWord, SPReg, TempReg);
 	genGetDoubleValueOfinto(ReceiverResultReg, DPFPReg0);
+	gMoveRR(TempReg, ClassReg);
 	jumpSmallInt = genJumpSmallIntegerInScratchReg(TempReg);
-	genGetCompactClassIndexNonIntOfinto(Arg0Reg, SendNumArgsReg);
+	genGetCompactClassIndexNonIntOfinto(ClassReg, SendNumArgsReg);
 	gCmpCqR(classFloatCompactIndex(), SendNumArgsReg);
 	jumpFail = gJumpNonZero(0);
-	genGetDoubleValueOfinto(Arg0Reg, DPFPReg1);
+	genGetDoubleValueOfinto(ClassReg, DPFPReg1);
 	if (invertComparison) {
 
 		/* May need to invert for NaNs */
@@ -7315,12 +7023,13 @@
 
 	jumpCond = jumpOpcodeGenerator(0);
 	annotateobjRef(gMoveCwR(falseObject(), ReceiverResultReg), falseObject());
-	gRetN(0);
+	flag("currently caller pushes result");
+	gRetN(BytesPerWord * 2);
 	jmpTarget(jumpCond, annotateobjRef(gMoveCwR(trueObject(), ReceiverResultReg), trueObject()));
-	gRetN(0);
+	gRetN(BytesPerWord * 2);
 	jmpTarget(jumpSmallInt, gLabel());
-	genConvertSmallIntegerToIntegerInScratchReg(Arg0Reg);
-	gConvertRRd(Arg0Reg, DPFPReg1);
+	genConvertSmallIntegerToIntegerInScratchReg(ClassReg);
+	gConvertRRd(ClassReg, DPFPReg1);
 	gJump(compare);
 	jmpTarget(jumpFail, gLabel());
 	return 0;
@@ -7343,38 +7052,6 @@
 	then executes a return instruction to pop off the entry-point and jump to
 	it.  */
 
-static void (*genEnilopmartForandandcalled(sqInt regArg1, sqInt regArg2, sqInt regArg3, char *trampolineName))(void)
-
-{
-    sqInt endAddress;
-    sqInt enilopmart;
-    sqInt size;
-
-	opcodeIndex = 0;
-	genLoadStackPointers();
-	gPopR(regArg3);
-	gPopR(regArg2);
-	gPopR(regArg1);
-	gRetN(0);
-	computeMaximumSizes();
-	size = generateInstructionsAt(methodZoneBase);
-	endAddress = outputInstructionsAt(methodZoneBase);
-	assert((methodZoneBase + size) == endAddress);
-	enilopmart = methodZoneBase;
-	methodZoneBase = alignUptoRoutineBoundary(endAddress);
-	nopsFromto(backEnd, endAddress, methodZoneBase - 1);
-	recordGeneratedRunTimeaddress(trampolineName, enilopmart);
-	return ((void (*)(void)) enilopmart);
-}
-
-
-/*	An enilopmart (the reverse of a trampoline) is a piece of code that makes
-	the system-call-like transition from the C runtime into generated machine
-	code. The desired arguments and entry-point are pushed on a stackPage's
-	stack. The enilopmart pops off the values to be loaded into registers and
-	then executes a return instruction to pop off the entry-point and jump to
-	it.  */
-
 static void (*genEnilopmartForandcalled(sqInt regArg1, sqInt regArg2, char *trampolineName))(void)
 
 {
@@ -7429,44 +7106,6 @@
 }
 
 
-/*	Generate special versions of the ceEnterCogCodePopReceiverAndClassRegs
-	enilopmart that also pop register args from the stack to undo the pushing
-	of register args in the abort/miss trampolines. */
-
-static void (*genEnterPICEnilopmartNumArgs(sqInt numArgs))(void)
-
-{
-    sqInt endAddress;
-    sqInt enilopmart;
-    sqInt size;
-
-	opcodeIndex = 0;
-	genLoadStackPointers();
-	gPopR(ClassReg);
-	gPopR(TempReg);
-	gPopR(SendNumArgsReg);
-	if (numArgs > 0) {
-		if (numArgs > 1) {
-			gPopR(Arg1Reg);
-			assert((numRegArgs()) == 2);
-		}
-		gPopR(Arg0Reg);
-	}
-	gPopR(ReceiverResultReg);
-	gPushR(SendNumArgsReg);
-	gJumpR(TempReg);
-	computeMaximumSizes();
-	size = generateInstructionsAt(methodZoneBase);
-	endAddress = outputInstructionsAt(methodZoneBase);
-	assert((methodZoneBase + size) == endAddress);
-	enilopmart = methodZoneBase;
-	methodZoneBase = alignUptoRoutineBoundary(endAddress);
-	nopsFromto(backEnd, endAddress, methodZoneBase - 1);
-	recordGeneratedRunTimeaddress(trampolineNamenumArgs("ceEnterPIC", numArgs), enilopmart);
-	return ((void (*)(void)) enilopmart);
-}
-
-
 /*	Can use any of the first 32 literals for the selector and pass up to 7
 	arguments. 
  */
@@ -7483,13 +7122,9 @@
 	return genSendSupernumArgs(literalofMethod(byte1 & 31, methodObj), ((usqInt) byte1) >> 5);
 }
 
-
-/*	Override to push the register receiver and register arguments, if any. */
-
 static sqInt
 genExternalizePointersForPrimitiveCall(void)
 {
-	genPushRegisterArgs();
 	gMoveMwrR(0, SPReg, ClassReg);
 	gMoveRAw(FPReg, framePointerAddress());
 	gLoadEffectiveAddressMwrR(BytesPerWord, SPReg, TempReg);
@@ -7673,9 +7308,6 @@
 /*	Enilopmarts transfer control from C into machine code (backwards
 	trampolines). 
  */
-/*	Enilopmarts transfer control from C into machine code (backwards
-	trampolines). Override to add version for generic and PIC-specific entry
-	with reg args. */
 
 static void
 generateEnilopmarts(void)
@@ -7701,27 +7333,6 @@
 	cePrimReturnEnterCogCodeProfiling = methodZoneBase;
 	outputInstructionsForGeneratedRuntimeAt(cePrimReturnEnterCogCodeProfiling);
 	recordGeneratedRunTimeaddress("cePrimReturnEnterCogCodeProfiling", cePrimReturnEnterCogCodeProfiling);
-	
-#  if Debug
-	realCEEnterCogCodePopReceiverArg0Regs = genEnilopmartForandcalled(ReceiverResultReg, Arg0Reg, "realCEEnterCogCodePopReceiverArg0Regs");
-	ceEnterCogCodePopReceiverArg0Regs = enterCogCodePopReceiverArg0Regs;
-	realCEEnterCogCodePopReceiverArg1Arg0Regs = genEnilopmartForandandcalled(ReceiverResultReg, Arg0Reg, Arg1Reg, "realCEEnterCogCodePopReceiverArg1Arg0Regs");
-	ceEnterCogCodePopReceiverArg1Arg0Regs = enterCogCodePopReceiverArg1Arg0Regs;
-
-#  else /* Debug */
-	ceEnterCogCodePopReceiverArg0Regs = genEnilopmartForandcalled(ReceiverResultReg, Arg0Reg, "ceEnterCogCodePopReceiverArg0Regs");
-	ceEnterCogCodePopReceiverArg1Arg0Regs = genEnilopmartForandandcalled(ReceiverResultReg, Arg0Reg, Arg1Reg, "ceEnterCogCodePopReceiverArg1Arg0Regs");
-
-#  endif /* Debug */
-
-	ceEnter0ArgsPIC = genEnterPICEnilopmartNumArgs(0);
-	if ((numRegArgs()) >= 1) {
-		ceEnter1ArgsPIC = genEnterPICEnilopmartNumArgs(1);
-		if ((numRegArgs()) >= 2) {
-			ceEnter1ArgsPIC = genEnterPICEnilopmartNumArgs(2);
-			assert((numRegArgs()) == 2);
-		}
-	}
 }
 
 
@@ -7876,17 +7487,9 @@
 static void
 generateMissAbortTrampolines(void)
 {
-    sqInt numArgs;
-
-	for (numArgs = 0; numArgs <= ((numRegArgs()) + 1); numArgs += 1) {
-		methodAbortTrampolines[numArgs] = (genMethodAbortTrampolineFor(numArgs));
-	}
-	for (numArgs = 0; numArgs <= ((numRegArgs()) + 1); numArgs += 1) {
-		picAbortTrampolines[numArgs] = (genPICAbortTrampolineFor(numArgs));
-	}
-	for (numArgs = 0; numArgs <= ((numRegArgs()) + 1); numArgs += 1) {
-		picMissTrampolines[numArgs] = (genPICMissTrampolineFor(numArgs));
-	}
+	ceMethodAbortTrampoline = genMethodAbortTrampoline();
+	cePICAbortTrampoline = genPICAbortTrampoline();
+	ceCPICMissTrampoline = genTrampolineForcalledargarg(ceCPICMissreceiver, "ceCPICMissTrampoline", ClassReg, ReceiverResultReg);
 	;
 }
 
@@ -7946,9 +7549,6 @@
 }
 
 
-/*	Override to generate code to push the register arg(s) for <= numRegArg
-	arity sends.
- */
 /*	Slang needs these apparently superfluous asSymbol sends. */
 
 static void
@@ -7957,13 +7557,13 @@
     sqInt numArgs;
 
 	for (numArgs = 0; numArgs <= (NumSendTrampolines - 2); numArgs += 1) {
-		sendTrampolines[numArgs] = (genSendTrampolineFornumArgscalledargargargarg(ceSendsupertonumArgs, numArgs, trampolineNamenumArgs("ceSend", numArgs), ClassReg, 0, ReceiverResultReg, numArgs));
+		sendTrampolines[numArgs] = (genTrampolineForcalledargargargarg(ceSendsupertonumArgs, trampolineNamenumArgs("ceSend", numArgs), ClassReg, 0, ReceiverResultReg, numArgs));
 	}
-	sendTrampolines[NumSendTrampolines - 1] = (genSendTrampolineFornumArgscalledargargargarg(ceSendsupertonumArgs, (numRegArgs()) + 1, trampolineNamenumArgs("ceSend", -1), ClassReg, 0, ReceiverResultReg, SendNumArgsReg));
+	sendTrampolines[NumSendTrampolines - 1] = (genTrampolineForcalledargargargarg(ceSendsupertonumArgs, trampolineNamenumArgs("ceSend", -1), ClassReg, 0, ReceiverResultReg, SendNumArgsReg));
 	for (numArgs = 0; numArgs <= (NumSendTrampolines - 2); numArgs += 1) {
-		superSendTrampolines[numArgs] = (genSendTrampolineFornumArgscalledargargargarg(ceSendsupertonumArgs, numArgs, trampolineNamenumArgs("ceSuperSend", numArgs), ClassReg, 1, ReceiverResultReg, numArgs));
+		superSendTrampolines[numArgs] = (genTrampolineForcalledargargargarg(ceSendsupertonumArgs, trampolineNamenumArgs("ceSuperSend", numArgs), ClassReg, 1, ReceiverResultReg, numArgs));
 	}
-	superSendTrampolines[NumSendTrampolines - 1] = (genSendTrampolineFornumArgscalledargargargarg(ceSendsupertonumArgs, (numRegArgs()) + 1, trampolineNamenumArgs("ceSuperSend", -1), ClassReg, 1, ReceiverResultReg, SendNumArgsReg));
+	superSendTrampolines[NumSendTrampolines - 1] = (genTrampolineForcalledargargargarg(ceSendsupertonumArgs, trampolineNamenumArgs("ceSuperSend", -1), ClassReg, 1, ReceiverResultReg, SendNumArgsReg));
 	firstSend = sendTrampolines[0];
 	lastSend = superSendTrampolines[NumSendTrampolines - 1];
 }
@@ -8003,7 +7603,7 @@
 {
 	ceTraceLinkedSendTrampoline = genSafeTrampolineForcalledarg(ceTraceLinkedSend, "ceTraceLinkedSendTrampoline", ReceiverResultReg);
 	ceTraceBlockActivationTrampoline = genTrampolineForcalled(ceTraceBlockActivation, "ceTraceBlockActivationTrampoline");
-	ceTraceStoreTrampoline = genSafeTrampolineForcalledargarg(ceTraceStoreOfinto, "ceTraceStoreTrampoline", TempReg, ReceiverResultReg);
+	ceTraceStoreTrampoline = genSafeTrampolineForcalledargarg(ceTraceStoreOfinto, "ceTraceStoreTrampoline", ClassReg, ReceiverResultReg);
 }
 
 
@@ -8473,7 +8073,6 @@
 static sqInt
 genJumpBackTo(sqInt targetBytecodePC)
 {
-	ssFlushTo(simStackPtr);
 	gMoveAwR(stackLimitAddress(), TempReg);
 	gCmpRR(TempReg, SPReg);
 	gJumpAboveOrEqual(fixupAt(targetBytecodePC - initialPC));
@@ -8530,25 +8129,19 @@
 	return jumpToTarget;
 }
 
+
+/*	Cunning trick by LPD. If true and false are contiguous subtract the
+	smaller. Correct result is either 0 or the distance between them. If
+	result is not 0 or
+	their distance send mustBeBoolean. */
+
 static sqInt
 genJumpIfto(sqInt boolean, sqInt targetBytecodePC)
 {
-    CogSimStackEntry *desc;
     AbstractInstruction *ok;
 
-	ssFlushTo(simStackPtr - 1);
-	desc = ssTop();
-	ssPop(1);
-	if ((((desc->type)) == SSConstant)
-	 && ((((desc->constant)) == (trueObject()))
- || (((desc->constant)) == (falseObject())))) {
-		annotateBytecode((((desc->constant)) == boolean
-			? gJump(ensureFixupAt(targetBytecodePC - initialPC))
-			: gLabel()));
-		return 0;
-	}
-	popToReg(desc, TempReg);
 	assert((objectAfter(falseObject())) == (trueObject()));
+	gPopR(TempReg);
 	annotateobjRef(gSubCwR(boolean, TempReg), boolean);
 	gJumpZero(ensureFixupAt(targetBytecodePC - initialPC));
 	gCmpCqR((boolean == (falseObject())
@@ -8579,7 +8172,6 @@
 static sqInt
 genJumpTo(sqInt targetBytecodePC)
 {
-	ssFlushTo(simStackPtr);
 	gJump(ensureFixupAt(targetBytecodePC - initialPC));
 	return 0;
 }
@@ -8676,39 +8268,7 @@
 	return genJumpTo(targetpc);
 }
 
-static sqInt
-genMarshalledSendSupernumArgs(sqInt selector, sqInt numArgs)
-{
-	if (isYoung(selector)) {
-		hasYoungReferent = 1;
-	}
-	assert(needsFrame);
-	if (numArgs > 2) {
-		gMoveCqR(numArgs, SendNumArgsReg);
-	}
-	gMoveCwR(selector, ClassReg);
-	CallSend(superSendTrampolines[((numArgs < (NumSendTrampolines - 1)) ? numArgs : (NumSendTrampolines - 1))]);
-	(optStatus.isReceiverResultRegLive = 0);
-	return ssPushRegister(ReceiverResultReg);
-}
 
-static sqInt
-genMarshalledSendnumArgs(sqInt selector, sqInt numArgs)
-{
-	if (isYoung(selector)) {
-		hasYoungReferent = 1;
-	}
-	assert(needsFrame);
-	if (numArgs > 2) {
-		gMoveCqR(numArgs, SendNumArgsReg);
-	}
-	gMoveCwR(selector, ClassReg);
-	CallSend(sendTrampolines[((numArgs < (NumSendTrampolines - 1)) ? numArgs : (NumSendTrampolines - 1))]);
-	(optStatus.isReceiverResultRegLive = 0);
-	return ssPushRegister(ReceiverResultReg);
-}
-
-
 /*	Generate the abort for a method. This abort performs either a call of
 	ceSICMiss: to handle a single-in-line cache miss or a call of
 	ceStackOverflow: to handle a
@@ -8720,7 +8280,7 @@
 	miss.  */
 
 static sqInt
-genMethodAbortTrampolineFor(sqInt numArgs)
+genMethodAbortTrampoline(void)
 {
     AbstractInstruction *jumpSICMiss;
 
@@ -8729,10 +8289,7 @@
 	jumpSICMiss = gJumpNonZero(0);
 	compileTrampolineForcallJumpBarnumArgsargargargargsaveRegsresultReg(ceStackOverflow, 1, 1, SendNumArgsReg, null, null, null, 0, null);
 	jmpTarget(jumpSICMiss, gLabel());
-	genPushRegisterArgsForAbortMissNumArgs(numArgs);
-	return genTrampolineForcalledcallJumpBarnumArgsargargargargsaveRegsresultRegappendOpcodes(ceSICMiss, trampolineNamenumArgs("ceMethodAbort", (numArgs <= (numRegArgs())
-		? numArgs
-		: -1)), 1, 1, ReceiverResultReg, null, null, null, 0, null, 1);
+	return genTrampolineForcalledcallJumpBarnumArgsargargargargsaveRegsresultRegappendOpcodes(ceSICMiss, "ceMethodAbort", 1, 1, ReceiverResultReg, null, null, null, 0, null, 1);
 }
 
 static void
@@ -8785,71 +8342,62 @@
 	ClassReg. If the register is zero then this is an MNU. */
 
 static sqInt
-genPICAbortTrampolineFor(sqInt numArgs)
+genPICAbortTrampoline(void)
 {
 	opcodeIndex = 0;
-	genPushRegisterArgsForAbortMissNumArgs(numArgs);
-	return genInnerPICAbortTrampoline(trampolineNamenumArgs("cePICAbort", (numArgs <= (numRegArgs())
-		? numArgs
-		: -1)));
+	return genInnerPICAbortTrampoline("cePICAbort");
 }
 
 static sqInt
-genPICMissTrampolineFor(sqInt numArgs)
-{
-    sqInt startAddress;
-
-	startAddress = methodZoneBase;
-
-	/* N.B. a closed PIC jumps to the miss routine, not calls it, so there is only one retpc on the stack. */
-
-	opcodeIndex = 0;
-	genPushRegisterArgsForNumArgs(numArgs);
-	genTrampolineForcalledcallJumpBarnumArgsargargargargsaveRegsresultRegappendOpcodes(ceCPICMissreceiver, trampolineNamenumArgs("cePICMiss", (numArgs <= (numRegArgs())
-		? numArgs
-		: -1)), 1, 2, ClassReg, ReceiverResultReg, null, null, 0, null, 1);
-	return startAddress;
-}
-
-static sqInt
 genPopStackBytecode(void)
 {
-	if ((ssTop()->spilled)) {
-		gAddCqR(BytesPerWord, SPReg);
-	}
-	ssPop(1);
+	gAddCqR(BytesPerWord, SPReg);
 	return 0;
 }
 
+
+/*	Stack looks like
+	receiver (also in ResultReceiverReg)
+	arg
+	return address */
+
 static sqInt
 genPrimitiveAdd(void)
 {
     AbstractInstruction *jumpNotSI;
     AbstractInstruction *jumpOvfl;
 
-	gMoveRR(Arg0Reg, TempReg);
-	gMoveRR(Arg0Reg, ClassReg);
+	gMoveMwrR(BytesPerWord, SPReg, TempReg);
+	gMoveRR(TempReg, ClassReg);
 	jumpNotSI = genJumpNotSmallIntegerInScratchReg(TempReg);
 	genRemoveSmallIntegerTagsInScratchReg(ClassReg);
-	gAddRR(ReceiverResultReg, ClassReg);
+	gMoveRR(ReceiverResultReg, TempReg);
+	gAddRR(ClassReg, TempReg);
 	jumpOvfl = gJumpOverflow(0);
-	gMoveRR(ClassReg, ReceiverResultReg);
-	gRetN(0);
+	gMoveRR(TempReg, ReceiverResultReg);
+	flag("currently caller pushes result");
+	gRetN(BytesPerWord * 2);
 	jmpTarget(jumpOvfl, jmpTarget(jumpNotSI, gLabel()));
 	return 0;
 }
 
+
+/*	Stack looks like
+	receiver (also in ResultReceiverReg)
+	return address */
+
 static sqInt
 genPrimitiveAsFloat(void)
 {
     AbstractInstruction *jumpFailAlloc;
 
-	gMoveRR(ReceiverResultReg, TempReg);
-	genConvertSmallIntegerToIntegerInScratchReg(TempReg);
-	gConvertRRd(TempReg, DPFPReg0);
+	gMoveRR(ReceiverResultReg, ClassReg);
+	genConvertSmallIntegerToIntegerInScratchReg(ClassReg);
+	gConvertRRd(ClassReg, DPFPReg0);
 	jumpFailAlloc = genAllocFloatValueintoscratchRegscratchReg(DPFPReg0, SendNumArgsReg, ClassReg, TempReg);
 	gMoveRR(SendNumArgsReg, ReceiverResultReg);
-	gRetN(0);
+	flag("currently caller pushes result");
+	gRetN(BytesPerWord);
 	jmpTarget(jumpFailAlloc, gLabel());
 	compileInterpreterPrimitive(functionPointerForCompiledMethodprimitiveIndex(methodObj, primitiveIndex));
 	return 0;
@@ -8858,8 +8406,8 @@
 static sqInt
 genPrimitiveAt(void)
 {
-	assert((numRegArgs()) >= 1);
-	return genInnerPrimitiveAt(0);
+	gMoveMwrR(BytesPerWord, SPReg, Arg0Reg);
+	return genInnerPrimitiveAt(BytesPerWord * 2);
 }
 
 static sqInt
@@ -8867,13 +8415,15 @@
 {
     AbstractInstruction *jumpNotSI;
 
-	gMoveRR(Arg0Reg, TempReg);
+	gMoveMwrR(BytesPerWord, SPReg, TempReg);
+	gMoveRR(TempReg, ClassReg);
 
-	/* Whether the SmallInteger tags are zero or non-zero, oring them together will preserve them. */
+	/* Whether the SmallInteger tags are zero or non-zero, anding them together will preserve them. */
 
 	jumpNotSI = genJumpNotSmallIntegerInScratchReg(TempReg);
-	gAndRR(Arg0Reg, ReceiverResultReg);
-	gRetN(0);
+	gAndRR(ClassReg, ReceiverResultReg);
+	flag("currently caller pushes result");
+	gRetN(BytesPerWord * 2);
 	jmpTarget(jumpNotSI, gLabel());
 	return 0;
 }
@@ -8883,23 +8433,26 @@
 {
     AbstractInstruction *jumpNotSI;
 
-	gMoveRR(Arg0Reg, TempReg);
+	gMoveMwrR(BytesPerWord, SPReg, TempReg);
+	gMoveRR(TempReg, ClassReg);
 
 	/* Whether the SmallInteger tags are zero or non-zero, oring them together will preserve them. */
 
 	jumpNotSI = genJumpNotSmallIntegerInScratchReg(TempReg);
-	gOrRR(Arg0Reg, ReceiverResultReg);
-	gRetN(0);
+	gOrRR(ClassReg, ReceiverResultReg);
+	flag("currently caller pushes result");
+	gRetN(BytesPerWord * 2);
 	jmpTarget(jumpNotSI, gLabel());
 	return 0;
 }
 
 
-/*	Receiver and arg in registers.
-	Stack looks like
+/*	Stack looks like
+	receiver (also in ResultReceiverReg)
+	arg
 	return address
 	
-	rTemp := rArg0
+	rTemp := ArgOffset(SP)
 	rClass := tTemp
 	rTemp := rTemp & 1
 	jz nonInt
@@ -8941,9 +8494,8 @@
     AbstractInstruction *jumpOvfl;
     AbstractInstruction *jumpTooBig;
 
-	assert((numRegArgs()) >= 1);
-	gMoveRR(Arg0Reg, TempReg);
-	gMoveRR(Arg0Reg, ClassReg);
+	gMoveMwrR(BytesPerWord, SPReg, TempReg);
+	gMoveRR(TempReg, ClassReg);
 	jumpNotSI = genJumpNotSmallIntegerInScratchReg(TempReg);
 	genConvertSmallIntegerToIntegerInScratchReg(ClassReg);
 	if (!(setsConditionCodesFor(lastOpcode(), JumpNegative))) {
@@ -8960,14 +8512,14 @@
 	genRemoveSmallIntegerTagsInScratchReg(ReceiverResultReg);
 	gLogicalShiftLeftRR(ClassReg, ReceiverResultReg);
 	genAddSmallIntegerTagsTo(ReceiverResultReg);
-	gRetN(0);
+	gRetN(BytesPerWord * 2);
 	jmpTarget(jumpNegative, gNegateR(ClassReg));
 	gCmpCqR(numSmallIntegerBits(), ClassReg);
 	jumpInRange = gJumpLessOrEqual(0);
 	gMoveCqR(numSmallIntegerBits(), ClassReg);
 	jmpTarget(jumpInRange, gArithmeticShiftRightRR(ClassReg, ReceiverResultReg));
 	genSetSmallIntegerTagsIn(ReceiverResultReg);
-	gRetN(0);
+	gRetN(BytesPerWord * 2);
 	jmpTarget(jumpNotSI, jmpTarget(jumpTooBig, jmpTarget(jumpOvfl, gLabel())));
 	return 0;
 }
@@ -8977,14 +8529,16 @@
 {
     AbstractInstruction *jumpNotSI;
 
-	gMoveRR(Arg0Reg, TempReg);
+	gMoveMwrR(BytesPerWord, SPReg, TempReg);
+	gMoveRR(TempReg, ClassReg);
 
 	/* Clear one or the other tag so that xoring will preserve them. */
 
 	jumpNotSI = genJumpNotSmallIntegerInScratchReg(TempReg);
-	genRemoveSmallIntegerTagsInScratchReg(Arg0Reg);
-	gXorRR(Arg0Reg, ReceiverResultReg);
-	gRetN(0);
+	genRemoveSmallIntegerTagsInScratchReg(ClassReg);
+	gXorRR(ClassReg, ReceiverResultReg);
+	flag("currently caller pushes result");
+	gRetN(BytesPerWord * 2);
 	jmpTarget(jumpNotSI, gLabel());
 	return 0;
 }
@@ -8996,13 +8550,6 @@
 	block entry or the no-context-switch entry, as appropriate, and we're
 	done. If not,
 	invoke the interpreter primitive. */
-/*	Check the argument count. Fail if wrong.
-	Get the method from the outerContext and see if it is cogged. If so, jump
-	to the
-	block entry or the no-context-switch entry, as appropriate, and we're
-	done. If not,
-	invoke the interpreter primitive.
-	Override to push the register args first. */
 
 static sqInt
 genPrimitiveClosureValue(void)
@@ -9012,7 +8559,6 @@
     void (*primitiveRoutine)();
     sqInt result;
 
-	genPushRegisterArgs();
 	genLoadSlotsourceRegdestReg(ClosureNumArgsIndex, ReceiverResultReg, TempReg);
 	gCmpCqR(((methodOrBlockNumArgs << 1) | 1), TempReg);
 	jumpFail = gJumpNonZero(0);
@@ -9045,9 +8591,9 @@
     AbstractInstruction *jumpSameSign;
     AbstractInstruction *jumpZero;
 
-	gMoveRR(Arg0Reg, TempReg);
-	gMoveRR(Arg0Reg, ClassReg);
-	gMoveRR(Arg0Reg, Arg1Reg);
+	gMoveMwrR(BytesPerWord, SPReg, TempReg);
+	gMoveRR(TempReg, ClassReg);
+	gMoveRR(TempReg, Arg1Reg);
 
 	/* We must shift away the tags, not just subtract them, so that the
 	 overflow case doesn't actually overflow the machine instruction. */
@@ -9075,7 +8621,8 @@
 	jmpTarget(jumpSameSign, convert = gLabel());
 	genConvertIntegerToSmallIntegerInScratchReg(TempReg);
 	gMoveRR(TempReg, ReceiverResultReg);
-	gRetN(0);
+	flag("currently caller pushes result");
+	gRetN(BytesPerWord * 2);
 	jmpTarget(jumpExact, gCmpCqR(1 << ((numSmallIntegerBits()) - 1), TempReg));
 	gJumpLess(convert);
 	jmpTarget(jumpZero, jmpTarget(jumpNotSI, gLabel()));
@@ -9090,8 +8637,8 @@
     AbstractInstruction *jumpOverflow;
     AbstractInstruction *jumpZero;
 
-	gMoveRR(Arg0Reg, TempReg);
-	gMoveRR(Arg0Reg, ClassReg);
+	gMoveMwrR(BytesPerWord, SPReg, TempReg);
+	gMoveRR(TempReg, ClassReg);
 
 	/* We must shift away the tags, not just subtract them, so that the
 	 overflow case doesn't actually overflow the machine instruction. */
@@ -9111,7 +8658,8 @@
 	jumpOverflow = gJumpGreaterOrEqual(0);
 	genConvertIntegerToSmallIntegerInScratchReg(TempReg);
 	gMoveRR(TempReg, ReceiverResultReg);
-	gRetN(0);
+	flag("currently caller pushes result");
+	gRetN(BytesPerWord * 2);
 	jmpTarget(jumpOverflow, jmpTarget(jumpInexact, jmpTarget(jumpZero, jmpTarget(jumpNotSI, gLabel()))));
 	return 0;
 }
@@ -9123,8 +8671,9 @@
 }
 
 
-/*	Receiver and arg in registers.
-	Stack looks like
+/*	Stack looks like
+	receiver (also in ResultReceiverReg)
+	arg
 	return address */
 
 static sqInt
@@ -9132,12 +8681,14 @@
 {
     AbstractInstruction *jumpFalse;
 
-	gCmpRR(Arg0Reg, ReceiverResultReg);
+	gMoveMwrR(BytesPerWord, SPReg, TempReg);
+	gCmpRR(TempReg, ReceiverResultReg);
 	jumpFalse = gJumpNonZero(0);
 	annotateobjRef(gMoveCwR(trueObject(), ReceiverResultReg), trueObject());
-	gRetN(0);
+	flag("currently caller pushes result");
+	gRetN(BytesPerWord * 2);
 	jmpTarget(jumpFalse, annotateobjRef(gMoveCwR(falseObject(), ReceiverResultReg), falseObject()));
-	gRetN(0);
+	gRetN(BytesPerWord * 2);
 	return 0;
 }
 
@@ -9195,6 +8746,11 @@
 	return genDoubleComparisoninvert(gJumpFPNotEqual, 0);
 }
 
+
+/*	Stack looks like
+	receiver (also in ResultReceiverReg)
+	return address */
+
 static sqInt
 genPrimitiveFloatSquareRoot(void)
 {
@@ -9204,7 +8760,8 @@
 	gSqrtRd(DPFPReg0);
 	jumpFailAlloc = genAllocFloatValueintoscratchRegscratchReg(DPFPReg0, SendNumArgsReg, ClassReg, TempReg);
 	gMoveRR(SendNumArgsReg, ReceiverResultReg);
-	gRetN(0);
+	flag("currently caller pushes result");
+	gRetN(BytesPerWord);
 	jmpTarget(jumpFailAlloc, gLabel());
 	compileInterpreterPrimitive(functionPointerForCompiledMethodprimitiveIndex(methodObj, primitiveIndex));
 	return 0;
@@ -9237,7 +8794,8 @@
 	jumpSI = genJumpSmallIntegerInScratchReg(ClassReg);
 	genGetHashFieldNonIntOfasSmallIntegerInto(ReceiverResultReg, TempReg);
 	gMoveRR(TempReg, ReceiverResultReg);
-	gRetN(0);
+	flag("currently caller pushes result");
+	gRetN(BytesPerWord);
 	jmpTarget(jumpSI, gLabel());
 	return 0;
 }
@@ -9262,8 +8820,8 @@
     AbstractInstruction *jumpSameSign;
     AbstractInstruction *jumpZero;
 
-	gMoveRR(Arg0Reg, TempReg);
-	gMoveRR(Arg0Reg, ClassReg);
+	gMoveMwrR(BytesPerWord, SPReg, TempReg);
+	gMoveRR(TempReg, ClassReg);
 	jumpNotSI = genJumpNotSmallIntegerInScratchReg(TempReg);
 	genRemoveSmallIntegerTagsInScratchReg(ClassReg);
 	jumpZero = gJumpZero(0);
@@ -9286,7 +8844,8 @@
 	jmpTarget(jumpSameSign, jmpTarget(jumpExact, gLabel()));
 	genSetSmallIntegerTagsIn(ClassReg);
 	gMoveRR(ClassReg, ReceiverResultReg);
-	gRetN(0);
+	flag("currently caller pushes result");
+	gRetN(BytesPerWord * 2);
 	jmpTarget(jumpZero, jmpTarget(jumpNotSI, gLabel()));
 	return 0;
 }
@@ -9297,17 +8856,18 @@
     AbstractInstruction *jumpNotSI;
     AbstractInstruction *jumpOvfl;
 
-	gMoveRR(Arg0Reg, TempReg);
-	gMoveRR(Arg0Reg, ClassReg);
-	gMoveRR(ReceiverResultReg, Arg1Reg);
+	gMoveMwrR(BytesPerWord, SPReg, TempReg);
+	gMoveRR(TempReg, ClassReg);
 	jumpNotSI = genJumpNotSmallIntegerInScratchReg(TempReg);
 	genShiftAwaySmallIntegerTagsInScratchReg(ClassReg);
-	genRemoveSmallIntegerTagsInScratchReg(Arg1Reg);
-	gMulRR(Arg1Reg, ClassReg);
+	gMoveRR(ReceiverResultReg, TempReg);
+	genRemoveSmallIntegerTagsInScratchReg(TempReg);
+	gMulRR(TempReg, ClassReg);
 	jumpOvfl = gJumpOverflow(0);
 	genSetSmallIntegerTagsIn(ClassReg);
 	gMoveRR(ClassReg, ReceiverResultReg);
-	gRetN(0);
+	flag("currently caller pushes result");
+	gRetN(BytesPerWord * 2);
 	jmpTarget(jumpOvfl, jmpTarget(jumpNotSI, gLabel()));
 	return 0;
 }
@@ -9325,8 +8885,8 @@
     AbstractInstruction *jumpOverflow;
     AbstractInstruction *jumpZero;
 
-	gMoveRR(Arg0Reg, TempReg);
-	gMoveRR(Arg0Reg, ClassReg);
+	gMoveMwrR(BytesPerWord, SPReg, TempReg);
+	gMoveRR(TempReg, ClassReg);
 
 	/* We must shift away the tags, not just subtract them, so that the
 	 overflow case doesn't actually overflow the machine instruction. */
@@ -9344,7 +8904,8 @@
 	jumpOverflow = gJumpGreaterOrEqual(0);
 	genConvertIntegerToSmallIntegerInScratchReg(TempReg);
 	gMoveRR(TempReg, ReceiverResultReg);
-	gRetN(0);
+	flag("currently caller pushes result");
+	gRetN(BytesPerWord * 2);
 	jmpTarget(jumpOverflow, jmpTarget(jumpZero, jmpTarget(jumpNotSI, gLabel())));
 	return 0;
 }
@@ -9352,30 +8913,38 @@
 static sqInt
 genPrimitiveSize(void)
 {
-	return genInnerPrimitiveSize(0);
+	return genInnerPrimitiveSize(BytesPerWord);
 }
 
 static sqInt
 genPrimitiveStringAt(void)
 {
-	assert((numRegArgs()) >= 1);
-	return genInnerPrimitiveStringAt(0);
+	gMoveMwrR(BytesPerWord, SPReg, Arg0Reg);
+	return genInnerPrimitiveStringAt(BytesPerWord * 2);
 }
 
+
+/*	Stack looks like
+	receiver (also in ResultReceiverReg)
+	arg
+	return address */
+
 static sqInt
 genPrimitiveSubtract(void)
 {
     AbstractInstruction *jumpNotSI;
     AbstractInstruction *jumpOvfl;
 
-	gMoveRR(Arg0Reg, TempReg);
+	gMoveMwrR(BytesPerWord, SPReg, TempReg);
+	gMoveRR(TempReg, ClassReg);
 	jumpNotSI = genJumpNotSmallIntegerInScratchReg(TempReg);
 	gMoveRR(ReceiverResultReg, TempReg);
-	gSubRR(Arg0Reg, TempReg);
+	gSubRR(ClassReg, TempReg);
 	jumpOvfl = gJumpOverflow(0);
 	genAddSmallIntegerTagsTo(TempReg);
 	gMoveRR(TempReg, ReceiverResultReg);
-	gRetN(0);
+	flag("currently caller pushes result");
+	gRetN(BytesPerWord * 2);
 	jmpTarget(jumpOvfl, jmpTarget(jumpNotSI, gLabel()));
 	return 0;
 }
@@ -9449,10 +9018,9 @@
 genPushActiveContextBytecode(void)
 {
 	assert(needsFrame);
-	(optStatus.isReceiverResultRegLive = 0);
-	ssAllocateCallReg(ReceiverResultReg);
 	CallRT(cePushActiveContextTrampoline);
-	return ssPushRegister(ReceiverResultReg);
+	gPushR(ReceiverResultReg);
+	return 0;
 }
 
 
@@ -9486,18 +9054,18 @@
 
 	assert(needsFrame);
 	addBlockStartAtnumArgsnumCopiedspan(bytecodePointer + 4, byte1 & 15, numCopied = ((usqInt) byte1) >> 4, (byte2 << 8) + byte3);
-	if (numCopied > 0) {
-		ssFlushTo(simStackPtr);
-	}
-	(optStatus.isReceiverResultRegLive = 0);
-	ssAllocateCallRegand(SendNumArgsReg, ReceiverResultReg);
 	gMoveCqR(byte1 | ((bytecodePointer + 5) << 8), SendNumArgsReg);
 	CallRT(ceClosureCopyTrampoline);
 	if (numCopied > 0) {
-		gAddCqR(numCopied * BytesPerWord, SPReg);
-		ssPop(numCopied);
+		if (numCopied > 1) {
+			gAddCqR((numCopied - 1) * BytesPerWord, SPReg);
+		}
+		gMoveRMwr(ReceiverResultReg, 0, SPReg);
 	}
-	return ssPushRegister(ReceiverResultReg);
+	else {
+		gPushR(ReceiverResultReg);
+	}
+	return 0;
 }
 
 static sqInt
@@ -9546,25 +9114,22 @@
 genPushLiteralVariable(sqInt literalIndex)
 {
     sqInt association;
-    sqInt freeReg;
 
-	freeReg = ssAllocatePreferredReg(ClassReg);
 
 	/* N.B. Do _not_ use ReceiverResultReg to avoid overwriting receiver in assignment in frameless methods. */
-	/* So far descriptors are not rich enough to describe the entire dereference so generate the register
-	 load but don't push the result.  There is an order-or-evaluation issue if we defer the dereference. */
 
 	association = literalofMethod(literalIndex, methodObj);
-	annotateobjRef(gMoveCwR(association, TempReg), association);
-	genLoadSlotsourceRegdestReg(ValueIndex, TempReg, freeReg);
-	ssPushRegister(freeReg);
+	annotateobjRef(gMoveCwR(association, ClassReg), association);
+	genLoadSlotsourceRegdestReg(ValueIndex, ClassReg, TempReg);
+	gPushR(TempReg);
 	return 0;
 }
 
 static sqInt
 genPushLiteral(sqInt literal)
 {
-	return ssPushConstant(literal);
+	annotateobjRef(gPushCw(literal), literal);
+	return 0;
 }
 
 static sqInt
@@ -9574,16 +9139,14 @@
     AbstractInstruction *jmpSingle;
 
 	assert(needsFrame);
-	ssAllocateCallRegand(ReceiverResultReg, SendNumArgsReg);
-	ensureReceiverResultRegContainsSelf();
-	if ((registerMaskFor(ReceiverResultReg)) & callerSavedRegMask) {
-		(optStatus.isReceiverResultRegLive = 0);
-	}
 	if (slotIndex == InstructionPointerIndex) {
+		gMoveMwrR(FoxMFReceiver, FPReg, ReceiverResultReg);
 		gMoveCqR(slotIndex, SendNumArgsReg);
 		CallRT(ceFetchContextInstVarTrampoline);
-		return ssPushRegister(SendNumArgsReg);
+		gPushR(SendNumArgsReg);
+		return 0;
 	}
+	gMoveMwrR(FoxMFReceiver, FPReg, ReceiverResultReg);
 	genLoadSlotsourceRegdestReg(SenderIndex, ReceiverResultReg, TempReg);
 	jmpSingle = genJumpNotSmallIntegerInScratchReg(TempReg);
 	gMoveCqR(slotIndex, SendNumArgsReg);
@@ -9591,8 +9154,8 @@
 	jmpDone = gJump(0);
 	jmpTarget(jmpSingle, gLabel());
 	genLoadSlotsourceRegdestReg(slotIndex, ReceiverResultReg, SendNumArgsReg);
-	jmpTarget(jmpDone, gLabel());
-	return ssPushRegister(SendNumArgsReg);
+	jmpTarget(jmpDone, gPushR(SendNumArgsReg));
+	return 0;
 }
 
 static sqInt
@@ -9603,13 +9166,7 @@
     sqInt size;
 
 	assert(needsFrame);
-	(optStatus.isReceiverResultRegLive = 0);
-	if ((popValues = byte1 > 127)) {
-		ssFlushTo(simStackPtr);
-	}
-	else {
-		ssAllocateCallRegand(SendNumArgsReg, ReceiverResultReg);
-	}
+	popValues = byte1 > 127;
 	size = byte1 & 127;
 	gMoveCqR(size, SendNumArgsReg);
 	CallRT(ceCreateNewArrayTrampoline);
@@ -9618,9 +9175,9 @@
 			gPopR(TempReg);
 			genStoreSourceRegslotIndexintoNewObjectInDestReg(TempReg, i, ReceiverResultReg);
 		}
-		ssPop(size);
 	}
-	return ssPushRegister(ReceiverResultReg);
+	gPushR(ReceiverResultReg);
+	return 0;
 }
 
 static sqInt
@@ -9632,7 +9189,14 @@
 static sqInt
 genPushReceiverBytecode(void)
 {
-	return ssPushDesc(simSelf);
+	if (needsFrame) {
+		gMoveMwrR(FoxMFReceiver, FPReg, TempReg);
+		gPushR(TempReg);
+	}
+	else {
+		gPushR(ReceiverResultReg);
+	}
+	return 0;
 }
 
 static sqInt
@@ -9644,113 +9208,26 @@
 static sqInt
 genPushReceiverVariable(sqInt index)
 {
-	ensureReceiverResultRegContainsSelf();
-	return genSSPushSlotreg(index, ReceiverResultReg);
-}
+    sqInt maybeErr;
 
-
-/*	Ensure that the register args are pushed before the retpc for methods with
-	arity <= self numRegArgs.
- */
-/*	This won't be as clumsy on a RISC. But putting the receiver and
-	args above the return address means the CoInterpreter has a
-	single machine-code frame format which saves us a lot of work. */
-
-static void
-genPushRegisterArgs(void)
-{
-	if (!(regArgsHaveBeenPushed
-		 || (methodOrBlockNumArgs > (numRegArgs())))) {
-		genPushRegisterArgsForNumArgs(methodOrBlockNumArgs);
-		regArgsHaveBeenPushed = 1;
+	if (needsFrame) {
+		gMoveMwrR(FoxMFReceiver, FPReg, ReceiverResultReg);
 	}
-}
-
-
-/*	Ensure that the register args are pushed before the outer and
-	inner retpcs at an entry miss for arity <= self numRegArgs. The
-	outer retpc is that of a call at a send site. The inner is the call
-	from a method or PIC abort/miss to the trampoline. */
-/*	This won't be as clumsy on a RISC. But putting the receiver and
-	args above the return address means the CoInterpreter has a
-	single machine-code frame format which saves us a lot of work. */
-/*	Iff there are register args convert
-	base	->	outerRetpc		(send site retpc)
-	sp		->	innerRetpc		(PIC abort/miss retpc)
-	to
-	base	->	receiver
-	(arg0)
-	(arg1)
-	outerRetpc
-	sp		->	innerRetpc		(PIC abort/miss retpc) */
-
-static void
-genPushRegisterArgsForAbortMissNumArgs(sqInt numArgs)
-{
-	if (numArgs <= (numRegArgs())) {
-		assert((numRegArgs()) <= 2);
-		if (numArgs == 0) {
-			gMoveMwrR(0, SPReg, TempReg);
-			gPushR(TempReg);
-			gMoveMwrR(BytesPerWord * 2, SPReg, TempReg);
-			gMoveRMwr(TempReg, BytesPerWord, SPReg);
-			gMoveRMwr(ReceiverResultReg, 2 * BytesPerWord, SPReg);
-			return;
-		}
-		if (numArgs == 1) {
-			gMoveMwrR(BytesPerWord, SPReg, TempReg);
-			gPushR(TempReg);
-			gMoveMwrR(BytesPerWord, SPReg, TempReg);
-			gPushR(TempReg);
-			gMoveRMwr(ReceiverResultReg, 3 * BytesPerWord, SPReg);
-			gMoveRMwr(Arg0Reg, 2 * BytesPerWord, SPReg);
-			return;
-		}
-		if (numArgs == 2) {
-			gPushR(Arg1Reg);
-			gMoveMwrR(BytesPerWord * 2, SPReg, TempReg);
-			gPushR(TempReg);
-			gMoveMwrR(BytesPerWord * 2, SPReg, TempReg);
-			gPushR(TempReg);
-			gMoveRMwr(ReceiverResultReg, 4 * BytesPerWord, SPReg);
-			gMoveRMwr(Arg0Reg, 3 * BytesPerWord, SPReg);
-			return;
-		}
+	maybeErr = genLoadSlotsourceRegdestReg(index, ReceiverResultReg, TempReg);
+	if (maybeErr < 0) {
+		return maybeErr;
 	}
+	gPushR(TempReg);
+	return 0;
 }
 
-
-/*	Ensure that the register args are pushed before the retpc for arity <=
-	self numRegArgs.
- */
-/*	This won't be as clumsy on a RISC. But putting the receiver and
-	args above the return address means the CoInterpreter has a
-	single machine-code frame format which saves us a lot of work. */
-
-static void
-genPushRegisterArgsForNumArgs(sqInt numArgs)
-{
-	if (numArgs <= (numRegArgs())) {
-		gMoveMwrR(0, SPReg, TempReg);
-		gMoveRMwr(ReceiverResultReg, 0, SPReg);
-		assert((numRegArgs()) <= 2);
-		if (numArgs > 0) {
-			gPushR(Arg0Reg);
-			if (numArgs > 1) {
-				gPushR(Arg1Reg);
-			}
-		}
-		gPushR(TempReg);
-	}
-}
-
 static sqInt
 genPushRemoteTempLongBytecode(void)
 {
-	ssAllocateRequiredRegand(ClassReg, SendNumArgsReg);
 	gMoveMwrR(frameOffsetOfTemporary(byte2), FPReg, ClassReg);
-	genLoadSlotsourceRegdestReg(byte1, ClassReg, SendNumArgsReg);
-	return ssPushRegister(SendNumArgsReg);
+	genLoadSlotsourceRegdestReg(byte1, ClassReg, TempReg);
+	gPushR(TempReg);
+	return 0;
 }
 
 static sqInt
@@ -9762,7 +9239,9 @@
 static sqInt
 genPushTemporaryVariable(sqInt index)
 {
-	return ssPushDesc(simStack[index]);
+	gMoveMwrR(frameOffsetOfTemporary(index), FPReg, TempReg);
+	gPushR(TempReg);
+	return 0;
 }
 
 
@@ -9909,8 +9388,8 @@
 genReturnTopFromBlock(void)
 {
 	assert(inBlock);
-	popToReg(ssTop(), ReceiverResultReg);
-	ssPop(1);
+	flag("currently caller pushes result");
+	gPopR(ReceiverResultReg);
 	if (needsFrame) {
 		gMoveRR(FPReg, SPReg);
 		gPopR(FPReg);
@@ -9919,11 +9398,16 @@
 	return 0;
 }
 
+
+/*	Return pops receiver and arguments off the stack. Callee pushes the
+	result. 
+ */
+
 static sqInt
 genReturnTopFromMethod(void)
 {
-	popToReg(ssTop(), ReceiverResultReg);
-	ssPop(1);
+	flag("currently caller pushes result");
+	gPopR(ReceiverResultReg);
 	return genUpArrowReturn();
 }
 
@@ -10006,32 +9490,37 @@
 static sqInt
 genSendSupernumArgs(sqInt selector, sqInt numArgs)
 {
-	marshallSendArguments(numArgs);
-	return genMarshalledSendSupernumArgs(selector, numArgs);
+	assert(needsFrame);
+	if (isYoung(selector)) {
+		hasYoungReferent = 1;
+	}
+	gMoveMwrR(numArgs * BytesPerWord, SPReg, ReceiverResultReg);
+	if (numArgs > 2) {
+		gMoveCqR(numArgs, SendNumArgsReg);
+	}
+	gMoveCwR(selector, ClassReg);
+	CallSend(superSendTrampolines[((numArgs < (NumSendTrampolines - 1)) ? numArgs : (NumSendTrampolines - 1))]);
+	flag("currently caller pushes result");
+	gPushR(ReceiverResultReg);
+	return 0;
 }
 
-
-/*	Generate a trampoline with four arguments.
-	Hack: a negative value indicates an abstract register, a non-negative
-	value indicates a constant. */
-
 static sqInt
-genSendTrampolineFornumArgscalledargargargarg(void *aRoutine, sqInt numArgs, char *aString, sqInt regOrConst0, sqInt regOrConst1, sqInt regOrConst2, sqInt regOrConst3)
-{
-    sqInt startAddress;
-
-	startAddress = methodZoneBase;
-	opcodeIndex = 0;
-	genPushRegisterArgsForNumArgs(numArgs);
-	genTrampolineForcalledcallJumpBarnumArgsargargargargsaveRegsresultRegappendOpcodes(aRoutine, aString, 1, 4, regOrConst0, regOrConst1, regOrConst2, regOrConst3, 0, null, 1);
-	return startAddress;
-}
-
-static sqInt
 genSendnumArgs(sqInt selector, sqInt numArgs)
 {
-	marshallSendArguments(numArgs);
-	return genMarshalledSendnumArgs(selector, numArgs);
+	if (isYoung(selector)) {
+		hasYoungReferent = 1;
+	}
+	assert(needsFrame);
+	gMoveMwrR(numArgs * BytesPerWord, SPReg, ReceiverResultReg);
+	if (numArgs > 2) {
+		gMoveCqR(numArgs, SendNumArgsReg);
+	}
+	gMoveCwR(selector, ClassReg);
+	CallSend(sendTrampolines[((numArgs < (NumSendTrampolines - 1)) ? numArgs : (NumSendTrampolines - 1))]);
+	flag("currently caller pushes result");
+	gPushR(ReceiverResultReg);
+	return 0;
 }
 
 static sqInt
@@ -10063,367 +9552,55 @@
 	return genJumpTo(target);
 }
 
+
+/*	Stack looks like
+	receiver (also in ResultReceiverReg)
+	arg
+	return address */
+
 static sqInt
 genSmallIntegerComparison(sqInt jumpOpcode)
 {
     AbstractInstruction *jumpFail;
     AbstractInstruction *jumpTrue;
 
-	gMoveRR(Arg0Reg, TempReg);
+	gMoveMwrR(BytesPerWord, SPReg, TempReg);
+	gMoveRR(TempReg, ClassReg);
 	jumpFail = genJumpNotSmallIntegerInScratchReg(TempReg);
-	gCmpRR(Arg0Reg, ReceiverResultReg);
+	gCmpRR(ClassReg, ReceiverResultReg);
 	jumpTrue = gen(jumpOpcode);
 	annotateobjRef(gMoveCwR(falseObject(), ReceiverResultReg), falseObject());
-	gRetN(0);
+	flag("currently caller pushes result");
+	gRetN(BytesPerWord * 2);
 	jmpTarget(jumpTrue, annotateobjRef(gMoveCwR(trueObject(), ReceiverResultReg), trueObject()));
-	gRetN(0);
+	gRetN(BytesPerWord * 2);
 	jmpTarget(jumpFail, gLabel());
 	return 0;
 }
 
 static sqInt
-genSpecialSelectorArithmetic(void)
-{
-    sqInt argInt;
-    sqInt argIsInt;
-    AbstractInstruction *jumpContinue;
-    AbstractInstruction *jumpNotSmallInts;
-    BytecodeDescriptor *primDescriptor;
-    sqInt rcvrInt;
-    sqInt rcvrIsInt;
-    sqInt result;
-
-	primDescriptor = generatorAt(byte0);
-	argIsInt = (((ssTop()->type)) == SSConstant)
-	 && ((((argInt = (ssTop()->constant))) & 1));
-	rcvrIsInt = (((ssValue(1)->type)) == SSConstant)
-	 && ((((rcvrInt = (ssValue(1)->constant))) & 1));
-	if (argIsInt
-	 && (rcvrIsInt)) {
-		rcvrInt = (rcvrInt >> 1);
-		argInt = (argInt >> 1);
-		
-		switch ((primDescriptor->opcode)) {
-		case AddRR:
-						result = rcvrInt + argInt;
-			break;
-		case SubRR:
-						result = rcvrInt - argInt;
-			break;
-		case AndRR:
-						result = rcvrInt && argInt;
-			break;
-		case OrRR:
-						result = rcvrInt || argInt;
-			break;
-		default:
-			error("Case not found and no otherwise clause");
-		}
-		if (isIntegerValue(result)) {
-			annotateBytecode(gLabel());
-			return ssPop(2),ssPushConstant(((result << 1) | 1));
-		}
-		return genSpecialSelectorSend();
-	}
-	if (!(argIsInt
-		 || (rcvrIsInt))) {
-		return genSpecialSelectorSend();
-	}
-	if (argIsInt) {
-		ssFlushTo(simStackPtr - 2);
-		popToReg(ssValue(1), ReceiverResultReg);
-		ssPop(2);
-		gMoveRR(ReceiverResultReg, TempReg);
-	}
-	else {
-		marshallSendArguments(1);
-		gMoveRR(Arg0Reg, TempReg);
-		if (!(rcvrIsInt)) {
-			if (isSmallIntegerTagNonZero()) {
-				gAndRR(ReceiverResultReg, TempReg);
-			}
-			else {
-				gOrRR(ReceiverResultReg, TempReg);
-			}
-		}
-	}
-	jumpNotSmallInts = genJumpNotSmallIntegerInScratchReg(TempReg);
-	
-	switch ((primDescriptor->opcode)) {
-	case AddRR:
-				if (argIsInt) {
-			gAddCqR(argInt - ConstZero, ReceiverResultReg);
-
-			/* overflow; must undo the damage before continuing */
-
-			jumpContinue = gJumpNoOverflow(0);
-			gSubCqR(argInt - ConstZero, ReceiverResultReg);
-		}
-		else {
-			genRemoveSmallIntegerTagsInScratchReg(ReceiverResultReg);
-			gAddRR(Arg0Reg, ReceiverResultReg);
-
-			/* overflow; must undo the damage before continuing */
-
-			jumpContinue = gJumpNoOverflow(0);
-			if (rcvrIsInt) {
-				gMoveCqR(rcvrInt, ReceiverResultReg);
-			}
-			else {
-				gSubRR(Arg0Reg, ReceiverResultReg);
-				genSetSmallIntegerTagsIn(ReceiverResultReg);
-			}
-		}
-		break;
-	case SubRR:
-				if (argIsInt) {
-			gSubCqR(argInt - ConstZero, ReceiverResultReg);
-
-			/* overflow; must undo the damage before continuing */
-
-			jumpContinue = gJumpNoOverflow(0);
-			gAddCqR(argInt - ConstZero, ReceiverResultReg);
-		}
-		else {
-			genRemoveSmallIntegerTagsInScratchReg(Arg0Reg);
-			gSubRR(Arg0Reg, ReceiverResultReg);
-
-			/* overflow; must undo the damage before continuing */
-
-			jumpContinue = gJumpNoOverflow(0);
-			gAddRR(Arg0Reg, ReceiverResultReg);
-			genSetSmallIntegerTagsIn(Arg0Reg);
-		}
-		break;
-	case AndRR:
-				if (argIsInt) {
-			gAndCqR(argInt, ReceiverResultReg);
-		}
-		else {
-			gAndRR(Arg0Reg, ReceiverResultReg);
-		}
-		jumpContinue = gJump(0);
-		break;
-	case OrRR:
-				if (argIsInt) {
-			gOrCqR(argInt, ReceiverResultReg);
-		}
-		else {
-			gOrRR(Arg0Reg, ReceiverResultReg);
-		}
-		jumpContinue = gJump(0);
-		break;
-	default:
-		error("Case not found and no otherwise clause");
-	}
-	jmpTarget(jumpNotSmallInts, gLabel());
-	if (argIsInt) {
-		gMoveCqR(argInt, Arg0Reg);
-	}
-	genMarshalledSendnumArgs(specialSelector(byte0 - 176), 1);
-	jmpTarget(jumpContinue, gLabel());
-	return 0;
-}
-
-static sqInt
 genSpecialSelectorClass(void)
 {
-	ssPop(1);
-	ssAllocateRequiredRegand(SendNumArgsReg, ClassReg);
-	ssPush(1);
-	popToReg(ssTop(), SendNumArgsReg);
+	gMoveMwrR(0, SPReg, SendNumArgsReg);
 	genGetClassObjectOfintoscratchReg(SendNumArgsReg, ClassReg, TempReg);
-	return ssPop(1),ssPushRegister(ClassReg);
+	gMoveRMwr(ClassReg, 0, SPReg);
+	return 0;
 }
 
 static sqInt
-genSpecialSelectorComparison(void)
-{
-    sqInt argInt;
-    sqInt argIsInt;
-    sqInt branchBytecode;
-    BytecodeDescriptor *branchDescriptor;
-    sqInt branchPC;
-    sqInt inlineCAB;
-    AbstractInstruction *jumpNotSmallInts;
-    sqInt postBranchPC;
-    BytecodeDescriptor *primDescriptor;
-    sqInt rcvrInt;
-    sqInt rcvrIsInt;
-    sqInt result;
-    sqInt targetBytecodePC;
-
-	ssFlushTo(simStackPtr - 2);
-	primDescriptor = generatorAt(byte0);
-	argIsInt = (((ssTop()->type)) == SSConstant)
-	 && ((((argInt = (ssTop()->constant))) & 1));
-	rcvrIsInt = (((ssValue(1)->type)) == SSConstant)
-	 && ((((rcvrInt = (ssValue(1)->constant))) & 1));
-	if (argIsInt
-	 && (rcvrIsInt)) {
-		;
-		
-		switch ((primDescriptor->opcode)) {
-		case JumpLess:
-						result = rcvrInt < argInt;
-			break;
-		case JumpLessOrEqual:
-						result = rcvrInt <= argInt;
-			break;
-		case JumpGreater:
-						result = rcvrInt > argInt;
-			break;
-		case JumpGreaterOrEqual:
-						result = rcvrInt >= argInt;
-			break;
-		case JumpZero:
-						result = rcvrInt == argInt;
-			break;
-		case JumpNonZero:
-						result = rcvrInt != argInt;
-			break;
-		default:
-			error("Case not found and no otherwise clause");
-		}
-		annotateBytecode(gLabel());
-		ssPop(2);
-		return ssPushConstant((result
-			? trueObject()
-			: falseObject()));
-	}
-	branchPC = bytecodePointer + ((primDescriptor->numBytes));
-	branchBytecode = fetchByteofObject(branchPC, methodObj);
-
-	/* Only interested in inlining if followed by a conditional branch. */
-
-	branchDescriptor = generatorAt(branchBytecode);
-
-	/* Further, only interested in inlining = and ~= if there's a SmallInteger constant involved.
-	 The relational operators successfully staticaly predict SmallIntegers; the equality operators do not. */
-
-	inlineCAB = ((branchDescriptor->isBranchTrue))
-	 || ((branchDescriptor->isBranchFalse));
-	if (inlineCAB
-	 && ((((primDescriptor->opcode)) == JumpZero)
- || (((primDescriptor->opcode)) == JumpNonZero))) {
-		inlineCAB = argIsInt
-		 || (rcvrIsInt);
-	}
-	if (!(inlineCAB)) {
-		return genSpecialSelectorSend();
-	}
-	targetBytecodePC = (branchPC + ((branchDescriptor->numBytes))) + (spanForatbyte0in(branchDescriptor, branchPC, branchBytecode, methodObj));
-	postBranchPC = branchPC + ((branchDescriptor->numBytes));
-	if (argIsInt) {
-		ssFlushTo(simStackPtr - 2);
-		popToReg(ssValue(1), ReceiverResultReg);
-		ssPop(2);
-		gMoveRR(ReceiverResultReg, TempReg);
-	}
-	else {
-		marshallSendArguments(1);
-		gMoveRR(Arg0Reg, TempReg);
-		if (!(rcvrIsInt)) {
-			if (isSmallIntegerTagNonZero()) {
-				gAndRR(ReceiverResultReg, TempReg);
-			}
-			else {
-				gOrRR(ReceiverResultReg, TempReg);
-			}
-		}
-	}
-	jumpNotSmallInts = genJumpNotSmallIntegerInScratchReg(TempReg);
-	if (argIsInt) {
-		gCmpCqR(argInt, ReceiverResultReg);
-	}
-	else {
-		gCmpRR(Arg0Reg, ReceiverResultReg);
-	}
-	genoperand(((branchDescriptor->isBranchTrue)
-		? (primDescriptor->opcode)
-		: inverseBranchFor((primDescriptor->opcode))), ((usqInt)(ensureNonMergeFixupAt(targetBytecodePC - initialPC))));
-	gJump(ensureNonMergeFixupAt(postBranchPC - initialPC));
-	jmpTarget(jumpNotSmallInts, gLabel());
-	if (argIsInt) {
-		gMoveCqR(argInt, Arg0Reg);
-	}
-	return genMarshalledSendnumArgs(specialSelector(byte0 - 176), 1);
-}
-
-static sqInt
 genSpecialSelectorEqualsEquals(void)
 {
-    sqInt argReg;
-    sqInt branchBytecode;
-    BytecodeDescriptor *branchDescriptor;
-    AbstractInstruction *jumpEqual;
     AbstractInstruction *jumpNotEqual;
-    sqInt nextPC;
-    sqInt postBranchPC;
-    BytecodeDescriptor *primDescriptor;
-    sqInt rcvrReg;
-    sqInt resultReg;
-    sqInt targetBytecodePC;
+    AbstractInstruction *jumpPush;
 
-	ssPop(2);
-	resultReg = availableRegisterOrNil();
-	if (!(resultReg)) {
-		ssAllocateRequiredReg(resultReg = Arg1Reg);
-	}
-	ssPush(2);
-	if ((((ssTop()->type)) == SSConstant)
-	 && (!((ssTop()->spilled)))) {
-		if (((ssValue(1)->type)) == SSRegister) {
-
-			/* if spilled we must generate a real pop */
-
-			rcvrReg = (ssValue(1)->registerr);
-		}
-		else {
-			popToReg(ssValue(1), rcvrReg = resultReg);
-		}
-		if (shouldAnnotateObjectReference((ssTop()->constant))) {
-			annotateobjRef(gCmpCwR((ssTop()->constant), rcvrReg), (ssTop()->constant));
-		}
-		else {
-			gCmpCqR((ssTop()->constant), rcvrReg);
-		}
-		ssPop(1);
-	}
-	else {
-		argReg = ssStorePoptoPreferredReg(1, TempReg);
-		rcvrReg = (argReg == resultReg
-			? TempReg
-			: resultReg);
-		popToReg(ssTop(), rcvrReg);
-		gCmpRR(argReg, rcvrReg);
-	}
-	ssPop(1);
-	ssPushRegister(resultReg);
-	primDescriptor = generatorAt(byte0);
-	nextPC = bytecodePointer + ((primDescriptor->numBytes));
-	branchBytecode = fetchByteofObject(nextPC, methodObj);
-	branchDescriptor = generatorAt(branchBytecode);
-	if (((branchDescriptor->isBranchTrue))
-	 || ((branchDescriptor->isBranchFalse))) {
-		ssFlushTo(simStackPtr - 1);
-		targetBytecodePC = (nextPC + ((branchDescriptor->numBytes))) + (spanForatbyte0in(branchDescriptor, nextPC, branchBytecode, methodObj));
-		postBranchPC = nextPC + ((branchDescriptor->numBytes));
-		genoperand(((branchDescriptor->isBranchTrue)
-			? JumpZero
-			: JumpNonZero), ((usqInt)(ensureNonMergeFixupAt(targetBytecodePC - initialPC))));
-		gJump(ensureNonMergeFixupAt(postBranchPC - initialPC));
-	}
-	else {
-		jumpNotEqual = gJumpNonZero(0);
-		annotateobjRef(gMoveCwR(trueObject(), resultReg), trueObject());
-		jumpEqual = gJump(0);
-		jmpTarget(jumpNotEqual, annotateobjRef(gMoveCwR(falseObject(), resultReg), falseObject()));
-		jmpTarget(jumpEqual, gLabel());
-	}
-	if (resultReg == ReceiverResultReg) {
-		(optStatus.isReceiverResultRegLive = 0);
-	}
+	gPopR(TempReg);
+	gMoveMwrR(0, SPReg, ClassReg);
+	gCmpRR(TempReg, ClassReg);
+	jumpNotEqual = gJumpNonZero(0);
+	annotateobjRef(gMoveCwR(trueObject(), TempReg), trueObject());
+	jumpPush = gJump(0);
+	jmpTarget(jumpNotEqual, annotateobjRef(gMoveCwR(falseObject(), TempReg), falseObject()));
+	jmpTarget(jumpPush, gMoveRMwr(TempReg, 0, SPReg));
 	return 0;
 }
 
@@ -10441,12 +9618,6 @@
 }
 
 static sqInt
-genSSPushSlotreg(sqInt index, sqInt baseReg)
-{
-	return ssPushBaseoffset(baseReg, slotOffsetOfInstVarIndex(index));
-}
-
-static sqInt
 genStoreAndPopReceiverVariableBytecode(void)
 {
 	return genStorePopReceiverVariable(1, byte0 & 7);
@@ -10474,57 +9645,23 @@
 }
 
 static sqInt
-genStoreImmediateInSourceRegslotIndexdestReg(sqInt sourceReg, sqInt index, sqInt destReg)
-{
-	gMoveRMwr(sourceReg, (index * BytesPerWord) + BaseHeaderSize, destReg);
-	return 0;
-}
-
-static sqInt
 genStorePopLiteralVariable(sqInt popBoolean, sqInt litVarIndex)
 {
     sqInt association;
-    sqInt constVal;
-    sqInt topReg;
-    sqInt valueReg;
 
-	flag("with better register allocation this wouldn't need a frame.  e.g. use SendNumArgs instead of ReceiverResultReg");
 	assert(needsFrame);
 	association = literalofMethod(litVarIndex, methodObj);
-	(optStatus.isReceiverResultRegLive = 0);
-	if ((((ssTop()->type)) == SSConstant)
-	 && (isImmediate((ssTop()->constant)))) {
-		constVal = (ssTop()->constant);
-		if (popBoolean) {
-			ssPop(1);
-		}
-		ssAllocateRequiredReg(ReceiverResultReg);
-		annotateobjRef(gMoveCwR(association, ReceiverResultReg), association);
-		gMoveCqR(constVal, TempReg);
-		if (traceStores > 0) {
-			CallRT(ceTraceStoreTrampoline);
-		}
-		return genStoreImmediateInSourceRegslotIndexdestReg(TempReg, ValueIndex, ReceiverResultReg);
+	annotateobjRef(gMoveCwR(association, ReceiverResultReg), association);
+	if (popBoolean) {
+		gPopR(ClassReg);
 	}
-	if ((((topReg = registerOrNil(ssTop()))) == null)
-	 || (topReg == ReceiverResultReg)) {
-		topReg = ClassReg;
+	else {
+		gMoveMwrR(0, SPReg, ClassReg);
 	}
-	ssPop(1);
-	ssAllocateRequiredReg(topReg);
-	ssPush(1);
-	flag("but what if we don't pop?  The top reg is still potentially trashed in the call;. think this through");
-	valueReg = ssStorePoptoPreferredReg(popBoolean, topReg);
-	if (valueReg == ReceiverResultReg) {
-		gMoveRR(valueReg, topReg);
-	}
-	ssAllocateCallReg(ReceiverResultReg);
-	annotateobjRef(gMoveCwR(association, ReceiverResultReg), association);
 	if (traceStores > 0) {
-		gMoveRR(topReg, TempReg);
 		CallRT(ceTraceStoreTrampoline);
 	}
-	return genStoreSourceRegslotIndexdestRegscratchReg(topReg, ValueIndex, ReceiverResultReg, TempReg);
+	return genStoreSourceRegslotIndexdestRegscratchReg(ClassReg, ValueIndex, ReceiverResultReg, TempReg);
 }
 
 static sqInt
@@ -10534,28 +9671,21 @@
     AbstractInstruction *jmpSingle;
 
 	assert(needsFrame);
-	ssFlushUpThroughReceiverVariable(slotIndex);
-	ensureReceiverResultRegContainsSelf();
-	ssPop(1);
-	ssAllocateCallRegand(ClassReg, SendNumArgsReg);
-	ssPush(1);
+	gMoveMwrR(FoxMFReceiver, FPReg, ReceiverResultReg);
 	genLoadSlotsourceRegdestReg(SenderIndex, ReceiverResultReg, TempReg);
-	flag("why do we always pop??");
-	flag("but what if we don't pop?  The top reg is still potentially trashed in the call;. think this through");
-	popToReg(ssTop(), ClassReg);
+	gMoveMwrR(0, SPReg, ClassReg);
 	jmpSingle = genJumpNotSmallIntegerInScratchReg(TempReg);
 	gMoveCqR(slotIndex, SendNumArgsReg);
 	CallRT(ceStoreContextInstVarTrampoline);
 	jmpDone = gJump(0);
 	jmpTarget(jmpSingle, gLabel());
 	if (traceStores > 0) {
-		gMoveRR(ClassReg, TempReg);
 		CallRT(ceTraceStoreTrampoline);
 	}
 	genStoreSourceRegslotIndexdestRegscratchReg(ClassReg, slotIndex, ReceiverResultReg, TempReg);
 	jmpTarget(jmpDone, gLabel());
 	if (popBoolean) {
-		ssPop(1);
+		gAddCqR(BytesPerWord, SPReg);
 	}
 	return 0;
 }
@@ -10563,100 +9693,48 @@
 static sqInt
 genStorePopReceiverVariable(sqInt popBoolean, sqInt slotIndex)
 {
-    sqInt constVal;
-    sqInt topReg;
-    sqInt valueReg;
-
-	ssFlushUpThroughReceiverVariable(slotIndex);
-	if ((((ssTop()->type)) == SSConstant)
-	 && (isImmediate((ssTop()->constant)))) {
-		constVal = (ssTop()->constant);
-		if (popBoolean) {
-			ssPop(1);
-		}
-		ensureReceiverResultRegContainsSelf();
-		gMoveCqR(constVal, TempReg);
-		if (traceStores > 0) {
-			CallRT(ceTraceStoreTrampoline);
-		}
-		return genStoreImmediateInSourceRegslotIndexdestReg(TempReg, slotIndex, ReceiverResultReg);
+	if (needsFrame) {
+		gMoveMwrR(FoxMFReceiver, FPReg, ReceiverResultReg);
 	}
-	if ((((topReg = registerOrNil(ssTop()))) == null)
-	 || (topReg == ReceiverResultReg)) {
-		topReg = ClassReg;
+	if (popBoolean) {
+		gPopR(ClassReg);
 	}
-	ssPop(1);
-	ssAllocateCallReg(topReg);
-	ssPush(1);
-	flag("but what if we don't pop?  The top reg is still potentially trashed in the call;. think this through");
-	valueReg = ssStorePoptoPreferredReg(popBoolean, topReg);
-	if (valueReg == ReceiverResultReg) {
-		gMoveRR(valueReg, topReg);
+	else {
+		gMoveMwrR(0, SPReg, ClassReg);
 	}
-	ensureReceiverResultRegContainsSelf();
 	if (traceStores > 0) {
-		gMoveRR(topReg, TempReg);
 		CallRT(ceTraceStoreTrampoline);
 	}
-	return genStoreSourceRegslotIndexdestRegscratchReg(topReg, slotIndex, ReceiverResultReg, TempReg);
+	return genStoreSourceRegslotIndexdestRegscratchReg(ClassReg, slotIndex, ReceiverResultReg, TempReg);
 }
 
 static sqInt
 genStorePopRemoteTempAt(sqInt popBoolean, sqInt slotIndex, sqInt remoteTempIndex)
 {
-    sqInt constVal;
-    sqInt topReg;
-    sqInt valueReg;
-
 	assert(needsFrame);
-	(optStatus.isReceiverResultRegLive = 0);
-	if ((((ssTop()->type)) == SSConstant)
-	 && (isImmediate((ssTop()->constant)))) {
-		constVal = (ssTop()->constant);
-		if (popBoolean) {
-			ssPop(1);
-		}
-		ssAllocateRequiredReg(ReceiverResultReg);
-		gMoveMwrR(frameOffsetOfTemporary(remoteTempIndex), FPReg, ReceiverResultReg);
-		gMoveCqR(constVal, TempReg);
-		if (traceStores > 0) {
-			CallRT(ceTraceStoreTrampoline);
-		}
-		return genStoreImmediateInSourceRegslotIndexdestReg(TempReg, slotIndex, ReceiverResultReg);
+	if (popBoolean) {
+		gPopR(ClassReg);
 	}
-	if ((((topReg = registerOrNil(ssTop()))) == null)
-	 || (topReg == ReceiverResultReg)) {
-		topReg = ClassReg;
+	else {
+		gMoveMwrR(0, SPReg, ClassReg);
 	}
-	ssPop(1);
-	ssAllocateRequiredReg(topReg);
-	ssPush(1);
-	flag("but what if we don't pop?  The top reg is still potentially trashed in the call;. think this through");
-	valueReg = ssStorePoptoPreferredReg(popBoolean, topReg);
-	if (valueReg == ReceiverResultReg) {
-		gMoveRR(valueReg, topReg);
-	}
-	if (!(popBoolean)) {
-		ssPop(1);
-		ssPushRegister(topReg);
-	}
-	ssAllocateCallReg(ReceiverResultReg);
 	gMoveMwrR(frameOffsetOfTemporary(remoteTempIndex), FPReg, ReceiverResultReg);
 	if (traceStores > 0) {
-		gMoveRR(topReg, TempReg);
 		CallRT(ceTraceStoreTrampoline);
 	}
-	return genStoreSourceRegslotIndexdestRegscratchReg(topReg, slotIndex, ReceiverResultReg, TempReg);
+	return genStoreSourceRegslotIndexdestRegscratchReg(ClassReg, slotIndex, ReceiverResultReg, TempReg);
 }
 
 static sqInt
 genStorePopTemporaryVariable(sqInt popBoolean, sqInt tempIndex)
 {
-    sqInt reg;
-
-	ssFlushUpThroughTemporaryVariable(tempIndex);
-	reg = ssStorePoptoPreferredReg(popBoolean, TempReg);
-	gMoveRMwr(reg, frameOffsetOfTemporary(tempIndex), FPReg);
+	if (popBoolean) {
+		gPopR(TempReg);
+	}
+	else {
+		gMoveMwrR(0, SPReg, TempReg);
+	}
+	gMoveRMwr(TempReg, frameOffsetOfTemporary(tempIndex), FPReg);
 	return 0;
 }
 
@@ -10749,6 +9827,28 @@
 }
 
 
+/*	Generate a trampoline with two arguments.
+	Hack: a negative value indicates an abstract register, a non-negative
+	value indicates a constant. */
+
+static sqInt
+genTrampolineForcalledargarg(void *aRoutine, char *aString, sqInt regOrConst0, sqInt regOrConst1)
+{
+	return genTrampolineForcalledcallJumpBarnumArgsargargargargsaveRegsresultRegappendOpcodes(aRoutine, aString, 1, 2, regOrConst0, regOrConst1, null, null, 0, null, 0);
+}
+
+
+/*	Generate a trampoline with four arguments.
+	Hack: a negative value indicates an abstract register, a non-negative
+	value indicates a constant. */
+
+static sqInt
+genTrampolineForcalledargargargarg(void *aRoutine, char *aString, sqInt regOrConst0, sqInt regOrConst1, sqInt regOrConst2, sqInt regOrConst3)
+{
+	return genTrampolineForcalledcallJumpBarnumArgsargargargargsaveRegsresultRegappendOpcodes(aRoutine, aString, 1, 4, regOrConst0, regOrConst1, regOrConst2, regOrConst3, 0, null, 0);
+}
+
+
 /*	Generate a trampoline with two arguments that answers a result.
 	Hack: a negative value indicates an abstract register, a non-negative
 	value indicates a constant. */
@@ -10818,6 +9918,7 @@
 static sqInt
 genUpArrowReturn(void)
 {
+	flag("currently caller pushes result");
 	if (inBlock) {
 		assert(needsFrame);
 		annotateBytecode(CallRT(ceNonLocalReturnTrampoline));
@@ -10826,14 +9927,8 @@
 	if (needsFrame) {
 		gMoveRR(FPReg, SPReg);
 		gPopR(FPReg);
-		gRetN((methodOrBlockNumArgs + 1) * BytesPerWord);
 	}
-	else {
-		gRetN(((methodOrBlockNumArgs > (numRegArgs()))
-		 || (regArgsHaveBeenPushed)
-			? (methodOrBlockNumArgs + 1) * BytesPerWord
-			: 0));
-	}
+	gRetN((methodOrBlockNumArgs + 1) * BytesPerWord);
 	return 0;
 }
 
@@ -11059,7 +10154,6 @@
 	(methodLabel->opcode = Label);
 	((methodLabel->operands))[0] = 0;
 	((methodLabel->operands))[1] = 0;
-	callerSavedRegMask = callerSavedRegisterMask(backEnd);
 }
 
 void
@@ -11084,9 +10178,6 @@
 
 /*	Make sure there's a flagged fixup at the targetIndex (pc relative to first
 	pc) in fixups.
-	These are the targets of backward branches. A backward branch fixup's
-	simStackPtr needs to be set when generating the code for the bytecode at
-	the targetIndex.
 	Initially a fixup's target is just a flag. Later on it is replaced with a
 	proper instruction. */
 
@@ -11096,8 +10187,7 @@
     BytecodeFixup *fixup;
 
 	fixup = fixupAt(targetIndex);
-	(fixup->targetInstruction = ((AbstractInstruction *) 2));
-	(fixup->simStackPtr = -2);
+	(fixup->targetInstruction = ((AbstractInstruction *) 1));
 	return fixup;
 }
 
@@ -11128,73 +10218,7 @@
 	return 3;
 }
 
-static void
-initSimStackForFramefulMethod(sqInt startpc)
-{
-    CogSimStackEntry *desc;
-    sqInt i;
 
-	(optStatus.isReceiverResultRegLive = 0);
-	(simSelf.type = SSBaseOffset);
-	(simSelf.registerr = FPReg);
-	(simSelf.offset = FoxMFReceiver);
-	(simSelf.spilled = 1);
-
-	/* N.B. Includes num args */
-
-	simSpillBase = methodOrBlockNumTemps;
-
-	/* args */
-
-	simStackPtr = simSpillBase - 1;
-	for (i = 0; i <= (methodOrBlockNumArgs - 1); i += 1) {
-		desc = simStackAt(i);
-		(desc->type = SSBaseOffset);
-		(desc->registerr = FPReg);
-		(desc->offset = FoxCallerSavedIP + ((methodOrBlockNumArgs - i) * BytesPerWord));
-		(desc->spilled = 1);
-		(desc->bcptr = startpc);
-	}
-	for (i = methodOrBlockNumArgs; i <= simStackPtr; i += 1) {
-		desc = simStackAt(i);
-		(desc->type = SSBaseOffset);
-		(desc->registerr = FPReg);
-		(desc->offset = FoxMFReceiver - (((i - methodOrBlockNumArgs) + 1) * BytesPerWord));
-		(desc->spilled = 1);
-		(desc->bcptr = startpc);
-	}
-}
-
-static void
-initSimStackForFramelessMethod(sqInt startpc)
-{
-    CogSimStackEntry *desc;
-
-	(simSelf.type = SSRegister);
-	(simSelf.registerr = ReceiverResultReg);
-	(simSelf.spilled = 0);
-	(optStatus.isReceiverResultRegLive = 1);
-	(optStatus.ssEntry = (&simSelf));
-	assert(methodOrBlockNumTemps == methodOrBlockNumArgs);
-	simStackPtr = simSpillBase = -1;
-	assert((numRegArgs()) <= 2);
-	if (((methodOrBlockNumArgs >= 1) && (methodOrBlockNumArgs <= (numRegArgs())))) {
-		desc = simStackAt(0);
-		(desc->type = SSRegister);
-		(desc->registerr = Arg0Reg);
-		(desc->spilled = 0);
-		(desc->bcptr = startpc);
-		if (methodOrBlockNumArgs > 1) {
-			desc = simStackAt(1);
-			(desc->type = SSRegister);
-			(desc->registerr = Arg1Reg);
-			(desc->spilled = 0);
-			(desc->bcptr = startpc);
-		}
-	}
-}
-
-
 /*	Answer the inline cache tag for the return address of a send. */
 
 static sqInt
@@ -11287,72 +10311,6 @@
 }
 
 static sqInt
-inverseBranchFor(sqInt opcode)
-{
-	
-	switch (opcode) {
-	case JumpLongZero:
-				return JumpLongNonZero;
-
-	case JumpLongNonZero:
-				return JumpLongZero;
-
-	case JumpZero:
-				return JumpNonZero;
-
-	case JumpNonZero:
-				return JumpZero;
-
-	case JumpNegative:
-				return JumpNonNegative;
-
-	case JumpNonNegative:
-				return JumpNegative;
-
-	case JumpOverflow:
-				return JumpNoOverflow;
-
-	case JumpNoOverflow:
-				return JumpOverflow;
-
-	case JumpCarry:
-				return JumpNoCarry;
-
-	case JumpNoCarry:
-				return JumpCarry;
-
-	case JumpLess:
-				return JumpGreaterOrEqual;
-
-	case JumpGreaterOrEqual:
-				return JumpLess;
-
-	case JumpGreater:
-				return JumpLessOrEqual;
-
-	case JumpLessOrEqual:
-				return JumpGreater;
-
-	case JumpBelow:
-				return JumpAboveOrEqual;
-
-	case JumpAboveOrEqual:
-				return JumpBelow;
-
-	case JumpAbove:
-				return JumpBelowOrEqual;
-
-	case JumpBelowOrEqual:
-				return JumpAbove;
-
-	default:
-		error("Case not found and no otherwise clause");
-	}
-	error("invalid opcode for inverse");
-	return 0;
-}
-
-static sqInt
 isAFixup(AbstractInstruction * self_in_isAFixup, void *fixupOrAddress)
 {
 	return addressIsInFixups(fixupOrAddress);
@@ -11438,12 +10396,6 @@
 	 || (((target >= methodZoneBase) && (target <= (zoneLimit()))));
 }
 
-static sqInt
-isSmallIntegerTagNonZero(void)
-{
-	return 1;
-}
-
 static AbstractInstruction *
 gJumpAboveOrEqual(void *jumpTarget)
 {
@@ -11551,12 +10503,6 @@
 }
 
 static AbstractInstruction *
-gJumpNoOverflow(void *jumpTarget)
-{
-	return genoperand(JumpNoOverflow, ((sqInt)jumpTarget));
-}
-
-static AbstractInstruction *
 gJumpOverflow(void *jumpTarget)
 {
 	return genoperand(JumpOverflow, ((sqInt)jumpTarget));
@@ -11782,20 +10728,7 @@
 	return ((((byteAt(followingAddress - 1)) << 24) + ((byteAt(followingAddress - 2)) << 16)) + ((byteAt(followingAddress - 3)) << 8)) + (byteAt(followingAddress - 4));
 }
 
-static sqInt
-liveRegisters(void)
-{
-    sqInt i;
-    sqInt regsSet;
 
-	regsSet = 0;
-	for (i = (((simSpillBase < 0) ? 0 : simSpillBase)); i <= simStackPtr; i += 1) {
-		regsSet = regsSet | (registerMask(simStackAt(i)));
-	}
-	return regsSet;
-}
-
-
 /*	Answer the byte size of a MoveCwR opcode's corresponding machine code */
 
 static sqInt
@@ -12000,6 +10933,10 @@
 		homeMethod = ((CogMethod *) cogMethod);
 		assert(startbcpc == (startPCOfMethodHeader((homeMethod->methodHeader))));
 		map = findMapLocationForMcpcinMethod(mcpc, homeMethod);
+		assert(map != 0);
+		if (map == 0) {
+			return 0;
+		}
 		assert(((((usqInt) (byteAt(map))) >> AnnotationShift) == IsMethodReference)
 		 || (((((usqInt) (byteAt(map))) >> AnnotationShift) == IsRelativeCall)
  || ((((usqInt) (byteAt(map))) >> AnnotationShift) == IsDisplacementX2N)));
@@ -12009,6 +10946,10 @@
 		mcpc = (((sqInt)cogMethod)) + (sizeof(CogBlockMethod));
 		homeMethod = cogHomeMethod(cogMethod);
 		map = findMapLocationForMcpcinMethod(mcpc, homeMethod);
+		assert(map != 0);
+		if (map == 0) {
+			return 0;
+		}
 		assert(((((usqInt) (byteAt(map))) >> AnnotationShift) == HasBytecodePC)
 		 || ((((usqInt) (byteAt(map))) >> AnnotationShift) == IsDisplacementX2N));
 		while ((((usqInt) (byteAt(map))) >> AnnotationShift) != HasBytecodePC) {
@@ -12489,45 +11430,6 @@
 	return 0;
 }
 
-
-/*	Spill everything on the simulated stack that needs spilling (that below
-	receiver and arguments).
-	Marshall receiver and arguments to stack and/or registers depending on arg
-	count. If the args don't fit in registers push receiver and args (spill
-	everything), but still assign
-	the receiver to ReceiverResultReg. */
-
-static void
-marshallSendArguments(sqInt numArgs)
-{
-	if (numArgs > (numRegArgs())) {
-		ssFlushTo(simStackPtr);
-		storeToReg(simStackAt(simStackPtr - numArgs), ReceiverResultReg);
-	}
-	else {
-		ssFlushTo((simStackPtr - numArgs) - 1);
-		if (numArgs > 0) {
-			if (((numRegArgs()) > 1)
-			 && (numArgs > 1)) {
-				ssAllocateRequiredRegupThrough(Arg0Reg, simStackPtr - 2);
-				ssAllocateRequiredRegupThrough(Arg1Reg, simStackPtr - 1);
-			}
-			else {
-				ssAllocateRequiredRegupThrough(Arg0Reg, simStackPtr - 1);
-			}
-		}
-		if (((numRegArgs()) > 1)
-		 && (numArgs > 1)) {
-			popToReg(simStackAt(simStackPtr), Arg1Reg);
-		}
-		if (numArgs > 0) {
-			popToReg(simStackAt((simStackPtr - numArgs) + 1), Arg0Reg);
-		}
-		popToReg(simStackAt(simStackPtr - numArgs), ReceiverResultReg);
-	}
-	ssPop(numArgs + 1);
-}
-
 usqInt
 maxCogMethodAddress(void)
 {
@@ -12607,64 +11509,10 @@
 		: absPC);
 }
 
-
-/*	Discard type information because of a control-flow merge. */
-
-static void
-mergeAtfrom(CogSimStackEntry * self_in_mergeAtfrom, sqInt baseOffset, sqInt baseRegister)
-{
-	assert((self_in_mergeAtfrom->spilled));
-	if (((self_in_mergeAtfrom->type)) == SSSpill) {
-		assert((((self_in_mergeAtfrom->offset)) == baseOffset)
-		 && (((self_in_mergeAtfrom->registerr)) == baseRegister));
-	}
-	else {
-		(self_in_mergeAtfrom->type) = SSSpill;
-		(self_in_mergeAtfrom->offset) = baseOffset;
-		(self_in_mergeAtfrom->registerr) = baseRegister;
-	}
-}
-
-
-/*	Merge control flow at a fixup. The fixup holds the simStackPtr at the jump
-	to this target.
-	See stackToRegisterMapping on the class side for a full description. */
-
-static void
-mergeafterReturn(BytecodeFixup *fixup, sqInt mergeFollowsReturn)
-{
-    sqInt i;
-
-	traceMerge(fixup);
-	(optStatus.isReceiverResultRegLive = 0);
-	if (mergeFollowsReturn) {
-		assert((((usqInt)((fixup->targetInstruction)))) >= 2);
-		simStackPtr = (fixup->simStackPtr);
-	}
-	if ((((usqInt)((fixup->targetInstruction)))) <= 2) {
-		ssFlushTo(simStackPtr);
-		if (((fixup->simStackPtr)) <= -2) {
-			(fixup->simStackPtr = simStackPtr);
-		}
-		(fixup->targetInstruction = gLabel());
-	}
-	assert(simStackPtr >= ((fixup->simStackPtr)));
-	;
-	simStackPtr = (fixup->simStackPtr);
-
-	/* For now throw away all type information for values on the stack, but sometime consider
-	 the more sophisticated merge described in the class side stackToRegisterMapping. */
-
-	simSpillBase = methodOrBlockNumTemps;
-	for (i = methodOrBlockNumTemps; i <= simStackPtr; i += 1) {
-		mergeAtfrom(simStackAt(i), FoxMFReceiver - (((i - methodOrBlockNumArgs) + 1) * BytesPerOop), FPReg);
-	}
-}
-
 static sqInt
 methodAbortTrampolineFor(sqInt numArgs)
 {
-	return methodAbortTrampolines[((numArgs < ((numRegArgs()) + 1)) ? numArgs : ((numRegArgs()) + 1))];
+	return ceMethodAbortTrampoline;
 }
 
 static CogMethod *
@@ -12719,13 +11567,7 @@
 	return genoperand(NegateR, reg);
 }
 
-static AbstractInstruction *
-gNop(void)
-{
-	return gen(Nop);
-}
 
-
 /*	Compute the distance to the logically subsequent bytecode, i.e. skip over
 	blocks. 
  */
@@ -13052,7 +11894,7 @@
 static sqInt
 picAbortTrampolineFor(sqInt numArgs)
 {
-	return picAbortTrampolines[((numArgs < ((numRegArgs()) + 1)) ? numArgs : ((numRegArgs()) + 1))];
+	return cePICAbortTrampoline;
 }
 
 
@@ -13080,37 +11922,7 @@
 	}
 }
 
-static void
-popToReg(CogSimStackEntry * self_in_popToReg, sqInt reg)
-{
-	if ((self_in_popToReg->spilled)) {
-		gPopR(reg);
-		return;
-	}
-	
-	switch ((self_in_popToReg->type)) {
-	case SSBaseOffset:
-				gMoveMwrR((self_in_popToReg->offset), (self_in_popToReg->registerr), reg);
-		break;
-	case SSConstant:
-				if (shouldAnnotateObjectReference((self_in_popToReg->constant))) {
-			annotateobjRef(gMoveCwR((self_in_popToReg->constant), reg), (self_in_popToReg->constant));
-		}
-		else {
-			gMoveCqR((self_in_popToReg->constant), reg);
-		}
-		break;
-	case SSRegister:
-				if (reg != ((self_in_popToReg->registerr))) {
-			gMoveRR((self_in_popToReg->registerr), reg);
-		}
-		break;
-	default:
-		error("Case not found and no otherwise clause");
-	}
-}
 
-
 /*	If there is a generator for the current primitive then answer it;
 	otherwise answer nil. */
 
@@ -13298,45 +12110,15 @@
 }
 
 
-/*	Answer a bit mask for the receiver's register, if any. */
+/*	Dummy implementation for CogFooCompiler>callerSavedRegisterMask
+	which doesn't get pruned due to Slang limitations. */
 
 static sqInt
-registerMask(CogSimStackEntry * self_in_registerMask)
-{
-	return ((((self_in_registerMask->type)) == SSBaseOffset)
-	 || (((self_in_registerMask->type)) == SSRegister)
-		? registerMaskFor((self_in_registerMask->registerr))
-		: 0);
-}
-
-
-/*	Answer a bit mask identifying the symbolic register.
-	Registers are negative numbers. */
-
-static sqInt
-registerMaskFor(sqInt reg)
-{
-	return (((1 - reg) < 0) ? ((usqInt) 1 >> -(1 - reg)) : ((usqInt) 1 << (1 - reg)));
-}
-
-
-/*	Answer a bit mask identifying the symbolic registers.
-	Registers are negative numbers. */
-
-static sqInt
 registerMaskForandand(sqInt reg1, sqInt reg2, sqInt reg3)
 {
-	return (((((1 - reg1) < 0) ? ((usqInt) 1 >> -(1 - reg1)) : ((usqInt) 1 << (1 - reg1)))) | ((((1 - reg2) < 0) ? ((usqInt) 1 >> -(1 - reg2)) : ((usqInt) 1 << (1 - reg2))))) | ((((1 - reg3) < 0) ? ((usqInt) 1 >> -(1 - reg3)) : ((usqInt) 1 << (1 - reg3))));
+	return 0;
 }
 
-static sqInt
-registerOrNil(CogSimStackEntry * self_in_registerOrNil)
-{
-	return (((self_in_registerOrNil->type)) == SSRegister
-		? (self_in_registerOrNil->registerr)
-		: 0);
-}
-
 static void
 relocateAndPruneYoungReferrers(void)
 {
@@ -13629,21 +12411,12 @@
 }
 
 
-/*	We must ensure the ReceiverResultReg is live across the store check so
-	that we can store into receiver inst vars in a frameless method since self
-	exists only in ReceiverResultReg in a frameless method. So if
-	ReceiverResultReg is
-	caller-saved we use the fact that ceStoreCheck: answers its argument to
-	reload ReceiverResultReg cheaply. Otherwise we don't care about the result
-	and use the cResultRegister, effectively a no-op (see
-	compileTrampoline...)  */
+/*	See the subclass for explanation. */
 
 static sqInt
 returnRegForStoreCheck(void)
 {
-	return ((registerMaskFor(ReceiverResultReg)) & callerSavedRegMask
-		? ReceiverResultReg
-		: cResultRegister(backEnd));
+	return cResultRegister(backEnd);
 }
 
 
@@ -13789,7 +12562,6 @@
     BytecodeDescriptor *descriptor;
     sqInt end;
     sqInt pc;
-    sqInt pushingNils;
     sqInt stackDelta;
 
 	needsFrame = 0;
@@ -13797,8 +12569,6 @@
 	pc = (blockStart->startpc);
 	end = ((blockStart->startpc)) + ((blockStart->span));
 	stackDelta = 0;
-	pushingNils = 1;
-	(blockStart->numInitialNils = 0);
 	while (pc < end) {
 		byte0 = fetchByteofObject(pc, methodObj);
 		descriptor = generatorAt(byte0);
@@ -13810,20 +12580,12 @@
 				stackDelta += (descriptor->stackDelta);
 			}
 		}
-		if (pushingNils) {
-			if ((pushingNils = (((descriptor->generator)) == (genPushConstantNilBytecode))
-			 && (((fixupAt(pc - initialPC)->targetInstruction)) == 0))) {
-				assert(((descriptor->numBytes)) == 1);
-				(blockStart->numInitialNils = ((blockStart->numInitialNils)) + 1);
-			}
-		}
 		pc = nextBytecodePCForatbyte0in(descriptor, pc, byte0, methodObj);
 	}
 	if (!(needsFrame)) {
 		if (stackDelta < 0) {
 			error("negative stack delta in block; block contains bogus code or internal error");
 		}
-		(blockStart->numInitialNils = 0);
 		while (stackDelta > 0) {
 			descriptor = generatorAt(fetchByteofObject((blockStart->startpc), methodObj));
 			if (((descriptor->generator)) != (genPushConstantNilBytecode)) {
@@ -14146,289 +12908,7 @@
 	}
 }
 
-static void
-ssAllocateCallReg(sqInt requiredReg1)
-{
-	ssAllocateRequiredRegMaskupThrough(callerSavedRegMask | (registerMaskFor(requiredReg1)), simStackPtr);
-}
-
-static void
-ssAllocateCallRegand(sqInt requiredReg1, sqInt requiredReg2)
-{
-	ssAllocateRequiredRegMaskupThrough(callerSavedRegMask | ((registerMaskFor(requiredReg1)) | (registerMaskFor(requiredReg2))), simStackPtr);
-}
-
 static sqInt
-ssAllocatePreferredReg(sqInt preferredReg)
-{
-    sqInt i;
-    sqInt lastPreferred;
-    sqInt liveRegs;
-    sqInt preferredMask;
-    sqInt reg;
-
-
-	/* compute live regs while noting the last occurrence of preferredReg.
-	 If there are none free we must spill from simSpillBase to last occurrence. */
-
-	lastPreferred = -1;
-	preferredMask = registerMaskFor(preferredReg);
-	liveRegs = registerMaskForandand(TempReg, FPReg, SPReg);
-	for (i = (((simSpillBase < 0) ? 0 : simSpillBase)); i <= simStackPtr; i += 1) {
-		liveRegs = liveRegs | (registerMask(simStackAt(i)));
-		if ((liveRegs & preferredMask) != 0) {
-			lastPreferred = i;
-		}
-	}
-	if ((liveRegs & (registerMaskFor(preferredReg))) == 0) {
-		return preferredReg;
-	}
-	for (reg = GPRegMin; reg <= GPRegMax; reg += 1) {
-		if ((liveRegs & (registerMaskFor(reg))) == 0) {
-			return reg;
-		}
-	}
-	ssFlushTo(lastPreferred);
-	assert(((liveRegisters()) & preferredMask) == 0);
-	return preferredReg;
-}
-
-static void
-ssAllocateRequiredRegMaskupThrough(sqInt requiredRegsMask, sqInt stackPtr)
-{
-    sqInt i;
-    sqInt lastRequired;
-    sqInt liveRegs;
-
-
-	/* compute live regs while noting the last occurrence of required regs.
-	 If these are not free we must spill from simSpillBase to last occurrence.
-	 Note we are conservative here; we could allocate FPReg in frameless methods. */
-
-	lastRequired = -1;
-	liveRegs = registerMaskForandand(TempReg, FPReg, SPReg);
-	for (i = (((simSpillBase < 0) ? 0 : simSpillBase)); i <= stackPtr; i += 1) {
-		liveRegs = liveRegs | (registerMask(simStackAt(i)));
-		if ((liveRegs & requiredRegsMask) != 0) {
-			lastRequired = i;
-		}
-	}
-	if (!((liveRegs & requiredRegsMask) == 0)) {
-		ssFlushTo(lastRequired);
-		assert(((liveRegisters()) & requiredRegsMask) == 0);
-	}
-}
-
-static void
-ssAllocateRequiredReg(sqInt requiredReg)
-{
-	ssAllocateRequiredRegMaskupThrough(registerMaskFor(requiredReg), simStackPtr);
-}
-
-static void
-ssAllocateRequiredRegand(sqInt requiredReg1, sqInt requiredReg2)
-{
-	ssAllocateRequiredRegMaskupThrough((registerMaskFor(requiredReg1)) | (registerMaskFor(requiredReg2)), simStackPtr);
-}
-
-static void
-ssAllocateRequiredRegupThrough(sqInt requiredReg, sqInt stackPtr)
-{
-	ssAllocateRequiredRegMaskupThrough(registerMaskFor(requiredReg), stackPtr);
-}
-
-static void
-ssFlushTo(sqInt index)
-{
-    sqInt i;
-
-	for (i = methodOrBlockNumTemps; i <= (simSpillBase - 1); i += 1) {
-		assert((simStackAt(i)->spilled));
-	}
-	if (simSpillBase <= index) {
-		for (i = (((simSpillBase < 0) ? 0 : simSpillBase)); i <= index; i += 1) {
-			assert(needsFrame);
-			ensureSpilledAtfrom(simStackAt(i), frameOffsetOfTemporary(i), FPReg);
-		}
-		simSpillBase = index + 1;
-	}
-}
-
-
-/*	Any occurrences on the stack of the value being stored must
-	be flushed, and hence any values colder than them stack. */
-
-static void
-ssFlushUpThroughReceiverVariable(sqInt slotIndex)
-{
-    CogSimStackEntry *desc;
-    sqInt index;
-
-	for (index = simStackPtr; index >= (((simSpillBase < 0) ? 0 : simSpillBase)); index += -1) {
-		desc = simStackAt(index);
-		if ((((desc->type)) == SSBaseOffset)
-		 && ((((desc->registerr)) == ReceiverResultReg)
- && (((desc->offset)) == (slotOffsetOfInstVarIndex(slotIndex))))) {
-			ssFlushTo(index);
-			return;
-		}
-	}
-}
-
-
-/*	Any occurrences on the stack of the value being stored must
-	be flushed, and hence any values colder than them stack. */
-
-static void
-ssFlushUpThroughTemporaryVariable(sqInt tempIndex)
-{
-    CogSimStackEntry *desc;
-    sqInt index;
-
-	for (index = simStackPtr; index >= simSpillBase; index += -1) {
-		desc = simStackAt(index);
-		if ((((desc->type)) == SSBaseOffset)
-		 && ((((desc->registerr)) == FPReg)
- && (((desc->offset)) == (frameOffsetOfTemporary(tempIndex))))) {
-			ssFlushTo(index);
-			return;
-		}
-	}
-}
-
-static void
-ssPop(sqInt n)
-{
-	assert(((simStackPtr - n) >= (methodOrBlockNumTemps - 1))
-	 || ((!needsFrame)
- && ((simStackPtr - n) >= -1)));
-	simStackPtr -= n;
-}
-
-static sqInt
-ssPushBaseoffset(sqInt reg, sqInt offset)
-{
-    CogSimStackEntry * cascade0;
-
-	ssPush(1);
-	if (simSpillBase > simStackPtr) {
-		simSpillBase = ((simStackPtr < 0) ? 0 : simStackPtr);
-	}
-	cascade0 = ssTop();
-	(cascade0->type = SSBaseOffset);
-	(cascade0->registerr = reg);
-	(cascade0->offset = offset);
-	(cascade0->spilled = 0);
-	(cascade0->bcptr = bytecodePointer);
-	return 0;
-}
-
-static sqInt
-ssPushConstant(sqInt literal)
-{
-    CogSimStackEntry * cascade0;
-
-	ssPush(1);
-	if (simSpillBase > simStackPtr) {
-		simSpillBase = ((simStackPtr < 0) ? 0 : simStackPtr);
-	}
-	cascade0 = ssTop();
-	(cascade0->type = SSConstant);
-	(cascade0->constant = literal);
-	(cascade0->spilled = 0);
-	(cascade0->bcptr = bytecodePointer);
-	return 0;
-}
-
-static sqInt
-ssPushDesc(CogSimStackEntry simStackEntry)
-{
-	if (((simStackEntry.type)) == SSSpill) {
-		(simStackEntry.type = SSBaseOffset);
-	}
-	(simStackEntry.spilled = 0);
-	(simStackEntry.bcptr = bytecodePointer);
-	simStack[(simStackPtr += 1)] = simStackEntry;
-	if (simSpillBase > simStackPtr) {
-		simSpillBase = ((simStackPtr < 0) ? 0 : simStackPtr);
-	}
-	return 0;
-}
-
-static sqInt
-ssPushRegister(sqInt reg)
-{
-    CogSimStackEntry * cascade0;
-
-	ssPush(1);
-	if (simSpillBase > simStackPtr) {
-		simSpillBase = ((simStackPtr < 0) ? 0 : simStackPtr);
-	}
-	cascade0 = ssTop();
-	(cascade0->type = SSRegister);
-	(cascade0->registerr = reg);
-	(cascade0->spilled = 0);
-	(cascade0->bcptr = bytecodePointer);
-	return 0;
-}
-
-static void
-ssPush(sqInt n)
-{
-	simStackPtr += n;
-}
-
-
-/*	Store or pop the top simulated stack entry to a register.
-	Pop to preferredReg if the entry is not itself a register.
-	Answer the actual register the result ends up in. */
-
-static sqInt
-ssStorePoptoPreferredReg(sqInt popBoolean, sqInt preferredReg)
-{
-    sqInt actualReg;
-
-	actualReg = preferredReg;
-	if (popBoolean) {
-		if ((((ssTop()->type)) == SSRegister)
-		 && (!((ssTop()->spilled)))) {
-			actualReg = (ssTop()->registerr);
-		}
-		else {
-			popToReg(ssTop(), preferredReg);
-		}
-		ssPop(1);
-	}
-	else {
-		if (((ssTop()->type)) == SSRegister) {
-			actualReg = (ssTop()->registerr);
-		}
-		else {
-			storeToReg(ssTop(), preferredReg);
-		}
-	}
-	return actualReg;
-}
-
-static CogSimStackEntry *
-ssTop(void)
-{
-	return simStackAt(simStackPtr);
-}
-
-static CogSimStackEntry
-ssTopDescriptor(void)
-{
-	return simStack[simStackPtr];
-}
-
-static CogSimStackEntry *
-ssValue(sqInt n)
-{
-	return simStackAt(simStackPtr - n);
-}
-
-static sqInt
 stackBytesForNumArgs(AbstractInstruction * self_in_stackBytesForNumArgs, sqInt numArgs)
 {
 	return numArgs * 4;
@@ -14472,33 +12952,6 @@
 	byteAtput(followingAddress - 4, literal & 255);
 }
 
-static void
-storeToReg(CogSimStackEntry * self_in_storeToReg, sqInt reg)
-{
-	
-	switch ((self_in_storeToReg->type)) {
-	case SSBaseOffset:
-	case SSSpill:
-				gMoveMwrR((self_in_storeToReg->offset), (self_in_storeToReg->registerr), reg);
-		break;
-	case SSConstant:
-				if (shouldAnnotateObjectReference((self_in_storeToReg->constant))) {
-			annotateobjRef(gMoveCwR((self_in_storeToReg->constant), reg), (self_in_storeToReg->constant));
-		}
-		else {
-			gMoveCqR((self_in_storeToReg->constant), reg);
-		}
-		break;
-	case SSRegister:
-				if (reg != ((self_in_storeToReg->registerr))) {
-			gMoveRR((self_in_storeToReg->registerr), reg);
-		}
-		break;
-	default:
-		error("Case not found and no otherwise clause");
-	}
-}
-
 static sqInt
 sib(AbstractInstruction * self_in_sib, sqInt scale, sqInt indexReg, sqInt baseReg)
 {

Modified: branches/Cog/src/vm/cogit.h
===================================================================
--- branches/Cog/src/vm/cogit.h	2010-12-31 19:27:35 UTC (rev 2336)
+++ branches/Cog/src/vm/cogit.h	2011-01-01 20:18:49 UTC (rev 2337)
@@ -1,5 +1,5 @@
 /* Automatically generated by
-	CCodeGenerator VMMaker-oscog.40 uuid: 637db40c-33c6-4263-816e-1b8cc19e3c99
+	CCodeGenerator VMMaker-oscog.41 uuid: 096b8a29-e7e8-4cbf-b29c-0f096abbdd5c
  */
 
 
@@ -11,12 +11,7 @@
 sqInt canMapBytecodePCsToNativePCs(void);
 extern void (*ceCaptureCStackPointers)();
 sqInt ceCPICMissreceiver(CogMethod *cPIC, sqInt receiver);
-extern void (*ceEnter0ArgsPIC)();
-extern void (*ceEnter1ArgsPIC)();
-extern void (*ceEnter2ArgsPIC)();
 extern void (*ceEnterCogCodePopReceiverAndClassRegs)();
-extern void (*ceEnterCogCodePopReceiverArg0Regs)();
-extern void (*ceEnterCogCodePopReceiverArg1Arg0Regs)();
 extern void (*ceEnterCogCodePopReceiverReg)();
 sqInt ceSICMiss(sqInt receiver);
 void checkAssertsEnabledInCogit(void);
@@ -31,8 +26,6 @@
 void compactCogCompiledCode(void);
 void enterCogCodePopReceiver(void);
 void enterCogCodePopReceiverAndClassRegs(void);
-void enterCogCodePopReceiverArg0Regs(void);
-void enterCogCodePopReceiverArg1Arg0Regs(void);
 CogBlockMethod * findEnclosingMethodForinHomeMethod(sqInt mcpc, CogMethod *cogMethod);
 CogBlockMethod * findMethodForStartBcpcinHomeMethod(sqInt startbcpc, CogMethod *cogMethod);
 sqInt genQuickReturnConst(void);
@@ -83,12 +76,7 @@
 sqInt ceCannotResumeTrampoline;
 void (*ceCaptureCStackPointers)(void);
 sqInt ceCheckForInterruptTrampoline;
-void (*ceEnter0ArgsPIC)(void);
-void (*ceEnter1ArgsPIC)(void);
-void (*ceEnter2ArgsPIC)(void);
 void (*ceEnterCogCodePopReceiverAndClassRegs)(void);
-void (*ceEnterCogCodePopReceiverArg0Regs)(void);
-void (*ceEnterCogCodePopReceiverArg1Arg0Regs)(void);
 void (*ceEnterCogCodePopReceiverReg)(void);
 unsigned long (*ceGetSP)(void);
 sqInt ceReturnToInterpreterTrampoline;
@@ -99,8 +87,6 @@
 sqInt cmNoCheckEntryOffset;
 unsigned long debugPrimCallStackOffset;
 void (*realCEEnterCogCodePopReceiverAndClassRegs)(void);
-void (*realCEEnterCogCodePopReceiverArg0Regs)(void);
-void (*realCEEnterCogCodePopReceiverArg1Arg0Regs)(void);
 void (*realCEEnterCogCodePopReceiverReg)(void);
 int traceLinkedSends ;
 sqInt traceStores;
@@ -115,7 +101,7 @@
 #define getCStackPointer() CStackPointer
 #define noCheckEntryOffset() cmNoCheckEntryOffset
 #define noContextSwitchBlockEntryOffset() blockNoContextSwitchOffset
-#define numRegArgs() 1
+#define numRegArgs() 0
 #define printOnTrace() (traceLinkedSends & 8)
 #define recordEventTrace() (traceLinkedSends & 4)
 #define recordPrimTrace() (traceLinkedSends & 2)

Modified: branches/Cog/src/vm/cointerp.c
===================================================================
--- branches/Cog/src/vm/cointerp.c	2010-12-31 19:27:35 UTC (rev 2336)
+++ branches/Cog/src/vm/cointerp.c	2011-01-01 20:18:49 UTC (rev 2337)
@@ -1,9 +1,9 @@
 /* Automatically generated by
-	CCodeGeneratorGlobalStructure VMMaker-oscog.40 uuid: 637db40c-33c6-4263-816e-1b8cc19e3c99
+	CCodeGeneratorGlobalStructure VMMaker-oscog.41 uuid: 096b8a29-e7e8-4cbf-b29c-0f096abbdd5c
    from
-	CoInterpreter VMMaker-oscog.40 uuid: 637db40c-33c6-4263-816e-1b8cc19e3c99
+	CoInterpreter VMMaker-oscog.41 uuid: 096b8a29-e7e8-4cbf-b29c-0f096abbdd5c
  */
-static char __buildInfo[] = "CoInterpreter VMMaker-oscog.40 uuid: 637db40c-33c6-4263-816e-1b8cc19e3c99 " __DATE__ ;
+static char __buildInfo[] = "CoInterpreter VMMaker-oscog.41 uuid: 096b8a29-e7e8-4cbf-b29c-0f096abbdd5c " __DATE__ ;
 char *__interpBuildInfo = __buildInfo;
 
 
@@ -1859,7 +1859,7 @@
 	/* 575 */ (void (*)(void))0,
  0 };
 static void (*externalPrimitiveTable[MaxExternalPrimitiveTableSize + 1 /* 4097 */])(void);
-const char *interpreterVersion = "Croquet Closure Cog VM [CoInterpreter VMMaker-oscog.40]";
+const char *interpreterVersion = "Croquet Closure Cog VM [CoInterpreter VMMaker-oscog.41]";
 sqInt minBackwardJumpCountForCompile = MinBackwardJumpCountForCompile /* 10 */;
 static volatile int sendTrace;
 
@@ -8649,7 +8649,13 @@
 	GIV(stackPointer) += BytesPerWord;
 	GIV(instructionPointer) = ((sqInt) top);
 	if (primitiveFunctionPointer != 0) {
-		assert((primitiveIndexOf(GIV(newMethod))) != 0);
+		if (primitiveFunctionPointer == (primitiveInvokeObjectAsMethod)) {
+			assert(!(isOopCompiledMethod(GIV(newMethod))));
+		}
+		else {
+			assert((isOopCompiledMethod(GIV(newMethod)))
+			 && ((primitiveIndexOf(GIV(newMethod))) != 0));
+		}
 		(GIV(stackPage)->headFP = GIV(framePointer));
 		if ((((unsigned long) primitiveFunctionPointer)) <= MaxQuickPrimitiveIndex) {
 			externalQuickPrimitiveResponse();
@@ -14016,6 +14022,8 @@
     char *sp1;
     char *sp2;
 
+	
+#  if (numRegArgs()) > 0
 	assert(((numRegArgs()) > 0)
 	 && ((numRegArgs()) <= 2));
 	if (((cogMethod->cmNumArgs)) == 2) {
@@ -14046,6 +14054,12 @@
 	longAtput(sp2 = GIV(stackPointer) - BytesPerWord, rcvr);
 	GIV(stackPointer) = sp2;
 	ceEnterCogCodePopReceiverReg();
+
+#  else /* (numRegArgs()) > 0 */
+	assert(0);
+
+#  endif /* (numRegArgs()) > 0 */
+
 }
 
 

Modified: branches/Cog/src/vm/gcc3x-cointerp.c
===================================================================
--- branches/Cog/src/vm/gcc3x-cointerp.c	2010-12-31 19:27:35 UTC (rev 2336)
+++ branches/Cog/src/vm/gcc3x-cointerp.c	2011-01-01 20:18:49 UTC (rev 2337)
@@ -2,11 +2,11 @@
 
 
 /* Automatically generated by
-	CCodeGeneratorGlobalStructure VMMaker-oscog.40 uuid: 637db40c-33c6-4263-816e-1b8cc19e3c99
+	CCodeGeneratorGlobalStructure VMMaker-oscog.41 uuid: 096b8a29-e7e8-4cbf-b29c-0f096abbdd5c
    from
-	CoInterpreter VMMaker-oscog.40 uuid: 637db40c-33c6-4263-816e-1b8cc19e3c99
+	CoInterpreter VMMaker-oscog.41 uuid: 096b8a29-e7e8-4cbf-b29c-0f096abbdd5c
  */
-static char __buildInfo[] = "CoInterpreter VMMaker-oscog.40 uuid: 637db40c-33c6-4263-816e-1b8cc19e3c99 " __DATE__ ;
+static char __buildInfo[] = "CoInterpreter VMMaker-oscog.41 uuid: 096b8a29-e7e8-4cbf-b29c-0f096abbdd5c " __DATE__ ;
 char *__interpBuildInfo = __buildInfo;
 
 
@@ -1862,7 +1862,7 @@
 	/* 575 */ (void (*)(void))0,
  0 };
 static void (*externalPrimitiveTable[MaxExternalPrimitiveTableSize + 1 /* 4097 */])(void);
-const char *interpreterVersion = "Croquet Closure Cog VM [CoInterpreter VMMaker-oscog.40]";
+const char *interpreterVersion = "Croquet Closure Cog VM [CoInterpreter VMMaker-oscog.41]";
 sqInt minBackwardJumpCountForCompile = MinBackwardJumpCountForCompile /* 10 */;
 static volatile int sendTrace;
 
@@ -1915,12 +1915,13 @@
 interpret(void)
 {   DECL_MAYBE_SQ_GLOBAL_STRUCT
     sqInt backwardJumpCount;
-    sqInt currentBytecode;
+    sqInt currentBytecode CB_REG;
     sqInt lastBackwardJumpMethod;
-    char * localFP;
-    char * localIP;
+    char* localFP FP_REG;
+    char* localIP IP_REG;
     sqInt localReturnValue;
-    char * localSP;
+    char* localSP SP_REG;
+    JUMP_TABLE;
 
 	if (GIV(stackLimit) == 0) {
 		return initStackPagesAndInterpret();
@@ -1938,7 +1939,7 @@
 
 		VM_LABEL(0bytecodeDispatch);
 		switch (currentBytecode) {
-		case 0:
+		CASE(0)
 			/* pushReceiverVariableBytecode */
 			{
 
@@ -1950,8 +1951,8 @@
 				longAtPointerput(localSP -= BytesPerWord, longAt(((longAt(localFP + FoxIFReceiver)) + BaseHeaderSize) + ((0 & 15) << ShiftForWord)));
 			}
 ;
-			break;
-		case 1:
+			BREAK;
+		CASE(1)
 			/* pushReceiverVariableBytecode */
 			{
 
@@ -1963,8 +1964,8 @@
 				longAtPointerput(localSP -= BytesPerWord, longAt(((longAt(localFP + FoxIFReceiver)) + BaseHeaderSize) + ((1 & 15) << ShiftForWord)));
 			}
 ;
-			break;
-		case 2:
+			BREAK;
+		CASE(2)
 			/* pushReceiverVariableBytecode */
 			{
 
@@ -1976,8 +1977,8 @@
 				longAtPointerput(localSP -= BytesPerWord, longAt(((longAt(localFP + FoxIFReceiver)) + BaseHeaderSize) + ((2 & 15) << ShiftForWord)));
 			}
 ;
-			break;
-		case 3:
+			BREAK;
+		CASE(3)
 			/* pushReceiverVariableBytecode */
 			{
 
@@ -1989,8 +1990,8 @@
 				longAtPointerput(localSP -= BytesPerWord, longAt(((longAt(localFP + FoxIFReceiver)) + BaseHeaderSize) + ((3 & 15) << ShiftForWord)));
 			}
 ;
-			break;
-		case 4:
+			BREAK;
+		CASE(4)
 			/* pushReceiverVariableBytecode */
 			{
 
@@ -2002,8 +2003,8 @@
 				longAtPointerput(localSP -= BytesPerWord, longAt(((longAt(localFP + FoxIFReceiver)) + BaseHeaderSize) + ((4 & 15) << ShiftForWord)));
 			}
 ;
-			break;
-		case 5:
+			BREAK;
+		CASE(5)
 			/* pushReceiverVariableBytecode */
 			{
 
@@ -2015,8 +2016,8 @@
 				longAtPointerput(localSP -= BytesPerWord, longAt(((longAt(localFP + FoxIFReceiver)) + BaseHeaderSize) + ((5 & 15) << ShiftForWord)));
 			}
 ;
-			break;
-		case 6:
+			BREAK;
+		CASE(6)
 			/* pushReceiverVariableBytecode */
 			{
 
@@ -2028,8 +2029,8 @@
 				longAtPointerput(localSP -= BytesPerWord, longAt(((longAt(localFP + FoxIFReceiver)) + BaseHeaderSize) + ((6 & 15) << ShiftForWord)));
 			}
 ;
-			break;
-		case 7:
+			BREAK;
+		CASE(7)
 			/* pushReceiverVariableBytecode */
 			{
 
@@ -2041,8 +2042,8 @@
 				longAtPointerput(localSP -= BytesPerWord, longAt(((longAt(localFP + FoxIFReceiver)) + BaseHeaderSize) + ((7 & 15) << ShiftForWord)));
 			}
 ;
-			break;
-		case 8:
+			BREAK;
+		CASE(8)
 			/* pushReceiverVariableBytecode */
 			{
 
@@ -2054,8 +2055,8 @@
 				longAtPointerput(localSP -= BytesPerWord, longAt(((longAt(localFP + FoxIFReceiver)) + BaseHeaderSize) + ((8 & 15) << ShiftForWord)));
 			}
 ;
-			break;
-		case 9:
+			BREAK;
+		CASE(9)
 			/* pushReceiverVariableBytecode */
 			{
 
@@ -2067,8 +2068,8 @@
 				longAtPointerput(localSP -= BytesPerWord, longAt(((longAt(localFP + FoxIFReceiver)) + BaseHeaderSize) + ((9 & 15) << ShiftForWord)));
 			}
 ;
-			break;
-		case 10:
+			BREAK;
+		CASE(10)
 			/* pushReceiverVariableBytecode */
 			{
 
@@ -2080,8 +2081,8 @@
 				longAtPointerput(localSP -= BytesPerWord, longAt(((longAt(localFP + FoxIFReceiver)) + BaseHeaderSize) + ((10 & 15) << ShiftForWord)));
 			}
 ;
-			break;
-		case 11:
+			BREAK;
+		CASE(11)
 			/* pushReceiverVariableBytecode */
 			{
 
@@ -2093,8 +2094,8 @@
 				longAtPointerput(localSP -= BytesPerWord, longAt(((longAt(localFP + FoxIFReceiver)) + BaseHeaderSize) + ((11 & 15) << ShiftForWord)));
 			}
 ;
-			break;
-		case 12:
+			BREAK;
+		CASE(12)
 			/* pushReceiverVariableBytecode */
 			{
 
@@ -2106,8 +2107,8 @@
 				longAtPointerput(localSP -= BytesPerWord, longAt(((longAt(localFP + FoxIFReceiver)) + BaseHeaderSize) + ((12 & 15) << ShiftForWord)));
 			}
 ;
-			break;
-		case 13:
+			BREAK;
+		CASE(13)
 			/* pushReceiverVariableBytecode */
 			{
 
@@ -2119,8 +2120,8 @@
 				longAtPointerput(localSP -= BytesPerWord, longAt(((longAt(localFP + FoxIFReceiver)) + BaseHeaderSize) + ((13 & 15) << ShiftForWord)));
 			}
 ;
-			break;
-		case 14:
+			BREAK;
+		CASE(14)
 			/* pushReceiverVariableBytecode */
 			{
 
@@ -2132,8 +2133,8 @@
 				longAtPointerput(localSP -= BytesPerWord, longAt(((longAt(localFP + FoxIFReceiver)) + BaseHeaderSize) + ((14 & 15) << ShiftForWord)));
 			}
 ;
-			break;
-		case 15:
+			BREAK;
+		CASE(15)
 			/* pushReceiverVariableBytecode */
 			{
 
@@ -2145,8 +2146,8 @@
 				longAtPointerput(localSP -= BytesPerWord, longAt(((longAt(localFP + FoxIFReceiver)) + BaseHeaderSize) + ((15 & 15) << ShiftForWord)));
 			}
 ;
-			break;
-		case 16:
+			BREAK;
+		CASE(16)
 			/* pushTemporaryVariableBytecode */
 			{
 				sqInt frameNumArgs;
@@ -2164,8 +2165,8 @@
 				longAtPointerput(localSP -= BytesPerWord, object);
 			}
 ;
-			break;
-		case 17:
+			BREAK;
+		CASE(17)
 			/* pushTemporaryVariableBytecode */
 			{
 				sqInt frameNumArgs;
@@ -2183,8 +2184,8 @@
 				longAtPointerput(localSP -= BytesPerWord, object);
 			}
 ;
-			break;
-		case 18:
+			BREAK;
+		CASE(18)
 			/* pushTemporaryVariableBytecode */
 			{
 				sqInt frameNumArgs;
@@ -2202,8 +2203,8 @@
 				longAtPointerput(localSP -= BytesPerWord, object);
 			}
 ;
-			break;
-		case 19:
+			BREAK;
+		CASE(19)
 			/* pushTemporaryVariableBytecode */
 			{
 				sqInt frameNumArgs;
@@ -2221,8 +2222,8 @@
 				longAtPointerput(localSP -= BytesPerWord, object);
 			}
 ;
-			break;
-		case 20:
+			BREAK;
+		CASE(20)
 			/* pushTemporaryVariableBytecode */
 			{
 				sqInt frameNumArgs;
@@ -2240,8 +2241,8 @@
 				longAtPointerput(localSP -= BytesPerWord, object);
 			}
 ;
-			break;
-		case 21:
+			BREAK;
+		CASE(21)
 			/* pushTemporaryVariableBytecode */
 			{
 				sqInt frameNumArgs;
@@ -2259,8 +2260,8 @@
 				longAtPointerput(localSP -= BytesPerWord, object);
 			}
 ;
-			break;
-		case 22:
+			BREAK;
+		CASE(22)
 			/* pushTemporaryVariableBytecode */
 			{
 				sqInt frameNumArgs;
@@ -2278,8 +2279,8 @@
 				longAtPointerput(localSP -= BytesPerWord, object);
 			}
 ;
-			break;
-		case 23:
+			BREAK;
+		CASE(23)
 			/* pushTemporaryVariableBytecode */
 			{
 				sqInt frameNumArgs;
@@ -2297,8 +2298,8 @@
 				longAtPointerput(localSP -= BytesPerWord, object);
 			}
 ;
-			break;
-		case 24:
+			BREAK;
+		CASE(24)
 			/* pushTemporaryVariableBytecode */
 			{
 				sqInt frameNumArgs;
@@ -2316,8 +2317,8 @@
 				longAtPointerput(localSP -= BytesPerWord, object);
 			}
 ;
-			break;
-		case 25:
+			BREAK;
+		CASE(25)
 			/* pushTemporaryVariableBytecode */
 			{
 				sqInt frameNumArgs;
@@ -2335,8 +2336,8 @@
 				longAtPointerput(localSP -= BytesPerWord, object);
 			}
 ;
-			break;
-		case 26:
+			BREAK;
+		CASE(26)
 			/* pushTemporaryVariableBytecode */
 			{
 				sqInt frameNumArgs;
@@ -2354,8 +2355,8 @@
 				longAtPointerput(localSP -= BytesPerWord, object);
 			}
 ;
-			break;
-		case 27:
+			BREAK;
+		CASE(27)
 			/* pushTemporaryVariableBytecode */
 			{
 				sqInt frameNumArgs;
@@ -2373,8 +2374,8 @@
 				longAtPointerput(localSP -= BytesPerWord, object);
 			}
 ;
-			break;
-		case 28:
+			BREAK;
+		CASE(28)
 			/* pushTemporaryVariableBytecode */
 			{
 				sqInt frameNumArgs;
@@ -2392,8 +2393,8 @@
 				longAtPointerput(localSP -= BytesPerWord, object);
 			}
 ;
-			break;
-		case 29:
+			BREAK;
+		CASE(29)
 			/* pushTemporaryVariableBytecode */
 			{
 				sqInt frameNumArgs;
@@ -2411,8 +2412,8 @@
 				longAtPointerput(localSP -= BytesPerWord, object);
 			}
 ;
-			break;
-		case 30:
+			BREAK;
+		CASE(30)
 			/* pushTemporaryVariableBytecode */
 			{
 				sqInt frameNumArgs;
@@ -2430,8 +2431,8 @@
 				longAtPointerput(localSP -= BytesPerWord, object);
 			}
 ;
-			break;
-		case 31:
+			BREAK;
+		CASE(31)
 			/* pushTemporaryVariableBytecode */
 			{
 				sqInt frameNumArgs;
@@ -2449,8 +2450,8 @@
 				longAtPointerput(localSP -= BytesPerWord, object);
 			}
 ;
-			break;
-		case 32:
+			BREAK;
+		CASE(32)
 			/* pushLiteralConstantBytecode */
 			{
 				sqInt object;
@@ -2466,8 +2467,8 @@
 				longAtPointerput(localSP -= BytesPerWord, object);
 			}
 ;
-			break;
-		case 33:
+			BREAK;
+		CASE(33)
 			/* pushLiteralConstantBytecode */
 			{
 				sqInt object;
@@ -2483,8 +2484,8 @@
 				longAtPointerput(localSP -= BytesPerWord, object);
 			}
 ;
-			break;
-		case 34:
+			BREAK;
+		CASE(34)
 			/* pushLiteralConstantBytecode */
 			{
 				sqInt object;
@@ -2500,8 +2501,8 @@
 				longAtPointerput(localSP -= BytesPerWord, object);
 			}
 ;
-			break;
-		case 35:
+			BREAK;
+		CASE(35)
 			/* pushLiteralConstantBytecode */
 			{
 				sqInt object;
@@ -2517,8 +2518,8 @@
 				longAtPointerput(localSP -= BytesPerWord, object);
 			}
 ;
-			break;
-		case 36:
+			BREAK;
+		CASE(36)
 			/* pushLiteralConstantBytecode */
 			{
 				sqInt object;
@@ -2534,8 +2535,8 @@
 				longAtPointerput(localSP -= BytesPerWord, object);
 			}
 ;
-			break;
-		case 37:
+			BREAK;
+		CASE(37)
 			/* pushLiteralConstantBytecode */
 			{
 				sqInt object;
@@ -2551,8 +2552,8 @@
 				longAtPointerput(localSP -= BytesPerWord, object);
 			}
 ;
-			break;
-		case 38:
+			BREAK;
+		CASE(38)
 			/* pushLiteralConstantBytecode */
 			{
 				sqInt object;
@@ -2568,8 +2569,8 @@
 				longAtPointerput(localSP -= BytesPerWord, object);
 			}
 ;
-			break;
-		case 39:
+			BREAK;
+		CASE(39)
 			/* pushLiteralConstantBytecode */
 			{
 				sqInt object;
@@ -2585,8 +2586,8 @@
 				longAtPointerput(localSP -= BytesPerWord, object);
 			}
 ;
-			break;
-		case 40:
+			BREAK;
+		CASE(40)
 			/* pushLiteralConstantBytecode */
 			{
 				sqInt object;
@@ -2602,8 +2603,8 @@
 				longAtPointerput(localSP -= BytesPerWord, object);
 			}
 ;
-			break;
-		case 41:
+			BREAK;
+		CASE(41)
 			/* pushLiteralConstantBytecode */
 			{
 				sqInt object;
@@ -2619,8 +2620,8 @@
 				longAtPointerput(localSP -= BytesPerWord, object);
 			}
 ;
-			break;
-		case 42:
+			BREAK;
+		CASE(42)
 			/* pushLiteralConstantBytecode */
 			{
 				sqInt object;
@@ -2636,8 +2637,8 @@
 				longAtPointerput(localSP -= BytesPerWord, object);
 			}
 ;
-			break;
-		case 43:
+			BREAK;
+		CASE(43)
 			/* pushLiteralConstantBytecode */
 			{
 				sqInt object;
@@ -2653,8 +2654,8 @@
 				longAtPointerput(localSP -= BytesPerWord, object);
 			}
 ;
-			break;
-		case 44:
+			BREAK;
+		CASE(44)
 			/* pushLiteralConstantBytecode */
 			{
 				sqInt object;
@@ -2670,8 +2671,8 @@
 				longAtPointerput(localSP -= BytesPerWord, object);
 			}
 ;
-			break;
-		case 45:
+			BREAK;
+		CASE(45)
 			/* pushLiteralConstantBytecode */
 			{
 				sqInt object;
@@ -2687,8 +2688,8 @@
 				longAtPointerput(localSP -= BytesPerWord, object);
 			}
 ;
-			break;
-		case 46:
+			BREAK;
+		CASE(46)
 			/* pushLiteralConstantBytecode */
 			{
 				sqInt object;
@@ -2704,8 +2705,8 @@
 				longAtPointerput(localSP -= BytesPerWord, object);
 			}
 ;
-			break;
-		case 47:
+			BREAK;
+		CASE(47)
 			/* pushLiteralConstantBytecode */
 			{
 				sqInt object;
@@ -2721,8 +2722,8 @@
 				longAtPointerput(localSP -= BytesPerWord, object);
 			}
 ;
-			break;
-		case 48:
+			BREAK;
+		CASE(48)
 			/* pushLiteralConstantBytecode */
 			{
 				sqInt object;
@@ -2738,8 +2739,8 @@
 				longAtPointerput(localSP -= BytesPerWord, object);
 			}
 ;
-			break;
-		case 49:
+			BREAK;
+		CASE(49)
 			/* pushLiteralConstantBytecode */
 			{
 				sqInt object;
@@ -2755,8 +2756,8 @@
 				longAtPointerput(localSP -= BytesPerWord, object);
 			}
 ;
-			break;
-		case 50:
+			BREAK;
+		CASE(50)
 			/* pushLiteralConstantBytecode */
 			{
 				sqInt object;
@@ -2772,8 +2773,8 @@
 				longAtPointerput(localSP -= BytesPerWord, object);
 			}
 ;
-			break;
-		case 51:
+			BREAK;
+		CASE(51)
 			/* pushLiteralConstantBytecode */
 			{
 				sqInt object;
@@ -2789,8 +2790,8 @@
 				longAtPointerput(localSP -= BytesPerWord, object);
 			}
 ;
-			break;
-		case 52:
+			BREAK;
+		CASE(52)
 			/* pushLiteralConstantBytecode */
 			{
 				sqInt object;
@@ -2806,8 +2807,8 @@
 				longAtPointerput(localSP -= BytesPerWord, object);
 			}
 ;
-			break;
-		case 53:
+			BREAK;
+		CASE(53)
 			/* pushLiteralConstantBytecode */
 			{
 				sqInt object;
@@ -2823,8 +2824,8 @@
 				longAtPointerput(localSP -= BytesPerWord, object);
 			}
 ;
-			break;
-		case 54:
+			BREAK;
+		CASE(54)
 			/* pushLiteralConstantBytecode */
 			{
 				sqInt object;
@@ -2840,8 +2841,8 @@
 				longAtPointerput(localSP -= BytesPerWord, object);
 			}
 ;
-			break;
-		case 55:
+			BREAK;
+		CASE(55)
 			/* pushLiteralConstantBytecode */
 			{
 				sqInt object;
@@ -2857,8 +2858,8 @@
 				longAtPointerput(localSP -= BytesPerWord, object);
 			}
 ;
-			break;
-		case 56:
+			BREAK;
+		CASE(56)
 			/* pushLiteralConstantBytecode */
 			{
 				sqInt object;
@@ -2874,8 +2875,8 @@
 				longAtPointerput(localSP -= BytesPerWord, object);
 			}
 ;
-			break;
-		case 57:
+			BREAK;
+		CASE(57)
 			/* pushLiteralConstantBytecode */
 			{
 				sqInt object;
@@ -2891,8 +2892,8 @@
 				longAtPointerput(localSP -= BytesPerWord, object);
 			}
 ;
-			break;
-		case 58:
+			BREAK;
+		CASE(58)
 			/* pushLiteralConstantBytecode */
 			{
 				sqInt object;
@@ -2908,8 +2909,8 @@
 				longAtPointerput(localSP -= BytesPerWord, object);
 			}
 ;
-			break;
-		case 59:
+			BREAK;
+		CASE(59)
 			/* pushLiteralConstantBytecode */
 			{
 				sqInt object;
@@ -2925,8 +2926,8 @@
 				longAtPointerput(localSP -= BytesPerWord, object);
 			}
 ;
-			break;
-		case 60:
+			BREAK;
+		CASE(60)
 			/* pushLiteralConstantBytecode */
 			{
 				sqInt object;
@@ -2942,8 +2943,8 @@
 				longAtPointerput(localSP -= BytesPerWord, object);
 			}
 ;
-			break;
-		case 61:
+			BREAK;
+		CASE(61)
 			/* pushLiteralConstantBytecode */
 			{
 				sqInt object;
@@ -2959,8 +2960,8 @@
 				longAtPointerput(localSP -= BytesPerWord, object);
 			}
 ;
-			break;
-		case 62:
+			BREAK;
+		CASE(62)
 			/* pushLiteralConstantBytecode */
 			{
 				sqInt object;
@@ -2976,8 +2977,8 @@
 				longAtPointerput(localSP -= BytesPerWord, object);
 			}
 ;
-			break;
-		case 63:
+			BREAK;
+		CASE(63)
 			/* pushLiteralConstantBytecode */
 			{
 				sqInt object;
@@ -2993,8 +2994,8 @@
 				longAtPointerput(localSP -= BytesPerWord, object);
 			}
 ;
-			break;
-		case 64:
+			BREAK;
+		CASE(64)
 			/* pushLiteralVariableBytecode */
 			{
 				sqInt object;
@@ -3013,8 +3014,8 @@
 				longAtPointerput(localSP -= BytesPerWord, object);
 			}
 ;
-			break;
-		case 65:
+			BREAK;
+		CASE(65)
 			/* pushLiteralVariableBytecode */
 			{
 				sqInt object;
@@ -3033,8 +3034,8 @@
 				longAtPointerput(localSP -= BytesPerWord, object);
 			}
 ;
-			break;
-		case 66:
+			BREAK;
+		CASE(66)
 			/* pushLiteralVariableBytecode */
 			{
 				sqInt object;
@@ -3053,8 +3054,8 @@
 				longAtPointerput(localSP -= BytesPerWord, object);
 			}
 ;
-			break;
-		case 67:
+			BREAK;
+		CASE(67)
 			/* pushLiteralVariableBytecode */
 			{
 				sqInt object;
@@ -3073,8 +3074,8 @@
 				longAtPointerput(localSP -= BytesPerWord, object);
 			}
 ;
-			break;
-		case 68:
+			BREAK;
+		CASE(68)
 			/* pushLiteralVariableBytecode */
 			{
 				sqInt object;
@@ -3093,8 +3094,8 @@
 				longAtPointerput(localSP -= BytesPerWord, object);
 			}
 ;
-			break;
-		case 69:
+			BREAK;
+		CASE(69)
 			/* pushLiteralVariableBytecode */
 			{
 				sqInt object;
@@ -3113,8 +3114,8 @@
 				longAtPointerput(localSP -= BytesPerWord, object);
 			}
 ;
-			break;
-		case 70:
+			BREAK;
+		CASE(70)
 			/* pushLiteralVariableBytecode */
 			{
 				sqInt object;
@@ -3133,8 +3134,8 @@
 				longAtPointerput(localSP -= BytesPerWord, object);
 			}
 ;
-			break;
-		case 71:
+			BREAK;
+		CASE(71)
 			/* pushLiteralVariableBytecode */
 			{
 				sqInt object;
@@ -3153,8 +3154,8 @@
 				longAtPointerput(localSP -= BytesPerWord, object);
 			}
 ;
-			break;
-		case 72:
+			BREAK;
+		CASE(72)
 			/* pushLiteralVariableBytecode */
 			{
 				sqInt object;
@@ -3173,8 +3174,8 @@
 				longAtPointerput(localSP -= BytesPerWord, object);
 			}
 ;
-			break;
-		case 73:
+			BREAK;
+		CASE(73)
 			/* pushLiteralVariableBytecode */
 			{
 				sqInt object;
@@ -3193,8 +3194,8 @@
 				longAtPointerput(localSP -= BytesPerWord, object);
 			}
 ;
-			break;
-		case 74:
+			BREAK;
+		CASE(74)
 			/* pushLiteralVariableBytecode */
 			{
 				sqInt object;
@@ -3213,8 +3214,8 @@
 				longAtPointerput(localSP -= BytesPerWord, object);
 			}
 ;
-			break;
-		case 75:
+			BREAK;
+		CASE(75)
 			/* pushLiteralVariableBytecode */
 			{
 				sqInt object;
@@ -3233,8 +3234,8 @@
 				longAtPointerput(localSP -= BytesPerWord, object);
 			}
 ;
-			break;
-		case 76:
+			BREAK;
+		CASE(76)
 			/* pushLiteralVariableBytecode */
 			{
 				sqInt object;
@@ -3253,8 +3254,8 @@
 				longAtPointerput(localSP -= BytesPerWord, object);
 			}
 ;
-			break;
-		case 77:
+			BREAK;
+		CASE(77)
 			/* pushLiteralVariableBytecode */
 			{
 				sqInt object;
@@ -3273,8 +3274,8 @@
 				longAtPointerput(localSP -= BytesPerWord, object);
 			}
 ;
-			break;
-		case 78:
+			BREAK;
+		CASE(78)
 			/* pushLiteralVariableBytecode */
 			{
 				sqInt object;
@@ -3293,8 +3294,8 @@
 				longAtPointerput(localSP -= BytesPerWord, object);
 			}
 ;
-			break;
-		case 79:
+			BREAK;
+		CASE(79)
 			/* pushLiteralVariableBytecode */
 			{
 				sqInt object;
@@ -3313,8 +3314,8 @@
 				longAtPointerput(localSP -= BytesPerWord, object);
 			}
 ;
-			break;
-		case 80:
+			BREAK;
+		CASE(80)
 			/* pushLiteralVariableBytecode */
 			{
 				sqInt object;
@@ -3333,8 +3334,8 @@
 				longAtPointerput(localSP -= BytesPerWord, object);
 			}
 ;
-			break;
-		case 81:
+			BREAK;
+		CASE(81)
 			/* pushLiteralVariableBytecode */
 			{
 				sqInt object;
@@ -3353,8 +3354,8 @@
 				longAtPointerput(localSP -= BytesPerWord, object);
 			}
 ;
-			break;
-		case 82:
+			BREAK;
+		CASE(82)
 			/* pushLiteralVariableBytecode */
 			{
 				sqInt object;
@@ -3373,8 +3374,8 @@
 				longAtPointerput(localSP -= BytesPerWord, object);
 			}
 ;
-			break;
-		case 83:
+			BREAK;
+		CASE(83)
 			/* pushLiteralVariableBytecode */
 			{
 				sqInt object;
@@ -3393,8 +3394,8 @@
 				longAtPointerput(localSP -= BytesPerWord, object);
 			}
 ;
-			break;
-		case 84:
+			BREAK;
+		CASE(84)
 			/* pushLiteralVariableBytecode */
 			{
 				sqInt object;
@@ -3413,8 +3414,8 @@
 				longAtPointerput(localSP -= BytesPerWord, object);
 			}
 ;
-			break;
-		case 85:
+			BREAK;
+		CASE(85)
 			/* pushLiteralVariableBytecode */
 			{
 				sqInt object;
@@ -3433,8 +3434,8 @@
 				longAtPointerput(localSP -= BytesPerWord, object);
 			}
 ;
-			break;
-		case 86:
+			BREAK;
+		CASE(86)
 			/* pushLiteralVariableBytecode */
 			{
 				sqInt object;
@@ -3453,8 +3454,8 @@
 				longAtPointerput(localSP -= BytesPerWord, object);
 			}
 ;
-			break;
-		case 87:
+			BREAK;
+		CASE(87)
 			/* pushLiteralVariableBytecode */
 			{
 				sqInt object;
@@ -3473,8 +3474,8 @@
 				longAtPointerput(localSP -= BytesPerWord, object);
 			}
 ;
-			break;
-		case 88:
+			BREAK;
+		CASE(88)
 			/* pushLiteralVariableBytecode */
 			{
 				sqInt object;
@@ -3493,8 +3494,8 @@
 				longAtPointerput(localSP -= BytesPerWord, object);
 			}
 ;
-			break;
-		case 89:
+			BREAK;
+		CASE(89)
 			/* pushLiteralVariableBytecode */
 			{
 				sqInt object;
@@ -3513,8 +3514,8 @@
 				longAtPointerput(localSP -= BytesPerWord, object);
 			}
 ;
-			break;
-		case 90:
+			BREAK;
+		CASE(90)
 			/* pushLiteralVariableBytecode */
 			{
 				sqInt object;
@@ -3533,8 +3534,8 @@
 				longAtPointerput(localSP -= BytesPerWord, object);
 			}
 ;
-			break;
-		case 91:
+			BREAK;
+		CASE(91)
 			/* pushLiteralVariableBytecode */
 			{
 				sqInt object;
@@ -3553,8 +3554,8 @@
 				longAtPointerput(localSP -= BytesPerWord, object);
 			}
 ;
-			break;
-		case 92:
+			BREAK;
+		CASE(92)
 			/* pushLiteralVariableBytecode */
 			{
 				sqInt object;
@@ -3573,8 +3574,8 @@
 				longAtPointerput(localSP -= BytesPerWord, object);
 			}
 ;
-			break;
-		case 93:
+			BREAK;
+		CASE(93)
 			/* pushLiteralVariableBytecode */
 			{
 				sqInt object;
@@ -3593,8 +3594,8 @@
 				longAtPointerput(localSP -= BytesPerWord, object);
 			}
 ;
-			break;
-		case 94:
+			BREAK;
+		CASE(94)
 			/* pushLiteralVariableBytecode */
 			{
 				sqInt object;
@@ -3613,8 +3614,8 @@
 				longAtPointerput(localSP -= BytesPerWord, object);
 			}
 ;
-			break;
-		case 95:
+			BREAK;
+		CASE(95)
 			/* pushLiteralVariableBytecode */
 			{
 				sqInt object;
@@ -3633,15 +3634,15 @@
 				longAtPointerput(localSP -= BytesPerWord, object);
 			}
 ;
-			break;
-		case 96:
-		case 97:
-		case 98:
-		case 99:
-		case 100:
-		case 101:
-		case 102:
-		case 103:
+			BREAK;
+		CASE(96)
+		CASE(97)
+		CASE(98)
+		CASE(99)
+		CASE(100)
+		CASE(101)
+		CASE(102)
+		CASE(103)
 			/* storeAndPopReceiverVariableBytecode */
 			{
 				sqInt rcvr;
@@ -3660,8 +3661,8 @@
 				localSP += 1 * BytesPerWord;
 			}
 ;
-			break;
-		case 104:
+			BREAK;
+		CASE(104)
 			/* storeAndPopTemporaryVariableBytecode */
 			{
 				sqInt frameNumArgs;
@@ -3681,8 +3682,8 @@
 				localSP += 1 * BytesPerWord;
 			}
 ;
-			break;
-		case 105:
+			BREAK;
+		CASE(105)
 			/* storeAndPopTemporaryVariableBytecode */
 			{
 				sqInt frameNumArgs;
@@ -3702,8 +3703,8 @@
 				localSP += 1 * BytesPerWord;
 			}
 ;
-			break;
-		case 106:
+			BREAK;
+		CASE(106)
 			/* storeAndPopTemporaryVariableBytecode */
 			{
 				sqInt frameNumArgs;
@@ -3723,8 +3724,8 @@
 				localSP += 1 * BytesPerWord;
 			}
 ;
-			break;
-		case 107:
+			BREAK;
+		CASE(107)
 			/* storeAndPopTemporaryVariableBytecode */
 			{
 				sqInt frameNumArgs;
@@ -3744,8 +3745,8 @@
 				localSP += 1 * BytesPerWord;
 			}
 ;
-			break;
-		case 108:
+			BREAK;
+		CASE(108)
 			/* storeAndPopTemporaryVariableBytecode */
 			{
 				sqInt frameNumArgs;
@@ -3765,8 +3766,8 @@
 				localSP += 1 * BytesPerWord;
 			}
 ;
-			break;
-		case 109:
+			BREAK;
+		CASE(109)
 			/* storeAndPopTemporaryVariableBytecode */
 			{
 				sqInt frameNumArgs;
@@ -3786,8 +3787,8 @@
 				localSP += 1 * BytesPerWord;
 			}
 ;
-			break;
-		case 110:
+			BREAK;
+		CASE(110)
 			/* storeAndPopTemporaryVariableBytecode */
 			{
 				sqInt frameNumArgs;
@@ -3807,8 +3808,8 @@
 				localSP += 1 * BytesPerWord;
 			}
 ;
-			break;
-		case 111:
+			BREAK;
+		CASE(111)
 			/* storeAndPopTemporaryVariableBytecode */
 			{
 				sqInt frameNumArgs;
@@ -3828,8 +3829,8 @@
 				localSP += 1 * BytesPerWord;
 			}
 ;
-			break;
-		case 112:
+			BREAK;
+		CASE(112)
 			/* pushReceiverBytecode */
 			{
 
@@ -3840,8 +3841,8 @@
 				longAtPointerput(localSP -= BytesPerWord, longAt(localFP + FoxIFReceiver));
 			}
 ;
-			break;
-		case 113:
+			BREAK;
+		CASE(113)
 			/* pushConstantTrueBytecode */
 			{
 
@@ -3852,8 +3853,8 @@
 				longAtPointerput(localSP -= BytesPerWord, GIV(trueObj));
 			}
 ;
-			break;
-		case 114:
+			BREAK;
+		CASE(114)
 			/* pushConstantFalseBytecode */
 			{
 
@@ -3864,8 +3865,8 @@
 				longAtPointerput(localSP -= BytesPerWord, GIV(falseObj));
 			}
 ;
-			break;
-		case 115:
+			BREAK;
+		CASE(115)
 			/* pushConstantNilBytecode */
 			{
 
@@ -3876,8 +3877,8 @@
 				longAtPointerput(localSP -= BytesPerWord, GIV(nilObj));
 			}
 ;
-			break;
-		case 116:
+			BREAK;
+		CASE(116)
 			/* pushConstantMinusOneBytecode */
 			{
 
@@ -3888,8 +3889,8 @@
 				longAtPointerput(localSP -= BytesPerWord, ConstMinusOne);
 			}
 ;
-			break;
-		case 117:
+			BREAK;
+		CASE(117)
 			/* pushConstantZeroBytecode */
 			{
 
@@ -3900,8 +3901,8 @@
 				longAtPointerput(localSP -= BytesPerWord, ConstZero);
 			}
 ;
-			break;
-		case 118:
+			BREAK;
+		CASE(118)
 			/* pushConstantOneBytecode */
 			{
 
@@ -3912,8 +3913,8 @@
 				longAtPointerput(localSP -= BytesPerWord, ConstOne);
 			}
 ;
-			break;
-		case 119:
+			BREAK;
+		CASE(119)
 			/* pushConstantTwoBytecode */
 			{
 
@@ -3924,8 +3925,8 @@
 				longAtPointerput(localSP -= BytesPerWord, ConstTwo);
 			}
 ;
-			break;
-		case 120:
+			BREAK;
+		CASE(120)
 			/* returnReceiver */
 			{
 
@@ -4253,8 +4254,8 @@
 			}
 ;
 		l94:	/* end case */;
-			break;
-		case 121:
+			BREAK;
+		CASE(121)
 			/* returnTrue */
 			{
 
@@ -4263,8 +4264,8 @@
 				goto commonReturn;
 			}
 ;
-			break;
-		case 122:
+			BREAK;
+		CASE(122)
 			/* returnFalse */
 			{
 
@@ -4273,8 +4274,8 @@
 				goto commonReturn;
 			}
 ;
-			break;
-		case 123:
+			BREAK;
+		CASE(123)
 			/* returnNil */
 			{
 
@@ -4283,8 +4284,8 @@
 				goto commonReturn;
 			}
 ;
-			break;
-		case 124:
+			BREAK;
+		CASE(124)
 			/* returnTopFromMethod */
 			{
 
@@ -4293,8 +4294,8 @@
 				goto commonReturn;
 			}
 ;
-			break;
-		case 125:
+			BREAK;
+		CASE(125)
 			/* returnTopFromBlock */
 			{
 
@@ -4502,9 +4503,9 @@
 			}
 ;
 		l99:	/* end case */;
-			break;
-		case 126:
-		case 127:
+			BREAK;
+		CASE(126)
+		CASE(127)
 			/* unknownBytecode */
 			{
 
@@ -4512,8 +4513,8 @@
 								error("Unknown bytecode");
 			}
 ;
-			break;
-		case 128:
+			BREAK;
+		CASE(128)
 			/* extendedPushBytecode */
 			{
 				sqInt descriptor;
@@ -4569,8 +4570,8 @@
 			}
 ;
 		l1:	/* end case */;
-			break;
-		case 129:
+			BREAK;
+		CASE(129)
 			/* extendedStoreBytecode */
 			{
 				sqInt association;
@@ -4618,8 +4619,8 @@
 			}
 ;
 		l2:	/* end case */;
-			break;
-		case 130:
+			BREAK;
+		CASE(130)
 			/* extendedStoreAndPopBytecode */
 			{
 				sqInt association;
@@ -4671,8 +4672,8 @@
 				localSP += 1 * BytesPerWord;
 			}
 ;
-			break;
-		case 131:
+			BREAK;
+		CASE(131)
 			/* singleExtendedSendBytecode */
 			{
 				sqInt descriptor;
@@ -5001,8 +5002,8 @@
 				currentBytecode = byteAtPointer(++localIP);
 			}
 ;
-			break;
-		case 132:
+			BREAK;
+		CASE(132)
 			/* doubleExtendedDoAnythingBytecode */
 			{
 				sqInt byte2;
@@ -5340,8 +5341,8 @@
 			}
 ;
 		l4:	/* end case */;
-			break;
-		case 133:
+			BREAK;
+		CASE(133)
 			/* singleExtendedSuperBytecode */
 			{
 				sqInt descriptor;
@@ -5376,8 +5377,8 @@
 				goto commonSend;
 			}
 ;
-			break;
-		case 134:
+			BREAK;
+		CASE(134)
 			/* secondExtendedSendBytecode */
 			{
 				sqInt descriptor;
@@ -5391,8 +5392,8 @@
 				goto normalSend;
 			}
 ;
-			break;
-		case 135:
+			BREAK;
+		CASE(135)
 			/* popStackBytecode */
 			{
 
@@ -5403,8 +5404,8 @@
 				localSP += 1 * BytesPerWord;
 			}
 ;
-			break;
-		case 136:
+			BREAK;
+		CASE(136)
 			/* duplicateTopBytecode */
 			{
 				sqInt object;
@@ -5417,8 +5418,8 @@
 				longAtPointerput(localSP -= BytesPerWord, object);
 			}
 ;
-			break;
-		case 137:
+			BREAK;
+		CASE(137)
 			/* pushActiveContextBytecode */
 			{
 				sqInt ourContext;
@@ -5445,8 +5446,8 @@
 				longAtPointerput(localSP -= BytesPerWord, ourContext);
 			}
 ;
-			break;
-		case 138:
+			BREAK;
+		CASE(138)
 			/* pushNewArrayBytecode */
 			{
 				sqInt array;
@@ -5487,8 +5488,8 @@
 				longAtPointerput(localSP -= BytesPerWord, array);
 			}
 ;
-			break;
-		case 139:
+			BREAK;
+		CASE(139)
 			/* unknownBytecode */
 			{
 
@@ -5496,8 +5497,8 @@
 								error("Unknown bytecode");
 			}
 ;
-			break;
-		case 140:
+			BREAK;
+		CASE(140)
 			/* pushRemoteTempLongBytecode */
 			{
 				sqInt remoteTempIndex;
@@ -5519,8 +5520,8 @@
 				longAtPointerput(localSP -= BytesPerWord, longAt((tempVector + BaseHeaderSize) + (remoteTempIndex << ShiftForWord)));
 			}
 ;
-			break;
-		case 141:
+			BREAK;
+		CASE(141)
 			/* storeRemoteTempLongBytecode */
 			{
 				sqInt remoteTempIndex;
@@ -5545,8 +5546,8 @@
 				longAtput((tempVector + BaseHeaderSize) + (remoteTempIndex << ShiftForWord), longAtPointer(localSP));
 			}
 ;
-			break;
-		case 142:
+			BREAK;
+		CASE(142)
 			/* storeAndPopRemoteTempLongBytecode */
 			{
 				sqInt remoteTempIndex;
@@ -5574,8 +5575,8 @@
 				localSP += 1 * BytesPerWord;
 			}
 ;
-			break;
-		case 143:
+			BREAK;
+		CASE(143)
 			/* pushClosureCopyCopiedValuesBytecode */
 			{
 				sqInt blockSize;
@@ -5645,8 +5646,8 @@
 				longAtPointerput(localSP -= BytesPerWord, newClosure);
 			}
 ;
-			break;
-		case 144:
+			BREAK;
+		CASE(144)
 			/* shortUnconditionalJump */
 			{
 				sqInt offset;
@@ -5658,8 +5659,8 @@
 				currentBytecode = byteAtPointer(localIP);
 			}
 ;
-			break;
-		case 145:
+			BREAK;
+		CASE(145)
 			/* shortUnconditionalJump */
 			{
 				sqInt offset;
@@ -5671,8 +5672,8 @@
 				currentBytecode = byteAtPointer(localIP);
 			}
 ;
-			break;
-		case 146:
+			BREAK;
+		CASE(146)
 			/* shortUnconditionalJump */
 			{
 				sqInt offset;
@@ -5684,8 +5685,8 @@
 				currentBytecode = byteAtPointer(localIP);
 			}
 ;
-			break;
-		case 147:
+			BREAK;
+		CASE(147)
 			/* shortUnconditionalJump */
 			{
 				sqInt offset;
@@ -5697,8 +5698,8 @@
 				currentBytecode = byteAtPointer(localIP);
 			}
 ;
-			break;
-		case 148:
+			BREAK;
+		CASE(148)
 			/* shortUnconditionalJump */
 			{
 				sqInt offset;
@@ -5710,8 +5711,8 @@
 				currentBytecode = byteAtPointer(localIP);
 			}
 ;
-			break;
-		case 149:
+			BREAK;
+		CASE(149)
 			/* shortUnconditionalJump */
 			{
 				sqInt offset;
@@ -5723,8 +5724,8 @@
 				currentBytecode = byteAtPointer(localIP);
 			}
 ;
-			break;
-		case 150:
+			BREAK;
+		CASE(150)
 			/* shortUnconditionalJump */
 			{
 				sqInt offset;
@@ -5736,8 +5737,8 @@
 				currentBytecode = byteAtPointer(localIP);
 			}
 ;
-			break;
-		case 151:
+			BREAK;
+		CASE(151)
 			/* shortUnconditionalJump */
 			{
 				sqInt offset;
@@ -5749,15 +5750,15 @@
 				currentBytecode = byteAtPointer(localIP);
 			}
 ;
-			break;
-		case 152:
-		case 153:
-		case 154:
-		case 155:
-		case 156:
-		case 157:
-		case 158:
-		case 159:
+			BREAK;
+		CASE(152)
+		CASE(153)
+		CASE(154)
+		CASE(155)
+		CASE(156)
+		CASE(157)
+		CASE(158)
+		CASE(159)
 			/* shortConditionalJump */
 			{
 				sqInt offset;
@@ -5788,15 +5789,15 @@
 			l10:	/* end jumplfFalseBy: */;
 			}
 ;
-			break;
-		case 160:
-		case 161:
-		case 162:
-		case 163:
-		case 164:
-		case 165:
-		case 166:
-		case 167:
+			BREAK;
+		CASE(160)
+		CASE(161)
+		CASE(162)
+		CASE(163)
+		CASE(164)
+		CASE(165)
+		CASE(166)
+		CASE(167)
 			/* longUnconditionalJump */
 			{
 				sqInt offset;
@@ -5940,11 +5941,11 @@
 				currentBytecode = byteAtPointer(++localIP);
 			}
 ;
-			break;
-		case 168:
-		case 169:
-		case 170:
-		case 171:
+			BREAK;
+		CASE(168)
+		CASE(169)
+		CASE(170)
+		CASE(171)
 			/* longJumpIfTrue */
 			{
 				sqInt offset;
@@ -5975,11 +5976,11 @@
 			l11:	/* end jumplfTrueBy: */;
 			}
 ;
-			break;
-		case 172:
-		case 173:
-		case 174:
-		case 175:
+			BREAK;
+		CASE(172)
+		CASE(173)
+		CASE(174)
+		CASE(175)
 			/* longJumpIfFalse */
 			{
 				sqInt offset;
@@ -6010,8 +6011,8 @@
 			l12:	/* end jumplfFalseBy: */;
 			}
 ;
-			break;
-		case 176:
+			BREAK;
+		CASE(176)
 			/* bytecodePrimAdd */
 			{
 				sqInt arg;
@@ -6141,8 +6142,8 @@
 			}
 ;
 		l13:	/* end case */;
-			break;
-		case 177:
+			BREAK;
+		CASE(177)
 			/* bytecodePrimSubtract */
 			{
 				sqInt arg;
@@ -6272,8 +6273,8 @@
 			}
 ;
 		l18:	/* end case */;
-			break;
-		case 178:
+			BREAK;
+		CASE(178)
 			/* bytecodePrimLessThan */
 			{
 				sqInt aBool;
@@ -6424,8 +6425,8 @@
 			}
 ;
 		l107:	/* end case */;
-			break;
-		case 179:
+			BREAK;
+		CASE(179)
 			/* bytecodePrimGreaterThan */
 			{
 				sqInt aBool;
@@ -6582,8 +6583,8 @@
 			}
 ;
 		l108:	/* end case */;
-			break;
-		case 180:
+			BREAK;
+		CASE(180)
 			/* bytecodePrimLessOrEqual */
 			{
 				sqInt aBool;
@@ -6701,8 +6702,8 @@
 			}
 ;
 		l33:	/* end case */;
-			break;
-		case 181:
+			BREAK;
+		CASE(181)
 			/* bytecodePrimGreaterOrEqual */
 			{
 				sqInt aBool;
@@ -6820,8 +6821,8 @@
 			}
 ;
 		l38:	/* end case */;
-			break;
-		case 182:
+			BREAK;
+		CASE(182)
 			/* bytecodePrimEqual */
 			{
 				sqInt aBool;
@@ -6939,8 +6940,8 @@
 			}
 ;
 		l43:	/* end case */;
-			break;
-		case 183:
+			BREAK;
+		CASE(183)
 			/* bytecodePrimNotEqual */
 			{
 				sqInt aBool;
@@ -7058,8 +7059,8 @@
 			}
 ;
 		l48:	/* end case */;
-			break;
-		case 184:
+			BREAK;
+		CASE(184)
 			/* bytecodePrimMultiply */
 			{
 				sqInt arg;
@@ -7193,8 +7194,8 @@
 			}
 ;
 		l53:	/* end case */;
-			break;
-		case 185:
+			BREAK;
+		CASE(185)
 			/* bytecodePrimDivide */
 			{
 				sqInt arg;
@@ -7341,8 +7342,8 @@
 			}
 ;
 		l58:	/* end case */;
-			break;
-		case 186:
+			BREAK;
+		CASE(186)
 			/* bytecodePrimMod */
 			{
 				sqInt mod;
@@ -7364,8 +7365,8 @@
 			}
 ;
 		l63:	/* end case */;
-			break;
-		case 187:
+			BREAK;
+		CASE(187)
 			/* bytecodePrimMakePoint */
 			{
 				sqInt argument;
@@ -7461,8 +7462,8 @@
 			}
 ;
 		l64:	/* end case */;
-			break;
-		case 188:
+			BREAK;
+		CASE(188)
 			/* bytecodePrimBitShift */
 			{
 				sqInt integerArgument;
@@ -7571,8 +7572,8 @@
 			}
 ;
 		l66:	/* end case */;
-			break;
-		case 189:
+			BREAK;
+		CASE(189)
 			/* bytecodePrimDiv */
 			{
 				sqInt quotient;
@@ -7594,8 +7595,8 @@
 			}
 ;
 		l68:	/* end case */;
-			break;
-		case 190:
+			BREAK;
+		CASE(190)
 			/* bytecodePrimBitAnd */
 			{
 				sqInt integerArgument;
@@ -7654,8 +7655,8 @@
 			}
 ;
 		l69:	/* end case */;
-			break;
-		case 191:
+			BREAK;
+		CASE(191)
 			/* bytecodePrimBitOr */
 			{
 				sqInt integerArgument;
@@ -7714,8 +7715,8 @@
 			}
 ;
 		l70:	/* end case */;
-			break;
-		case 192:
+			BREAK;
+		CASE(192)
 			/* bytecodePrimAt */
 			{
 				sqInt atIx;
@@ -7812,8 +7813,8 @@
 			}
 ;
 		l71:	/* end case */;
-			break;
-		case 193:
+			BREAK;
+		CASE(193)
 			/* bytecodePrimAtPut */
 			{
 				sqInt atIx;
@@ -7934,8 +7935,8 @@
 			}
 ;
 		l74:	/* end case */;
-			break;
-		case 194:
+			BREAK;
+		CASE(194)
 			/* bytecodePrimSize */
 			{
 				sqInt isArray;
@@ -8047,8 +8048,8 @@
 			}
 ;
 		l77:	/* end case */;
-			break;
-		case 195:
+			BREAK;
+		CASE(195)
 			/* bytecodePrimNext */
 			{
 
@@ -8058,8 +8059,8 @@
 				goto normalSend;
 			}
 ;
-			break;
-		case 196:
+			BREAK;
+		CASE(196)
 			/* bytecodePrimNextPut */
 			{
 
@@ -8069,8 +8070,8 @@
 				goto normalSend;
 			}
 ;
-			break;
-		case 197:
+			BREAK;
+		CASE(197)
 			/* bytecodePrimAtEnd */
 			{
 
@@ -8080,8 +8081,8 @@
 				goto normalSend;
 			}
 ;
-			break;
-		case 198:
+			BREAK;
+		CASE(198)
 			/* bytecodePrimEquivalent */
 			{
 				sqInt arg;
@@ -8099,8 +8100,8 @@
 				}
 			}
 ;
-			break;
-		case 199:
+			BREAK;
+		CASE(199)
 			/* bytecodePrimClass */
 			{
 				sqInt rcvr;
@@ -8129,8 +8130,8 @@
 				currentBytecode = byteAtPointer(++localIP);
 			}
 ;
-			break;
-		case 200:
+			BREAK;
+		CASE(200)
 			/* bytecodePrimBlockCopy */
 			{
 
@@ -8140,8 +8141,8 @@
 				goto normalSend;
 			}
 ;
-			break;
-		case 201:
+			BREAK;
+		CASE(201)
 			/* bytecodePrimValue */
 			{
 				sqInt isBlock;
@@ -8190,8 +8191,8 @@
 			}
 ;
 		l83:	/* end case */;
-			break;
-		case 202:
+			BREAK;
+		CASE(202)
 			/* bytecodePrimValueWithArg */
 			{
 				sqInt isBlock;
@@ -8240,8 +8241,8 @@
 			}
 ;
 		l85:	/* end case */;
-			break;
-		case 203:
+			BREAK;
+		CASE(203)
 			/* bytecodePrimDo */
 			{
 
@@ -8251,8 +8252,8 @@
 				goto normalSend;
 			}
 ;
-			break;
-		case 204:
+			BREAK;
+		CASE(204)
 			/* bytecodePrimNew */
 			{
 
@@ -8262,8 +8263,8 @@
 				goto normalSend;
 			}
 ;
-			break;
-		case 205:
+			BREAK;
+		CASE(205)
 			/* bytecodePrimNewWithArg */
 			{
 
@@ -8273,8 +8274,8 @@
 				goto normalSend;
 			}
 ;
-			break;
-		case 206:
+			BREAK;
+		CASE(206)
 			/* bytecodePrimPointX */
 			{
 				sqInt rcvr;
@@ -8319,8 +8320,8 @@
 			}
 ;
 		l87:	/* end case */;
-			break;
-		case 207:
+			BREAK;
+		CASE(207)
 			/* bytecodePrimPointY */
 			{
 				sqInt rcvr;
@@ -8365,23 +8366,23 @@
 			}
 ;
 		l89:	/* end case */;
-			break;
-		case 208:
-		case 209:
-		case 210:
-		case 211:
-		case 212:
-		case 213:
-		case 214:
-		case 215:
-		case 216:
-		case 217:
-		case 218:
-		case 219:
-		case 220:
-		case 221:
-		case 222:
-		case 223:
+			BREAK;
+		CASE(208)
+		CASE(209)
+		CASE(210)
+		CASE(211)
+		CASE(212)
+		CASE(213)
+		CASE(214)
+		CASE(215)
+		CASE(216)
+		CASE(217)
+		CASE(218)
+		CASE(219)
+		CASE(220)
+		CASE(221)
+		CASE(222)
+		CASE(223)
 			/* sendLiteralSelector0ArgsBytecode */
 			{
 				sqInt rcvr;
@@ -8411,23 +8412,23 @@
 				goto commonSend;
 			}
 ;
-			break;
-		case 224:
-		case 225:
-		case 226:
-		case 227:
-		case 228:
-		case 229:
-		case 230:
-		case 231:
-		case 232:
-		case 233:
-		case 234:
-		case 235:
-		case 236:
-		case 237:
-		case 238:
-		case 239:
+			BREAK;
+		CASE(224)
+		CASE(225)
+		CASE(226)
+		CASE(227)
+		CASE(228)
+		CASE(229)
+		CASE(230)
+		CASE(231)
+		CASE(232)
+		CASE(233)
+		CASE(234)
+		CASE(235)
+		CASE(236)
+		CASE(237)
+		CASE(238)
+		CASE(239)
 			/* sendLiteralSelector1ArgBytecode */
 			{
 				sqInt rcvr;
@@ -8457,23 +8458,23 @@
 				goto commonSend;
 			}
 ;
-			break;
-		case 240:
-		case 241:
-		case 242:
-		case 243:
-		case 244:
-		case 245:
-		case 246:
-		case 247:
-		case 248:
-		case 249:
-		case 250:
-		case 251:
-		case 252:
-		case 253:
-		case 254:
-		case 255:
+			BREAK;
+		CASE(240)
+		CASE(241)
+		CASE(242)
+		CASE(243)
+		CASE(244)
+		CASE(245)
+		CASE(246)
+		CASE(247)
+		CASE(248)
+		CASE(249)
+		CASE(250)
+		CASE(251)
+		CASE(252)
+		CASE(253)
+		CASE(254)
+		CASE(255)
 			/* sendLiteralSelector2ArgsBytecode */
 			{
 				sqInt rcvr;
@@ -8503,7 +8504,7 @@
 				goto commonSend;
 			}
 ;
-			break;
+			BREAK;
 		}
 	}
 
@@ -8652,7 +8653,13 @@
 	GIV(stackPointer) += BytesPerWord;
 	GIV(instructionPointer) = ((sqInt) top);
 	if (primitiveFunctionPointer != 0) {
-		assert((primitiveIndexOf(GIV(newMethod))) != 0);
+		if (primitiveFunctionPointer == (primitiveInvokeObjectAsMethod)) {
+			assert(!(isOopCompiledMethod(GIV(newMethod))));
+		}
+		else {
+			assert((isOopCompiledMethod(GIV(newMethod)))
+			 && ((primitiveIndexOf(GIV(newMethod))) != 0));
+		}
 		(GIV(stackPage)->headFP = GIV(framePointer));
 		if ((((unsigned long) primitiveFunctionPointer)) <= MaxQuickPrimitiveIndex) {
 			externalQuickPrimitiveResponse();
@@ -14019,6 +14026,8 @@
     char *sp1;
     char *sp2;
 
+	
+#  if (numRegArgs()) > 0
 	assert(((numRegArgs()) > 0)
 	 && ((numRegArgs()) <= 2));
 	if (((cogMethod->cmNumArgs)) == 2) {
@@ -14049,6 +14058,12 @@
 	longAtput(sp2 = GIV(stackPointer) - BytesPerWord, rcvr);
 	GIV(stackPointer) = sp2;
 	ceEnterCogCodePopReceiverReg();
+
+#  else /* (numRegArgs()) > 0 */
+	assert(0);
+
+#  endif /* (numRegArgs()) > 0 */
+
 }