"{ Package: 'stx:goodies/newcompiler' }"

IRInterpreter subclass:#IRDecompiler

	instanceVariableNames:'stack sp scope currentInstr valueLabelMap mapEmptyStatement'

	classVariableNames:''

	poolDictionaries:''

	category:'NewCompiler-IR'

!

IRDecompiler comment:'I interpret IRMethod instructions and generate a Smalltalk abstract syntax tree rooted at a RBMethodNode.

This is implemented like a shift-reduce parser.  Each instruction either causes a node to be pushed on the stack (shift), or causes one or more nodes to be popped and combined into a single node which is push back on the stack (reduce).  Most reduction is done at the "label: labelNum" instruction where it tries to reduce jump structures into control messages like #ifTrue:, whileFalse:, etc.

Several pseudo nodes (RBPseudoNode and subclasses) are used to represent basic instructions that have not been reduced to real AST nodes yet.
'

!

!IRDecompiler class methodsFor:'as yet unclassified'!

dummySelector: numArgs

	"Answer a dummy selector with number of args"

	| sel |

	sel _ 'unknown'.

	1 to: numArgs do: [:i |

		sel _ sel, 'with:'].

	^ sel asSymbol

! !

!IRDecompiler methodsFor:'accessing'!

scope

	^scope

! !

!IRDecompiler methodsFor:'init'!

addTempToScope: ir 

	"Temp may be created only if they are not used in the method"

	0 to: ir numRargs - 1 do: [:i | (scope 

		rawVarAt: i 

		ifNone: [

			scope capturedVars do: [:each | 

				each index = i ifTrue:[

					scope tempVarAt: scope capturedVars size + scope tempVars size.

					^self]].

			scope tempVarAt: i]) markArg]

!

