Eliot Miranda uploaded a new version of Compiler to project The Trunk:
http://source.squeak.org/trunk/Compiler-eem.347.mcz

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

Name: Compiler-eem.347
Author: eem
Time: 6 April 2017, 12:08:22.719112 pm
UUID: d778b11b-16be-4455-8955-cac9921e64a0
Ancestors: Compiler-eem.346

Provide is(Non)SyntheticStoreAt:in:for: for SistaV1.
Fix selectorToSendOrItselfFor:in:at: so that it is not follwed if invoked at a raw bytecode that is preceeded by an extension.

=============== Diff against Compiler-eem.346 ===============

Item was added:
+ ----- Method: EncoderForSistaV1 class>>isSyntheticStoreAt:in:for: (in category 'instruction stream support') -----
+ isSyntheticStoreAt: pc in: method for: anInstructionStream
+ 	"Answer whether the bytecode at pc is a store or store-pop of an indirect temp vector,
+ 	 which implement mutable closed-over variables in the the closure implementation.
+ 	 Stores into temp vectors are not real stores.  N.B. pcPreviousTo:in:for: is slow, so filter
+ 	 out any preceding bytecodes other than what looks like a pushNewArrayCode.  But the
+ 	 pcPreviousTo:in:for: is still necessary, since the presence of a pcPreviousTo:in:for: in the
+ 	 right place is potentially ambiguous, possibly part of a different bytecode sequence."
+ 
+ 	^(self isTempStoreAt: pc in: method)
+ 	  and: [pc - 2 >= method initialPC
+ 	  and: [(method at: pc - 2) = self pushNewArrayCode
+ 	  and: [(method at: pc - 1) <= 127
+ 	  and: [pc - 2 = (self pcPreviousTo: pc in: method for: anInstructionStream)]]]]!

Item was added:
+ ----- Method: EncoderForSistaV1 class>>isTempStoreAt:in: (in category 'instruction stream support') -----
+ isTempStoreAt: pc in: method
+ 	"Answer if the bytecode at pc is a store or store-pop into a temporary variable.
+ 	 208-215	11010 iii			Pop and Store Temporary Variable #iii
+ 	 242		11110010	iiiiiiii		Pop and Store Temporary Variable #iiiiiiii
+ 	 245		11110110	iiiiiiii		Store Temporary Variable #iiiiiiii"
+ 
+ 	| byte |
+ 	byte := method at: pc.
+ 	^byte >= 208
+ 	  and: [byte <= 215
+ 			or: [byte = 242 and: [byte = 245]]]!

Item was added:
+ ----- Method: EncoderForSistaV1 class>>pushNewArrayCode (in category 'bytecode decoding') -----
+ pushNewArrayCode
+ 	"231		11100111	jkkkkkkk	Push (Array new: kkkkkkk) (j = 0)
+ 									&	Pop kkkkkkk elements into: (Array new: kkkkkkk) (j = 1)"
+ 	^231!

Item was changed:
  ----- Method: EncoderForSistaV1 class>>selectorToSendOrItselfFor:in:at: (in category 'instruction stream support') -----
  selectorToSendOrItselfFor: anInstructionStream in: method at: pc
  	"If anInstructionStream is at a send bytecode then answer the send's selector,
  	 otherwise answer anInstructionStream itself.  The rationale for answering
  	 anInstructionStream instead of, say, nil, is that potentially any existing object
  	 can be used as a selector, but since anInstructionStream postdates the method,
  	 it can't be one of them.
  
