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

commits at source.squeak.org commits at source.squeak.org
Tue Apr 28 21:09:51 UTC 2015


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

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

Name: Cog-eem.262
Author: eem
Time: 28 April 2015, 2:09:33.609 pm
UUID: 358d33f0-74ee-4f59-b3df-9e6907d66705
Ancestors: Cog-eem.261

empty log message

=============== Diff against Cog-eem.261 ===============

Item was changed:
  ----- Method: GdbARMAlien>>decorateDisassembly:for:fromAddress: (in category 'disassembly') -----
  decorateDisassembly: anInstructionString for: aSymbolManager fromAddress: address
  "Decode what we can of the instruction and decorate it with useful stuff"
  	| word opcode rotate mode operand memory addressinatorBlock|
+ 	addressinatorBlock :=
+ 		[:value| | string |
+ 		(value notNil
+ 		 and: [(string := aSymbolManager lookupAddress: value) notNil])
+ 			ifTrue: [ ' = ', value hex, ' = ', string]
+ 			ifFalse: ['']].
- 	addressinatorBlock := [:value|
- 		(aSymbolManager lookupAddress: value)
- 		ifNotNil: [:string| ' = ', value hex, ' = ', string]
- 		ifNil: ['']].
  	
  	word := (memory:= aSymbolManager objectMemory) longAt: address.
  	(self instructionIsAnyB: word)
  		ifTrue:
+ 			[((self instructionIsB: word) or: [self instructionIsBL: word]) ifTrue:
+ 				["We can extract the offset from a plain B/BL instruction"
+ 				 operand := self extractOffsetFromBL: word..
+ 				 operand := operand + address + 8 bitAnd: aSymbolManager addressSpaceMask].
+ 			"We can't extract the offset from a  BX/BLX instructions register, unless we're at the current pc,
+ 			 because otherwise its current value has nothing to do with the value when this instruction is executed."
+ 			(self pc = address
+ 			 and: [(self instructionIsBX: word) or: [self instructionIsBLX: word]]) ifTrue:
+ 					[operand := (self perform: (self registerStateGetters at: (word bitAnd: 15) + 1))]]
- 			[((self instructionIsB: word) or: [self instructionIsBL: word])
- 				ifTrue:["We can extract the offset from a plain B/BL instruction"
- 					operand := self extractOffsetFromBL: word..
- 					 operand := operand + address + 8 bitAnd: aSymbolManager addressSpaceMask].
- 			((self instructionIsBX: word) or: [self instructionIsBLX: word])
- 				ifTrue:["We can extract the offset from a  BX/BLX instructions register"			
- 					operand := (self perform: (self registerStateGetters at: (word bitAnd: 15) + 1))].
- 			
- 			(aSymbolManager lookupAddress: operand) ifNotNil:
- 				[:name| ^anInstructionString, ' = ', operand hex, ' = ', name]]
  		ifFalse:
  			[(self instructionIsAnyLoadStore: word)
  				ifTrue: [|baseR|
  					"first see if this is a load via the varBase register - quick access globals. We'll trust
  					that nobody makes a nasty instruction that uses this reg in a mean way" 
+ 					operand := (baseR := (word >> 16 bitAnd: 15)) = CogARMCompiler VarBaseReg
+ 									ifTrue: [aSymbolManager varBaseAddress + (word bitAnd: 1 << 12 - 1)]
+ 									ifFalse: [self pc = address ifTrue:
+ 												[(self register: baseR) + (self extractOffsetFromLoadStore: word)]].
- 					(baseR := (word >> 16 bitAnd: 15)) = CogARMCompiler VarBaseReg
- 						ifTrue:[ operand := aSymbolManager varBaseAddress + (word bitAnd: 1 << 12 - 1)]
- 						ifFalse:[ operand := (self register: baseR) + (self extractOffsetFromLoadStore: word)].
  
  					"look for SP operations -pop/push"
+ 					 (self instructionIsPush: word) ifTrue: "push - "
+ 						[|srcR|
- 					 (self instructionIsPush: word) ifTrue: ["push - "
- 						|srcR|
  						srcR := word >>12 bitAnd: 16rF.
+ 						^ (anInstructionString readStream upTo: $}), '}', (self pc = address ifTrue: ['  (', (self register: srcR) hex, ') to ',  (self sp - 4) hex] ifFalse: [''])].
+ 					(self instructionIsPop: word) ifTrue: "pop - " 
+ 						[^ (anInstructionString readStream upTo: $}), '}', (self pc = address ifTrue: ['  (', (memory longAt: self sp) hex, ') ' , ' from ' , self sp hex] ifFalse: [''])].
- 						^ (anInstructionString readStream upTo: $}), '}  (', (self register: srcR) hex, ') to ',  (self sp - 4) hex ].
- 					(self instructionIsPop: word) ifTrue: ["pop - " 
- 						^ (anInstructionString readStream upTo: $}), '}  (', (memory longAt: self sp) hex, ') ' , ' from ' , self sp hex ].
  
  					"look for a ld/st of the sp"
+ 					(self instructionIsLDRSP: word) ifTrue:
+ 						[^anInstructionString, '; Load SP from ', (addressinatorBlock value: operand)].
+ 					(self instructionIsSTRSP: word) ifTrue:
+ 						[^anInstructionString, '; Save SP to ', (addressinatorBlock value: operand)]]
- 					(self instructionIsLDRSP: word) ifTrue:[| val |
- 						val := operand > memory memory size
- 											ifTrue: [aSymbolManager simulatedVariableAt: operand ]
- 											ifFalse: [memory longAt: operand].
- 						^anInstructionString, '; Load SP (', (val ifNil:['unknown'] ifNotNil:[:v| v hex]) , ') from ', (addressinatorBlock value: operand)].
- 					(self instructionIsSTRSP: word) ifTrue:[
- 						^anInstructionString, '; Save SP (', self sp hex, ') to ',  (addressinatorBlock value: operand)].
- 					]
  				ifFalse:
  					["check for SP changers not relating to read/writing data"
+ 					(self instructionIsAlignSP: word) ifTrue:
+ 						[^anInstructionString, ' ALIGN SP ', (self pc = address ifTrue: [self sp hex] ifFalse: [''])].
+ 					(self instructionIsAddSP: word) ifTrue:
+ 						[^anInstructionString, ' ADD ', (word bitAnd: 16rFF) asString,' to SP ', (self pc = address ifTrue: ['= ' , self sp hex] ifFalse: [''])].
- 					(self instructionIsAlignSP: word)
- 						ifTrue: [^anInstructionString, ' ALIGN SP ' , self sp hex; cr].
- 					(self instructionIsAddSP: word)
- 						ifTrue:[^anInstructionString, ' ADD ', (word bitAnd: 16rFF) asString,' to SP = ' , self sp hex].				
  
  					"check for the end of a mov/orr/orr/orr set filling a reg with a const"
  					opcode := word >> 21 bitAnd: 16rF.
  					 opcode ~= CogARMCompiler orOpcode ifTrue:
  						[^anInstructionString].
  					 rotate := word >> 8 bitAnd: 16rF.
  					 mode := word >> 25 bitAnd: 7.
  					 "CogARMCompiler always uses a 0 rotate in the last operand of the final ORR when building long constants."
  					 (mode = 1 and: [rotate ~= 0]) ifTrue:
  						[^anInstructionString].
  					 operand := aSymbolManager backEnd literalBeforeFollowingAddress: address + 4]].
  	"is there an interesting address with this?"
  	^anInstructionString, (addressinatorBlock value: operand)!



More information about the Vm-dev mailing list