Vm-dev December 2017

vm-dev@lists.squeakfoundation.org

22 participants
79 discussions

[OpenSmalltalk/opensmalltalk-vm] 7e9fab: pointing to new server and path
by GitHub 21 Dec '17

21 Dec '17

Branch: refs/heads/estebanlm/fix-pharo-upload Home: https://github.com/OpenSmalltalk/opensmalltalk-vm Commit: 7e9fab08042a70da6f6729377069b788a525fa50 https://github.com/OpenSmalltalk/opensmalltalk-vm/commit/7e9fab08042a70da6f… Author: Esteban Lorenzano <estebanlm(a)gmail.com> Date: 2017-12-21 (Thu, 21 Dec 2017) Changed paths: M deploy/pharo/deploy-files.pharo.org.sh M deploy/pharo/deploy-key.sh Log Message: ----------- pointing to new server and path

1 0

[OpenSmalltalk/opensmalltalk-vm] 151dba: fix branch
by GitHub 21 Dec '17

21 Dec '17

Branch: refs/heads/estebanlm/fix-pharo-upload Home: https://github.com/OpenSmalltalk/opensmalltalk-vm Commit: 151dba203e3e8bd7f14f98b8e01704be7edf052b https://github.com/OpenSmalltalk/opensmalltalk-vm/commit/151dba203e3e8bd7f1… Author: Esteban Lorenzano <estebanlm(a)gmail.com> Date: 2017-12-21 (Thu, 21 Dec 2017) Changed paths: M .travis.yml Log Message: ----------- fix branch

1 0

[OpenSmalltalk/opensmalltalk-vm] cfb95f: allow deploy from branch to test
by GitHub 21 Dec '17

21 Dec '17

Branch: refs/heads/estebanlm/fix-pharo-upload Home: https://github.com/OpenSmalltalk/opensmalltalk-vm Commit: cfb95fb34368278fffaa9b4483ec9b54c79dac92 https://github.com/OpenSmalltalk/opensmalltalk-vm/commit/cfb95fb34368278fff… Author: Esteban Lorenzano <estebanlm(a)gmail.com> Date: 2017-12-21 (Thu, 21 Dec 2017) Changed paths: M .travis.yml M deploy/pharo/filter-exec.sh Log Message: ----------- allow deploy from branch to test

1 0

[OpenSmalltalk/opensmalltalk-vm] 3fc3a2: remove all noise so I can check results faster
by GitHub 21 Dec '17

21 Dec '17

Branch: refs/heads/estebanlm/fix-pharo-upload Home: https://github.com/OpenSmalltalk/opensmalltalk-vm Commit: 3fc3a2b65b8b95a32eaeea95ff182f435199683b https://github.com/OpenSmalltalk/opensmalltalk-vm/commit/3fc3a2b65b8b95a32e… Author: Esteban Lorenzano <estebanlm(a)gmail.com> Date: 2017-12-21 (Thu, 21 Dec 2017) Changed paths: M .travis.yml Log Message: ----------- remove all noise so I can check results faster

1 0

[OpenSmalltalk/opensmalltalk-vm]
by GitHub 21 Dec '17

21 Dec '17

Branch: refs/heads/estebanlm/fix-pharo-upload Home: https://github.com/OpenSmalltalk/opensmalltalk-vm

1 0

VM Maker: VMMaker.oscog-eem.2298.mcz
by commits＠source.squeak.org 21 Dec '17

21 Dec '17

