[Vm-dev] VM Maker: VMMaker.oscog-tpr.1280.mcz

commits at source.squeak.org commits at source.squeak.org
Mon May 4 22:22:14 UTC 2015


tim Rowledge uploaded a new version of VMMaker to project VM Maker:
http://source.squeak.org/VMMaker/VMMaker.oscog-tpr.1280.mcz

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

Name: VMMaker.oscog-tpr.1280
Author: tpr
Time: 4 May 2015, 3:20:50.336 pm
UUID: 311d1461-dec3-4161-8c5b-350075f9752a
Ancestors: VMMaker.oscog-eem.1279

Catch some - surely not all - place where values need to be typed as signed ints. At the least this fixes a fun case where a 
lrd r7, [r11, #-12] 
becase
ldr 77, [r11, #4084].

=============== Diff against VMMaker.oscog-eem.1279 ===============

Item was changed:
  ----- Method: CogARMCompiler>>concretizeMoveCqR (in category 'generate machine code - concretize') -----
  concretizeMoveCqR
  	"Will get inlined into concretizeAt: switch."
  	"If the quick constant is in fact a shiftable 8bit, generate the apropriate MOV, otherwise do what is necessary for a whole word."
+ 	<var: #word type: #sqInt>
  	<inline: true>
  	|word reg|
  	word := operands at: 0.
  	reg := self concreteRegister: (operands at: 1).
  	self 
+ 		rotateable8bitImmediate: word 
- 		rotateable8bitImmediate: (operands at: 0) 
  		ifTrue: [:rot :immediate |
  			self machineCodeAt: 0 put: (self mov: reg imm: immediate ror: rot).
  			^machineCodeSize := 4]
  		ifFalse: [|invVal|
  			word <0
  				ifTrue:[invVal := -1 - word]
  				ifFalse:[invVal := word bitInvert32].
  			self rotateable8bitImmediate: invVal
  				ifTrue: [ :rot :immediate |
  					self machineCodeAt: 0 put: (self mvn: reg imm: immediate ror: rot).
  					^machineCodeSize := 4]
  				ifFalse: [^self concretizeMoveCwR]].
  	^0 "to keep Slang happy"!

Item was changed:
  ----- Method: CogARMCompiler>>concretizeMoveM16rR (in category 'generate machine code - concretize') -----
  concretizeMoveM16rR
  	"Will get inlined into concretizeAt: switch."
  	"ldrh destReg, [srcReg, #immediate],
  	or 
  	move offset to ConcreteIPReg
  	ldrh destReg, [srcReg, ConcreteIPReg]"
+ 	<var: #offset type: #sqInt>
  	<inline: true>
  	| srcReg offset destReg instrOffset|
  	offset := operands at: 0.
  	srcReg := self concreteRegister: (operands at: 1).
  	destReg := self concreteRegister: (operands at: 2).
  	self is8BitValue: offset
  		ifTrue:
  			[ :u :immediate | 
  			self machineCodeAt: 0 "ldrh destReg, [srcReg, #immediate]"
  				put: (self ldrh: destReg rn: srcReg plus: u imm: immediate).
  			^machineCodeSize := 4]
  		ifFalse:
  			[instrOffset := self at: 0 moveCw: offset intoR: ConcreteIPReg.
  			"ldrh destReg, [srcReg, ConcreteIPReg]"
  			self machineCodeAt: instrOffset put: (self ldrh: destReg rn: srcReg rm: ConcreteIPReg).
  			^machineCodeSize := instrOffset + 4 ].
  	^0 "to keep Slang happy"!

Item was changed:
  ----- Method: CogARMCompiler>>concretizeMoveMbrR (in category 'generate machine code - concretize') -----
  concretizeMoveMbrR
  	"Will get inlined into concretizeAt: switch."
  	"ldrb destReg, [srcReg, #immediate] or ldrb destReg, [srcReg, ConcreteIPReg]"
+ 	<var: #offset type: #sqInt>
  	<inline: true>
  	| srcReg offset destReg instrOffset|
  	offset := operands at: 0.
  	srcReg := self concreteRegister: (operands at: 1).
  	destReg := self concreteRegister: (operands at: 2).
  	self is12BitValue: offset
  		ifTrue:
  			[ :u :immediate | 
  			self machineCodeAt: 0 "ldrb destReg, [srcReg, #immediate]"
  				put: (self ldrb: destReg rn: srcReg plus: u imm: immediate).
  			^machineCodeSize := 4]
  		ifFalse:
  			[(self isAddressRelativeToVarBase: offset)
  				ifTrue:
  					[self machineCodeAt: 0 put: (self adds: ConcreteIPReg rn: ConcreteVarBaseReg imm: offset - cogit varBaseAddress ror: 0).
  					 instrOffset := 4]
  				ifFalse:
  					[instrOffset := self at: 0 moveCw: offset intoR: ConcreteIPReg].
  			 "ldrb destReg, [srcReg, ConcreteIPReg]"
  			 self machineCodeAt: instrOffset put: (self ldrb: destReg rn: srcReg rm: ConcreteIPReg).
  			 ^machineCodeSize := instrOffset + 4].
  	^0 "to keep Slang happy"!

Item was changed:
  ----- Method: CogARMCompiler>>concretizeMoveMwrR (in category 'generate machine code - concretize') -----
  concretizeMoveMwrR
  	"Will get inlined into concretizeAt: switch."
+ 	<var: #offset type: #sqInt>
  	<inline: true>
  	| srcReg offset destReg instrOffset|
  	offset := operands at: 0.
  	srcReg := self concreteRegister: (operands at: 1).
  	destReg := self concreteRegister: (operands at: 2).
  	self is12BitValue: offset
  		ifTrue:
  			[ :u :immediate | 
  			self machineCodeAt: 0 "ldr destReg, [srcReg, #immediate]"
  				put: (self ldr: destReg rn: srcReg plus: u imm: immediate).
  			^machineCodeSize := 4]
  		ifFalse:
  			[instrOffset := self at: 0 moveCw: offset intoR: ConcreteIPReg.
  			"ldr destReg, [srcReg, ConcreteIPReg]"
  			self machineCodeAt: instrOffset put: (self ldr: destReg rn: srcReg rm: ConcreteIPReg).
  			^machineCodeSize := instrOffset + 4].
  	^0 "to keep Slang happy"!

Item was changed:
  ----- Method: CogARMCompiler>>concretizeMoveRMbr (in category 'generate machine code - concretize') -----
  concretizeMoveRMbr
  	"Will get inlined into concretizeAt: switch."
+ 	<var: #offset type: #sqInt>
  	<inline: true>
  	| srcReg offset baseReg instrOffset|
  	srcReg := self concreteRegister: (operands at: 0).
  	offset := operands at: 1.
  	baseReg := self concreteRegister: (operands at: 2).
  	self is12BitValue: offset
  		ifTrue:
  			[ :u :immediate | 
  			self machineCodeAt: 0 "strb 	srcReg, [baseReg, #immediate]"
  				put: (self strb: srcReg rn: baseReg plus: u imm: immediate).
  			^machineCodeSize := 4]
  		ifFalse:
  			[(self isAddressRelativeToVarBase: offset)
  				ifTrue:
  					[self machineCodeAt: 0 put: (self adds: ConcreteIPReg rn: ConcreteVarBaseReg imm: offset - cogit varBaseAddress ror: 0).
  					 instrOffset := 4]
  				ifFalse:
  					[instrOffset := self at: 0 moveCw: offset intoR: ConcreteIPReg].
  			"strb 	srcReg, [baseReg, ConcreteIPReg]"
  			self machineCodeAt: instrOffset put: (self strb: srcReg rn: baseReg rm: ConcreteIPReg).
  			^machineCodeSize := instrOffset + 4 ].
  	^0 "to keep Slang happy"!

Item was changed:
  ----- Method: CogARMCompiler>>concretizeMoveRMwr (in category 'generate machine code - concretize') -----
  concretizeMoveRMwr
  	"Will get inlined into concretizeAt: switch."
+ 	<var: #offset type: #sqInt>
  	<inline: true>
  	| srcReg offset baseReg instrOffset|
  	srcReg := self concreteRegister: (operands at: 0).
  	offset := operands at: 1.
  	baseReg := self concreteRegister: (operands at: 2).
  	self is12BitValue: offset
  		ifTrue:
  			[ :u :immediate | 
  			self machineCodeAt: 0  "str 	srcReg, [baseReg, #immediate]"
  				put: (self str: srcReg rn: baseReg plus: u imm: immediate).
  			^machineCodeSize := 4]
  		ifFalse:
  			[instrOffset := self at: 0 moveCw: offset intoR: ConcreteIPReg.
  			"str srcReg, [baseReg, ConcreteIPReg]"
  			self machineCodeAt: instrOffset put: (self str: srcReg rn: baseReg rm: ConcreteIPReg).
  			^machineCodeSize := instrOffset + 4].
  	^0 "to keep Slang happy"!

Item was changed:
  ----- Method: CogARMCompiler>>concretizeRetN (in category 'generate machine code - concretize') -----
  concretizeRetN
  	"Will get inlined into concretizeAt: switch."
+ 	<var: #offset type: #sqInt>
  	<inline: true>
  	| offset |
  	offset := operands at: 0.
  	offset = 0 ifTrue:
  		[self machineCodeAt: 0 put: (self mov: PC rn: LR). "pop	{pc}"
  		^machineCodeSize := 4].
  	self assert: offset < 255. "We have an 8 bit immediate. If needed, we could rotate it less than 30 bit."
  
  	self machineCodeAt: 0 put: (self add: SP rn: SP imm: offset  ror: 0).
  	self machineCodeAt: 4 put: (self mov: PC rn: LR).  "pop	{pc}"
  	^machineCodeSize := 8!

Item was changed:
  ----- Method: CogARMCompiler>>concretizeSubCqR (in category 'generate machine code - concretize') -----
  concretizeSubCqR
  	"Will get inlined into concretizeAt: switch."
  	"Try whether the quick constant is a small negative number. If it is, optimize."
+ 	<var: #word type: #sqInt>
  	<inline: true>
+ 	| word |
+ 	word := operands at: 0.
+ 	self rotateable8bitImmediate: word
- 	self rotateable8bitImmediate: (operands at: 0)
  		ifTrue: [ :rot :immediate | | reg |
  			reg := self concreteRegister: (operands at: 1).
  			self machineCodeAt: 0 put: (self subs: reg rn: reg imm: immediate ror: rot).
  			^machineCodeSize := 4]
  		ifFalse: [
+ 			"before building a full load of a big constant, see if we can do an add of the constant negated"
+ 			self rotateable8bitImmediate: word negated
- 			"before building a full load of a big cinstant, see if we can do an add of the constant negated"
- 			self rotateable8bitImmediate: (operands at: 0) negated
  				ifTrue: [ :rot :immediate | | reg |
  					reg := self concreteRegister: (operands at: 1).
  					self machineCodeAt: 0 put: (self adds: reg rn: reg imm: immediate ror: rot).
  					^machineCodeSize := 4]
  				ifFalse: [^self concretizeDataOperationCwR: 2]].
  	^0 "to keep Slang happy"!

Item was changed:
  ----- Method: CogARMCompiler>>isAddressRelativeToVarBase: (in category 'testing') -----
  isAddressRelativeToVarBase: varAddress
+ 	<inline: true>
+ 	<var: #varAddress type: #sqInt>
  	"Support for addressing variables off the dedicated VarBaseReg"
  	^varAddress notNil
  	  and: [varAddress >= cogit varBaseAddress
  	  and: [varAddress - cogit varBaseAddress < (1 << 12)]]!



More information about the Vm-dev mailing list