[Vm-dev] VM Maker: VMMaker.oscog-eem.2688.mcz

[commits at source.squeak.org]

Eliot Miranda uploaded a new version of VMMaker to project VM Maker:
http://source.squeak.org/VMMaker/VMMaker.oscog-eem.2688.mcz

==================== Summary ====================

Name: VMMaker.oscog-eem.2688
Author: eem
Time: 29 January 2020, 5:35:28.094553 pm
UUID: f874f102-0876-492c-a56e-5b3e6449b2e7
Ancestors: VMMaker.oscog-nice.2687

Cogit/ARMv8/Slang: fix several C compiler warnings re the Cogit (ARMv8 now has no warnings).

Cogit:
Refactor indexForSelector:in:at: to indexForSelector:in: in the back end so it can be inlined (via a macro).

Dual mapped zone:
Refactor initializeCodeZoneFrom:upTo:executableCodeZone:  to initializeCodeZoneFrom:upTo:writableCodeZone:, i.e. writableCodeZone = 0 is the flag that we're in the old regime.  Change the mapper to be ioAllocateDualMappedCodeZone:OfSize:WritableZone:, both to arrange that the zones are ordered as we want (executable below writable) but also to evade security-policy scrambling of pointers to mapped memory.

Slang: emit constant for (M << N) and (M - N) - L for constant integers.

=============== Diff against VMMaker.oscog-nice.2687 ===============

Item was changed:
  ----- Method: CCodeGenerator>>generateAsConstantExpression:on: (in category 'C translation support') -----
  generateAsConstantExpression: msgNode on: aStream
  	"Attempt to generate the C code for this message onto the given stream.
  	 Answer if the attempt succeeded.  This handles integer overflow of int
  	 expressions in a 64-bit compiler."
  
  	msgNode constantNumbericValueOrNil ifNotNil:
  		[:value|
+ 		 ((vmClass notNil and: [vmClass objectMemoryClass wordSize = 8])
+ 			ifTrue: [value between: -1 << 63 and: 1 << 64 - 1]
+ 			ifFalse: [value between: -1 << 31 and: 1 << 32 - 1]) ifTrue:
+ 				[aStream nextPutAll: (self cLiteralFor: value).
+ 				 ^true]].
- 		 (value between: -1 << 31 and: 1 << 31 - 1) ifFalse:
- 			[aStream nextPutAll: (self cLiteralFor: value).
- 			 ^true]].
  	^false!

Item was added:
+ ----- Method: CCodeGenerator>>maybeBreakOnInlineIn: (in category 'inlining') -----
+ maybeBreakOnInlineIn: aTMethod
+ 	"convenient for debugging..."
+ 	breakOnInline == true ifTrue:
+ 		[aTMethod halt: aTMethod selector]!

Item was changed:
  ----- Method: CoInterpreter>>initializeCodeGenerator:executableZone: (in category 'initialization') -----
  initializeCodeGenerator: writableCodeZone executableZone: executableZone
  	"If the OS platform requires dual mapping to achieve a writable code zone
  	 then writableCodeZone will be the non-zero address of the read/write zone
  	 and executableZone will be the address of the read/execute zone.  If the OS
  	 platform does not require dual mapping then writableCodeZone will be the
  	 first address past the guard page  and executableZone will be zero (i.e. we
  	 use the first cogCodeSize bytes of memory to house the code zone)."
  	cogit
+ 		initializeCodeZoneFrom: executableZone
+ 		upTo: executableZone + cogCodeSize
+ 		writableCodeZone: writableCodeZone.
- 		initializeCodeZoneFrom: writableCodeZone
- 		upTo: writableCodeZone + cogCodeSize
- 		executableCodeZone: executableZone.
  	self assert: heapBase >= (writableCodeZone + cogCodeSize max: executableZone + cogCodeSize)!

Item was changed:
  ----- Method: CoInterpreter>>readImageFromFile:HeapSize:StartingAt: (in category 'image save/restore') -----
  readImageFromFile: f HeapSize: desiredHeapSize StartingAt: imageOffset
  	"Read an image from the given file stream, allocating an amount of memory to its object heap.
  	
  	 V3: desiredHeapSize is the total size of the heap.  Fail if the image has an unknown format or
  	 requires more than the specified amount of memory.
  
  	 Spur: desiredHeapSize is ignored; this routine will attempt to provide at least extraVMMemory's
  	 ammount of free space after the image is loaded, taking any free space in teh image into account.
  	 extraVMMemory is stored in the image header and is accessible as vmParameterAt: 23.  If
  	 extraVMMemory is 0, the value defaults to the default grow headroom.  Fail if the image has an
  	 unknown format or if sufficient memory cannot be allocated.
  
  	 Details: This method detects when the image was stored on a machine with the opposite byte
  	 ordering from this machine and swaps the bytes automatically. Furthermore, it allows the header
  	 information to start 512 bytes into the file, since some file transfer programs for the Macintosh
  	 apparently prepend a Mac-specific header of this size. Note that this same 512 bytes of prefix
  	 area could also be used to store an exec command on Unix systems, allowing one to launch
  	 Smalltalk by invoking the image name as a command."
  
  	| swapBytes headerStart headerSize dataSize oldBaseAddr
  	  minimumMemory heapSize bytesRead bytesToShift firstSegSize
  	  hdrNumStackPages hdrEdenBytes hdrCogCodeSize headerFlags hdrMaxExtSemTabSize
  	  allocationReserve executableZone writableCodeZone |
  	<var: #f type: #sqImageFile>
  	<var: #heapSize type: #usqInt>
  	<var: #dataSize type: #'size_t'>
  	<var: #minimumMemory type: #usqInt>
  	<var: #desiredHeapSize type: #usqInt>
  	<var: #allocationReserve type: #usqInt>
  	<var: #headerStart type: #squeakFileOffsetType>
  	<var: #imageOffset type: #squeakFileOffsetType>
  	<var: #executableZone type: #'char *'>
  	<var: #writableCodeZone type: #'char *'>
  
  	metaclassNumSlots := 6.	"guess Metaclass instSize"
  	classNameIndex := 6.		"guess (Class instVarIndexFor: 'name' ifAbsent: []) - 1"
  	swapBytes := self checkImageVersionFrom: f startingAt: imageOffset.
  	headerStart := (self sqImageFilePosition: f) - 4.  "record header start position"
  
  	headerSize			:= self getWord32FromFile: f swap: swapBytes.
  	dataSize			:= self getLongFromFile: f swap: swapBytes.
  	oldBaseAddr		:= self getLongFromFile: f swap: swapBytes.
  	objectMemory specialObjectsOop: (self getLongFromFile: f swap: swapBytes).
  	objectMemory lastHash: (self getLongFromFile: f swap: swapBytes). "N.B.  not used."
  	savedWindowSize	:= self getLongFromFile: f swap: swapBytes.
  	headerFlags		:= self getLongFromFile: f swap: swapBytes.
  	self setImageHeaderFlagsFrom: headerFlags.
  	extraVMMemory	:= self getWord32FromFile: f swap: swapBytes. "N.B.  ignored in V3."
  	hdrNumStackPages	:= self getShortFromFile: f swap: swapBytes.
  	"4 stack pages is small.  Should be able to run with as few as
  	 three. 4 should be comfortable but slow.  8 is a reasonable
  	 default.  Can be changed via vmParameterAt: 43 put: n.
  	 Can be set as a preference (Info.plist, VM.ini, command line etc).
  	 If desiredNumStackPages is already non-zero then it has been
  	 set as a preference.  Ignore (but preserve) the header's default."
  	numStackPages := desiredNumStackPages ~= 0
  						ifTrue: [desiredNumStackPages]
  						ifFalse: [hdrNumStackPages = 0
  									ifTrue: [self defaultNumStackPages]
  									ifFalse: [hdrNumStackPages]].
  	desiredNumStackPages := hdrNumStackPages.
  	"This slot holds the size of the native method zone in 1k units. (pad to word boundary)."
  	hdrCogCodeSize := (self getShortFromFile: f swap: swapBytes) * 1024.
  	cogCodeSize := desiredCogCodeSize ~= 0
  						ifTrue: [desiredCogCodeSize]
  						ifFalse:
  							[hdrCogCodeSize = 0
  									ifTrue: [cogit defaultCogCodeSize]
  									ifFalse: [hdrCogCodeSize]].
  	cogCodeSize > cogit maxCogCodeSize ifTrue:
  		[cogCodeSize := cogit maxCogCodeSize].
  	hdrEdenBytes		:= self getWord32FromFile: f swap: swapBytes.
  	objectMemory edenBytes: (desiredEdenBytes ~= 0
  						ifTrue: [desiredEdenBytes]
  						ifFalse:
  							[hdrEdenBytes = 0
  									ifTrue: [objectMemory defaultEdenBytes]
  									ifFalse: [hdrEdenBytes]]).
  	desiredEdenBytes := hdrEdenBytes.
  	hdrMaxExtSemTabSize := self getShortFromFile: f swap: swapBytes.
  	hdrMaxExtSemTabSize ~= 0 ifTrue:
  		[self setMaxExtSemSizeTo: hdrMaxExtSemTabSize].
  	"pad to word boundary.  This slot can be used for anything else that will fit in 16 bits.
  	 Preserve it to be polite to other VMs."
  	the2ndUnknownShort	:= self getShortFromFile: f swap: swapBytes.
  	firstSegSize := self getLongFromFile: f swap: swapBytes.
  	objectMemory firstSegmentSize: firstSegSize.
  
  	"To cope with modern OSs that disallow executing code in writable memory we dual-map
  	 the code zone, one mapping with read/write permissions and the other with read/execute
  	 permissions. In such a configuration the code zone has already been alloated and is not
  	 included in (what is no longer) the initial alloc."
+ 	self ioAllocateDualMappedCodeZone: (self addressOf: executableZone) OfSize: cogCodeSize WritableZone: (self addressOf: writableCodeZone).
- 	executableZone := self ioAllocateDualMappedCodeZoneOfSize: cogCodeSize MethodZone: (self addressOf: writableCodeZone).
  	effectiveCogCodeSize := executableZone > 0 ifTrue: [0] ifFalse: [cogCodeSize].
  	"compare memory requirements with availability"
  	allocationReserve := self interpreterAllocationReserveBytes.
  	minimumMemory := "no need to include the stackZone; this is alloca'ed"
  						effectiveCogCodeSize
  						+ dataSize
  						+ objectMemory newSpaceBytes
  						+ allocationReserve.
  	objectMemory hasSpurMemoryManagerAPI
  		ifTrue:
  			[| freeOldSpaceInImage headroom |
  			 freeOldSpaceInImage := self getLongFromFile: f swap: swapBytes.
  			 headroom := objectMemory
  							initialHeadroom: extraVMMemory
  							givenFreeOldSpaceInImage: freeOldSpaceInImage.
  			 heapSize := objectMemory roundUpHeapSize:
  						   effectiveCogCodeSize "no need to include the stackZone; this is alloca'ed"
  						+ dataSize
  						+ headroom
  						+ objectMemory newSpaceBytes
  						+ (headroom > allocationReserve
  							ifTrue: [0]
  							ifFalse: [allocationReserve])]
  		ifFalse:
  			[heapSize :=  effectiveCogCodeSize "no need to include the stackZone; this is alloca'ed"
  						+ desiredHeapSize
  						+ objectMemory newSpaceBytes
  						+ (desiredHeapSize - dataSize > allocationReserve
  							ifTrue: [0]
  							ifFalse: [allocationReserve]).
  			 heapSize < minimumMemory ifTrue:
  				[self insufficientMemorySpecifiedError]].
  
  	"allocate a contiguous block of memory for the Squeak heap and ancilliary data structures"
  	objectMemory memory: (self
  								allocateMemory: heapSize
  								minimum: minimumMemory
  								imageFile: f
  								headerSize: headerSize) asUnsignedInteger.
  	objectMemory memory ifNil:
  		[self insufficientMemoryAvailableError].
  
  	heapBase := objectMemory
  					setHeapBase: objectMemory memory + effectiveCogCodeSize
  					memoryLimit: objectMemory memory + heapSize
  					endOfMemory: objectMemory memory + effectiveCogCodeSize + dataSize.
  
  	"position file after the header"
  	self sqImageFile: f Seek: headerStart + headerSize.
  
  	"read in the image in bulk, then swap the bytes if necessary"
  	bytesRead := objectMemory readHeapFromImageFile: f dataBytes: dataSize.
  	bytesRead ~= dataSize ifTrue: [self unableToReadImageError].
  
  	self ensureImageFormatIsUpToDate: swapBytes.
  
  	"compute difference between old and new memory base addresses"
  	bytesToShift := objectMemory memoryBaseForImageRead - oldBaseAddr.
  	self initializeInterpreter: bytesToShift.  "adjusts all oops to new location"