Eliot Miranda uploaded a new version of VMMaker to project VM Maker: http://source.squeak.org/VMMaker/VMMaker.oscog-eem.2298.mcz ==================== Summary ==================== Name: VMMaker.oscog-eem.2298 Author: eem Time: 20 December 2017, 10:55:04.881437 pm UUID: e8cddc90-a9f5-4eb7-90a4-b0efbda600bb Ancestors: VMMaker.oscog-eem.2297 Cogit: More work to full 64-bit access in at:[put:] primitives. Fix slip in x64 setsConditionCodesFor:. Correct 16-bit bounds check in at:. Implement 64-bit long access in at:put:. Neither primitive is correct as yet. =============== Diff against VMMaker.oscog-eem.2297 =============== Item was changed: ----- Method: CogObjectRepresentationFor64BitSpur>>genAlloc64BitIntegerValue:into:scratchReg:scratchReg: (in category 'primitive generators') ----- genAlloc64BitIntegerValue: valueReg into: resultReg scratchReg: scratch1 scratchReg: scratch2 <returnTypeC: #'AbstractInstruction *'> | allocSize newLPIHeader jumpFail | <var: #jumpFail type: #'AbstractInstruction *'> allocSize := objectMemory baseHeaderSize + objectMemory wordSize. newLPIHeader := objectMemory headerForSlots: 1 format: objectMemory firstByteFormat classIndex: ClassLargePositiveIntegerCompactIndex. cogit MoveAw: objectMemory freeStartAddress R: resultReg. cogit LoadEffectiveAddressMw: allocSize r: resultReg R: scratch1. cogit CmpCq: objectMemory getScavengeThreshold R: scratch1. jumpFail := cogit JumpAboveOrEqual: 0. cogit MoveR: scratch1 Aw: objectMemory freeStartAddress. self genStoreHeader: newLPIHeader intoNewInstance: resultReg using: scratch1. + cogit MoveR: valueReg Mw: objectMemory baseHeaderSize r: resultReg. - cogit MoveR: valueReg M64: objectMemory baseHeaderSize r: resultReg. ^jumpFail! Item was changed: ----- Method: CogObjectRepresentationFor64BitSpur>>genPrimitiveAt (in category 'primitive generators') ----- genPrimitiveAt + | formatReg nSlotsOrElementsReg convertToIntAndReturn methodInBounds - | formatReg nSlotsOrBytesReg convertToIntAndReturn methodInBounds jumpNotIndexable jumpImmediate jumpBadIndex jumpIsBytes jumpIsShorts jumpIsWords jumpIsLongs jumpIsMethod jumpIsArray jumpIsContext jumpHasFixedFields jumpArrayOutOfBounds jumpFixedFieldsOutOfBounds jumpBytesOutOfBounds jumpShortsOutOfBounds jumpWordsOutOfBounds jumpLongsOutOfBounds jumpFailAlloc jumpNotSmallInteger | "c.f. StackInterpreter>>stSizeOf: SpurMemoryManager>>lengthOf:format: fixedFieldsOf:format:length:" <var: #jumpIsBytes type: #'AbstractInstruction *'> <var: #jumpIsLongs type: #'AbstractInstruction *'> <var: #jumpFailAlloc type: #'AbstractInstruction *'> <var: #jumpIsShorts type: #'AbstractInstruction *'> <var: #jumpIsMethod type: #'AbstractInstruction *'> <var: #jumpBadIndex type: #'AbstractInstruction *'> <var: #jumpIsContext type: #'AbstractInstruction *'> <var: #jumpImmediate type: #'AbstractInstruction *'> <var: #methodInBounds type: #'AbstractInstruction *'> <var: #jumpNotIndexable type: #'AbstractInstruction *'> <var: #jumpHasFixedFields type: #'AbstractInstruction *'> <var: #jumpNotSmallInteger type: #'AbstractInstruction *'> <var: #convertToIntAndReturn type: #'AbstractInstruction *'> <var: #jumpArrayOutOfBounds type: #'AbstractInstruction *'> <var: #jumpBytesOutOfBounds type: #'AbstractInstruction *'> <var: #jumpLongsOutOfBounds type: #'AbstractInstruction *'> <var: #jumpShortsOutOfBounds type: #'AbstractInstruction *'> <var: #jumpWordsOutOfBounds type: #'AbstractInstruction *'> <var: #jumpFixedFieldsOutOfBounds type: #'AbstractInstruction *'> + nSlotsOrElementsReg := ClassReg. - nSlotsOrBytesReg := ClassReg. cogit genLoadArgAtDepth: 0 into: Arg0Reg. jumpImmediate := self genJumpImmediate: ReceiverResultReg. cogit MoveR: Arg0Reg R: Arg1Reg. jumpBadIndex := self genJumpNotSmallInteger: Arg0Reg scratchReg: TempReg. self genConvertSmallIntegerToIntegerInReg: Arg1Reg. cogit SubCq: 1 R: Arg1Reg. "1-rel => 0-rel" "formatReg := self formatOf: ReceiverResultReg" self genGetFormatOf: ReceiverResultReg into: (formatReg := SendNumArgsReg) leastSignificantHalfOfBaseHeaderIntoScratch: TempReg. + self genGetNumSlotsOf: ReceiverResultReg into: nSlotsOrElementsReg. - self genGetNumSlotsOf: ReceiverResultReg into: nSlotsOrBytesReg. "dispatch on format in a combination of highest dynamic frequency order first and convenience. 0 = 0 sized objects (UndefinedObject True False et al) 1 = non-indexable objects with inst vars (Point et al) 2 = indexable objects with no inst vars (Array et al) 3 = indexable objects with inst vars (MethodContext AdditionalMethodState et al) 4 = weak indexable objects with inst vars (WeakArray et al) 5 = weak non-indexable objects with inst vars (ephemerons) (Ephemeron) 6 unused, reserved for exotic pointer objects? 7 Forwarded Object, 1st field is pointer, rest of fields are ignored 8 unused, reserved for exotic non-pointer objects? 9 64-bit indexable 10 - 11 32-bit indexable 12 - 15 16-bit indexable 16 - 23 byte indexable 24 - 31 compiled method" cogit CmpCq: objectMemory firstByteFormat R: formatReg. jumpIsBytes := cogit JumpAboveOrEqual: 0. cogit CmpCq: objectMemory arrayFormat R: formatReg. jumpIsArray := cogit JumpZero: 0. jumpNotIndexable := cogit JumpBelow: 0. cogit CmpCq: objectMemory weakArrayFormat R: formatReg. jumpHasFixedFields := cogit JumpBelowOrEqual: 0. cogit CmpCq: objectMemory firstShortFormat R: formatReg. jumpIsShorts := cogit JumpAboveOrEqual: 0. cogit CmpCq: objectMemory firstLongFormat R: formatReg. jumpIsWords := cogit JumpAboveOrEqual: 0. cogit CmpCq: objectMemory sixtyFourBitIndexableFormat R: formatReg. jumpIsLongs := cogit JumpZero: 0. jumpNotIndexable jmpTarget: cogit Label. jumpNotIndexable := cogit Jump: 0. jumpIsArray jmpTarget: + (cogit CmpR: Arg1Reg R: nSlotsOrElementsReg). - (cogit CmpR: Arg1Reg R: nSlotsOrBytesReg). jumpArrayOutOfBounds := cogit JumpBelowOrEqual: 0. cogit AddCq: objectMemory baseHeaderSize >> objectMemory shiftForWord R: Arg1Reg. cogit MoveXwr: Arg1Reg R: ReceiverResultReg R: ReceiverResultReg. cogit genPrimReturn. jumpIsBytes jmpTarget: + (cogit LogicalShiftLeftCq: objectMemory shiftForWord R: nSlotsOrElementsReg). + cogit AndCq: 7 R: formatReg R: TempReg. + cogit SubR: TempReg R: nSlotsOrElementsReg; + CmpR: Arg1Reg R: nSlotsOrElementsReg. - (cogit LogicalShiftLeftCq: objectMemory shiftForWord R: nSlotsOrBytesReg). - cogit AndCq: objectMemory wordSize - 1 R: formatReg R: TempReg. - cogit SubR: TempReg R: nSlotsOrBytesReg; - CmpR: Arg1Reg R: nSlotsOrBytesReg. jumpBytesOutOfBounds := cogit JumpBelowOrEqual: 0. cogit CmpCq: objectMemory firstCompiledMethodFormat R: formatReg. jumpIsMethod := cogit JumpAboveOrEqual: 0. methodInBounds := (cogit AddCq: objectMemory baseHeaderSize R: Arg1Reg). cogit backEnd byteReadsZeroExtend ifTrue: [cogit MoveXbr: Arg1Reg R: ReceiverResultReg R: ReceiverResultReg] ifFalse: [cogit "formatReg already contains a value <= 16r1f, so no need to zero it" MoveXbr: Arg1Reg R: ReceiverResultReg R: formatReg; MoveR: formatReg R: ReceiverResultReg]. convertToIntAndReturn := cogit Label. self genConvertIntegerToSmallIntegerInReg: ReceiverResultReg. cogit genPrimReturn. jumpIsShorts jmpTarget: + (cogit LogicalShiftLeftCq: objectMemory shiftForWord - 1 R: nSlotsOrElementsReg). + cogit AndCq: 3 R: formatReg. + cogit SubR: formatReg R: nSlotsOrElementsReg; + CmpR: Arg1Reg R: nSlotsOrElementsReg. - (cogit LogicalShiftLeftCq: objectMemory shiftForWord - 1 R: nSlotsOrBytesReg). - cogit AndCq: 1 R: formatReg. - cogit SubR: formatReg R: nSlotsOrBytesReg; - CmpR: Arg1Reg R: nSlotsOrBytesReg. jumpShortsOutOfBounds := cogit JumpBelowOrEqual: 0. cogit AddR: Arg1Reg R: ReceiverResultReg. cogit AddR: Arg1Reg R: ReceiverResultReg. cogit MoveM16: objectMemory baseHeaderSize r: ReceiverResultReg R: ReceiverResultReg. cogit Jump: convertToIntAndReturn. jumpIsWords jmpTarget: + (cogit LogicalShiftLeftCq: objectMemory shiftForWord - 2 R: nSlotsOrElementsReg). + cogit AndCq: 1 R: formatReg. + cogit SubR: formatReg R: nSlotsOrElementsReg; + CmpR: Arg1Reg R: nSlotsOrElementsReg. - (cogit CmpR: Arg1Reg R: nSlotsOrBytesReg). jumpWordsOutOfBounds := cogit JumpBelowOrEqual: 0. cogit AddCq: objectMemory baseHeaderSize >> (objectMemory shiftForWord - 1) R: Arg1Reg. cogit MoveX32r: Arg1Reg R: ReceiverResultReg R: TempReg. cogit MoveR: TempReg R: ReceiverResultReg. cogit Jump: convertToIntAndReturn. jumpHasFixedFields jmpTarget: (cogit AndCq: objectMemory classIndexMask R: TempReg). cogit MoveR: TempReg R: formatReg. cogit CmpCq: ClassMethodContextCompactIndex R: TempReg. jumpIsContext := cogit JumpZero: 0. self genGetClassObjectOfClassIndex: formatReg into: Extra0Reg scratchReg: TempReg. self genLoadSlot: InstanceSpecificationIndex sourceReg: Extra0Reg destReg: formatReg. self genConvertSmallIntegerToIntegerInReg: formatReg. cogit AndCq: objectMemory fixedFieldsOfClassFormatMask R: formatReg; + SubR: formatReg R: nSlotsOrElementsReg; + CmpR: Arg1Reg R: nSlotsOrElementsReg. - SubR: formatReg R: nSlotsOrBytesReg; - CmpR: Arg1Reg R: nSlotsOrBytesReg. jumpFixedFieldsOutOfBounds := cogit JumpBelowOrEqual: 0. "index is (formatReg (fixed fields) + Arg1Reg (0-rel index)) * wordSize + baseHeaderSize" cogit AddR: formatReg R: Arg1Reg. cogit AddCq: objectMemory baseHeaderSize >> objectMemory shiftForWord R: Arg1Reg. cogit MoveXwr: Arg1Reg R: ReceiverResultReg R: ReceiverResultReg. cogit genPrimReturn. jumpIsLongs jmpTarget: + (cogit CmpR: Arg1Reg R: nSlotsOrElementsReg). - (cogit CmpR: Arg1Reg R: nSlotsOrBytesReg). jumpLongsOutOfBounds := cogit JumpBelowOrEqual: 0. cogit AddCq: objectMemory baseHeaderSize >> objectMemory shiftForWord R: Arg1Reg. cogit MoveXwr: Arg1Reg R: ReceiverResultReg R: ClassReg. cogit MoveR: ClassReg R: TempReg. cogit LogicalShiftRightCq: self numSmallIntegerBits R: TempReg. "If in range this is now 0" (cogit lastOpcode setsConditionCodesFor: JumpZero) ifFalse: + [cogit CmpCq: 0 R: TempReg]. "N.B. FLAGS := ClassReg - 0" - [cogit CmpCq: 0 R: ClassReg]. "N.B. FLAGS := ClassReg - 0" jumpNotSmallInteger := cogit JumpNonZero: 0. cogit MoveR: ClassReg R: ReceiverResultReg. cogit Jump: convertToIntAndReturn. jumpNotSmallInteger jmpTarget: cogit Label. jumpFailAlloc := self genAlloc64BitIntegerValue: ClassReg into: SendNumArgsReg scratchReg: Extra0Reg scratchReg: TempReg. cogit MoveR: SendNumArgsReg R: ReceiverResultReg. cogit genPrimReturn. jumpIsMethod jmpTarget: cogit Label. "Now check that the index is beyond the method's literals..." + self getLiteralCountOf: ReceiverResultReg plusOne: true inBytes: true into: nSlotsOrElementsReg scratch: TempReg. + cogit CmpR: Arg1Reg R: nSlotsOrElementsReg. - self getLiteralCountOf: ReceiverResultReg plusOne: true inBytes: true into: nSlotsOrBytesReg scratch: TempReg. - cogit CmpR: Arg1Reg R: nSlotsOrBytesReg. cogit JumpBelow: methodInBounds. jumpFailAlloc jmpTarget: (jumpLongsOutOfBounds jmpTarget: (jumpFixedFieldsOutOfBounds jmpTarget: (jumpArrayOutOfBounds jmpTarget: (jumpBytesOutOfBounds jmpTarget: (jumpShortsOutOfBounds jmpTarget: (jumpWordsOutOfBounds jmpTarget: (jumpNotIndexable jmpTarget: (jumpIsContext jmpTarget: (jumpBadIndex jmpTarget: (jumpImmediate jmpTarget: cogit Label)))))))))). ^0! Item was changed: ----- Method: CogObjectRepresentationFor64BitSpur>>genPrimitiveAtPut (in category 'primitive generators') ----- genPrimitiveAtPut | formatReg nSlotsOrBytesReg methodInBounds jumpImmediate jumpBadIndex jumpImmutable jumpNotIndexablePointers jumpNotIndexableBits + jumpIsContext jumpIsCompiledMethod jumpIsBytes jumpIsShorts jumpIsWords jumpHasFixedFields - jumpIsContext jumpIsCompiledMethod jumpIsBytes jumpIsShorts jumpHasFixedFields jumpArrayOutOfBounds jumpFixedFieldsOutOfBounds jumpWordsOutOfBounds jumpShortsOutOfBounds jumpBytesOutOfBounds jumpShortsOutOfRange jumpWordsOutOfRange jumpBytesOutOfRange jumpNonSmallIntegerValue jumpNotPointers + rejoin jumpNegative jump64BitsOutOfBounds jumpNot64BitIndexable jump64BitArgIsImmediate jumpNot8ByteInteger | "c.f. StackInterpreter>>stSizeOf: SpurMemoryManager>>lengthOf:format: fixedFieldsOf:format:length:" <var: #jumpIsBytes type: #'AbstractInstruction *'> + <var: #jumpIsWords type: #'AbstractInstruction *'> <var: #jumpIsShorts type: #'AbstractInstruction *'> <var: #jumpBadIndex type: #'AbstractInstruction *'> <var: #jumpIsContext type: #'AbstractInstruction *'> <var: #jumpImmediate type: #'AbstractInstruction *'> <var: #methodInBounds type: #'AbstractInstruction *'> <var: #jumpHasFixedFields type: #'AbstractInstruction *'> <var: #jumpNotIndexableBits type: #'AbstractInstruction *'> <var: #jumpBytesOutOfRange type: #'AbstractInstruction *'> <var: #jumpWordsOutOfRange type: #'AbstractInstruction *'> <var: #jumpShortsOutOfRange type: #'AbstractInstruction *'> <var: #jumpArrayOutOfBounds type: #'AbstractInstruction *'> <var: #jumpBytesOutOfBounds type: #'AbstractInstruction *'> <var: #jumpWordsOutOfBounds type: #'AbstractInstruction *'> <var: #jumpShortsOutOfBounds type: #'AbstractInstruction *'> <var: #jumpNotIndexablePointers type: #'AbstractInstruction *'> + <var: #rejoin type: #'AbstractInstruction *'> + <var: #jumpNegative type: #'AbstractInstruction *'> + <var: #jumpNot8ByteInteger type: #'AbstractInstruction *'> + <var: #jumpNot64BitIndexable type: #'AbstractInstruction *'> + <var: #jump64BitsOutOfBounds type: #'AbstractInstruction *'> + <var: #jump64BitArgIsImmediate type: #'AbstractInstruction *'> - nSlotsOrBytesReg := ClassReg. cogit genLoadArgAtDepth: 1 into: Arg0Reg. cogit genLoadArgAtDepth: 0 into: Arg1Reg. jumpImmediate := self genJumpImmediate: ReceiverResultReg. jumpBadIndex := self genJumpNotSmallInteger: Arg0Reg scratchReg: TempReg. self genConvertSmallIntegerToIntegerInReg: Arg0Reg. cogit SubCq: 1 R: Arg0Reg. "1-rel => 0-rel" "formatReg := self formatOf: ReceiverResultReg" self cppIf: IMMUTABILITY ifTrue: [ self genGetFormatOf: ReceiverResultReg into: (formatReg := SendNumArgsReg) leastSignificantHalfOfBaseHeaderIntoScratch: TempReg. jumpImmutable := self genJumpBaseHeaderImmutable: TempReg ] ifFalse: [ self genGetFormatOf: ReceiverResultReg into: (formatReg := SendNumArgsReg) leastSignificantHalfOfBaseHeaderIntoScratch: NoReg ]. self genGetNumSlotsOf: ReceiverResultReg into: nSlotsOrBytesReg. "dispatch on format in a combination of highest dynamic frequency order first and convenience. 0 = 0 sized objects (UndefinedObject True False et al) 1 = non-indexable objects with inst vars (Point et al) 2 = indexable objects with no inst vars (Array et al) 3 = indexable objects with inst vars (MethodContext AdditionalMethodState et al) 4 = weak indexable objects with inst vars (WeakArray et al) 5 = weak non-indexable objects with inst vars (ephemerons) (Ephemeron) 6 unused, reserved for exotic pointer objects? 7 Forwarded Object, 1st field is pointer, rest of fields are ignored 8 unused, reserved for exotic non-pointer objects? 9 64-bit indexable 10 - 11 32-bit indexable 12 - 15 16-bit indexable 16 - 23 byte indexable 24 - 31 compiled method" cogit CmpCq: objectMemory weakArrayFormat R: formatReg. jumpNotPointers := cogit JumpAbove: 0. "optimistic store check; assume index in range (almost always is)." self genStoreCheckReceiverReg: ReceiverResultReg valueReg: Arg1Reg scratchReg: TempReg inFrame: false. cogit CmpCq: objectMemory arrayFormat R: formatReg. jumpNotIndexablePointers := cogit JumpBelow: 0. jumpHasFixedFields := cogit JumpNonZero: 0. cogit CmpR: Arg0Reg R: nSlotsOrBytesReg. jumpArrayOutOfBounds := cogit JumpBelowOrEqual: 0. cogit AddCq: objectMemory baseHeaderSize >> objectMemory shiftForWord R: Arg0Reg. cogit MoveR: Arg1Reg Xwr: Arg0Reg R: ReceiverResultReg. cogit MoveR: Arg1Reg R: ReceiverResultReg. cogit genPrimReturn. jumpHasFixedFields jmpTarget: cogit Label. self genGetClassIndexOfNonImm: ReceiverResultReg into: formatReg. cogit CmpCq: ClassMethodContextCompactIndex R: formatReg. jumpIsContext := cogit JumpZero: 0. "get # fixed fields in formatReg" self genGetClassObjectOfClassIndex: formatReg into: Extra0Reg scratchReg: TempReg. self genLoadSlot: InstanceSpecificationIndex sourceReg: Extra0Reg destReg: formatReg. self genConvertSmallIntegerToIntegerInReg: formatReg. cogit AndCq: objectMemory fixedFieldsOfClassFormatMask R: formatReg. cogit SubR: formatReg R: nSlotsOrBytesReg. cogit AddCq: objectMemory baseHeaderSize >> objectMemory shiftForWord R: formatReg. cogit CmpR: Arg0Reg R: nSlotsOrBytesReg. jumpFixedFieldsOutOfBounds := cogit JumpBelowOrEqual: 0. cogit AddR: formatReg R: Arg0Reg. cogit MoveR: Arg1Reg Xwr: Arg0Reg R: ReceiverResultReg. cogit MoveR: Arg1Reg R: ReceiverResultReg. cogit genPrimReturn. jumpNotPointers jmpTarget: cogit Label. jumpNonSmallIntegerValue := self genJumpNotSmallInteger: Arg1Reg scratchReg: TempReg. cogit CmpCq: objectMemory firstByteFormat R: formatReg. jumpIsBytes := cogit JumpAboveOrEqual: 0. cogit CmpCq: objectMemory firstShortFormat R: formatReg. jumpIsShorts := cogit JumpAboveOrEqual: 0. cogit CmpCq: objectMemory firstLongFormat R: formatReg. + jumpIsWords := cogit JumpAboveOrEqual: 0. + cogit CmpCq: objectMemory sixtyFourBitIndexableFormat R: formatReg. + jumpNotIndexableBits := cogit JumpNonZero: 0. + "fall through to 64-bit words" + cogit MoveR: Arg1Reg R: SendNumArgsReg. + self genConvertSmallIntegerToIntegerInReg: SendNumArgsReg. + cogit CmpCq: 0 R: SendNumArgsReg. + jumpNegative := cogit JumpBelow: 0. + rejoin := + cogit CmpR: Arg0Reg R: nSlotsOrBytesReg. + jump64BitsOutOfBounds := cogit JumpBelowOrEqual: 0. + cogit AddCq: objectMemory baseHeaderSize >> objectMemory shiftForWord R: Arg0Reg. + cogit MoveR: SendNumArgsReg Xwr: Arg0Reg R: ReceiverResultReg. + cogit MoveR: Arg1Reg R: ReceiverResultReg. + cogit genPrimReturn. - "For now ignore 64-bit indexability." - jumpNotIndexableBits := cogit JumpBelow: 0. + jumpNonSmallIntegerValue jmpTarget: + (cogit CmpCq: objectMemory sixtyFourBitIndexableFormat R: formatReg). + jumpNot64BitIndexable := cogit JumpNonZero: 0. + jump64BitArgIsImmediate := self genJumpImmediate: Arg1Reg. + "Now check if the header is that of an 8 byte LargePositiveInteger" + cogit MoveMw: 0 r: Arg1Reg R: SendNumArgsReg. + cogit AndCq: (objectMemory + headerForSlots: objectMemory numSlotsMask + format: objectMemory formatMask + classIndex: objectMemory classIndexMask) + R: SendNumArgsReg. + cogit CmpCq: (objectMemory + headerForSlots: 1 + format: objectMemory firstByteFormat + classIndex: ClassLargePositiveIntegerCompactIndex) + R: SendNumArgsReg. + jumpNot8ByteInteger := cogit JumpNonZero: 0. + cogit MoveMw: objectMemory baseHeaderSize r: Arg1Reg R: SendNumArgsReg. + cogit Jump: rejoin. + + jumpIsWords jmpTarget: + (cogit CmpCq: (objectMemory integerObjectOf: 16rFFFFFFFF) R: Arg1Reg). - "fall through to words" - cogit CmpCq: (objectMemory integerObjectOf: 16rFFFFFFFF) R: Arg1Reg. jumpWordsOutOfRange := cogit JumpAbove: 0. cogit LogicalShiftLeftCq: objectMemory shiftForWord - 2 R: nSlotsOrBytesReg. cogit AndCq: objectMemory wordSize / 4 - 1 R: formatReg. cogit SubR: formatReg R: nSlotsOrBytesReg. cogit CmpR: Arg0Reg R: nSlotsOrBytesReg. jumpWordsOutOfBounds := cogit JumpBelowOrEqual: 0. cogit MoveR: Arg1Reg R: TempReg. self genConvertSmallIntegerToIntegerInReg: TempReg. cogit AddCq: objectMemory baseHeaderSize >> (objectMemory shiftForWord - 1) R: Arg0Reg. cogit MoveR: TempReg X32r: Arg0Reg R: ReceiverResultReg. cogit MoveR: Arg1Reg R: ReceiverResultReg. cogit genPrimReturn. jumpIsBytes jmpTarget: (cogit CmpCq: (objectMemory integerObjectOf: 255) R: Arg1Reg). jumpBytesOutOfRange := cogit JumpAbove: 0. cogit LogicalShiftLeftCq: objectMemory shiftForWord R: nSlotsOrBytesReg. cogit AndCq: objectMemory wordSize - 1 R: formatReg R: TempReg. cogit SubR: TempReg R: nSlotsOrBytesReg. cogit CmpR: Arg0Reg R: nSlotsOrBytesReg. jumpBytesOutOfBounds := cogit JumpBelowOrEqual: 0. cogit CmpCq: objectMemory firstCompiledMethodFormat R: formatReg. jumpIsCompiledMethod := cogit JumpAboveOrEqual: 0. methodInBounds := cogit MoveR: Arg1Reg R: TempReg. self genConvertSmallIntegerToIntegerInReg: TempReg. cogit AddCq: objectMemory baseHeaderSize R: Arg0Reg. cogit MoveR: TempReg Xbr: Arg0Reg R: ReceiverResultReg. cogit MoveR: Arg1Reg R: ReceiverResultReg. cogit genPrimReturn. jumpIsShorts jmpTarget: (cogit CmpCq: (objectMemory integerObjectOf: 65535) R: Arg1Reg). jumpShortsOutOfRange := cogit JumpAbove: 0. cogit LogicalShiftLeftCq: objectMemory shiftForWord - 1 R: nSlotsOrBytesReg. cogit AndCq: objectMemory wordSize / 2 - 1 R: formatReg. cogit SubR: formatReg R: nSlotsOrBytesReg. cogit CmpR: Arg0Reg R: nSlotsOrBytesReg. jumpShortsOutOfBounds := cogit JumpBelowOrEqual: 0. cogit MoveR: Arg1Reg R: TempReg. self genConvertSmallIntegerToIntegerInReg: TempReg. cogit AddR: Arg0Reg R: ReceiverResultReg. cogit AddR: Arg0Reg R: ReceiverResultReg. cogit MoveR: TempReg M16: objectMemory baseHeaderSize r: ReceiverResultReg. cogit MoveR: Arg1Reg R: ReceiverResultReg. cogit genPrimReturn. "Now check that the index is beyond the method's literals..." jumpIsCompiledMethod jmpTarget: cogit Label. self getLiteralCountOf: ReceiverResultReg plusOne: true inBytes: true into: nSlotsOrBytesReg scratch: TempReg. cogit CmpR: Arg0Reg R: nSlotsOrBytesReg. cogit JumpBelow: methodInBounds. + jumpNegative jmpTarget: + (jumpNot8ByteInteger jmpTarget: + (jump64BitArgIsImmediate jmpTarget: + (jumpNot64BitIndexable jmpTarget: + (jumpIsContext jmpTarget: - jumpIsContext jmpTarget: (jumpNotIndexableBits jmpTarget: (jumpBytesOutOfRange jmpTarget: (jumpShortsOutOfRange jmpTarget: (jumpWordsOutOfRange jmpTarget: (jumpIsCompiledMethod jmpTarget: (jumpArrayOutOfBounds jmpTarget: (jumpBytesOutOfBounds jmpTarget: (jumpShortsOutOfBounds jmpTarget: (jumpWordsOutOfBounds jmpTarget: + (jump64BitsOutOfBounds jmpTarget: (jumpNotIndexablePointers jmpTarget: + (jumpFixedFieldsOutOfBounds jmpTarget: cogit Label)))))))))))))))). - (jumpNonSmallIntegerValue jmpTarget: - (jumpFixedFieldsOutOfBounds jmpTarget: cogit Label)))))))))))). self cppIf: IMMUTABILITY ifTrue: [jumpImmutable jmpTarget: jumpIsContext getJmpTarget]. cogit AddCq: 1 R: Arg0Reg. "0-rel => 1-rel" self genConvertIntegerToSmallIntegerInReg: Arg0Reg. jumpBadIndex jmpTarget: (jumpImmediate jmpTarget: cogit Label). ^0 "Can't be complete because of contexts."! Item was changed: ----- Method: CogX64Compiler>>setsConditionCodesFor: (in category 'testing') ----- setsConditionCodesFor: aConditionalJumpOpcode <inline: false> "to save Slang from having to be a real compiler (it can't inline switches that return)" "Answer if the receiver's opcode sets the condition codes correctly for the given conditional jump opcode." ^opcode caseOf: { [ArithmeticShiftRightCqR] -> [self shiftSetsConditionCodesFor: aConditionalJumpOpcode]. [ArithmeticShiftRightRR] -> [self shiftSetsConditionCodesFor: aConditionalJumpOpcode]. [LogicalShiftLeftCqR] -> [self shiftSetsConditionCodesFor: aConditionalJumpOpcode]. + [LogicalShiftLeftRR] -> [self shiftSetsConditionCodesFor: aConditionalJumpOpcode]. + [LogicalShiftRightCqR] -> [false]. + [XorRR] -> [true] - [LogicalShiftLeftRR] -> [self shiftSetsConditionCodesFor: aConditionalJumpOpcode]. - [LogicalShiftRightCqR] -> [self shiftSetsConditionCodesFor: aConditionalJumpOpcode]. - [XorRR] -> [true] } otherwise: [self halt: 'unhandled opcode in setsConditionCodesFor:'. false]! Item was changed: ----- Method: StackInterpreter>>longPrintOop: (in category 'debug printing') ----- longPrintOop: oop <api> | fmt lastIndex startIP bytecodesPerLine column | ((objectMemory isImmediate: oop) or: [(objectMemory addressCouldBeObj: oop) not or: [(oop bitAnd: objectMemory allocationUnit - 1) ~= 0 or: [(objectMemory isFreeObject: oop) or: [objectMemory isForwarded: oop]]]]) ifTrue: [self printOop: oop. ^self]. self printHex: oop. (objectMemory fetchClassOfNonImm: oop) ifNil: [self print: ' has a nil class!!!!'] ifNotNil: [:class| self print: ': a(n) '; printNameOfClass: class count: 5; print: ' ('. objectMemory hasSpurMemoryManagerAPI ifTrue: [self printHexnp: (objectMemory compactClassIndexOf: oop); print: '=>']. self printHexnp: class; print: ')']. fmt := objectMemory formatOf: oop. self print: ' format '; printHexnp: fmt. fmt > objectMemory lastPointerFormat ifTrue: [self print: ' nbytes '; printNum: (objectMemory numBytesOf: oop)] ifFalse: [(objectMemory isIndexableFormat: fmt) ifTrue: [| len | len := objectMemory lengthOf: oop. self print: ' size '; printNum: len - (objectMemory fixedFieldsOf: oop format: fmt length: len)]]. objectMemory printHeaderTypeOf: oop. self print: ' hash '; printHexnp: (objectMemory rawHashBitsOf: oop). self cr. (fmt between: objectMemory firstByteFormat and: objectMemory firstCompiledMethodFormat - 1) ifTrue: [^self printStringOf: oop; cr]. (fmt between: objectMemory firstLongFormat and: objectMemory firstByteFormat - 1) ifTrue: [0 to: ((objectMemory num32BitUnitsOf: oop) min: 256) - 1 do: + [:i| | field32 | + field32 := objectMemory fetchLong32: i ofObject: oop. + self space; printNum: i; space; printHex: field32; space; cr]. - [:i| | fieldOop | - fieldOop := objectMemory fetchLong32: i ofObject: oop. - self space; printNum: i; space; printHex: fieldOop; space; cr]. ^self]. + objectMemory hasSpurMemoryManagerAPI ifTrue: + [fmt = objectMemory sixtyFourBitIndexableFormat ifTrue: + [0 to: ((objectMemory num64BitUnitsOf: oop) min: 256) - 1 do: + [:i| | field64 | + field64 := objectMemory fetchLong64: i ofObject: oop. + self space; printNum: i; space; printHex: field64; space; cr]. + ^self]. + (fmt between: objectMemory firstShortFormat and: objectMemory firstShortFormat + 1) ifTrue: + [0 to: ((objectMemory num16BitUnitsOf: oop) min: 256) - 1 do: + [:i| | field16 | + field16 := objectMemory fetchShort16: i ofObject: oop. + self space; printNum: i; space; printHex: field16; space; cr]. + ^self]]. "this is nonsense. apologies." startIP := (objectMemory lastPointerOf: oop) + objectMemory bytesPerOop - objectMemory baseHeaderSize / objectMemory bytesPerOop. lastIndex := 256 min: startIP. lastIndex > 0 ifTrue: [1 to: lastIndex do: [:i| | fieldOop | fieldOop := objectMemory fetchPointer: i - 1 ofObject: oop. self space; printNum: i - 1; space; printHex: fieldOop; space. (i = 1 and: [objectMemory isCompiledMethod: oop]) ifTrue: [self printMethodHeaderOop: fieldOop] ifFalse: [self cCode: [self printOopShort: fieldOop] inSmalltalk: [self print: (self shortPrint: fieldOop)]]. self cr]]. (objectMemory isCompiledMethod: oop) ifFalse: [startIP > lastIndex ifTrue: [self print: '...'; cr]] ifTrue: [startIP := startIP * objectMemory wordSize + 1. lastIndex := objectMemory lengthOf: oop. lastIndex - startIP > 100 ifTrue: [lastIndex := startIP + 100]. bytecodesPerLine := 8. column := 1. startIP to: lastIndex do: [:index| | byte | column = 1 ifTrue: [self cCode: 'printf("0x%08" PRIxSQPTR ": ", (usqIntptr_t)(oop+BaseHeaderSize+index-1))' inSmalltalk: [self print: (oop+objectMemory baseHeaderSize+index-1) hex; print: ': ']]. byte := objectMemory fetchByte: index - 1 ofObject: oop. self cCode: 'printf(" %02x/%-3d", (int)byte,(int)byte)' inSmalltalk: [self space; print: (byte radix: 16); printChar: $/; printNum: byte]. column := column + 1. column > bytecodesPerLine ifTrue: [column := 1. self cr]]. column = 1 ifFalse: [self cr]]!