decompileIR: ir 

	| sequenceNode temps args goto seq value method |

	scope isBlockScope 

		ifTrue:[(scope addTemp: 'parent env') markArg]

		ifFalse:[(scope addTemp: 'self') markArg].

	ir tempKeys do: [:temp | scope tempVarAt: temp].

	0 to: ir numRargs - 1 do: [:i | (scope tempVarAt: i) markArg].

	self interpret: ir.

	self addTempToScope: ir.

	self label: #return.

	self Label: #return.

	(self endCase: #lastReturn) ifFalse:[self Label: #return.].

	goto := self Goto.

	value := self ValueOrNone.

	seq := self Sequence.

	self removeClosureCreation: seq.

	sp = 1 ifFalse: [stack explore. self error: 'error'].

	value ifNotNil: [seq addNode: value].

	sequenceNode := (self newBlock: seq return: goto) body.

	temps := scope compactIndexTemps asArray.

	ir tempKeys: temps.

	args := (temps first: ir numRargs) allButFirst.

	args := args collect: [:var | self newVar: var].

	temps := temps allButFirst: ir numRargs.

	sequenceNode temporaries: (temps collect: [:var | self newVar: var]), 

		((scope capturedVars select:[:var | var name ~= 'self' and: [var sourceTemp == nil]]) 

			collect:[:var | self newVar: var]).

	method := (RBMethodNode new)

				selectorParts: (self 

							newSelectorParts: (self class dummySelector: args size));

				arguments: args;

				body: sequenceNode;

				primitiveNode: ir primitiveNode;

				scope: scope.

	sequenceNode parent: method.

	Preferences compileBlocksAsClosures 

		ifFalse: [ASTFixDecompileBlockScope new visitNode: method].

	^ method

!

removeClosureCreation: seq 

	(Preferences compileBlocksAsClosures 

		and: [seq statements size > 0]

		and: [seq statements first isClosureEnvironmentCreation]) ifTrue: [

			seq statements removeFirst.

			(seq statements size > 0

				and: [seq statements first isClosureEnvironmentRegistration])

				ifTrue: [seq statements removeFirst]].

	[Preferences compileBlocksAsClosures

		and: [seq statements size > 0]

		and: [seq statements first isClosureRegistrationAndCreation

			or: [seq statements first isSelfClosureRegistration]

			or: [seq statements first isTempClosureRegistration]]]

					whileTrue: [seq statements removeFirst]

!

scope: aLexicalScope

	scope := aLexicalScope

! !

!IRDecompiler methodsFor:'instructions'!

goto: seqNum

	self stackPush: (RBPseudoGotoNode new destination: seqNum).

!

if: bool goto: seqNum1 otherwise: seqNum2

	self stackPush: (RBPseudoIfNode new

		boolean: bool;

		destination: seqNum1;

		otherwise: seqNum2)

!

label: seqNum

	stack isEmpty ifTrue: [  "start"

		^ stack addLast: (RBPseudoLabelNode new destination: seqNum)].

	self captureEmptyStatement.

	"Reduce jump structures to one of the following if possible"

	[	(self endBlock: seqNum) or: [

		 (self endAndOr: seqNum) or: [

		  (self endAndOr2: seqNum) or: [

		   (self endIfThen: seqNum) or: [

		    (self endIfThen2: seqNum) or:[

		      (self endIfThenElse: seqNum) or: [

		       (self endCase: seqNum) or: [

		        (self endToDo: seqNum) or: [

		         (self endWhile: seqNum) or: [

			     (self endWhile2: seqNum) or: [

			      (self endIfNil: seqNum)]]]]]]]]]]

	] whileTrue.

	stack addLast: (RBPseudoLabelNode new destination: seqNum).

!

popTop

	| value |

	stack last ifNil: [^ stack removeLast].  "pop no-op from #simplifyTempAssign:"

	[stack last isLabel 

		and: [(stack atLast:2) isGoto] 

		and: [stack last destination = (stack atLast: 2) destination]]

			whileTrue: [

				stack removeLast.

				stack removeLast].

	stack last isValue ifTrue: [

		(stack atLast: 2) isSequence ifTrue: [

			value := stack removeLast.

			^ stack last addNode: value.

		] ifFalse: [(stack atLast: 2) isPseudo ifTrue: [

			value := stack removeLast.

			^ stack addLast: (RBSequenceNode statements: {value}).

		]].

	].

	stack addLast: RBPseudoPopNode new

!

pushBlock: irMethod

	self block: irMethod env: nil

!

pushBlockMethod: irMethod

	"block will recognized when send: #createBlock:"

	self pushLiteral: irMethod

!

pushDup

	stack addLast: RBPseudoDupNode new

!

pushInstVar: index

	self stackPush: (self newVar: (scope instanceScope instVar: index))

!

pushLiteral: object

	self stackPush: (self newLiteral: object).

!

pushLiteralVariable: object

	| var |

	var := scope lookupVar: object key asString.

	self stackPush: (self newVar: var)

!

pushTemp: tempIndex

	| var |

	var := scope basicTempVarAt: tempIndex.

	var isTemp ifTrue: [var cantBeCapture].

	self stackPush: (self newVar: var).

!

remoteReturn

	stack removeLast.  "pop home context free var"

	self goto: #return.

!

returnTop

	self goto: #return.

!

send: selector numArgs: numArgs

        | args rcvr |

        selector = #caseError ifTrue:[^self stackPush: (RBPseudoSendNode new selector: selector)].

        args := OrderedCollection new.

        [       selector numArgs timesRepeat: [args addFirst: self Value].

                rcvr := self Value.

        ] on: Abort do: [

                [self stackPush: (RBPseudoSendNode new selector: selector).

                ^self cascade] on: Abort do:[^false]

        ].

        Preferences compileBlocksAsClosures 

                        ifTrue: [ (rcvr isLiteral and: [selector = #createBlock:]) ifTrue: [

                                         ^ self block: rcvr value env: args first]]

                        ifFalse: [ (selector = #blockCopy:) ifTrue: [

                                         ^ self stackPush: (RBPseudoSendNode new selector: selector; arguments: args)]].

        self stackPush: (self simplify: (RBMessageNode new

                receiver: rcvr

                selectorParts: (self newSelectorParts: selector)

                arguments: args)).

    "Created: / 01-12-2008 / 19:40:52 / Jan Vrany <vranyj1@fel.cvut.cz>"

!

send: selector numArgs: numArgs toSuperOf: behavior

        | args rcvr |

        args := OrderedCollection new.

        selector numArgs timesRepeat: [args addFirst: self Value].

        rcvr := self Value.

        (rcvr isVariable and: [rcvr name = 'self']) ifFalse: [self patternError].

        rcvr identifierToken: (SqueakToken value: 'super' start: 0).

        self stackPush: (RBMessageNode new

                receiver: rcvr

                selectorParts: (self newSelectorParts: selector)

                arguments: args).

    "Created: / 01-12-2008 / 19:45:52 / Jan Vrany <vranyj1@fel.cvut.cz>"

!

storeIntoLiteralVariable: association

	| var |

	var := scope lookupVar: association key asString.

	self stackPush: (self simplifyTempAssign:

		(RBAssignmentNode variable: (self newVar: (var markWrite)) value: self Value))

!

storeTemp: tempIndex

	| var |

	var := scope basicTempVarAt: tempIndex.

	var isCaptured ifFalse: [var cantBeCapture].

	var isTemp ifTrue:[

		var isArg: false].

	self stackPush: (self simplifyTempAssign:

		(RBAssignmentNode variable: (self newVar: (var markWrite)) value: self Value)).

! !

!IRDecompiler methodsFor:'interpret'!

interpretInstruction: irInstruction

	currentInstr := irInstruction.

	super interpretInstruction: irInstruction.

!

interpretSequence: instructionSequence

	super interpretSequence: instructionSequence.

	"currentInstr := nil."

! !

!IRDecompiler methodsFor:'old blocks'!

blockReturnTop

	self goto: #return.

!

endBlock: seqNum

	| blockSeq block goto startBlock |

	[

		goto := self GotoOrReturn: seqNum.

		(goto isRet 

			or:[goto mapInstr notNil 

				and: [goto mapInstr isBlockReturnTop]]) ifFalse: [self abort].

		sp = 0 ifTrue: [self abort].

		blockSeq := self Sequence2.

		startBlock := self Label.

		block := self Block.

		(goto isRet not

			and:[goto mapInstr notNil] 

			and: [goto mapInstr isBlockReturnTop]

			and: [block successor ~= seqNum]) ifTrue:[

				self stackPush: block.

				self stackPush: startBlock.

				self stackPush: blockSeq. 

				self stackPush: goto.

				self abort].

		self Send.

	] on: Abort do: [^ false].

	self stackPush: (self newBlock: blockSeq return: goto).	

	stack last arguments: block arguments.

	"No extra scope is need if we don't use any temporaries and arguments.

	so we remove them"

	(stack last arguments isEmpty and: [stack last body temporaries isEmpty])

		ifTrue:[ASTReplaceVariableScope replace: stack last scope: scope outerScope ].

	scope := scope outerScope.

	currentInstr := nil.

	self goto: block successor.

	^ true

!

jumpOverBlock: seqNum1  to: seqNum2

	| numArgs args oldscope pseudoBlock |

	oldscope := scope.

	self scope: (scope newBlockScope).

	oldscope tempVarAt: 0.

	(scope addObjectTemp: (oldscope tempVarAt: 0)).

	numArgs := stack last arguments first value.

	self stackPush: (pseudoBlock := RBPseudoBlockNode new).

	args := OrderedCollection new.

	numArgs timesRepeat: [ | var instr |

		instr :=  currentInstr blockSequence removeFirst.

 		var := oldscope tempVarAt: instr number.

		args add: (self newVar: var).

		var isUnused ifTrue: [oldscope removeTempFromOldBlock: var].

		scope addObjectTemp: var.

		currentInstr blockSequence first isPop 

			ifFalse: [

				currentInstr blockSequence sequence addFirst: (IRInstruction pushTemp: var index)]

			ifTrue:[currentInstr blockSequence removeFirst].

	].

	args := args reverse.

	pseudoBlock

		block: seqNum1;

		successor: seqNum2;

		arguments: args

!

storeInstVar: number

	| var |

	var := scope  instanceScope instVar: number.

	self stackPush: (RBAssignmentNode variable: (self newVar: var)  value:  self Value)

! !

!IRDecompiler methodsFor:'priv instructions'!

addReturn: statements from: goto

		| ret |

		statements last isReturn ifTrue:[^self].

		ret := RBReturnNode value: statements last.

		Preferences compileBlocksAsClosures ifTrue:[

			scope isHome ifFalse: [ret homeBinding: scope outerEnvScope thisEnvVar]].

		goto mapInstr sourceNode: ret.

		statements atLast: 1 put: ret.

!

block: method env: envRefNode

	self stackPush: (IRDecompiler new

		scope: (scope newBlockScope "capturedVars: vars");

		decompileIR: method ir)

		asBlock

!

cascade

	| messages selector args rcvr |

	messages := OrderedCollection new.

	"last message"

	selector _ self Send selector.

	args := OrderedCollection new.

	selector numArgs timesRepeat: [args addFirst: self Value].

	messages addFirst: selector -> args.

	"rest of messages"

	[(rcvr := self ValueOrNone) isNil] whileTrue: [

		self Pop.

		selector := self Send selector.

		args := OrderedCollection new.

		selector numArgs timesRepeat: [args addFirst: self Value].

		self Dup.

		messages addFirst: selector -> args.

	].

	messages := messages collect: [:assoc |

		RBMessageNode

			receiver: rcvr

			selector: assoc key

			arguments: assoc value].

	self stackPush: (RBCascadeNode messages: messages).

!

endAndOr2: seqNum

	| goto seq p if2 test else o if1 seqValue elseTest otherwise |

	[

		goto _ self Goto.

		seqValue _ self ValueOrNone.

		seq _ self Sequence.

		p _ self Label destination.

		if2 _ self IfGoto: seqNum otherwise: p.

		elseTest _ self Value.

		else _ self SequenceBackTo: goto destination.

		o _ self Label destination.

		o = goto destination ifTrue: [self abort].

		if1 _ self IfGoto: seqNum otherwise: o.

		test _ self Value.

	] on: Abort do: [^ false].

	if1 boolean = if2 boolean 

		ifFalse: [

			otherwise := RBSequenceNode statements: #().

			otherwise addNode: (self newLiteral: if2 boolean).

			self stackPush: (RBMessageNode

				receiver: test 

				selector: (if2 boolean ifTrue: [#ifTrue:ifFalse:] ifFalse: [#ifFalse:ifTrue:]) 

				arguments: {self newBlock: (else addNode: elseTest).

					self newBlock: otherwise}).]

		ifTrue:[self stackPush: (RBMessageNode

			receiver: test

			selector: (if2 boolean ifTrue: [#or:] ifFalse: [#and:])

			arguments: {self newBlock: (else addNode: elseTest)})].

	stack addLast: if2.

	self label: p.

	stack addLast: seq.

	seqValue ifNotNil: [stack addLast: seqValue].

	stack addLast: goto.

	^ true

!

endAndOr: seqNum

	| o test branches if body block sel1 sel2 if2 |

	branches := OrderedCollection new.

	[

		(if2 := self If) otherwise = seqNum ifFalse: [self abort].

		[	test := self Value.

			body := self Sequence.

			branches add: {body. test}.

			o := self Label destination.

			(if := self If) otherwise = o ifFalse: [self abort].

			if destination = seqNum

		] whileFalse: [

			if boolean = if2 boolean ifFalse: [self abort].

			if destination = if2 destination ifFalse: [self abort].

		].

		if boolean = if2 boolean ifTrue: [self abort].

		test := self Value.

	] on: Abort do: [^ false].

	if boolean

		ifTrue: [sel1 := #or:. sel2 := #and:]

		ifFalse: [sel1 := #and:. sel2 := #or:].

	block := self newBlock: (branches first first addNode: branches first second).

	branches allButFirstDo: [:pair |

		block := self newBlock: (pair first addNode: (RBMessageNode

				receiver: pair second

				selector: sel2

				arguments: {block})).

	].

	self stackPush: (RBMessageNode

		receiver: test

		selector: sel1

		arguments: {block}).

	stack addLast: if2.

	^ true

!

endCase: seqNum

	| otherwiseGoto goto node otherwiseValue otherwiseSeq n branchValue branchSeq f caseValue caseSeq rcvr branches message seqEnd afterOterwise seq afterOterwiseValue |

	branches := OrderedCollection new.

	[	"otherwise"

		otherwiseGoto := self Goto.

		node := self stackDown.

		node isSequence ifTrue: [(node statements size = 1 

			and:[node statements first isSend] 

			and: [

				node := node statements first. 

				node selector == #caseError]) ifFalse: [

					otherwiseSeq := node] ].

		(node isPop or: [node isSend and: [node selector == #caseError]]) ifTrue: [

			node isPop ifTrue: [node := self Send].

			node selector == #caseError ifFalse: [self abort].

		] ifFalse: [

			sp := sp + 1.  "stackUp"

			seqNum == #lastReturn 

				ifFalse: [