[Vm-dev] VM Maker: Cog-eem.174.mcz

commits at source.squeak.org commits at source.squeak.org
Tue Jul 29 04:38:39 UTC 2014


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

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

Name: Cog-eem.174
Author: eem
Time: 28 July 2014, 6:38:12.482 pm
UUID: 8d96136f-1223-476e-9761-546dd9e1d66c
Ancestors: Cog-eem.173

Use numSlotsOf: and numBytesOf: in place of 
fetchLong32LengthOf:, fetchWordLengthOf: and byteLengthOf:.
Needs VMMaker.oscog-eem.837

=============== Diff against Cog-eem.173 ===============

Item was changed:
  ----- Method: SpurBootstrap>>clone:classIndex: (in category 'bootstrap image') -----
  clone: oldObj classIndex: classIndex
  	| newObj |
  	newObj := newHeap
+ 				allocateSlots: (oldHeap numSlotsOf: oldObj)
- 				allocateSlots: (oldHeap fetchWordLengthOf: oldObj)
  				format: (self newFormatFor: oldObj)
  				classIndex: classIndex.
  	reverseMap at: newObj put: oldObj.
  	^map at: oldObj put: newObj!

Item was changed:
  ----- Method: SpurBootstrap>>findLiteral: (in category 'bootstrap methods') -----
  findLiteral: aLiteral
  	| symbolOop smalltalk array |
  	aLiteral isString ifTrue:
  		[^self stringFor: aLiteral].
  	aLiteral isFloat ifTrue:
  		[^oldInterpreter floatObjectOf: aLiteral].
  	aLiteral isArray ifTrue:
  		[^self cloneArrayLiteral: aLiteral].
  	self assert: aLiteral isVariableBinding.
  	symbolOop := self findSymbol: aLiteral key.
  	smalltalk := oldHeap splObj: 8.
  	array := oldHeap fetchPointer: 1 ofObject: smalltalk.
  	self assert: (oldHeap isArray: array).
+ 	0 to: (oldHeap numSlotsOf: array) - 1 do:
- 	0 to: (oldHeap fetchWordLengthOf: array) - 1 do:
  		[:i| | bindingOrNil |
  		bindingOrNil := oldHeap fetchPointer: i ofObject: array.
  		(bindingOrNil ~= oldHeap nilObject
  		 and: [symbolOop = (oldHeap fetchPointer: KeyIndex ofObject: bindingOrNil)
  		 and: [aLiteral key == #Smalltalk
  				ifTrue:
  					[(oldHeap fetchPointer: ValueIndex ofObject: bindingOrNil) = smalltalk]
  				ifFalse:
  					[oldInterpreter
  						classNameOf: (oldHeap fetchPointer: ValueIndex ofObject: bindingOrNil)
  						Is: aLiteral key]]]) ifTrue:
  			[^bindingOrNil]].
  	self error: 'couldn''t find literal ', aLiteral printString!