1 0

[OpenSmalltalk/opensmalltalk-vm] 4d6aa8: CogVM source as per VMMaker.oscog-eem.2297
by GitHub 21 Dec '17

21 Dec '17

Branch: refs/heads/Cog Home: https://github.com/OpenSmalltalk/opensmalltalk-vm Commit: 4d6aa87b5415e76e517d0463c30f02621a0c865b https://github.com/OpenSmalltalk/opensmalltalk-vm/commit/4d6aa87b5415e76e51… Author: Eliot Miranda <eliot.miranda(a)gmail.com> Date: 2017-12-20 (Wed, 20 Dec 2017) Changed paths: M nsspur64src/vm/cogit.h M nsspur64src/vm/cogitX64SysV.c M nsspur64src/vm/cogitX64WIN64.c M spur64src/vm/cogit.h M spur64src/vm/cogitX64SysV.c M spur64src/vm/cogitX64WIN64.c M spurlowcode64src/vm/cogit.h M spurlowcode64src/vm/cogitX64SysV.c M spurlowcode64src/vm/cogitX64WIN64.c M spursista64src/vm/cogit.h M spursista64src/vm/cogitX64SysV.c M spursista64src/vm/cogitX64WIN64.c Log Message: ----------- CogVM source as per VMMaker.oscog-eem.2297 Cogit: Extend Spur 64-bit primitiveAt with full support for 64-bit longs.