+ 	 The complication is that for convenience we allow the pc to point to the
+ 	 raw send bytecode after its extension(s), or at the extension(s) preceeding it.
+ 	96-111		0110 iiii			Send Arithmetic Message #iiii (+ - < > <= >= = ~= * / \\ @ bitShift: // bitAnd: bitOr:)
+ 	112-119	01110 iii			Send Special Message #iii + 0 (at: at:put: size next nextPut: atEnd == class)
+ 	120-127	01111 iii			Send Special Message #iii + 8 (~~ value value: do: new new: x y)
+ 	128-143	1000 iiii			Send Literal Selector #iiii With 0 Argument
+ 	144-159	1001 iiii			Send Literal Selector #iiii With 1 Arguments
+ 	160-175	1010 iiii			Send Literal Selector #iiii With 2 Arguments
+ 	*	224	11100000	aaaaaaaa	Extend A (Ext A = Ext A prev * 256 + Ext A)
+ 	*	225	11100001	bbbbbbbb	Extend B (Ext B = Ext B prev * 256 + Ext B)
+ 	**	234	11101010	iiiiijjj		Send Literal Selector #iiiii (+ Extend A * 32) with jjj (+ Extend B * 8) Arguments
+ 	**	235	11101011	iiiiijjj	ExtendB < 64
+ 										ifTrue: [Send To Superclass Literal Selector #iiiii (+ Extend A * 32) with jjj (+ Extend B * 8) Arguments]
+ 										ifFalse: [Send To Superclass of Stacked Class Literal Selector #iiiii (+ Extend A * 32) with jjj (+ (Extend B "
- 	 The compilcation is that for convenience we assume the pc could be
- 	 pointing to the raw send bytecode after its extensions, or at the extension
- 	 preceeding the raw send bytecode.
- 		96-111		0110 iiii			Send Arithmetic Message #iiii #(#+ #- #< #> #'<=' #'>=' #= #'~=' #* #/ #'\\' #@ #bitShift: #'//' #bitAnd: #bitOr:)
- 		112-119	01110 iii			Send Special Message #iii #(#at: #at:put: #size #next #nextPut: #atEnd #'==' class)
- 		120		01111000			UNASSIGNED (was: blockCopy:)
- 		121		01111001			Send Special Message #value
- 		122-123	0111101 i			Send Special Message #i #(#value: #do:)
- 		124-127	011111 ii			Send Special Message #ii #(#new #new: #x #y))
- 		128-143	1000 iiii			Send Literal Selector #iiii With 0 Argument
- 		144-159	1001 iiii			Send Literal Selector #iiii With 1 Arguments
- 		160-175	1010 iiii			Send Literal Selector #iiii With 2 Arguments
- 	*	224		11100000	aaaaaaaa	Extend A (Ext A = Ext A prev * 256 + Ext A)
- 	*	225		11100001	bbbbbbbb	Extend B (Ext B = Ext B prev * 256 + Ext B)
- 	**	234		11101010	iiiiijjj		Send Literal Selector #iiiii (+ Extend A * 32) with jjj (+ Extend B * 8) Arguments
- 	**	235		11101011	iiiiijjj		Send To Superclass Literal Selector #iiiii (+ Extend A * 32) with jjj (+ Extend B * 8) Arguments"
  
  	| byte |
  	byte := method at: pc.
  	byte < 96 ifTrue:
  		[^anInstructionStream].
  	byte <= 175 ifTrue: 
  		["special byte or short send"
  		 ^byte >= 128
  			ifTrue: [method literalAt: (byte bitAnd: 15) + 1]
  			ifFalse: [Smalltalk specialSelectorAt: byte - 95]].
  	byte < 234 ifTrue: "need to check for either extension cuz order of extensions is not restricted. so extB could preceed extA"
  		[(byte >= 224 and: [byte <= 225]) ifTrue:
  			[^self extensionsAt: pc in: method into:
  				[:extA :extB :nExtBytes| | byteAfter index |
  				byteAfter := method at: pc + nExtBytes.
  				(byteAfter >= 234 and: [byteAfter <= 235])
  					ifTrue:
  						[index := ((method at: pc + nExtBytes + 1) bitShift: -3) + (extA bitShift: 5).
  						 method literalAt: index + 1]
  					ifFalse: [anInstructionStream]]].
  		^anInstructionStream].
  	byte > 235 ifTrue:
  		[^anInstructionStream].
  	"they could be extended..."
+ 	^self extensionsFor: pc in: method into:
- 	^self extensionsAt: pc in: method into:
  		[:extA :extB :nExtBytes| | index |
  		 index := ((method at: pc + 1) bitShift: -3) + (extA bitShift: 5).
  		 method literalAt: index + 1]!