Item was changed:
  ----- Method: SpurBootstrap>>findSymbol: (in category 'bootstrap methods') -----
  findSymbol: aString
  	"Find the Symbol equal to aString in oldHeap."
  	| symbolClass |
  	(literalMap at: aString ifAbsent: nil) ifNotNil:
  		[:oop| ^oop].
  	symbolClass := self symbolClass.
  	oldHeap allObjectsDo:
  		[:obj|
  		(symbolClass = (oldHeap fetchClassOfNonImm: obj)
+ 		 and: [(oldHeap numBytesOf: obj) = aString size
- 		 and: [(oldHeap byteLengthOf: obj) = aString size
  		 and: [aString = (oldHeap stringOf: obj)]]) ifTrue:
  			[^obj]].
  	^nil!

Item was changed:
  ----- Method: SpurBootstrap>>indexOfSelector:in: (in category 'bootstrap methods') -----
  indexOfSelector: selectorOop in: methodDict
+ 	SelectorStart to: (oldHeap numSlotsOf: methodDict) - 1 do:
- 	SelectorStart to: (oldHeap fetchWordLengthOf: methodDict) - 1 do:
  		[:i|
  		(oldHeap fetchPointer: i ofObject: methodDict) = selectorOop ifTrue:
  			[^i]].
  	self error: 'could not find selector in method dict'!

Item was changed:
  ----- Method: SpurBootstrap>>modifyCharacterMethods (in category 'bootstrap methods') -----
  modifyCharacterMethods
  	| cc md mda |
  	cc := oldHeap classCharacter.
  	md := oldHeap fetchPointer: MethodDictionaryIndex ofObject: cc.
  	mda := oldHeap fetchPointer: MethodArrayIndex ofObject: md..
+ 	0 to: (oldHeap numSlotsOf: mda) - 1 do:
- 	0 to: (oldHeap fetchWordLengthOf: mda) - 1 do:
  		[:i| | method |
  		method := oldHeap fetchPointer: i ofObject: mda.
  		method ~= oldHeap nilObject ifTrue:
  			[(self replacementForCharacterMethod: method) ifNotNil:
  				[:replacement|
  				Transcript
  					cr;
  					nextPutAll: 'replacing Character>>#';
  					nextPutAll: (oldHeap stringOf: (oldHeap fetchPointer: i + SelectorStart ofObject: md));
  					flush. 
  				oldHeap
  					storePointer: i
  					ofObject: mda
  					withValue: replacement]]]!

Item was changed:
  ----- Method: SpurBootstrap>>newFormatFor: (in category 'bootstrap image') -----
  newFormatFor: oldObj
  	"OLD:
  	 0	no fields
  	 1	fixed fields only (all containing pointers)
  	 2	indexable fields only (all containing pointers)
  	 3	both fixed and indexable fields (all containing pointers)
  	 4	both fixed and indexable weak fields (all containing pointers).
  
  	 5	unused
  	 6	indexable word fields only (no pointers)
  	 7	indexable long (64-bit) fields (only in 64-bit images)
   
  	 8-11	indexable byte fields only (no pointers) (low 2 bits are low 2 bits of size)
  	 12-15	compiled methods:
  	 	    # of literal oops specified in method header,
  	 	    followed by indexable bytes (same interpretation of low 2 bits as above)"
  
  	"NEW:
  	 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)
  
  	 and here it gets messy, we need 8 CompiledMethod values, 8 byte values, 4 16-bit values, 2 32-bit values and a 64-bit value, = 23 values, 23 + 5 = 30, so there may be room.
  
  	 9 (?) 64-bit indexable
  	 10 - 11 32-bit indexable
  	 12 - 15 16-bit indexable
  	 16 - 23 byte indexable
  	 24 - 31 compiled method"
  	| oldFormat |
  	oldFormat := oldHeap formatOf: oldObj.
  	oldFormat <= 4 ifTrue:
  		[^oldFormat].
  	oldFormat >= 12 ifTrue: "CompiledMethod"
+ 		[^24 + (self wordSize - (oldHeap numBytesOf: oldObj) bitAnd: self wordSizeMask)].
- 		[^24 + (self wordSize - (oldHeap byteLengthOf: oldObj) bitAnd: self wordSizeMask)].
  	oldFormat >= 8 ifTrue: "ByteArray et al"
+ 		[^16 + (self wordSize - (oldHeap numBytesOf: oldObj) bitAnd: self wordSizeMask)].
- 		[^16 + (self wordSize - (oldHeap byteLengthOf: oldObj) bitAnd: self wordSizeMask)].
  	oldFormat = 6 ifTrue: "32-bit indexable"
+ 		[^10 + ((oldHeap numBytesOf: oldObj) bitAnd: self wordSizeMask) sign].
- 		[^10 + ((oldHeap byteLengthOf: oldObj) bitAnd: self wordSizeMask) sign].
  	oldFormat = 7 ifTrue: "64-bit indexable"
  		[^9].
  	self error: 'illegal old format'!

Item was changed:
  ----- Method: SpurBootstrap32>>fillInBitsObject:from: (in category 'bootstrap') -----
  fillInBitsObject: newObj from: oldObj
+ 	0 to: (oldHeap numSlotsOf: oldObj) - 1 do:
- 	0 to: (oldHeap fetchLong32LengthOf: oldObj) - 1 do:
  		[:i|
  		newHeap
  			storeLong32: i
  			ofObject: newObj
  			withValue: (oldHeap fetchLong32: i ofObject: oldObj)]!



More information about the Vm-dev mailing list