2 1

VM Maker: VMMaker.oscog-eem.2297.mcz
by commits＠source.squeak.org 21 Dec '17

21 Dec '17

Eliot Miranda uploaded a new version of VMMaker to project VM Maker: http://source.squeak.org/VMMaker/VMMaker.oscog-eem.2297.mcz ==================== Summary ==================== Name: VMMaker.oscog-eem.2297 Author: eem Time: 20 December 2017, 3:18:42.905102 pm UUID: ed1f68f5-33bc-459c-b954-afc70c35b8a4 Ancestors: VMMaker.oscog-eem.2296 Cogit: Extend Spur 64-bit primitiveAt with full support for 64-bit longs. Fix some typos and comment out unused C64 & Xowr opcodes. =============== Diff against VMMaker.oscog-eem.2296 =============== Item was added: + ----- Method: CogObjectRepresentationFor64BitSpur>>genAlloc64BitIntegerValue:into:scratchReg:scratchReg: (in category 'primitive generators') ----- + genAlloc64BitIntegerValue: valueReg into: resultReg scratchReg: scratch1 scratchReg: scratch2 + <returnTypeC: #'AbstractInstruction *'> + | allocSize newLPIHeader jumpFail | + <var: #jumpFail type: #'AbstractInstruction *'> + allocSize := objectMemory baseHeaderSize + objectMemory wordSize. + newLPIHeader := objectMemory + headerForSlots: 1 + format: objectMemory firstByteFormat + classIndex: ClassLargePositiveIntegerCompactIndex. + cogit MoveAw: objectMemory freeStartAddress R: resultReg. + cogit LoadEffectiveAddressMw: allocSize r: resultReg R: scratch1. + cogit CmpCq: objectMemory getScavengeThreshold R: scratch1. + jumpFail := cogit JumpAboveOrEqual: 0. + cogit MoveR: scratch1 Aw: objectMemory freeStartAddress. + self genStoreHeader: newLPIHeader intoNewInstance: resultReg using: scratch1. + cogit MoveR: valueReg M64: objectMemory baseHeaderSize r: resultReg. + ^jumpFail! Item was changed: ----- Method: CogObjectRepresentationFor64BitSpur>>genPrimitiveAt (in category 'primitive generators') ----- genPrimitiveAt | formatReg nSlotsOrBytesReg convertToIntAndReturn methodInBounds jumpNotIndexable jumpImmediate jumpBadIndex + jumpIsBytes jumpIsShorts jumpIsWords jumpIsLongs jumpIsMethod jumpIsArray jumpIsContext - jumpIsBytes jumpIsShorts jumpIsWords jumpIsMethod jumpIsArray jumpIsContext jumpHasFixedFields jumpArrayOutOfBounds jumpFixedFieldsOutOfBounds + jumpBytesOutOfBounds jumpShortsOutOfBounds jumpWordsOutOfBounds jumpLongsOutOfBounds + jumpFailAlloc jumpNotSmallInteger | - jumpBytesOutOfBounds jumpShortsOutOfBounds jumpWordsOutOfBounds | "c.f. StackInterpreter>>stSizeOf: SpurMemoryManager>>lengthOf:format: fixedFieldsOf:format:length:" <var: #jumpIsBytes type: #'AbstractInstruction *'> + <var: #jumpIsLongs type: #'AbstractInstruction *'> + <var: #jumpFailAlloc type: #'AbstractInstruction *'> <var: #jumpIsShorts type: #'AbstractInstruction *'> - <var: #jumpBadIndex type: #'AbstractInstruction *'> <var: #jumpIsMethod type: #'AbstractInstruction *'> + <var: #jumpBadIndex type: #'AbstractInstruction *'> <var: #jumpIsContext type: #'AbstractInstruction *'> <var: #jumpImmediate type: #'AbstractInstruction *'> <var: #methodInBounds type: #'AbstractInstruction *'> <var: #jumpNotIndexable type: #'AbstractInstruction *'> <var: #jumpHasFixedFields type: #'AbstractInstruction *'> + <var: #jumpNotSmallInteger type: #'AbstractInstruction *'> <var: #convertToIntAndReturn type: #'AbstractInstruction *'> <var: #jumpArrayOutOfBounds type: #'AbstractInstruction *'> <var: #jumpBytesOutOfBounds type: #'AbstractInstruction *'> + <var: #jumpLongsOutOfBounds type: #'AbstractInstruction *'> <var: #jumpShortsOutOfBounds type: #'AbstractInstruction *'> <var: #jumpWordsOutOfBounds type: #'AbstractInstruction *'> <var: #jumpFixedFieldsOutOfBounds type: #'AbstractInstruction *'> nSlotsOrBytesReg := ClassReg. cogit genLoadArgAtDepth: 0 into: Arg0Reg. jumpImmediate := self genJumpImmediate: ReceiverResultReg. cogit MoveR: Arg0Reg R: Arg1Reg. jumpBadIndex := self genJumpNotSmallInteger: Arg0Reg scratchReg: TempReg. self genConvertSmallIntegerToIntegerInReg: Arg1Reg. cogit SubCq: 1 R: Arg1Reg. "1-rel => 0-rel" "formatReg := self formatOf: ReceiverResultReg" self genGetFormatOf: ReceiverResultReg into: (formatReg := SendNumArgsReg) leastSignificantHalfOfBaseHeaderIntoScratch: TempReg. self genGetNumSlotsOf: ReceiverResultReg into: nSlotsOrBytesReg. "dispatch on format in a combination of highest dynamic frequency order first and convenience. 0 = 0 sized objects (UndefinedObject True False et al) 1 = non-indexable objects with inst vars (Point et al) 2 = indexable objects with no inst vars (Array et al) 3 = indexable objects with inst vars (MethodContext AdditionalMethodState et al) 4 = weak indexable objects with inst vars (WeakArray et al) 5 = weak non-indexable objects with inst vars (ephemerons) (Ephemeron) 6 unused, reserved for exotic pointer objects? 7 Forwarded Object, 1st field is pointer, rest of fields are ignored 8 unused, reserved for exotic non-pointer objects? 9 64-bit indexable 10 - 11 32-bit indexable 12 - 15 16-bit indexable 16 - 23 byte indexable 24 - 31 compiled method" cogit CmpCq: objectMemory firstByteFormat R: formatReg. jumpIsBytes := cogit JumpAboveOrEqual: 0. cogit CmpCq: objectMemory arrayFormat R: formatReg. jumpIsArray := cogit JumpZero: 0. jumpNotIndexable := cogit JumpBelow: 0. cogit CmpCq: objectMemory weakArrayFormat R: formatReg. jumpHasFixedFields := cogit JumpBelowOrEqual: 0. cogit CmpCq: objectMemory firstShortFormat R: formatReg. jumpIsShorts := cogit JumpAboveOrEqual: 0. cogit CmpCq: objectMemory firstLongFormat R: formatReg. jumpIsWords := cogit JumpAboveOrEqual: 0. + cogit CmpCq: objectMemory sixtyFourBitIndexableFormat R: formatReg. + jumpIsLongs := cogit JumpZero: 0. - "For now ignore 64-bit indexability." jumpNotIndexable jmpTarget: cogit Label. jumpNotIndexable := cogit Jump: 0. jumpIsArray jmpTarget: (cogit CmpR: Arg1Reg R: nSlotsOrBytesReg). jumpArrayOutOfBounds := cogit JumpBelowOrEqual: 0. cogit AddCq: objectMemory baseHeaderSize >> objectMemory shiftForWord R: Arg1Reg. cogit MoveXwr: Arg1Reg R: ReceiverResultReg R: ReceiverResultReg. cogit genPrimReturn. jumpIsBytes jmpTarget: (cogit LogicalShiftLeftCq: objectMemory shiftForWord R: nSlotsOrBytesReg). cogit AndCq: objectMemory wordSize - 1 R: formatReg R: TempReg. cogit SubR: TempReg R: nSlotsOrBytesReg; CmpR: Arg1Reg R: nSlotsOrBytesReg. jumpBytesOutOfBounds := cogit JumpBelowOrEqual: 0. cogit CmpCq: objectMemory firstCompiledMethodFormat R: formatReg. jumpIsMethod := cogit JumpAboveOrEqual: 0. methodInBounds := (cogit AddCq: objectMemory baseHeaderSize R: Arg1Reg). cogit backEnd byteReadsZeroExtend ifTrue: [cogit MoveXbr: Arg1Reg R: ReceiverResultReg R: ReceiverResultReg] ifFalse: [cogit "formatReg already contains a value <= 16r1f, so no need to zero it" MoveXbr: Arg1Reg R: ReceiverResultReg R: formatReg; MoveR: formatReg R: ReceiverResultReg]. convertToIntAndReturn := cogit Label. self genConvertIntegerToSmallIntegerInReg: ReceiverResultReg. cogit genPrimReturn. jumpIsShorts jmpTarget: (cogit LogicalShiftLeftCq: objectMemory shiftForWord - 1 R: nSlotsOrBytesReg). cogit AndCq: 1 R: formatReg. cogit SubR: formatReg R: nSlotsOrBytesReg; CmpR: Arg1Reg R: nSlotsOrBytesReg. jumpShortsOutOfBounds := cogit JumpBelowOrEqual: 0. cogit AddR: Arg1Reg R: ReceiverResultReg. cogit AddR: Arg1Reg R: ReceiverResultReg. cogit MoveM16: objectMemory baseHeaderSize r: ReceiverResultReg R: ReceiverResultReg. cogit Jump: convertToIntAndReturn. jumpIsWords jmpTarget: (cogit CmpR: Arg1Reg R: nSlotsOrBytesReg). jumpWordsOutOfBounds := cogit JumpBelowOrEqual: 0. cogit AddCq: objectMemory baseHeaderSize >> (objectMemory shiftForWord - 1) R: Arg1Reg. cogit MoveX32r: Arg1Reg R: ReceiverResultReg R: TempReg. cogit MoveR: TempReg R: ReceiverResultReg. cogit Jump: convertToIntAndReturn. jumpHasFixedFields jmpTarget: (cogit AndCq: objectMemory classIndexMask R: TempReg). cogit MoveR: TempReg R: formatReg. cogit CmpCq: ClassMethodContextCompactIndex R: TempReg. jumpIsContext := cogit JumpZero: 0. self genGetClassObjectOfClassIndex: formatReg into: Extra0Reg scratchReg: TempReg. self genLoadSlot: InstanceSpecificationIndex sourceReg: Extra0Reg destReg: formatReg. self genConvertSmallIntegerToIntegerInReg: formatReg. cogit AndCq: objectMemory fixedFieldsOfClassFormatMask R: formatReg; SubR: formatReg R: nSlotsOrBytesReg; CmpR: Arg1Reg R: nSlotsOrBytesReg. jumpFixedFieldsOutOfBounds := cogit JumpBelowOrEqual: 0. "index is (formatReg (fixed fields) + Arg1Reg (0-rel index)) * wordSize + baseHeaderSize" cogit AddR: formatReg R: Arg1Reg. cogit AddCq: objectMemory baseHeaderSize >> objectMemory shiftForWord R: Arg1Reg. cogit MoveXwr: Arg1Reg R: ReceiverResultReg R: ReceiverResultReg. cogit genPrimReturn. + jumpIsLongs jmpTarget: + (cogit CmpR: Arg1Reg R: nSlotsOrBytesReg). + jumpLongsOutOfBounds := cogit JumpBelowOrEqual: 0. + cogit AddCq: objectMemory baseHeaderSize >> objectMemory shiftForWord R: Arg1Reg. + cogit MoveXwr: Arg1Reg R: ReceiverResultReg R: ClassReg. + cogit MoveR: ClassReg R: TempReg. + cogit LogicalShiftRightCq: self numSmallIntegerBits R: TempReg. "If in range this is now 0" + (cogit lastOpcode setsConditionCodesFor: JumpZero) ifFalse: + [cogit CmpCq: 0 R: ClassReg]. "N.B. FLAGS := ClassReg - 0" + jumpNotSmallInteger := cogit JumpNonZero: 0. + cogit MoveR: ClassReg R: ReceiverResultReg. + cogit Jump: convertToIntAndReturn. + jumpNotSmallInteger jmpTarget: cogit Label. + jumpFailAlloc := self genAlloc64BitIntegerValue: ClassReg into: SendNumArgsReg scratchReg: Extra0Reg scratchReg: TempReg. + cogit MoveR: SendNumArgsReg R: ReceiverResultReg. + cogit genPrimReturn. + jumpIsMethod jmpTarget: cogit Label. "Now check that the index is beyond the method's literals..." self getLiteralCountOf: ReceiverResultReg plusOne: true inBytes: true into: nSlotsOrBytesReg scratch: TempReg. cogit CmpR: Arg1Reg R: nSlotsOrBytesReg. cogit JumpBelow: methodInBounds. + jumpFailAlloc jmpTarget: + (jumpLongsOutOfBounds jmpTarget: + (jumpFixedFieldsOutOfBounds jmpTarget: - jumpFixedFieldsOutOfBounds jmpTarget: (jumpArrayOutOfBounds jmpTarget: (jumpBytesOutOfBounds jmpTarget: (jumpShortsOutOfBounds jmpTarget: (jumpWordsOutOfBounds jmpTarget: (jumpNotIndexable jmpTarget: (jumpIsContext jmpTarget: (jumpBadIndex jmpTarget: + (jumpImmediate jmpTarget: cogit Label)))))))))). - (jumpImmediate jmpTarget: cogit Label)))))))). ^0! Item was changed: SharedPool subclass: #CogRTLOpcodes instanceVariableNames: '' + classVariableNames: 'AddCqR AddCwR AddRR AddRdRd AddRsRs AddcCqR AddcRR AlignmentNops AndCqR AndCqRR AndCwR AndRR ArithmeticShiftRightCqR ArithmeticShiftRightRR Call CallFull CallR CmpC32R CmpCqR CmpCwR CmpRR CmpRdRd CmpRsRs ConvertRRd ConvertRRs ConvertRdR ConvertRdRs ConvertRsR ConvertRsRd DivRdRd DivRsRs Fill32 FirstJump FirstShortJump Jump JumpAbove JumpAboveOrEqual JumpBelow JumpBelowOrEqual JumpCarry JumpFPEqual JumpFPGreater JumpFPGreaterOrEqual JumpFPLess JumpFPLessOrEqual JumpFPNotEqual JumpFPOrdered JumpFPUnordered JumpFull JumpGreater JumpGreaterOrEqual JumpLess JumpLessOrEqual JumpLong JumpLongNonZero JumpLongZero JumpNegative JumpNoCarry JumpNoOverflow JumpNonNegative JumpNonZero JumpOverflow JumpR JumpZero Label LastJump LastRTLCode Literal LoadEffectiveAddressMwrR LogicalShiftLeftCqR LogicalShiftLeftRR LogicalShiftRightCqR LogicalShiftRightRR MoveA32R MoveAbR MoveAwR MoveC32R MoveCqR MoveCwR MoveM16rR MoveM32rR MoveM32rRs MoveM64rRd MoveM8rR MoveMbrR MoveMs8rR MoveM wrR MoveRA32 MoveRAb MoveRAw MoveRM16r MoveRM32r MoveRM8r MoveRMbr MoveRMwr MoveRR MoveRRd MoveRX16rR MoveRX32rR MoveRXbrR MoveRXwrR MoveRdM64r MoveRdR MoveRdRd MoveRsM32r MoveRsRs MoveX16rRR MoveX32rRR MoveXbrRR MoveXwrRR MulRdRd MulRsRs NegateR Nop NotR OrCqR OrCwR OrRR PopR PrefetchAw PushCq PushCw PushR RetN RotateLeftCqR RotateRightCqR SignExtend16RR SignExtend32RR SignExtend8RR SqrtRd SqrtRs Stop SubCqR SubCwR SubRR SubRdRd SubRsRs SubbCqR SubbRR TstCqR XorCqR XorCwR XorRR XorRdRd XorRsRs ZeroExtend16RR ZeroExtend32RR ZeroExtend8RR' - classVariableNames: 'AddCqR AddCwR AddRR AddRdRd AddRsRs AddcCqR AddcRR AlignmentNops AndCqR AndCqRR AndCwR AndRR ArithmeticShiftRightCqR ArithmeticShiftRightRR Call CallFull CallR CmpC32R CmpCqR CmpCwR CmpRR CmpRdRd CmpRsRs ConvertRRd ConvertRRs ConvertRdR ConvertRdRs ConvertRsR ConvertRsRd DivRdRd DivRsRs Fill32 FirstJump FirstShortJump Jump JumpAbove JumpAboveOrEqual JumpBelow JumpBelowOrEqual JumpCarry JumpFPEqual JumpFPGreater JumpFPGreaterOrEqual JumpFPLess JumpFPLessOrEqual JumpFPNotEqual JumpFPOrdered JumpFPUnordered JumpFull JumpGreater JumpGreaterOrEqual JumpLess JumpLessOrEqual JumpLong JumpLongNonZero JumpLongZero JumpNegative JumpNoCarry JumpNoOverflow JumpNonNegative JumpNonZero JumpOverflow JumpR JumpZero Label LastJump LastRTLCode Literal LoadEffectiveAddressMwrR LoadEffectiveAddressXowrR LogicalShiftLeftCqR LogicalShiftLeftRR LogicalShiftRightCqR LogicalShiftRightRR MoveA32R MoveAbR MoveAwR MoveC32R MoveC64R MoveCqR MoveCwR MoveM16rR MoveM32rR MoveM32rRs MoveM64rR d MoveM8rR MoveMbrR MoveMs8rR MoveMwrR MoveRA32 MoveRAb MoveRAw MoveRM16r MoveRM32r MoveRM8r MoveRMbr MoveRMwr MoveRR MoveRRd MoveRX16rR MoveRX32rR MoveRXbrR MoveRXowr MoveRXwrR MoveRdM64r MoveRdR MoveRdRd MoveRsM32r MoveRsRs MoveX16rRR MoveX32rRR MoveXbrRR MoveXowrR MoveXwrRR MulRdRd MulRsRs NegateR Nop NotR OrCqR OrCwR OrRR PopR PrefetchAw PushCq PushCw PushR RetN RotateLeftCqR RotateRightCqR SignExtend16RR SignExtend32RR SignExtend8RR SqrtRd SqrtRs Stop SubCqR SubCwR SubRR SubRdRd SubRsRs SubbCqR SubbRR TstCqR XorCqR XorCwR XorRR XorRdRd XorRsRs ZeroExtend16RR ZeroExtend32RR ZeroExtend8RR' poolDictionaries: '' category: 'VMMaker-JIT'! !CogRTLOpcodes commentStamp: 'eem 12/26/2015 14:00' prior: 0! I am a pool for the Register-Transfer-Language to which Cog compiles. I define unique integer values for all RTL opcodes. See CogAbstractInstruction for instances of instructions with the opcodes that I define.! Item was changed: ----- Method: CogRTLOpcodes class>>initialize (in category 'class initialization') ----- initialize "Abstract opcodes are a compound of a one word operation specifier and zero or more operand type specifiers. The assembler is in Cogit protocol abstract instructions and uses `at&t' syntax, assigning to the register on the right. e.g. MoveRR is the Move opcode with two register operand specifiers and defines a move register to register instruction from operand 0 to operand 1. The word and register size is assumed to be either 32-bits on a 32-bit architecture or 64-bits on a 64-bit architecture. The abstract machine is mostly a 2 address machine with the odd three address instruction added to better exploit RISCs. (self initialize) The operand specifiers are R - general purpose register Rs - single-precision floating-point register Rd - double-precision floating-point register Cq - a `quick' constant that can be encoded in the minimum space possible. Cw - a constant with word size where word is the default operand size for the Smalltalk VM, 32-bits for a 32-bit VM, 64-bits for a 64-bit VM. The generated constant must occupy the default number of bits. This allows e.g. a garbage collector to update the value without invalidating the code. C32 - a constant with 32 bit size. The generated constant must occupy 32 bits. C64 - a constant with 64 bit size. The generated constant must occupy 64 bits. Aw - memory word (32-bits for a 32-bit VM, 64-bits for a 64-bit VM) at an absolute address Ab - memory byte at an absolute address A32 - memory 32-bit halfword at an absolute address Mwr - memory word whose address is at a constant offset from an address in a register Mbr - memory byte whose address is at a constant offset from an address in a register (zero-extended on read) M16r - memory 16-bit halfword whose address is at a constant offset from an address in a register M32r - memory 32-bit halfword whose address is at a constant offset from an address in a register M64r - memory 64-bit doubleword whose address is at a constant offset from an address in a register Xbr - memory byte whose address is r * byte size away from an address in a register X16r - memory 16-bit halfword whose address is r * (2 bytes size) away from an address in a register + X32r - memory 32-bit halfword whose address is r * (4 bytes size) away from an address in a register (64-bit ISAs only) - X32r - memory 32-bit halfword whose address is r * (4 bytes size) away from an address in a register Xwr - memory word whose address is r * word size away from an address in a register Xowr - memory word whose address is o + (r * word size) away from an address in a register (scaled indexed) An alternative would be to decouple opcodes from operands, e.g. Move := 1. Add := 2. Sub := 3... RegisterOperand := 1. ConstantQuickOperand := 2. ConstantWordOperand := 3... But not all combinations make sense and even fewer are used so we stick with the simple compound approach. The assumption is that comparison and arithmetic instructions set condition codes and that move instructions leave the condition codes unaffected. In particular LoadEffectiveAddressMwrR does not set condition codes although it can be used to do arithmetic. On processors such as MIPS this distinction is invalid; there are no + condition codes. So the backend is allowed to collapse operation, branch pairs to internal instruction definitions + (see senders and implementors of noteFollowingConditionalBranch:). - condition codes. So the backend is allowed to collapse operation, branch pairs to internal instruciton definitions - (see sender and implementors of noteFollowingConditionalBranch:). Not all of the definitions in opcodeDefinitions below are implemented. In particular we do not implement the XowrR scaled index addressing mode since it requires 4 operands. Not all instructions make sense on all architectures. MoveRRd and MoveRdR aqre meaningful only on 64-bit machines. Note that there are no generic division instructions defined, but a processor may define some. Branch/Call ranges. Jump[Cond] can be generated as short as possible. Call/Jump[Cond]Long must be generated in the same number of bytes irrespective of displacement since their targets may be updated, but they need only span 16Mb, the maximum size of the code zone. This allows e.g. ARM to use single-word call and jump instructions for most calls and jumps. CallFull/JumpFull must also be generated in the same number of bytes irrespective of displacement for the same reason, but they must be able to span the full (32-bit or 64-bit) address space because they are used to call code in the C runtime, which may be distant from the code zone. CallFull/JumpFull are allowed to use the cResultRegister as a scratch if required (e.g. on x64 where there is no direct 64-bit call or jump). Byte reads. If the concrete compiler class answers true to byteReadsZeroExtend then byte reads must zero-extend the byte read into the destination register. If not, the other bits of the register should be left undisturbed and the Cogit will add an instruction to zero the register as required. Under no circumstances should byte reads sign-extend. 16-bit (and on 64-bits, 32-bit) reads. These /are/ expected to always zero-extend." | opcodeNames refs | opcodeNames := #("Noops & Pseudo Ops" Label Literal "a word-sized literal" AlignmentNops Fill32 "output four byte's worth of bytes with operand 0" Nop "Control" Call "call within the code zone" CallFull "call anywhere within the full address space" CallR RetN JumpR "Not a regular jump, i.e. not pc dependent." Stop "Halt the processor" "N.B. Jumps are contiguous. Long and Full jumps are contiguous within them. See FirstJump et al below" JumpFull "Jump anywhere within the address space" JumpLong "Jump anywhere within the 16mb code zone." JumpLongZero "a.k.a. JumpLongEqual" JumpLongNonZero "a.k.a. JumpLongNotEqual" Jump "short jumps; can be encoded in as few bytes as possible; will not be disturbed by GC or relocation." JumpZero "a.k.a. JumpEqual" JumpNonZero "a.k.a. JumpNotEqual" JumpNegative JumpNonNegative JumpOverflow JumpNoOverflow JumpCarry JumpNoCarry JumpLess "signed" JumpGreaterOrEqual JumpGreater JumpLessOrEqual JumpBelow "unsigned" JumpAboveOrEqual JumpAbove JumpBelowOrEqual JumpFPEqual JumpFPNotEqual JumpFPLess JumpFPLessOrEqual JumpFPGreater JumpFPGreaterOrEqual JumpFPOrdered JumpFPUnordered "Data Movement; destination is always last operand" MoveRR MoveAwR MoveA32R MoveRAw MoveRA32 MoveAbR MoveRAb + MoveMwrR MoveRMwr MoveXwrRR MoveRXwrR "MoveXowrR MoveRXowr""Unused" - MoveMwrR MoveRMwr MoveXwrRR MoveRXwrR MoveXowrR MoveRXowr MoveM8rR MoveMs8rR MoveRM8r MoveM16rR MoveRM16r MoveX16rRR MoveRX16rR MoveM32rR MoveRM32r MoveX32rRR MoveRX32rR MoveMbrR MoveRMbr MoveXbrRR MoveRXbrR + MoveCqR MoveCwR MoveC32R "MoveC64R""Not used" - MoveCqR MoveCwR MoveC32R MoveC64R MoveRRd MoveRdR MoveRdRd MoveM64rRd MoveRdM64r MoveRsRs MoveM32rRs MoveRsM32r PopR PushR PushCq PushCw PrefetchAw "Arithmetic; destination is always last operand except Cmp; CmpXR is SubRX with no update of result" + LoadEffectiveAddressMwrR "LoadEffectiveAddressXowrR" "Variants of add/multiply" - LoadEffectiveAddressMwrR LoadEffectiveAddressXowrR "Variants of add/multiply" NegateR "2's complement negation" NotR ArithmeticShiftRightCqR ArithmeticShiftRightRR LogicalShiftRightCqR LogicalShiftRightRR LogicalShiftLeftCqR LogicalShiftLeftRR RotateLeftCqR RotateRightCqR CmpRR AddRR SubRR AndRR OrRR XorRR CmpCqR AddCqR SubCqR AndCqR OrCqR TstCqR XorCqR CmpCwR CmpC32R AddCwR SubCwR AndCwR OrCwR XorCwR AddcRR AddcCqR SubbRR SubbCqR AndCqRR "Three address ops for RISCs; feel free to add and extend" CmpRdRd AddRdRd SubRdRd MulRdRd DivRdRd SqrtRd XorRdRd CmpRsRs AddRsRs SubRsRs MulRsRs DivRsRs SqrtRs XorRsRs "Conversion" ConvertRRd ConvertRdR ConvertRsRd ConvertRdRs ConvertRsR ConvertRRs SignExtend8RR SignExtend16RR SignExtend32RR ZeroExtend8RR ZeroExtend16RR ZeroExtend32RR LastRTLCode). "Magic auto declaration. Add to the classPool any new variables and nuke any obsolete ones, and assign values" "Find the variables directly referenced by this method" refs := (thisContext method literals select: [:l| l isVariableBinding and: [classPool includesKey: l key]]) collect: [:ea| ea key]. "Move to Undeclared any opcodes in classPool not in opcodes or this method." (classPool keys reject: [:k| (opcodeNames includes: k) or: [refs includes: k]]) do: [:k| Undeclared declare: k from: classPool]. "Declare as class variables and number elements of opcodeArray above" opcodeNames withIndexDo: [:classVarName :value| self classPool declare: classVarName from: Undeclared; at: classVarName put: value]. "For CogAbstractInstruction>>isJump etc..." FirstJump := JumpFull. LastJump := JumpFPUnordered. FirstShortJump := Jump. "And now initialize the backends; they add their own opcodes and hence these must be reinitialized." (Smalltalk classNamed: #CogAbstractInstruction) ifNotNil: [:cogAbstractInstruction| cogAbstractInstruction allSubclasses do: [:sc| sc initialize]]! Item was changed: ----- Method: CogX64Compiler>>setsConditionCodesFor: (in category 'testing') ----- setsConditionCodesFor: aConditionalJumpOpcode <inline: false> "to save Slang from having to be a real compiler (it can't inline switches that return)" "Answer if the receiver's opcode sets the condition codes correctly for the given conditional jump opcode." ^opcode caseOf: { [ArithmeticShiftRightCqR] -> [self shiftSetsConditionCodesFor: aConditionalJumpOpcode]. [ArithmeticShiftRightRR] -> [self shiftSetsConditionCodesFor: aConditionalJumpOpcode]. [LogicalShiftLeftCqR] -> [self shiftSetsConditionCodesFor: aConditionalJumpOpcode]. [LogicalShiftLeftRR] -> [self shiftSetsConditionCodesFor: aConditionalJumpOpcode]. + [LogicalShiftRightCqR] -> [self shiftSetsConditionCodesFor: aConditionalJumpOpcode]. [XorRR] -> [true] } otherwise: [self halt: 'unhandled opcode in setsConditionCodesFor:'. false]! Item was added: + ----- Method: CurrentImageCoInterpreterFacade>>sixtyFourBitIndexableFormat (in category 'accessing') ----- + sixtyFourBitIndexableFormat + ^objectMemory sixtyFourBitIndexableFormat!