+ 	self initializeCodeGenerator: writableCodeZone executableZone: objectMemory memory.
- 	self initializeCodeGenerator: writableCodeZone
- 		executableZone: (writableCodeZone > 0 ifTrue: [executableZone] ifFalse: [objectMemory memory]).
  	^dataSize!

Item was added:
+ ----- Method: CogAbstractInstruction>>inlineCacheValueForSelector:in: (in category 'inline cacheing') -----
+ inlineCacheValueForSelector: selector in: aCogMethod
+ 	"Answer the value to put in an inline-cache that is being loaded with the selector.
+ 	 Usually this is simply the selector, but in 64-bits the cache is only 32-bits wide and so the
+ 	 cache is loaded with the index of the selector.  This is the defalt 32-bit implementation."
+ 	<cmacro: '(backEnd,selector,aCogMethod) (selector)'>
+ 	^selector!

Item was changed:
  ----- Method: CogIA32Compiler>>dispatchConcretizeProcessorSpecific (in category 'generate machine code') -----
  dispatchConcretizeProcessorSpecific
  	"Attempt to generate concrete machine code for the instruction at address.
  	 This is part of the inner dispatch of concretizeAt: actualAddress which exists only
  	 to get around the number of literals limits in the SqueakV3 (blue book derived)
  	 bytecode set."
  	opcode caseOf: {
  		"Specific Control/Data Movement"
  		[CDQ]					-> [^self concretizeCDQ].
  		[IDIVR]					-> [^self concretizeIDIVR].
  		[IMULRR]				-> [^self concretizeMulRR].
  		[CPUID]					-> [^self concretizeCPUID].
  		[CMPXCHGAwR]			-> [^self concretizeCMPXCHGAwR].
  		[CMPXCHGMwrR]		-> [^self concretizeCMPXCHGMwrR].
  		[LFENCE]				-> [^self concretizeFENCE: 5].
  		[MFENCE]				-> [^self concretizeFENCE: 6].
  		[SFENCE]				-> [^self concretizeFENCE: 7].
  		[LOCK]					-> [^self concretizeLOCK].
  		[XCHGAwR]				-> [^self concretizeXCHGAwR].
  		[XCHGMwrR]			-> [^self concretizeXCHGMwrR].
  		[XCHGRR]				-> [^self concretizeXCHGRR].
  		[FSTPS]					-> [^self concretizeFSTPS].
  		[FSTPD]				-> [^self concretizeFSTPD].
  		[REP]					-> [^self concretizeREP].
  		[CLD]					-> [^self concretizeCLD].
  		[MOVSB]				-> [^self concretizeMOVSB].
  		[MOVSD]				-> [^self concretizeMOVSD].
  		[BSR]					-> [^self concretizeBSR].
+ 	}.
+ 	^0!
- 	}!

Item was changed:
  ----- Method: CogMethodZone>>clearSavedPICUsageCount: (in category 'compaction') -----
  clearSavedPICUsageCount: cogMethod
  	"For Sista, where we want PICs to last so they can be observed, we need to keep PICs unless
  	 they are definitely unused.  So we need to identify unused PICs.  So in planCompact, zero the
  	 usage counts of all PICs, saving the actual usage count in blockEntryOffset.  Then in
  	 relocateMethodsPreCompaction (actually in relocateIfCallOrMethodReference:mcpc:delta:)
  	 restore the usage counts of used PICs.  Finally in compactCompiledCode, clear the blockEntryOffset
  	 of the unused PICs; they will then have a zero count and be reclaimed in the next code compaction."
+ 	<inline: #always>
  	(SistaVM
  	 and: [cogMethod cmType = CMClosedPIC]) ifTrue:
  		[cogMethod blockEntryOffset: 0]!

Item was changed:
  ----- Method: CogMethodZone>>kosherYoungReferrers (in category 'young referers') -----
  kosherYoungReferrers
  	"Answer that all entries in youngReferrers are in-use and have the cmRefersToYoung flag set.
  	 Used to check that the youngreferrers pruning routines work correctly."
  	<api>
  	| pointer cogMethod |
  	<var: #pointer type: #usqInt>
  	<var: #cogMethod type: #'CogMethod *'>
  	(youngReferrers > limitAddress
  	 or: [youngReferrers < mzFreeStart]) ifTrue:
  		[^false].
  	pointer := youngReferrers.
  	[pointer < limitAddress] whileTrue:
  		[cogMethod := coInterpreter cCoerceSimple: (objectMemory longAt: pointer) to: #'CogMethod *'.
  		 cogMethod cmType ~= CMFree ifTrue:
  			[cogMethod cmRefersToYoung ifFalse:
  				[^false].
  			 (self occurrencesInYoungReferrers: cogMethod) ~= 1 ifTrue:
  				[^false]].
  		 pointer := pointer + objectMemory wordSize].
  	cogMethod := cogit cCoerceSimple: baseAddress to: #'CogMethod *'.
+ 	[cogMethod < self limitZony] whileTrue:
- 	[cogMethod < mzFreeStart] whileTrue:
  		[cogMethod cmType ~= CMFree ifTrue:
  			[(self occurrencesInYoungReferrers: cogMethod) ~= (cogMethod cmRefersToYoung ifTrue: [1] ifFalse: [0]) ifTrue:
  				[^false]].
  		 cogMethod := self methodAfter: cogMethod].
  	^true!

Item was changed:
  ----- Method: CogMethodZone>>linkOnUnpairedMethodList: (in category 'compaction') -----
  linkOnUnpairedMethodList: cogMethod
+ 	<inline: #always>
  	NewspeakVM ifTrue:
  		[cogMethod nextMethodOrIRCs: unpairedMethodList.
  		 unpairedMethodList := cogMethod asUnsignedInteger]!

Item was changed:
  ----- Method: CogMethodZone>>maybeLinkOnUnpairedMethodList: (in category 'compaction') -----
  maybeLinkOnUnpairedMethodList: cogMethod
+ 	<inline: #always>
  	NewspeakVM ifTrue:
  		[(cogMethod cmType = CMMethod
  		  and: [(coInterpreter rawHeaderOf: cogMethod methodObject) asInteger ~= cogMethod asInteger]) ifTrue:
  			[(cogit writableMethodFor: cogMethod) nextMethodOrIRCs: unpairedMethodList.
  			 unpairedMethodList := cogMethod asUnsignedInteger]]!

Item was changed:
  ----- Method: CogObjectRepresentation>>genSmallIntegerComparison:orDoubleComparison:invert: (in category 'primitive generators') -----
  genSmallIntegerComparison: jumpOpcode orDoubleComparison: jumpFPOpcodeGenerator invert: invertComparison
  	"Stack looks like
  		return address"
  	| jumpNonInt jumpFail jumpCond r |
+ 	<var: 'jumpFPOpcodeGenerator' declareC: 'AbstractInstruction * NoDbgRegParms (*jumpFPOpcodeGenerator)(void *)'>
+ 	<var: 'jumpCond' type: #'AbstractInstruction *'>
- 	<var: #jumpFPOpcodeGenerator declareC: 'AbstractInstruction * NoDbgRegParms (*jumpFPOpcodeGenerator)(void *)'>
  	r := self genSmallIntegerComparison: jumpOpcode.
  	r < 0 ifTrue:
  		[^r].
  	self cppIf: #DPFPReg0 defined ifTrue:
  	"Fall through on non-SmallInteger argument.  Argument may be a Float : let us check or fail"
  	[self smallIntegerIsOnlyImmediateType ifFalse:
  		[jumpNonInt := self genJumpImmediate: Arg0Reg].
  	self genGetCompactClassIndexNonImmOf: Arg0Reg into: SendNumArgsReg.
  	self genCmpClassFloatCompactIndexR: SendNumArgsReg.
  	jumpFail := cogit JumpNonZero: 0.
  
  	"It was a Float, so convert the receiver to double and perform the operation"
  	self genConvertSmallIntegerToIntegerInReg: ReceiverResultReg.
  	cogit ConvertR: ReceiverResultReg Rd: DPFPReg0.
  	self genGetDoubleValueOf: Arg0Reg into: DPFPReg1.
  	invertComparison "May need to invert for NaNs"
  		ifTrue: [cogit CmpRd: DPFPReg0 Rd: DPFPReg1]
  		ifFalse: [cogit CmpRd: DPFPReg1 Rd: DPFPReg0].
  	jumpCond := cogit perform: jumpFPOpcodeGenerator with: 0. "FP jumps are a little weird"
  	cogit genMoveFalseR: ReceiverResultReg.
  	cogit genPrimReturn.
  	jumpCond jmpTarget: (cogit genMoveTrueR: ReceiverResultReg).
  	cogit genPrimReturn.
  
  	self smallIntegerIsOnlyImmediateType
  		ifTrue: [jumpFail jmpTarget: cogit Label]
  		ifFalse: [jumpNonInt jmpTarget: (jumpFail jmpTarget: cogit Label)]].
  	^CompletePrimitive!

Item was changed:
  ----- Method: CogObjectRepresentationFor64BitSpur>>genSmallIntegerComparison:orDoubleComparison:invert: (in category 'primitive generators') -----
  genSmallIntegerComparison: jumpOpcode orDoubleComparison: jumpFPOpcodeGenerator invert: invertComparison
  	"Stack looks like
  		return address"
  	| jumpCond r compareIntFloat jumpAmbiguous jumpNotBoxedFloat jumpNotFloatAtAll jumpNotSmallFloat jumpTrue returnTrue |
  	<var: #jumpFPOpcodeGenerator declareC: 'AbstractInstruction * NoDbgRegParms (*jumpFPOpcodeGenerator)(void *)'>
+ 	<var: 'jumpCond' type: #'AbstractInstruction *'>
  	r := self genSmallIntegerComparison: jumpOpcode.
  	r < 0 ifTrue:
  		[^r].
  	self cppIf: #DPFPReg0 defined ifTrue:
  	"Fall through on non-SmallInteger argument.  Argument may be a Float : let us check or fail"
  	[
  	"check for Small Float argument"
  	jumpNotSmallFloat := self genJumpNotSmallFloat: Arg0Reg.
  	self genGetSmallFloatValueOf: Arg0Reg scratch: TempReg into: DPFPReg1.
  	
  	"Case of (int compare: float). Test for ambiguity, that is when (double) intRcvr == floatArg"
  	compareIntFloat := cogit Label.
  	self genConvertSmallIntegerToIntegerInReg: ReceiverResultReg.
  	cogit ConvertR: ReceiverResultReg Rd: DPFPReg0.
  	cogit CmpRd: DPFPReg0 Rd: DPFPReg1.
+ 	jumpAmbiguous := cogit JumpFPEqual: 0.
- 	jumpAmbiguous := cogit perform: #JumpFPEqual: with: 0.
  	"Case of non ambiguity, use compareFloat((double) intRcvr,floatArg)"
  	invertComparison "May need to invert for NaNs"
  					ifTrue: [cogit CmpRd: DPFPReg0 Rd: DPFPReg1]
  					ifFalse: [cogit CmpRd: DPFPReg1 Rd: DPFPReg0].
  	jumpCond := cogit perform: jumpFPOpcodeGenerator with: 0. "FP jumps are a little weird"
  	cogit genMoveFalseR: ReceiverResultReg.
  	cogit genPrimReturn.
  	jumpCond jmpTarget: (returnTrue := cogit genMoveTrueR: ReceiverResultReg).
  	cogit genPrimReturn.
  	"Case of ambiguity, use compareInt(intRcvr , (int64) floatArg)"
  	jumpAmbiguous jmpTarget: (cogit ConvertRd: DPFPReg1 R: Arg0Reg).
  	cogit CmpR: Arg0Reg R: ReceiverResultReg. "N.B. FLAGS := RRReg - Arg0Reg"
  	jumpTrue := cogit genConditionalBranch: jumpOpcode operand: 0.
  	cogit genMoveFalseR: ReceiverResultReg.
  	cogit genPrimReturn.
  	jumpTrue jmpTarget: returnTrue.
  					
  	"not a Small Float, check for Boxed Float argument"
  	jumpNotSmallFloat jmpTarget:cogit Label.
  	jumpNotFloatAtAll := self genJumpImmediate: Arg0Reg.
  	self genGetCompactClassIndexNonImmOf: Arg0Reg into: SendNumArgsReg.
  	self genCmpClassFloatCompactIndexR: SendNumArgsReg.
  	jumpNotBoxedFloat := cogit JumpNonZero: 0.
  	"It was a Boxed Float, so convert the receiver to double and perform the (int compare: float) operation"
  	self genGetDoubleValueOf: Arg0Reg into: DPFPReg1.
  	cogit Jump: compareIntFloat.
  	
  	"not a Float, just let the primitive fall thru failure"
  	jumpNotBoxedFloat jmpTarget: (jumpNotFloatAtAll jmpTarget: cogit Label)].
  	^CompletePrimitive!

