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

 
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 */
+
 }