2 1

VM Maker: VMMaker.oscog-eem.2296.mcz
by commits＠source.squeak.org 20 Dec '17

20 Dec '17

Eliot Miranda uploaded a new version of VMMaker to project VM Maker: http://source.squeak.org/VMMaker/VMMaker.oscog-eem.2296.mcz ==================== Summary ==================== Name: VMMaker.oscog-eem.2296 Author: eem Time: 20 December 2017, 12:36:23.101265 am UUID: e510f7d2-9ec9-4fa5-bee1-db1f59227058 Ancestors: VMMaker.oscog-eem.2295 Fix bugs in DoubleWordArray>>[unsigned]long64At: which failed to exclude extraneous bytes in the upper word of unaligned accesses. These along with the fix to hackBits: in Graphics-eem.389 fix simulating 64-bit images in 64-bits, ensuring that the display is visible. Add tests for hackBits: and signed access answering neghative values. Fix a comment typo. =============== Diff against VMMaker.oscog-eem.2295 =============== Item was changed: ----- Method: DoubleWordArray>>long64At: (in category '*VMMaker-JITSimulation') ----- long64At: byteIndex | lowBits wordIndex value high low | wordIndex := byteIndex - 1 // 8 + 1. (lowBits := byteIndex - 1 \\ 8) = 0 ifTrue: [value := self at: wordIndex] ifFalse: + [high := ((self at: wordIndex + 1) bitAnd: (1 bitShift: lowBits * 8) - 1) bitShift: 8 - lowBits * 8. - [high := (self at: wordIndex + 1) bitShift: 8 - lowBits * 8. low := (self at: wordIndex) bitShift: lowBits * -8. high = 0 ifTrue: [^low]. value := high + low]. ^(value bitShift: -56) <= 127 ifTrue: [value] ifFalse: [value - 16r10000000000000000]! Item was changed: ----- Method: DoubleWordArray>>unsignedLong64At: (in category '*VMMaker-JITSimulation') ----- unsignedLong64At: byteIndex "Compatiblity with the ByteArray & Alien methods of the same name." | wordIndex lowBits high low | wordIndex := byteIndex - 1 // 8 + 1. (lowBits := byteIndex - 1 bitAnd: 7) = 0 ifTrue: [^self at: wordIndex]. + high := ((self at: wordIndex + 1) bitAnd: (1 bitShift: lowBits * 8) - 1) bitShift: 8 - lowBits * 8. - high := (self at: wordIndex + 1) bitShift: 8 - lowBits * 8. low := (self at: wordIndex) bitShift: lowBits * -8. ^high = 0 ifTrue: [low] ifFalse: [high + low]! Item was changed: ----- Method: MemoryTests>>testLittleEndian32BitLongAccessFor: (in category 'test support') ----- testLittleEndian32BitLongAccessFor: aClass "Test that ByteArray provides big-endian access for 32-bit accessors" "memory copy changeClassTo: ByteArray" | memory | memory := aClass new: 64 / (aClass new: 0) bytesPerElement. "signed access" 0 to: 30 do: [:shift| #(-1 1) do: [:initial| | value | value := initial bitShift: shift. memory longAt: 1 put: value. self assert: value equals: (memory longAt: 1). "aligned store" memory longAt: 5 put: 16r55550000; longAt: 9 put: 16r00005555. self assert: 16r55555555 equals: (memory longAt: 7). memory longAt: 7 put: value. self assert: value equals: (memory longAt: 7). "check bytes either side have not been changed" 5 to: 6 do: [:i| self assert: 0 equals: (memory byteAt: i)]. 11 to: 15 do: [:i| self assert: 0 equals: (memory byteAt: i)]. "unaligned store" memory longAt: 6 put: 16r55550000; longAt: 10 put: 16r00005555. self assert: 16r55555555 equals: (memory longAt: 8). memory longAt: 8 put: value. self assert: value equals: (memory longAt: 8). "check bytes either side have not been changed" 5 to: 7 do: [:i| self assert: 0 equals: (memory byteAt: i)]. 12 to: 15 do: [:i| self assert: 0 equals: (memory byteAt: i)]]]. + memory + unsignedLongAt: 49 put: 16rAAAAAAAA; + unsignedLongAt: 53 put: 16rAAAAAAAA. + 49 to: 52 do: + [:i| + self assert: -1431655766 equals: (memory longAt: i)]. "unsigned access" 0 to: 31 do: [:shift| | value | value := 1 bitShift: shift. memory unsignedLongAt: 1 put: value. self assert: value equals: (memory unsignedLongAt: 1). "aligned store" memory longAt: 5 put: 16r55550000; longAt: 9 put: 16r00005555. self assert: 16r55555555 equals: (memory unsignedLongAt: 7). memory unsignedLongAt: 7 put: value. self assert: value equals: (memory unsignedLongAt: 7). "check bytes either side have not been changed" 5 to: 6 do: [:i| self assert: 0 equals: (memory byteAt: i)]. 11 to: 15 do: [:i| self assert: 0 equals: (memory byteAt: i)]. "unaligned store" memory longAt: 6 put: 16r55550000; longAt: 10 put: 16r00005555. self assert: 16r55555555 equals: (memory unsignedLongAt: 8). memory unsignedLongAt: 8 put: value. self assert: value equals: (memory unsignedLongAt: 8). "check bytes either side have not been changed" 5 to: 7 do: [:i| self assert: 0 equals: (memory byteAt: i)]. 12 to: 15 do: [:i| self assert: 0 equals: (memory byteAt: i)]]! Item was changed: ----- Method: MemoryTests>>testLittleEndian64BitLongAccessFor: (in category 'test support') ----- testLittleEndian64BitLongAccessFor: aClass "Test that the given class provides little-endian access for 64-bit accessors" "memory copy changeClassTo: ByteArray" | memory | memory := aClass new: 64 / (aClass new: 0) bytesPerElement. "signed access" 0 to: 62 do: [:shift| #(-1 1) do: [:initial| | value | value := initial bitShift: shift. memory long64At: 1 put: value. self assert: value equals: (memory long64At: 1). "aligned store" memory long64At: 9 put: 16r5555550000000000; long64At: 17 put: 16r0000005555555555. self assert: 16r5555555555555555 equals: (memory long64At: 14). memory long64At: 14 put: value. self assert: value equals: (memory long64At: 14). "check bytes either side have not been changed" 9 to: 13 do: [:i| self assert: 0 equals: (memory byteAt: i)]. 22 to: 31 do: [:i| self assert: 0 equals: (memory byteAt: i)]. "unaligned store" memory long64At: 10 put: 16r5555550000000000; long64At: 18 put: 16r0000005555555555. self assert: 16r5555555555555555 equals: (memory long64At: 15). memory long64At: 15 put: value. self assert: value equals: (memory long64At: 15). "check bytes either side have not been changed" 9 to: 14 do: [:i| self assert: 0 equals: (memory byteAt: i)]. 23 to: 31 do: [:i| self assert: 0 equals: (memory byteAt: i)]]]. + memory + unsignedLong64At: 49 put: 16rAAAAAAAAAAAAAAAA; + unsignedLong64At: 57 put: 16rAAAAAAAAAAAAAAAA. + 49 to: 56 do: + [:i| + self assert: -6148914691236517206 equals: (memory long64At: i)]. "unsigned access" 0 to: 63 do: [:shift| | value | value := 1 bitShift: shift. memory unsignedLong64At: 1 put: value. self assert: value equals: (memory unsignedLong64At: 1). "aligned store" memory unsignedLong64At: 9 put: 16r5555550000000000; unsignedLong64At: 17 put: 16r0000005555555555. self assert: 16r5555555555555555 equals: (memory unsignedLong64At: 14). memory unsignedLong64At: 14 put: value. self assert: value equals: (memory unsignedLong64At: 14). "check bytes either side have not been changed" 9 to: 13 do: [:i| self assert: 0 equals: (memory byteAt: i)]. 22 to: 31 do: [:i| self assert: 0 equals: (memory byteAt: i)]. "unaligned store" memory unsignedLong64At: 10 put: 16r5555550000000000; unsignedLong64At: 18 put: 16r0000005555555555. self assert: 16r5555555555555555 equals: (memory unsignedLong64At: 15). memory unsignedLong64At: 15 put: value. self assert: value equals: (memory unsignedLong64At: 15). "check bytes either side have not been changed" 9 to: 14 do: [:i| self assert: 0 equals: (memory byteAt: i)]. 23 to: 31 do: [:i| self assert: 0 equals: (memory byteAt: i)]]! Item was changed: ----- Method: Spur64BitMMLESimulatorFor64Bits>>long64At: (in category 'memory access') ----- long64At: byteAddress + "memory is a DoubleWordArray, a 64-bit indexable array of bits" - "memory is a DobleWordArray, a 64-bit indexable array of bits" byteAddress \\ 8 ~= 0 ifTrue: [self unalignedAccessError]. ^memory at: byteAddress // 8 + 1! Item was added: + ----- Method: StackInterpreterSimulatorTests>>testHackBits (in category 'tests') ----- + testHackBits + "Test that the hackBits plumbing, used for display update in the + simulated ioShow:D:i:s:p:l:a:y:, works for the underlying memory classes." + | mem32 mem64 disp32 disp64 hack32 hack64 | + mem32 := LittleEndianBitmap new: 65536 / 4. + mem64 := DoubleWordArray new: 65536 / 8. + 1 to: 65536 by: 8 do: + [:i| + mem32 + unsignedLong64At: i + put: ((i // 8) even + ifTrue: [16r5555555555555555] + ifFalse: [16rAAAAAAAAAAAAAAAA]). + mem64 + unsignedLong64At: i + put: ((i // 8) even + ifTrue: [16r5555555555555555] + ifFalse: [16rAAAAAAAAAAAAAAAA])]. + self assert: (mem32 copy changeClassTo: ByteArray) = (mem64 copy changeClassTo: ByteArray). + hack32 := Form new hackBits: mem32. + hack64 := Form new hackBits: mem64. + disp32 := Form new hackBits: (ByteArray new: 65536). + disp64 := Form new hackBits: (ByteArray new: 65536). + disp32 + copy: (0 @ 0 extent: 4 @ (65536 / 4)) + from: 0 @ 0 + in: hack32 + rule: Form over. + disp64 + copy: (0 @ 0 extent: 4 @ (65536 / 4)) + from: 0 @ 0 + in: hack64 + rule: Form over. + 1 to: 65536 by: 8 do: + [:i| + self assert: ((i // 8) even + ifTrue: [16r5555555555555555] + ifFalse: [16rAAAAAAAAAAAAAAAA]) + equals: (disp32 bits unsignedLong64At: i). + self assert: ((i // 8) even + ifTrue: [16r5555555555555555] + ifFalse: [16rAAAAAAAAAAAAAAAA]) + equals: (disp64 bits unsignedLong64At: i)] + !

1 0

[OpenSmalltalk/opensmalltalk-vm] ebe000: Revert attempt to address #160.
by GitHub 17 Dec '17

17 Dec '17

Branch: refs/heads/Cog Home: https://github.com/OpenSmalltalk/opensmalltalk-vm Commit: ebe0000158dba326a75ba96866edaf7187e62d44 https://github.com/OpenSmalltalk/opensmalltalk-vm/commit/ebe0000158dba326a7… Author: Fabio Niephaus <code(a)fniephaus.com> Date: 2017-12-17 (Sun, 17 Dec 2017) Changed paths: M .travis.yml Log Message: ----------- Revert attempt to address #160. Disable pharo deployment temporarily.

1 0

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

Vm-dev December 2017