Item was changed:
  ----- Method: CogObjectRepresentationForSpur>>genEnsureOopInRegNotForwarded:scratchReg:ifForwarder:ifNotForwarder: (in category 'compile abstract instructions') -----
  genEnsureOopInRegNotForwarded: reg scratchReg: scratch ifForwarder: fwdJumpTarget ifNotForwarder: nonFwdJumpTargetOrZero
  	"Make sure that the oop in reg is not forwarded.  
  	 Use the fact that isForwardedObjectClassIndexPun is a power of two to save an instruction."
+ 	<var: 'fwdJumpTarget' type: #'void *'> "maybe a fixup or an instruction"
+ 	<var: 'nonFwdJumpTargetOrZero' type: #'void *'> "maybe a fixup or an instruction"
  	| imm ok finished |
  	self assert: reg ~= scratch.
  	imm := self genJumpImmediate: reg.
  	"notionally
  		self genGetClassIndexOfNonImm: reg into: scratch.
  		cogit CmpCq: objectMemory isForwardedObjectClassIndexPun R: TempReg.
  	 but the following is an instruction shorter:"
  	cogit MoveMw: 0 r: reg R: scratch.
  	cogit
  		AndCq: objectMemory classIndexMask - objectMemory isForwardedObjectClassIndexPun
  		R: scratch.
  	ok := cogit JumpNonZero: 0.
  	self genLoadSlot: 0 sourceReg: reg destReg: reg.
  	cogit Jump: fwdJumpTarget.
  	finished := nonFwdJumpTargetOrZero asUnsignedInteger = 0
  					ifTrue: [cogit Label]
  					ifFalse: [nonFwdJumpTargetOrZero].
  	imm jmpTarget: (ok jmpTarget: finished).
  	^0!

Item was changed:
  ----- Method: CogObjectRepresentationForSpur>>genStoreTrampolineCalled:instVarIndex: (in category 'initialization') -----
  genStoreTrampolineCalled: trampolineName instVarIndex: instVarIndex
  	"Convention:
  	- RcvrResultReg holds the object mutated.
  	If immutability failure:
  	- TempReg holds the instance variable index mutated 
  		if instVarIndex > numDedicatedStoreTrampoline
  	- ClassReg holds the value to store
  	Registers are not lived across this trampoline as the 
  	immutability failure may need new stack frames."
  	
  	<option: #IMMUTABILITY>
+ 	<var: 'trampolineName' type: #'char *'>
  	<inline: false>
  	| startAddress |
  	startAddress := cogit methodZoneBase.
  	cogit zeroOpcodeIndex.
  	CheckRememberedInTrampoline
  		ifTrue:
  			[self genStoreTrampolineCheckingRememberedCalled: trampolineName instVarIndex: instVarIndex]
  		ifFalse:
  			[self genStoreTrampolineNotCheckingRememberedCalled: trampolineName instVarIndex: instVarIndex].
  		
  	cogit outputInstructionsForGeneratedRuntimeAt: startAddress.
  	cogit recordGeneratedRunTime: trampolineName address: startAddress.
  	cogit recordRunTimeObjectReferences.
  	^startAddress!

Item was changed:
  ----- Method: CogSSBytecodeFixup>>reinitialize (in category 'accessing') -----
  reinitialize
  	<inline: true>
+ 	targetInstruction := 0.
+ 	simStackPtr := 0.
- 	targetInstruction := simStackPtr := 0.
  	LowcodeVM ifTrue:
  		[simNativeStackPtr := simNativeStackSize := 0]!

Item was added:
+ ----- Method: CogVMSimulator>>ioAllocateDualMappedCodeZone:OfSize:WritableZone: (in category 'initialization') -----
+ ioAllocateDualMappedCodeZone: executableZonePluggableAccessor OfSize: codeSize WritableZone: writableZonePluggableAccessor
+ 	"Simulation of ioAllocateDualMappedCodeZoneOfSize:MethodZone:.
+ 	 If the DUAL_MAPPED_CODE_ZONE preference is set obey it and simulate a dual mapped zone,
+ 	 causing the system to use the first codeSize * 2 bytes of memory to simulate a dual mapped zone.
+ 	 Otherwise answer zero, causing the system to work as it used to, using the first codeSize bytes of
+ 	 memory for the code zone."
+ 	(InitializationOptions at: #'DUAL_MAPPED_CODE_ZONE' ifAbsent: [false])
+ 		ifTrue:
+ 			[executableZonePluggableAccessor at: 0 put: Cogit guardPageSize.
+ 			 writableZonePluggableAccessor at: 0 put: codeSize]
+ 		ifFalse:
+ 			[executableZonePluggableAccessor at: 0 put: 0.
+ 			 writableZonePluggableAccessor at: 0 put: 0]!

Item was removed:
- ----- Method: CogVMSimulator>>ioAllocateDualMappedCodeZoneOfSize:MethodZone: (in category 'initialization') -----
- ioAllocateDualMappedCodeZoneOfSize: codeSize MethodZone: writableCodeZonePluggableAccessor
- 	"Simulation of ioAllocateDualMappedCodeZoneOfSize:MethodZone:.
- 	 If the DUAL_MAPPED_CODE_ZONE preference is set obey it and simulate a dual mapped zone,
- 	 causing the system to use the first codeSize * 2 bytes of memory to simulate a dual mapped zone.
- 	 Otherwise answer zero, causing the system to work as it used to, using the first codeSize bytes of
- 	 memory for the code zone."
- 	^(InitializationOptions at: #'DUAL_MAPPED_CODE_ZONE' ifAbsent: [false])
- 		ifTrue:
- 			[writableCodeZonePluggableAccessor at: 0 put: codeSize.
- 			 Cogit guardPageSize]
- 		ifFalse:
- 			[0]!

Item was changed:
  ----- Method: CogVMSimulator>>openOn:extraMemory: (in category 'initialization') -----
  openOn: fileName extraMemory: extraBytes
  	"CogVMSimulator new openOn: 'clone.im' extraMemory: 100000"
  
  	| f version headerSize dataSize count oldBaseAddr bytesToShift swapBytes
  	  headerFlags firstSegSize heapSize
  	  hdrNumStackPages hdrEdenBytes hdrMaxExtSemTabSize
  	  hdrCogCodeSize stackZoneSize methodCacheSize primTraceLogSize
  	  allocationReserve executableZone writableCodeZone |
  	"open image file and read the header"
  
  	(f := self openImageFileNamed: fileName) ifNil: [^self].
  
  	"Set the image name and the first argument; there are
  	 no arguments during simulation unless set explicitly."
  	systemAttributes at: 1 put: fileName.
  
  	["begin ensure block..."
  	imageName := f fullName.
  	f binary.
  
  	version := self getWord32FromFile: f swap: false.  "current version: 16r1968 (=6504) vive la revolucion!!"
  	(self readableFormat: version)
  		ifTrue: [swapBytes := false]
  		ifFalse: [(version := version byteSwap32) = self imageFormatVersion
  					ifTrue: [swapBytes := true]
  					ifFalse: [self error: 'incomaptible image format']].
  	headerSize := self getWord32FromFile: f swap: swapBytes.
  	dataSize := self getLongFromFile: f swap: swapBytes.  "length of heap in file"
  	oldBaseAddr := self getLongFromFile: f swap: swapBytes.  "object memory base address of image"
  	objectMemory specialObjectsOop: (self getLongFromFile: f swap: swapBytes).
  	objectMemory lastHash: (self getLongFromFile: f swap: swapBytes).  "Should be loaded from, and saved to the image header"
  
  	savedWindowSize	:= self getLongFromFile: f swap: swapBytes.
  	headerFlags		:= self getLongFromFile: f swap: swapBytes.
  	self setImageHeaderFlagsFrom: headerFlags.
  	extraVMMemory	:= self getWord32FromFile: f swap: swapBytes.
  	hdrNumStackPages	:= self getShortFromFile: f swap: swapBytes.
  	"4 stack pages is small.  Should be able to run with as few as
  	 three. 4 should be comfortable but slow.  8 is a reasonable
  	 default. Can be changed via vmParameterAt: 43 put: n"
  	numStackPages := desiredNumStackPages ~= 0
  						ifTrue: [desiredNumStackPages]
  						ifFalse: [hdrNumStackPages = 0
  									ifTrue: [self defaultNumStackPages]
  									ifFalse: [hdrNumStackPages]].
  	desiredNumStackPages := hdrNumStackPages.
  	stackZoneSize := self computeStackZoneSize.
  	"This slot holds the size of the native method zone in 1k units. (pad to word boundary)."
  	hdrCogCodeSize := (self getShortFromFile: f swap: swapBytes) * 1024.
  	cogCodeSize := desiredCogCodeSize ~= 0
  						ifTrue: [desiredCogCodeSize]
  						ifFalse:
  							[hdrCogCodeSize = 0
  									ifTrue: [cogit defaultCogCodeSize]
  									ifFalse: [hdrCogCodeSize]].
  	desiredCogCodeSize := hdrCogCodeSize.
  	self assert: f position = (objectMemory wordSize = 4 ifTrue: [40] ifFalse: [64]).
  	hdrEdenBytes	:= self getWord32FromFile: f swap: swapBytes.
  	objectMemory edenBytes: (desiredEdenBytes ~= 0
  						ifTrue: [desiredEdenBytes]
  						ifFalse:
  							[hdrEdenBytes = 0
  									ifTrue: [objectMemory defaultEdenBytes]
  									ifFalse: [hdrEdenBytes]]).
  	desiredEdenBytes := hdrEdenBytes.
  	hdrMaxExtSemTabSize := self getShortFromFile: f swap: swapBytes.
  	hdrMaxExtSemTabSize ~= 0 ifTrue:
  		[self setMaxExtSemSizeTo: hdrMaxExtSemTabSize].
  	"pad to word boundary.  This slot can be used for anything else that will fit in 16 bits.
  	 Preserve it to be polite to other VMs."
  	the2ndUnknownShort	:= self getShortFromFile: f swap: swapBytes.
  	self assert: f position = (objectMemory wordSize = 4 ifTrue: [48] ifFalse: [72]).
  	firstSegSize := self getLongFromFile: f swap: swapBytes.
  	objectMemory firstSegmentSize: firstSegSize.
  	"For Open PICs to be able to probe the method cache during
  	 simulation the methodCache must be relocated to memory."
  	methodCacheSize := methodCache size * objectMemory wordSize.
  	primTraceLogSize := primTraceLog size * objectMemory wordSize.
  
  	"To cope with modern OSs that disallow executing code in writable memory we dual-map
  	 the code zone, one mapping with read/write permissions and the other with read/execute
  	 permissions. In such a configuration the code zone has already been alloated and is not
  	 included in (what is no longer) the initial alloc."
+ 	self ioAllocateDualMappedCodeZone: (self addressOf: executableZone put: [:v| executableZone := v])
+ 		OfSize: cogCodeSize
+ 		WritableZone: (self addressOf: writableCodeZone put: [:v| writableCodeZone := v]).
- 	executableZone := self ioAllocateDualMappedCodeZoneOfSize: cogCodeSize
- 							MethodZone: (self addressOf: writableCodeZone put: [:v| writableCodeZone := v]).
  	"In simulation all we can do is use memory, so if we're simulating dual mapping we
  	 use double the memory and simulate the memory sharing in the Cogit's backEnd."
+ 	effectiveCogCodeSize := writableCodeZone > 0 ifTrue: [cogCodeSize * 2] ifFalse: [cogCodeSize].
- 	effectiveCogCodeSize := executableZone > 0 ifTrue: [cogCodeSize * 2] ifFalse: [cogCodeSize].
  
  	"allocate interpreter memory. This list is in address order, low to high.
  	 In the actual VM the stack zone exists on the C stack."
  	heapBase := (Cogit guardPageSize
  				+ effectiveCogCodeSize
  				+ stackZoneSize
  				+ methodCacheSize
  				+ primTraceLogSize
  				+ self rumpCStackSize) roundUpTo: objectMemory allocationUnit.
  	"compare memory requirements with availability"
  	allocationReserve := self interpreterAllocationReserveBytes.
  	objectMemory hasSpurMemoryManagerAPI
  		ifTrue:
  			[| freeOldSpaceInImage headroom |
  			 freeOldSpaceInImage := self getLongFromFile: f swap: swapBytes.
  			 headroom := objectMemory
  							initialHeadroom: extraVMMemory
  							givenFreeOldSpaceInImage: freeOldSpaceInImage.
  			 heapSize := objectMemory roundUpHeapSize:
  						   dataSize
  						+ headroom
  						+ objectMemory newSpaceBytes
  						+ (headroom > allocationReserve
  							ifTrue: [0]
  							ifFalse: [allocationReserve])]
  		ifFalse:
  			[heapSize :=  dataSize
  						+ extraBytes
  						+ objectMemory newSpaceBytes
  						+ (extraBytes > allocationReserve
  							ifTrue: [0]
  							ifFalse: [allocationReserve])].
  	heapBase := objectMemory
  					setHeapBase: heapBase
  					memoryLimit:  heapBase + heapSize
  					endOfMemory: heapBase + dataSize.
  
  	self assert: cogCodeSize \\ 4 = 0.
  	self assert: objectMemory memoryLimit \\ 4 = 0.
  	self assert: self rumpCStackSize \\ 4 = 0.
  	objectMemory allocateMemoryOfSize: objectMemory memoryLimit.
  	"read in the image in bulk, then swap the bytes if necessary"
  	f position: headerSize.
  	count := objectMemory readHeapFromImageFile: f dataBytes: dataSize.
  	count ~= dataSize ifTrue: [self halt]]
  		ensure: [f close].
  	self moveMethodCacheToMemoryAt: objectMemory cogCodeBase + effectiveCogCodeSize + stackZoneSize.
  	self movePrimTraceLogToMemoryAt: objectMemory cogCodeBase + effectiveCogCodeSize + stackZoneSize + methodCacheSize.
  
  	self ensureImageFormatIsUpToDate: swapBytes.
  
  	bytesToShift := objectMemory memoryBaseForImageRead - oldBaseAddr.  "adjust pointers for zero base address"
  	UIManager default
  		informUser: 'Relocating object pointers...'
  		during: [self initializeInterpreter: bytesToShift].
+ 	writableCodeZone ~= 0
- 	executableZone ~= 0
  		ifTrue:
  			[self initializeCodeGenerator: cogCodeSize + (Cogit guardPageSize * 2)
  				executableZone: Cogit guardPageSize]
  		ifFalse:
+ 			[self initializeCodeGenerator: 0
+ 				executableZone: Cogit guardPageSize]!
- 			[self initializeCodeGenerator: Cogit guardPageSize
- 				executableZone: 0]!

Item was changed:
  ----- Method: CogX64Compiler>>dispatchConcretizeProcessorSpecific (in category 'generate machine code') -----
  dispatchConcretizeProcessorSpecific
  	"Attempt to generate concrete machine code for the instruction at address.
  	 This is part of the inner dispatch of concretizeAt: actualAddress which exists only
  	 to get around the number of literals limits in the SqueakV3 (blue book derived)
  	 bytecode set."
  	opcode caseOf: {
  		"Specific Control/Data Movement"
  		[CDQ]					-> [^self concretizeCDQ].
  		[IDIVR]					-> [^self concretizeIDIVR].
  		[IMULRR]				-> [^self concretizeMulRR].
  		[CPUID]					-> [^self concretizeCPUID].
  		"[CMPXCHGAwR]			-> [^self concretizeCMPXCHGAwR]."
  		"[CMPXCHGMwrR]		-> [^self concretizeCMPXCHGMwrR]."
  		"[LFENCE]				-> [^self concretizeFENCE: 5]."
  		"[MFENCE]				-> [^self concretizeFENCE: 6].
  		[SFENCE]				-> [^self concretizeFENCE: 7]."
  		"[LOCK]					-> [^self concretizeLOCK]."
  		"[XCHGAwR]				-> [^self concretizeXCHGAwR]."
  		"[XCHGMwrR]			-> [^self concretizeXCHGMwrR]."
  		[XCHGRR]				-> [^self concretizeXCHGRR].
  		[REP]					-> [^self concretizeREP].
  		[CLD]					-> [^self concretizeCLD].
  		[MOVSB]				-> [^self concretizeMOVSB].
  		[MOVSQ]				-> [^self concretizeMOVSQ].
  		[BSR]					-> [^self concretizeBSR].
+ 	}.
+ 	^0!
- 	}!

Item was added:
+ ----- Method: CogX64Compiler>>inlineCacheValueForSelector:in: (in category 'inline cacheing') -----
+ inlineCacheValueForSelector: selector in: aCogMethod
+ 	"Answer the value to put in an inline-cache that is being loaded with the selector.
+ 	 Usually this is simply the selector, but in 64-bits the cache is only 32-bits wide and so the
+ 	 cache is loaded with the index of the selector.  Override to use the 64-bit implementation."
+ 	<cmacro: '(backEnd,selector,aCogMethod) indexForSelectorin(selector,aCogMethod)'>
+ 	^cogit indexForSelector: selector in: aCogMethod!

Item was changed:
  ----- Method: Cogit class>>declareCVarsIn: (in category 'translation') -----
  declareCVarsIn: aCCodeGenerator
  	#(	'coInterpreter' 'objectMemory' 'methodZone' 'objectRepresentation'
  		'cogBlockMethodSurrogateClass' 'cogMethodSurrogateClass' 'nsSendCacheSurrogateClass'
  		'threadManager' 'processor' 'lastNInstructions' 'simulatedAddresses'
  		'simulatedTrampolines' 'simulatedVariableGetters' 'simulatedVariableSetters'
  		'processorFrameValid' 'printRegisters' 'printInstructions' 'clickConfirm' 'singleStep') do:
  			[:simulationVariableNotNeededForRealVM|
  			aCCodeGenerator removeVariable: simulationVariableNotNeededForRealVM].
  	NewspeakVM ifFalse:
  		[#(	'selfSendTrampolines' 'dynamicSuperSendTrampolines'
  			'implicitReceiverSendTrampolines' 'outerSendTrampolines'
  			'ceEnclosingObjectTrampoline' 'numIRCs' 'indexOfIRC' 'theIRCs') do:
  				[:variableNotNeededInNormalVM|
  				aCCodeGenerator removeVariable: variableNotNeededInNormalVM]].
  	aCCodeGenerator removeConstant: #COGMTVM. "this should be defined at compile time"
  	aCCodeGenerator
  		addHeaderFile:'<stddef.h>'; "for e.g. offsetof"
  		addHeaderFile:'"sqCogStackAlignment.h"';
  		addHeaderFile:'"dispdbg.h"'; "must precede cointerp.h & cogit.h otherwise NoDbgRegParms gets screwed up"
  		addHeaderFile:'"cogmethod.h"'.
  	NewspeakVM ifTrue:
  		[aCCodeGenerator addHeaderFile:'"nssendcache.h"'].
  	aCCodeGenerator
  		addHeaderFile:'#if COGMTVM';
  		addHeaderFile:'"cointerpmt.h"';
  		addHeaderFile:'#else';
  		addHeaderFile:'"cointerp.h"';
  		addHeaderFile:'#endif';
  		addHeaderFile:'"cogit.h"'.
  	aCCodeGenerator
  		var: #ceGetFP
  			declareC: 'usqIntptr_t (*ceGetFP)(void)';
  		var: #ceGetSP
  			declareC: 'usqIntptr_t (*ceGetSP)(void)';
  		var: #ceCaptureCStackPointers
  			declareC: 'void (*ceCaptureCStackPointers)(void)';
  		var: #ceEnterCogCodePopReceiverReg
  			declareC: 'void (*ceEnterCogCodePopReceiverReg)(void)';
  		var: #realCEEnterCogCodePopReceiverReg
  			declareC: 'void (*realCEEnterCogCodePopReceiverReg)(void)';
  		var: #ceCallCogCodePopReceiverReg
  			declareC: 'void (*ceCallCogCodePopReceiverReg)(void)';
  		var: #realCECallCogCodePopReceiverReg
  			declareC: 'void (*realCECallCogCodePopReceiverReg)(void)';
  		var: #ceCallCogCodePopReceiverAndClassRegs
  			declareC: 'void (*ceCallCogCodePopReceiverAndClassRegs)(void)';
  		var: #realCECallCogCodePopReceiverAndClassRegs
  			declareC: 'void (*realCECallCogCodePopReceiverAndClassRegs)(void)';
  		var: #postCompileHook
  			declareC: 'void (*postCompileHook)(CogMethod *)';
  		var: #openPICList declareC: 'CogMethod *openPICList = 0';
  		var: #maxMethodBefore type: #'CogBlockMethod *';
  		var: 'enumeratingCogMethod' type: #'CogMethod *'.
  	
  	aCCodeGenerator
  		var: #ceTryLockVMOwner
  			declareC: '#if COGMTVM\usqIntptr_t (*ceTryLockVMOwner)(void)' withCRs;
  		var: #ceUnlockVMOwner
  			declareC: 'void (*ceUnlockVMOwner)(void)\#endif /* COGMTVM */' withCRs.
  
  	CogCompilerClass basicNew numCheckLZCNTOpcodes > 0 ifTrue:
  		[aCCodeGenerator
  			var: #ceCheckLZCNTFunction
  				declareC: 'static usqIntptr_t (*ceCheckLZCNTFunction)(void)'].
  	CogCompilerClass basicNew numCheckFeaturesOpcodes > 0 ifTrue:
  		[aCCodeGenerator
  			var: #ceCheckFeaturesFunction
  				declareC: 'static usqIntptr_t (*ceCheckFeaturesFunction)(void)'].
  	CogCompilerClass basicNew numICacheFlushOpcodes > 0 ifTrue:
  		[aCCodeGenerator
  			var: #ceFlushICache
  				declareC: 'static void (*ceFlushICache)(usqIntptr_t from, usqIntptr_t to)'].
  
  	aCCodeGenerator
  		declareVar: 'aMethodLabel' type: #'AbstractInstruction'; "Has to come lexicographically before backEnd & methodLabel"
  		var: #backEnd declareC: 'AbstractInstruction * const backEnd = &aMethodLabel';
  		var: #methodLabel declareC: 'AbstractInstruction * const methodLabel = &aMethodLabel'.
  	self declareC: #(abstractOpcodes stackCheckLabel
  					blockEntryLabel blockEntryNoContextSwitch
  					stackOverflowCall sendMiss
  					entry noCheckEntry selfSendEntry dynSuperEntry
  					fullBlockNoContextSwitchEntry fullBlockEntry
  					picMNUAbort picInterpretAbort  endCPICCase0 endCPICCase1 cPICEndOfCodeLabel)
  			as: #'AbstractInstruction *'
  				in: aCCodeGenerator.
+ 	aCCodeGenerator declareVar: #cPICPrototype type: #'CogMethod *'.
  	aCCodeGenerator
  		declareVar: #blockStarts type: #'BlockStart *';
  		declareVar: #fixups type: #'BytecodeFixup *'.
  	aCCodeGenerator
  		var: #ordinarySendTrampolines
  			declareC: 'sqInt ordinarySendTrampolines[NumSendTrampolines]';
  		var: #superSendTrampolines
  			declareC: 'sqInt superSendTrampolines[NumSendTrampolines]'.
  	BytecodeSetHasDirectedSuperSend ifTrue:
  		[aCCodeGenerator
  			var: #directedSuperSendTrampolines
  				declareC: 'sqInt directedSuperSendTrampolines[NumSendTrampolines]';
  			var: #directedSuperBindingSendTrampolines
  				declareC: 'sqInt directedSuperBindingSendTrampolines[NumSendTrampolines]'].
  	NewspeakVM ifTrue:
  		[aCCodeGenerator
  			var: #selfSendTrampolines
  				declareC: 'sqInt selfSendTrampolines[NumSendTrampolines]';
  			var: #dynamicSuperSendTrampolines
  				declareC: 'sqInt dynamicSuperSendTrampolines[NumSendTrampolines]';
  			var: #implicitReceiverSendTrampolines
  				declareC: 'sqInt implicitReceiverSendTrampolines[NumSendTrampolines]';
  			var: #outerSendTrampolines
  				declareC: 'sqInt outerSendTrampolines[NumSendTrampolines]'].
  	aCCodeGenerator
  		var: #trampolineAddresses
  			declareC: 'static char *trampolineAddresses[NumTrampolines*2]';
  		var: #objectReferencesInRuntime
  			declareC: 'static usqInt objectReferencesInRuntime[NumObjRefsInRuntime+1]';
  		var: #labelCounter
  			type: #int;
  		var: #traceFlags
  			declareC: 'int traceFlags = 8 /* prim trace log on by default */';
  		var: #cStackAlignment
  			declareC: 'const int cStackAlignment = STACK_ALIGN_BYTES'.
  	aCCodeGenerator
  		declareVar: #minValidCallAddress type: #'usqIntptr_t';
  		declareVar: #debugPrimCallStackOffset type: #'usqIntptr_t'.
  	aCCodeGenerator vmClass generatorTable ifNotNil:
  		[:bytecodeGenTable|
  		aCCodeGenerator
  			var: #generatorTable
  				declareC: 'static BytecodeDescriptor generatorTable[', bytecodeGenTable size printString, ']',
  							(self tableInitializerFor: bytecodeGenTable
  								in: aCCodeGenerator)].
  	"In C the abstract opcode names clash with the Smalltak generator syntactic sugar.
  	 Most of the syntactic sugar is inlined, but alas some remains.  Rename the syntactic
  	 sugar to avoid the clash."
  	(self organization listAtCategoryNamed: #'abstract instructions') do:
  		[:s|
  		aCCodeGenerator addSelectorTranslation: s to: 'g', (aCCodeGenerator cFunctionNameFor: s)].
  	aCCodeGenerator addSelectorTranslation: #halt: to: 'haltmsg'!

Item was added:
+ ----- Method: Cogit class>>prepareToBeAddedToCodeGenerator: (in category 'translation') -----
+ prepareToBeAddedToCodeGenerator: aCodeGen
+ 	"It is either this or scan cmacro methods for selectors."
+ 	BytesPerWord = 8 ifTrue:
+ 		[aCodeGen retainMethods: #(indexForSelector:in:)]!

Item was changed:
  ----- Method: Cogit>>addressIsInInstructions: (in category 'testing') -----
  addressIsInInstructions: address
+ 	<cmacro: '(address) (!!((usqInt)(address) & (BytesPerWord-1)) \
+ 							&& (address) >= &abstractOpcodes[0] \
+ 							&& (address) < &abstractOpcodes[opcodeIndex])'>
+ 	^(abstractOpcodes object identityIndexOf: address) between: 1 and: opcodeIndex!
- 	<var: #address type: #'AbstractInstruction *'>
- 	^self cCode: '!!((usqInt)(address) & BytesPerWord-1) \
- 				&& (address) >= &abstractOpcodes[0] \
- 				&& (address) < &abstractOpcodes[opcodeIndex]'
- 		inSmalltalk: [(abstractOpcodes object identityIndexOf: address) between: 1 and: opcodeIndex]!

Item was changed:
  ----- Method: Cogit>>cPICPrototype (in category 'accessing') -----
  cPICPrototype
  	"For Cogit clas>>#genAndDisPICoptions:"
  	<doNotGenerate>
+ 	^cPICPrototype address!
- 	^cPICPrototype!

Item was changed:
  ----- Method: Cogit>>ceSICMiss: (in category 'in-line cacheing') -----
  ceSICMiss: receiver
  	"An in-line cache check in a method has failed.  The failing entry check has jumped
  	 to the ceMethodAbort abort call at the start of the method which has called this routine.
  	 If possible allocate a closed PIC for the current and existing classes.
  	 The stack looks like:
  			receiver
  			args
  			sender return address
  	  sp=>	ceMethodAbort call return address
  	 So we can find the method that did the failing entry check at
  		ceMethodAbort call return address - missOffset
  	 and we can find the send site from the outer return address."
  	<api>
  	| pic innerReturn outerReturn entryPoint targetMethod newTargetMethodOrNil errorSelectorOrNil cacheTag extent result |
  	<var: #pic type: #'CogMethod *'>
  	<var: #targetMethod type: #'CogMethod *'>
  	"Whether we can relink to a PIC or not we need to pop off the inner return and identify the target method."
  	innerReturn := coInterpreter popStack asUnsignedInteger.
  	targetMethod := self cCoerceSimple: innerReturn - missOffset to: #'CogMethod *'.
  	(objectMemory isOopForwarded: receiver) ifTrue:
  		[^coInterpreter ceSendFromInLineCacheMiss: targetMethod].
  	outerReturn := coInterpreter stackTop asUnsignedInteger.
  	self assert: (outerReturn between: methodZoneBase and: methodZone freeStart).
  	entryPoint := backEnd callTargetFromReturnAddress: outerReturn.
  
  	self assert: targetMethod selector ~= objectMemory nilObject.
  	self assert: targetMethod asInteger + cmEntryOffset = entryPoint.
  
  	self lookup: targetMethod selector
  		for: receiver
  		methodAndErrorSelectorInto:
  			[:method :errsel|
  			newTargetMethodOrNil := method.
  			errorSelectorOrNil := errsel].
  	"We assume lookupAndCog:for: will *not* reclaim the method zone"
  	self assert: outerReturn = coInterpreter stackTop.
  	cacheTag := objectRepresentation inlineCacheTagForInstance: receiver.
  	((errorSelectorOrNil notNil and: [errorSelectorOrNil ~= SelectorDoesNotUnderstand])
  	 or: [(objectRepresentation inlineCacheTagIsYoung: cacheTag)
  	 or: [(backEnd inlineCacheTagAt: outerReturn) = self picAbortDiscriminatorValue
  	 or: [newTargetMethodOrNil isNil
  	 or: [objectMemory isYoung: newTargetMethodOrNil]]]]) ifTrue:
  		[result := self patchToOpenPICFor: targetMethod selector
  					numArgs: targetMethod cmNumArgs
  					receiver: receiver.
  		 self assert: result not. "If patchToOpenPICFor:.. returns we're out of code memory"
  		 ^coInterpreter ceSendFromInLineCacheMiss: targetMethod].
  	"See if an Open PIC is already available."
  	pic := methodZone openPICWithSelector: targetMethod selector.
  	(pic isNil or: [self allowEarlyOpenPICPromotion not]) ifTrue:
  		["otherwise attempt to create a closed PIC for the two cases."
  		 pic := self cogPICSelector: targetMethod selector
  					numArgs: targetMethod cmNumArgs
  					Case0Method: targetMethod
  					Case1Method: newTargetMethodOrNil
  					tag: cacheTag
  					isMNUCase: errorSelectorOrNil = SelectorDoesNotUnderstand.
  		 (pic asInteger between: MaxNegativeErrorCode and: -1) ifTrue:
  			["For some reason the PIC couldn't be generated, most likely a lack of code memory.
  			  Continue as if this is an unlinked send."
  			 pic asInteger = InsufficientCodeSpace ifTrue:
  				[coInterpreter callForCogCompiledCodeCompaction].
  			^coInterpreter ceSendFromInLineCacheMiss: targetMethod].
  		 backEnd flushICacheFrom: pic asUnsignedInteger to: pic asUnsignedInteger + closedPICSize].
  	"Relink the send site to the pic.  If to an open PIC then reset the cache tag to the selector,
  	 for the benefit of the cacheTag assert check in checkIfValidOopRef:pc:cogMethod: et al."
  	extent := pic cmType = CMOpenPIC
  				ifTrue:
  					[backEnd
  						rewriteInlineCacheAt: outerReturn
+ 						tag: (backEnd
+ 								inlineCacheValueForSelector: targetMethod selector
+ 								in: coInterpreter mframeHomeMethodExport)
- 						tag: (self inlineCacheValueForSelector: targetMethod selector
- 								  in: coInterpreter mframeHomeMethodExport
- 								  at: outerReturn)
  						target: pic asInteger + cmEntryOffset]
  				ifFalse:
  					[backEnd
  						rewriteCallAt: outerReturn
  						target: pic asInteger + cmEntryOffset].
  	backEnd flushICacheFrom: outerReturn asUnsignedInteger - extent to: outerReturn asUnsignedInteger.
  	"Jump back into the pic at its entry in case this is an MNU (newTargetMethodOrNil is nil)"
  	coInterpreter
  		executeCogPIC: pic
  		fromLinkedSendWithReceiver: receiver
  		andCacheTag: (backEnd inlineCacheTagAt: outerReturn).
  	"NOTREACHED"
  	^nil!

Item was changed:
  ----- Method: Cogit>>codeByteAt:put: (in category 'generate machine code - dual mapped zone support') -----
  codeByteAt: address put: aByte
  	"production uses the macro..."
+ 	<cmacro: '(address,value) byteAtput((address) + codeToDataDelta, value)'>
- 	<cmacro: '(adress,value) byteAtput((address) + codeToDataDelta, value)'>
  	self codeWriteBreakpoint: address.
  	"simulation writes twice if simulating dual mapping..."
  	codeToDataDelta ~= 0 ifTrue:
  		[objectMemory byteAt: address + codeToDataDelta put: aByte].
  	^objectMemory byteAt: address put: aByte!

Item was changed:
  ----- Method: Cogit>>codeLongAt:put: (in category 'generate machine code - dual mapped zone support') -----
  codeLongAt: address put: aLong
  	"production uses the macro..."
+ 	<cmacro: '(address,value) longAtput((address) + codeToDataDelta, value)'>
- 	<cmacro: '(adress,value) longAtput((address) + codeToDataDelta, value)'>
  	self codeWriteBreakpoint: address.
  	"simulation writes twice if simulating dual mapping..."
  	codeToDataDelta ~= 0 ifTrue:
  		[objectMemory longAt: address + codeToDataDelta put: aLong].
  	^objectMemory longAt: address put: aLong!

Item was changed:
  ----- Method: Cogit>>codeWriteBreakpoint: (in category 'generate machine code - dual mapped zone support') -----
  codeWriteBreakpoint: address
+ 	<doNotGenerate>
  	"(address = 16r520) ifTrue:
  		[self halt]"
  	"(address between: 16r2398 and: 16r23B0) ifTrue:
  		[self halt]"!

Item was changed:
  ----- Method: Cogit>>cogMNUPICSelector:receiver:methodOperand:numArgs: (in category 'in-line cacheing') -----
  cogMNUPICSelector: selector receiver: rcvr methodOperand: methodOperand numArgs: numArgs
  	<api>
  	"Attempt to create a one-case PIC for an MNU.
  	 The tag for the case is at the send site and so doesn't need to be generated."
  	<returnTypeC: #'CogMethod *'>
  	| startAddress writablePIC actualPIC |
  	((objectMemory isYoung: selector)
  	 or: [(objectRepresentation inlineCacheTagForInstance: rcvr) = self picAbortDiscriminatorValue]) ifTrue:
  		[^0].
  	coInterpreter
  		compilationBreak: selector
  		point: (objectMemory numBytesOf: selector)
  		isMNUCase: true.
  	self assert: endCPICCase0 notNil.
  
  	"get memory in the code zone for the CPIC; if that fails we return an error code for the sender to use to work out how to blow up"
  	startAddress := methodZone allocate: closedPICSize.
  	startAddress = 0 ifTrue:
  		[coInterpreter callForCogCompiledCodeCompaction.
  		 ^0].
  	self maybeBreakGeneratingFrom: startAddress to: startAddress + closedPICSize - 1.
  
  	writablePIC := self writableMethodFor: startAddress.
  	"memcpy the prototype across to our allocated space; because anything else would be silly"
+ 	self codeMemcpy: writablePIC _: cPICPrototype _: closedPICSize.
- 	self codeMemcpy: writablePIC
- 		_: (self cCoerceSimple: cPICPrototype to: #'CogMethod *')
- 		_: closedPICSize.
  
  	self
  		fillInCPICHeader: writablePIC
  		numArgs: numArgs
  		numCases: 1
  		hasMNUCase: true
  		selector: selector.
  
  	self configureMNUCPIC: (actualPIC := self cCoerceSimple: startAddress to: #'CogMethod *')
  		methodOperand: methodOperand
  		numArgs: numArgs
+ 		delta: startAddress - cPICPrototype asUnsignedInteger.
- 		delta: startAddress - cPICPrototype.
  
  	self assert: (backEnd callTargetFromReturnAddress: startAddress + missOffset) = (self picAbortTrampolineFor: numArgs).
  	self assertValidDualZoneFrom: startAddress to: startAddress + closedPICSize.
  	backEnd flushICacheFrom: startAddress to: startAddress + closedPICSize.
  
  	^actualPIC!

Item was changed:
  ----- Method: Cogit>>cogMethodDoesntLookKosher: (in category 'debugging') -----
  cogMethodDoesntLookKosher: cogMethod
  	"Check that the header fields onf a non-free method are consistent with
  	 the type. Answer 0 if it is ok, otherwise answer a code for the error."
  	<api>
  	<inline: false>
  	<var: #cogMethod type: #'CogMethod *'>
  	((cogMethod blockSize bitAnd: objectMemory wordSize - 1) ~= 0
  	 or: [cogMethod blockSize < (self sizeof: CogMethod)
  	 or: [cogMethod blockSize >= 32768]]) ifTrue:
  		[^1].
  
  	cogMethod cmType = CMFree ifTrue: [^2].
  
  	cogMethod cmType = CMMethod ifTrue:
  		[(objectMemory isIntegerObject: cogMethod methodHeader) ifFalse:
  			[^11].
  		 (objectRepresentation couldBeObject: cogMethod methodObject) ifFalse:
  			[^12].
  		 (cogMethod stackCheckOffset > 0
  		  and: [cogMethod stackCheckOffset < cmNoCheckEntryOffset]) ifTrue:
  			[^13].
  		 (SistaVM
  		  and: [objectRepresentation canPinObjects
  		  and: [cogMethod counters ~= 0]]) ifTrue:
  			[(objectRepresentation couldBeDerivedObject: cogMethod counters) ifFalse:
  				[^14]].
  		 (NewspeakVM
  		  and: [objectRepresentation canPinObjects
  		  and: [cogMethod nextMethodOrIRCs ~= 0]]) ifTrue:
  			[(cogMethod nextMethodOrIRCs < methodZone zoneEnd)
  				ifTrue: "check the nextMethod (unpairedMethodList) unless we're compacting."
  					[(methodZone compactionInProgress
+ 					  or: [cogMethod nextMethodOrIRCs = (methodZone methodFor: cogMethod nextMethodOrIRCs asVoidPointer) asUnsignedInteger]) ifFalse:
- 					  or: [cogMethod nextMethodOrIRCs = (methodZone methodFor: cogMethod nextMethodOrIRCs) asUnsignedInteger]) ifFalse:
  						[^15]]
  				ifFalse:
  					[(objectRepresentation couldBeDerivedObject: cogMethod nextMethodOrIRCs) ifFalse:
  						[^16]]].
  		 ^0].
  
  	cogMethod cmType = CMOpenPIC ifTrue:
  		[cogMethod blockSize ~= openPICSize ifTrue:
  			[^21].
  		 cogMethod methodHeader ~= 0 ifTrue:
  			[^22].
  		 "Check the nextOpenPIC link unless we're compacting"
  		 cogMethod objectHeader >= 0 ifTrue:
  			[(cogMethod methodObject = 0
  			  or: [methodZone compactionInProgress
+ 			  or: [cogMethod methodObject = (methodZone methodFor: cogMethod methodObject asVoidPointer) asUnsignedInteger]]) ifFalse:
- 			  or: [cogMethod methodObject = (methodZone methodFor: cogMethod methodObject) asUnsignedInteger]]) ifFalse:
  				[^23]].
  		 cogMethod stackCheckOffset ~= 0 ifTrue:
  			[^24].
  		 ^0].
  
  	cogMethod cmType = CMClosedPIC ifTrue:
  		[cogMethod blockSize ~= closedPICSize ifTrue:
  			[^31].
  		 (cogMethod cPICNumCases between: 1 and: MaxCPICCases) ifFalse:
  			[^32].
  		 cogMethod methodHeader ~= 0 ifTrue:
  			[^33].
  		 cogMethod methodObject ~= 0 ifTrue:
  			[^34].
  		 ^0].
  
  	^9!

Item was changed:
  ----- Method: Cogit>>cogPICSelector:numArgs:Case0Method:Case1Method:tag:isMNUCase: (in category 'in-line cacheing') -----
  cogPICSelector: selector numArgs: numArgs Case0Method: case0CogMethod Case1Method: case1MethodOrNil tag: case1Tag isMNUCase: isMNUCase
  	"Attempt to create a two-case PIC for case0CogMethod and  case1Method,case1Tag.
  	 The tag for case0CogMethod is at the send site and so doesn't need to be generated.
  	 case1Method may be any of
  		- a Cog method; link to its unchecked entry-point
  		- a CompiledMethod; link to ceInterpretMethodFromPIC:
  		- a CompiledMethod; link to ceMNUFromPICMNUMethod:receiver:"
  	<var: #case0CogMethod type: #'CogMethod *'>
  	<returnTypeC: #'CogMethod *'>
  	| startAddress writablePIC actualPIC |
  	(objectMemory isYoung: selector) ifTrue:
  		[^self cCoerceSimple: YoungSelectorInPIC to: #'CogMethod *'].
  	coInterpreter
  		compilationBreak: selector
  		point: (objectMemory numBytesOf: selector)
  		isMNUCase: isMNUCase.
  	
  	"get memory in the code zone for the CPIC; if that fails we return an error code for the sender to use to work out how to blow up"
  	startAddress := methodZone allocate: closedPICSize.
  	startAddress = 0 ifTrue:
  		[^self cCoerceSimple: InsufficientCodeSpace to: #'CogMethod *'].
  	self maybeBreakGeneratingFrom: startAddress to: startAddress + closedPICSize - 1.
  
  	writablePIC := self writableMethodFor: startAddress.
  	"memcpy the prototype across to our allocated space; because anything else would be silly"
+ 	self codeMemcpy: writablePIC _: cPICPrototype _: closedPICSize.
- 	self codeMemcpy: writablePIC
- 		_: (self cCoerceSimple: cPICPrototype to: #'CogMethod *')
- 		_: closedPICSize.
  
  	self
  		fillInCPICHeader: writablePIC
  		numArgs: numArgs
  		numCases: 2
  		hasMNUCase: isMNUCase
  		selector: selector.
  
  	self configureCPIC: (actualPIC := self cCoerceSimple: startAddress to: #'CogMethod *')
  		Case0: case0CogMethod
  		Case1Method: case1MethodOrNil
  		tag: case1Tag
  		isMNUCase: isMNUCase
  		numArgs: numArgs
+ 		delta: startAddress - cPICPrototype asUnsignedInteger.
- 		delta: startAddress - cPICPrototype.
  
  	self assert: (backEnd callTargetFromReturnAddress: startAddress + missOffset) = (self picAbortTrampolineFor: numArgs).
  	self assertValidDualZoneFrom: startAddress to: startAddress + closedPICSize.
  	backEnd flushICacheFrom: startAddress to: startAddress + closedPICSize.
  
  	^actualPIC!

Item was changed:
  ----- Method: Cogit>>collectCogConstituentFor:Annotation:Mcpc:Bcpc:Method: (in category 'profiling primitives') -----
  collectCogConstituentFor: descriptor Annotation: isBackwardBranchAndAnnotation Mcpc: mcpc Bcpc: bcpc Method: cogMethodArg
  	<var: #descriptor type: #'BytecodeDescriptor *'>
  	<var: #mcpc type: #'char *'>
  	<var: #cogMethodArg type: #'void *'>
  	<var: #targetMethod type: #'CogMethod *'>
  	| address entryPoint |
  	descriptor ifNil: [^0].
  	descriptor isMapped ifFalse: [^0].
+ 	address := self positiveMachineIntegerFor: mcpc asUnsignedInteger.
- 	address := self positiveMachineIntegerFor: mcpc.
  	address ifNil: [^PrimErrNoMemory]. "This cannot trigger a GC but fails if not enough space in Eden,"
  	"Assumes we write the values into topRemappableOop"
  	coInterpreter
  		storePointerUnchecked: cogConstituentIndex
  		ofObject: coInterpreter topRemappableOop
  		withValue: address.
  	coInterpreter
  		storePointerUnchecked: cogConstituentIndex + 1
  		ofObject: coInterpreter topRemappableOop
  		withValue: (objectMemory integerObjectOf: bcpc).
  	cogConstituentIndex := cogConstituentIndex + 2.
  
  	"Collect any first case classTags for closed PICs."
  	((isBackwardBranchAndAnnotation noMask: 1)
  	 and: [self isSendAnnotation: isBackwardBranchAndAnnotation >> 1]) ifTrue:
  		[entryPoint := backEnd callTargetFromReturnAddress: mcpc asInteger.
  		 entryPoint > methodZoneBase ifTrue: "send is linked"
  			[self targetMethodAndSendTableFor: entryPoint annotation: isBackwardBranchAndAnnotation >> 1 into:
  				[:targetMethod :sendTable|
  				  targetMethod cmType = CMClosedPIC ifTrue:
  					[targetMethod methodObject: (objectRepresentation classForInlineCacheTag: (backEnd inlineCacheTagAt: mcpc))]]]].
  	^0!

Item was added:
+ ----- Method: Cogit>>indexForSelector:in: (in category 'in-line cacheing') -----
+ indexForSelector: selector in: cogMethod
+ 	"Answer the value to put in an inline-cache that is being loaded with the selector.
+ 	 Usually this is simply the selector, but in 64-bits the cache is only 32-bits wide
+ 	 and so the cache is loaded with the index of the selector."
+ 	<var: #cogMethod type: #'CogMethod *'>
+ 	<inline: false>
+ 	| methodOop |
+ 	"First search the special selectors; there are only 32 of them so this shouldn't take too long.
+ 	 We could short-circuit this by keeping a hint bit in the target method, or by maintaining the
+ 	 maximum range of selector oops in specialSelectors since they're likely to cluster."
+ 	0 to: NumSpecialSelectors - 1 do:
+ 		[:i|
+ 		selector = (coInterpreter specialSelector: i) ifTrue:
+ 			[^-1 - i]].
+ 	methodOop := cogMethod methodObject.
+ 	"Then search the method's literal frame... open code fetchPointer:ofObject: for speed..."
+ 	LiteralStart to: (objectMemory literalCountOfMethodHeader: cogMethod methodHeader) do:
+ 		[:i|
+ 		(objectMemory longAt: i * objectMemory bytesPerOop + objectMemory baseHeaderSize + methodOop) = selector ifTrue:
+ 			[self assert: selector = (coInterpreter literal: i - 1 ofMethod: methodOop).
+ 			 ^i - 1]].
+ 
+ 	self error: 'could not find selector in method when unlinking send site'.
+ 	^0!

Item was removed:
- ----- Method: Cogit>>indexForSelector:in:at: (in category 'in-line cacheing') -----
- indexForSelector: selector in: cogMethod at: mcpc
- 	"Answer the value to put in an inline-cache that is being loaded with the selector.
- 	 Usually this is simply the selector, but in 64-bits the cache is only 32-bits wide
- 	 and so the cache is loaded with the index of the selector."
- 	<var: #cogMethod type: #'CogMethod *'>
- 	<inline: false>
- 	| methodOop |
- 	self assert: (mcpc asUnsignedInteger > cogMethod asUnsignedInteger
- 				and: [mcpc < (cogMethod asUnsignedInteger + cogMethod blockSize)]).
- 	"First search the special selectors; there are only 32 of them so this shouldn't take too long.
- 	 We could short-circuit this by keeping a hint bit in the target method, or by maintaining the
- 	 maximum range of selector oops in specialSelectors since they're likely to cluster."
- 	0 to: NumSpecialSelectors - 1 do:
- 		[:i|
- 		selector = (coInterpreter specialSelector: i) ifTrue:
- 			[^-1 - i]].
- 	methodOop := cogMethod methodObject.
- 	"Then search the method's literal frame... open code fetchPointer:ofObject: for speed..."
- 	LiteralStart to: (objectMemory literalCountOfMethodHeader: cogMethod methodHeader) do:
- 		[:i|
- 		(objectMemory longAt: i * objectMemory bytesPerOop + objectMemory baseHeaderSize + methodOop) = selector ifTrue:
- 			[self assert: selector = (coInterpreter literal: i - 1 ofMethod: methodOop).
- 			 ^i - 1]].
- 
- 	self error: 'could not find selector in method when unlinking send site'.
- 	^0!

Item was removed:
- ----- Method: Cogit>>initializeCodeZoneFrom:upTo:executableCodeZone: (in category 'initialization') -----
- initializeCodeZoneFrom: startAddress upTo: endAddress executableCodeZone: executableCodeZone
- 	<api>
- 	"If the OS platform requires dual mapping to achieve a writable code zone
- 	 then startAddress will be the non-zero address of the read/write zone and
- 	 executableCodeZone will be the non-zero address of the read/execute zone.
- 	 If the OS platform does not require dual mapping then startAddress will be
- 	 the first address of the read/write/executable zone and executableCodeZone
- 	 will be zero."
- 	self initializeBackend.
- 	codeToDataDelta := executableCodeZone = 0 ifTrue: [0] ifFalse: [startAddress - executableCodeZone].
- 	backEnd stopsFrom: startAddress - codeToDataDelta to: endAddress - codeToDataDelta - 1.
- 	self cCode:
- 			[executableCodeZone = 0 ifTrue:
- 				[self sqMakeMemoryExecutableFrom: startAddress To: endAddress]]
- 		inSmalltalk:
- 			[startAddress = self class guardPageSize ifTrue:
- 				[backEnd stopsFrom: 0 to: endAddress - 1].
- 			 self initializeProcessor].
- 	"Logically we want to deal with execution addresses; these are what we want to call,
- 	 modify, etc.  All we have to do is arrange that whenever we write, we write to the
- 	 corresponding data address for each execution address, but *what* we write is only
- 	 sensible within *execution* addresses.  Therefore...
- 	 dataAddress := executableAddress + codeToDataDelta, hence
- 	 codeToDataDelta := startAddress - executableCodeZone"
- 
- 	codeBase := methodZoneBase := startAddress - codeToDataDelta.
- 	minValidCallAddress := (codeBase min: coInterpreter interpretAddress)
- 								min: coInterpreter primitiveFailAddress.
- 	methodZone manageFrom: methodZoneBase to: endAddress - codeToDataDelta.
- 	self assertValidDualZone.
- 	self maybeGenerateCheckFeatures.
- 	self maybeGenerateCheckLZCNT.
- 	self maybeGenerateICacheFlush.
- 	self generateVMOwnerLockFunctions.
- 	self genGetLeafCallStackPointer.
- 	self generateStackPointerCapture.
- 	self generateTrampolines.
- 	self computeEntryOffsets.
- 	self computeFullBlockEntryOffsets.
- 	self generateClosedPICPrototype.
- 	self alignMethodZoneBase.
- 	"repeat so that now the methodZone ignores the generated run-time"
- 	methodZone manageFrom: methodZoneBase to: endAddress - codeToDataDelta.
- 	"N.B. this is assumed to be the last thing done in initialization; see Cogit>>initialized"
- 	self generateOpenPICPrototype!

Item was added:
+ ----- Method: Cogit>>initializeCodeZoneFrom:upTo:writableCodeZone: (in category 'initialization') -----
+ initializeCodeZoneFrom: startAddress upTo: endAddress writableCodeZone: writableCodeZone
+ 	<api>
+ 	"If the OS platform requires dual mapping to achieve a writable code zone
+ 	 then startAddress will be the non-zero address of the read/write zone and
+ 	 executableCodeZone will be the non-zero address of the read/execute zone.
+ 	 If the OS platform does not require dual mapping then startAddress will be
+ 	 the first address of the read/write/executable zone and executableCodeZone
+ 	 will be zero."
+ 	self initializeBackend.
+ 	codeToDataDelta := writableCodeZone = 0 ifTrue: [0] ifFalse: [writableCodeZone - startAddress].
+ 	backEnd stopsFrom: startAddress to: endAddress - 1.
+ 	self cCode:
+ 			[writableCodeZone = 0 ifTrue:
+ 				[self sqMakeMemoryExecutableFrom: startAddress To: endAddress]]
+ 		inSmalltalk:
+ 			[startAddress = self class guardPageSize ifTrue:
+ 				[backEnd stopsFrom: 0 to: endAddress - 1].
+ 			 self initializeProcessor].
+ 
+ 	codeBase := methodZoneBase := startAddress.
+ 	minValidCallAddress := (codeBase min: coInterpreter interpretAddress) min: coInterpreter primitiveFailAddress.
+ 	methodZone manageFrom: methodZoneBase to: endAddress.
+ 	self assertValidDualZone.
+ 	self maybeGenerateCheckFeatures.
+ 	self maybeGenerateCheckLZCNT.
+ 	self maybeGenerateICacheFlush.
+ 	self generateVMOwnerLockFunctions.
+ 	self genGetLeafCallStackPointer.
+ 	self generateStackPointerCapture.
+ 	self generateTrampolines.
+ 	self computeEntryOffsets.
+ 	self computeFullBlockEntryOffsets.
+ 	self generateClosedPICPrototype.
+ 	self alignMethodZoneBase.
+ 	"repeat so that now the methodZone ignores the generated run-time"
+ 	methodZone manageFrom: methodZoneBase to: endAddress.
+ 	"N.B. this is assumed to be the last thing done in initialization; see Cogit>>initialized"
+ 	self generateOpenPICPrototype!

Item was removed:
- ----- Method: Cogit>>inlineCacheValueForSelector:in:at: (in category 'in-line cacheing') -----
- inlineCacheValueForSelector: selector in: aCogMethod at: mcpc
- 	"Answer the value to put in an inline-cache that is being loaded with the selector.
- 	 Usually this is simply the selector, but in 64-bits the cache is only 32-bits wide
- 	 and so the cache is loaded with the index of the selector."
- 	<var: #aCogMethod type: #'CogMethod *'>
- 	<inline: true>
- 	^self inlineCacheTagsAreIndexes
- 		ifTrue: [self indexForSelector: selector in: aCogMethod at: mcpc]
- 		ifFalse: [selector]!

Item was changed:
  ----- Method: Cogit>>patchToOpenPICFor:numArgs:receiver: (in category 'in-line cacheing') -----
  patchToOpenPICFor: selector numArgs: numArgs receiver: receiver
  	"Code entry closed PIC full or miss to an instance of a young class or to a young target method.
  	 Attempt to patch the send site to an open PIC.  Answer if the attempt succeeded; in fact it will
  	 only return if the attempt failed.
  	 The stack looks like:
  			receiver
  			args
  	 sp=>	sender return address"
  	<api>
  	| oPIC outerReturn extent |
  	<var: #oPIC type: #'CogMethod *'>
  	outerReturn := coInterpreter stackTop.
  	"See if an Open PIC is already available."
  	oPIC := methodZone openPICWithSelector: selector.
  	oPIC ifNil:
  		["otherwise attempt to create an Open PIC."
  		oPIC := self cogOpenPICSelector: selector numArgs: numArgs.
  		(oPIC asInteger between: MaxNegativeErrorCode and: -1) ifTrue:
  			["For some reason the PIC couldn't be generated, most likely a lack of code memory."
  			oPIC asInteger = InsufficientCodeSpace ifTrue:
  				[coInterpreter callForCogCompiledCodeCompaction].
  			^false]].
  	"Relink the send site to the pic.  Reset the cache tag to the selector, for the
  	 benefit of the cacheTag assert check in checkIfValidOopRef:pc:cogMethod: et al."
  	extent := backEnd
  				rewriteInlineCacheAt: outerReturn
+ 				tag: (backEnd
+ 						inlineCacheValueForSelector: selector
+ 						in: coInterpreter mframeHomeMethodExport)
- 				tag: (self inlineCacheValueForSelector: selector
- 						  in: coInterpreter mframeHomeMethodExport
- 						  at: outerReturn)
  				target: oPIC asInteger + cmEntryOffset.
  	backEnd
  		flushICacheFrom: outerReturn asUnsignedInteger - extent to: outerReturn asUnsignedInteger;
  		flushICacheFrom: oPIC asUnsignedInteger to: oPIC asUnsignedInteger + openPICSize.
  	"Jump into the oPIC at its entry"
  	coInterpreter executeCogMethod: oPIC fromLinkedSendWithReceiver: receiver.
  	"NOTREACHED"
  	^true!

Item was changed:
  ----- Method: Cogit>>relocateIfCallOrMethodReference:mcpc:delta: (in category 'compaction') -----
  relocateIfCallOrMethodReference: annotation mcpc: mcpc delta: refDelta
  	<var: #mcpc type: #'char *'>
  	| callDelta entryPoint targetMethod unlinkedRoutine |
  	<var: #targetMethod type: #'CogMethod *'>
  	<var: #nsSendCache type: #'NSSendCache *'>
  
  	callDelta := backEnd zoneCallsAreRelative ifTrue: [refDelta] ifFalse: [0].
  	
  	NewspeakVM ifTrue:
  		[| nsSendCache |
  		 annotation = IsNSSendCall ifTrue:
  			["Retrieve the send cache before relocating the stub call. Fetching the send
  			  cache asserts the stub call points below all the cogged methods, but
  			  until this method is actually moved, the adjusted stub call may appear to
  			  point to somewhere in the method zone."
  			nsSendCache := self nsSendCacheFromReturnAddress: mcpc asInteger.
  
  			"Fix call to trampoline. This method is moving [delta] bytes, and calls are
  			 relative, so adjust the call by -[delta] bytes"
  			backEnd relocateCallBeforeReturnPC: mcpc asInteger by: callDelta negated.
  
  			nsSendCache target ~= 0 ifTrue: "Send is linked"
  				[entryPoint := nsSendCache target.
  				targetMethod := self cCoerceSimple: entryPoint - cmNoCheckEntryOffset to: #'CogMethod *'.
  				targetMethod cmType = CMMethod
  					ifTrue: "send target not freed; just relocate. The cache has an absolute
  							target, so only adjust by the target method's displacement."
  						[nsSendCache target: entryPoint + targetMethod objectHeader]
  					ifFalse: "send target was freed, unlink"
  						[self voidNSSendCache: nsSendCache]].
  			^0]].
  
  	(self isPureSendAnnotation: annotation) ifTrue:
  		[entryPoint := backEnd callTargetFromReturnAddress: mcpc asInteger.
  		entryPoint <= methodZoneBase ifTrue: "send is not linked; just relocate"
  			[backEnd relocateCallBeforeReturnPC: mcpc asInteger by: callDelta negated.
  			 ^0].
  		"It's a linked send; find which kind."
  		self
  			offsetAndSendTableFor: entryPoint
  			annotation: annotation
  			into: [:offset :sendTable|
  				 targetMethod := self cCoerceSimple: entryPoint - offset to: #'CogMethod *'.
  				 targetMethod cmType ~= CMFree ifTrue: "send target not freed; just relocate."
  					[backEnd
  						relocateCallBeforeReturnPC: mcpc asInteger
  						by: (callDelta - targetMethod objectHeader) negated.
  					 SistaVM ifTrue: "See comment in planCompaction"
  						[methodZone restorePICUsageCount: targetMethod].
  					 ^0].
  				 "Target was freed; map back to an unlinked send; but include this method's reocation"
  				 unlinkedRoutine := sendTable at: (targetMethod cmNumArgs min: NumSendTrampolines - 1).
  				 unlinkedRoutine := unlinkedRoutine - callDelta.
  				 backEnd
  					rewriteInlineCacheAt: mcpc asInteger
+ 					tag: (backEnd inlineCacheValueForSelector: targetMethod selector in: enumeratingCogMethod)
- 					tag: (self inlineCacheValueForSelector: targetMethod selector in: enumeratingCogMethod at: mcpc)
  					target: unlinkedRoutine.
  				 ^0]].
  
  	annotation = IsRelativeCall ifTrue:
  		[backEnd relocateCallBeforeReturnPC: mcpc asInteger by: callDelta negated.
  		 ^0].
  
  	annotation = IsAbsPCReference ifTrue:
  		[backEnd relocateMethodReferenceBeforeAddress: mcpc asInteger by: refDelta].
  
  	^0 "keep scanning"!

Item was changed:
  ----- Method: Cogit>>unlinkSendAt:targetMethod:sendTable: (in category 'in-line cacheing') -----
  unlinkSendAt: mcpc targetMethod: targetMethod sendTable: sendTable
  	<inline: true>
  	| unlinkedRoutine |
  	unlinkedRoutine := sendTable at: (targetMethod cmNumArgs min: NumSendTrampolines - 1).
  	backEnd
  		rewriteInlineCacheAt: mcpc asInteger
+ 		tag: (backEnd inlineCacheValueForSelector: targetMethod selector in: enumeratingCogMethod)
- 		tag: (self inlineCacheValueForSelector: targetMethod selector in: enumeratingCogMethod at: mcpc)
  		target: unlinkedRoutine.
  	codeModified := true!

Item was removed:
- ----- Method: RegisterAllocatingCogit>>initializeCodeZoneFrom:upTo:executableCodeZone: (in category 'initialization') -----
- initializeCodeZoneFrom: startAddress upTo: endAddress executableCodeZone: executableCodeZone
- 	scratchSimStack := self cCode: [self malloc: self simStackSlots * (self sizeof: CogSimStackEntry)]
- 							inSmalltalk: [CArrayAccessor on: ((1 to: self simStackSlots) collect: [:ign| CogRegisterAllocatingSimStackEntry new])].
- 	super initializeCodeZoneFrom: startAddress upTo: endAddress executableCodeZone: executableCodeZone!

Item was added:
+ ----- Method: RegisterAllocatingCogit>>initializeCodeZoneFrom:upTo:writableCodeZone: (in category 'initialization') -----
+ initializeCodeZoneFrom: startAddress upTo: endAddress writableCodeZone: writableCodeZone
+ 	scratchSimStack := self cCode: [self malloc: self simStackSlots * (self sizeof: CogSimStackEntry)]
+ 							inSmalltalk: [CArrayAccessor on: ((1 to: self simStackSlots) collect: [:ign| CogRegisterAllocatingSimStackEntry new])].
+ 	super initializeCodeZoneFrom: startAddress upTo: endAddress writableCodeZone: writableCodeZone!

Item was changed:
  ----- Method: SimpleStackBasedCogit>>compilePrimitive (in category 'primitive generators') -----
  compilePrimitive
  	"Compile a primitive.  If possible, performance-critical primtiives will
  	 be generated by their own routines (primitiveGenerator).  Otherwise,
  	 if there is a primitive at all, we call the C routine with the usual
  	 stack-switching dance, test the primFailCode and then either return
  	 on success or continue to the method body."
  	<inline: false>
  	| code opcodeIndexAtPrimitive primitiveDescriptor primitiveRoutine flags |
  	<var: #primitiveDescriptor type: #'PrimitiveDescriptor *'>
  	<var: #primitiveRoutine declareC: 'void (*primitiveRoutine)(void)'>
  	primitiveIndex = 0 ifTrue: [^0].
  	code := 0.
  	"Note opcodeIndex so that compileFallbackToInterpreterPrimitive:
  	 can discard arg load instructions for unimplemented primitives."
  	opcodeIndexAtPrimitive := opcodeIndex.
  	"If a descriptor specifies an argument count (by numArgs >= 0) then it must match
  	 for the generated code to be correct.  For example for speed many primitives use
  	 ResultReceiverReg instead of accessing the stack, so the receiver better be at
  	 numArgs down the stack.  Use the interpreter version if not."
  	((primitiveDescriptor := self primitiveGeneratorOrNil) notNil
  	 and: [primitiveDescriptor primitiveGenerator notNil
  	 and: [(primitiveDescriptor primNumArgs < 0 "means don't care"
  		   or: [primitiveDescriptor primNumArgs = (coInterpreter argumentCountOf: methodObj)])]]) ifTrue:
  		[code := objectRepresentation perform: primitiveDescriptor primitiveGenerator].
  	(code < 0 and: [code ~= UnimplementedPrimitive]) ifTrue: "Generator failed, so no point continuing..."
  		[^code].
  	code = UnfailingPrimitive ifTrue:
  		[^0].
  	"If the machine code verison handles all cases the only reason to call the interpreter
  	 primitive is to reap the primitive error code.  Don't bother if it isn't used."
  	(code = CompletePrimitive
  	 and: [(self methodUsesPrimitiveErrorCode: methodObj header: methodHeader) not]) ifTrue:
  		[^0].
  	"Discard any arg load code generated by the primitive generator."
  	code = UnimplementedPrimitive ifTrue:
  		[opcodeIndex := opcodeIndexAtPrimitive].
  
  	flags := coInterpreter primitivePropertyFlags: primitiveIndex.
  	(flags anyMask: PrimCallDoNotJIT) ifTrue:
  		[^ShouldNotJIT].
  
  	(flags anyMask: PrimCallOnSmalltalkStack) ifTrue:
  		[self assert: flags = PrimCallOnSmalltalkStack.
+ 		 ^self compileMachineCodeInterpreterPrimitive: (self cCoerceSimple: (coInterpreter mcprimFunctionForPrimitiveIndex: primitiveIndex)
+ 															to: 'void (*)(void)')].
- 		 ^self compileMachineCodeInterpreterPrimitive: (coInterpreter mcprimFunctionForPrimitiveIndex: primitiveIndex)].
  
  	((primitiveRoutine := coInterpreter
  							functionPointerForCompiledMethod: methodObj
  							primitiveIndex: primitiveIndex) = 0 "no primitive"
+ 	or: [primitiveRoutine = (self cCoerceSimple: #primitiveFail to: 'void (*)(void)')]) ifTrue:
- 	or: [primitiveRoutine = #primitiveFail]) ifTrue:
  		[^self genFastPrimFail].
  	minValidCallAddress := minValidCallAddress min: primitiveRoutine asUnsignedInteger.
  	^self compileInterpreterPrimitive: primitiveRoutine flags: flags!

Item was removed:
- ----- Method: SistaCogit>>initializeCodeZoneFrom:upTo:executableCodeZone: (in category 'initialization') -----
- initializeCodeZoneFrom: startAddress upTo: endAddress executableCodeZone: executableCodeZone
- 	initialCounterValue := MaxCounterValue.
- 	super initializeCodeZoneFrom: startAddress upTo: endAddress executableCodeZone: executableCodeZone!

Item was added:
+ ----- Method: SistaCogit>>initializeCodeZoneFrom:upTo:writableCodeZone: (in category 'initialization') -----
+ initializeCodeZoneFrom: startAddress upTo: endAddress writableCodeZone: writableCodeZone
+ 	initialCounterValue := MaxCounterValue.
+ 	super initializeCodeZoneFrom: startAddress upTo: endAddress writableCodeZone: writableCodeZone!

Item was removed:
- ----- Method: SistaCogitClone>>initializeCodeZoneFrom:upTo:executableCodeZone: (in category 'initialization') -----
- initializeCodeZoneFrom: startAddress upTo: endAddress executableCodeZone: executableCodeZone
- 	initialCounterValue := MaxCounterValue.
- 	super initializeCodeZoneFrom: startAddress upTo: endAddress executableCodeZone: executableCodeZone!

Item was added:
+ ----- Method: SistaCogitClone>>initializeCodeZoneFrom:upTo:writableCodeZone: (in category 'initialization') -----
+ initializeCodeZoneFrom: startAddress upTo: endAddress writableCodeZone: writableCodeZone
+ 	initialCounterValue := MaxCounterValue.
+ 	super initializeCodeZoneFrom: startAddress upTo: endAddress writableCodeZone: writableCodeZone!

Item was changed:
  ----- Method: TMethod>>inferReturnTypeFromReturnsIn: (in category 'type inference') -----
  inferReturnTypeFromReturnsIn: aCodeGen
  	"Attempt to infer the return type of the receiver from returns in the parse tree."
  
  	"this for determining which returns have which return types:"
  	"aCodeGen
  		pushScope: declarations
  		while: [parseTree
  				nodesSelect: [:n| n isReturn]
  				thenCollect: [:n| | s |
  					s := Set new.
  					self addTypesFor: n expression to: s in: aCodeGen.
  					{n. s}]]"
  			
  	aCodeGen maybeBreakForTestToInline: selector in: self.
  	returnType ifNotNil: [^self].
  	aCodeGen
  		pushScope: declarations
  		while:
  			[| hasReturn returnTypes |
  			 hasReturn := false.
  			 returnTypes := Set new.
  			 "Debug:
  			 (| rettypes |
  			  rettypes := Dictionary new.
  			  parseTree nodesDo:
  				[:node|
  				node isReturn ifTrue:
  					[| types |
  					 self addTypesFor: node expression to: (types := Set new) in: aCodeGen.
  					 rettypes at: node expression put: types]].
  			  rettypes)"
  			 parseTree nodesDo:
  				[:node|
  				node isReturn ifTrue:
  					[hasReturn := true.
  					 "If we encounter a send of an as-yet-untyped method then abort,
  					  retrying and computing the type when that method is fully typed."
  					 (self addTypesFor: node expression to: returnTypes in: aCodeGen) ifTrue:
  						[^self]]].
  			returnTypes remove: #implicit ifAbsent: [].
  			returnTypes := aCodeGen harmonizeReturnTypesIn: returnTypes.
  			hasReturn
  				ifTrue:
  					[returnTypes size > 1 ifTrue:
  						[| message |
  						 message := String streamContents:
  										[:s|
  										 s nextPutAll: 'conflicting return types '.
  										 returnTypes
  											do: [:t| s nextPutAll: t]
  											separatedBy: [s nextPutAll: ', '].
  										 s nextPutAll: ' in '; nextPutAll: selector; cr].
  						 Notification signal: message.
+ 						 aCodeGen logger ensureCr; show: message.
+ 						 aCodeGen maybeBreakOnInlineIn: self].
- 						 aCodeGen logger ensureCr; show: message].
  					 returnTypes size = 1 ifTrue:
  						[self returnType: returnTypes anyOne]]
  				ifFalse:
  					[self returnType: (aCodeGen implicitReturnTypeFor: selector)]]!

Item was changed:
  ----- Method: TSendNode>>constantNumbericValueOrNil (in category 'accessing') -----
  constantNumbericValueOrNil
+ 	(#(* // + - << >>) includes: selector) ifTrue:
- 	(#(* // + -) includes: selector) ifTrue:
  		[receiver constantNumbericValueOrNil ifNotNil:
  			[:rval|
  			arguments first constantNumbericValueOrNil ifNotNil:
  				[:aval|
  				^rval perform: selector with: aval]]].
  	^nil!