VM Maker: VMMaker.oscog-eem.1152.mcz

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

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

Name: VMMaker.oscog-eem.1152
Author: eem
Time: 2 April 2015, 9:50:29.616 am
UUID: 9ca91213-b542-43ee-8410-354257eaa7b1
Ancestors: VMMaker.oscog-eem.1151

Better living through compile-time type checking.
Fix offset calculation in followForwardingPointersInStackZone:
as indicated by a C compiler warning.

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

Item was changed:
  ----- Method: CoInterpreter>>followForwardingPointersInStackZone: (in category 'object memory support') -----
  followForwardingPointersInStackZone: theBecomeEffectsFlags
  "Spur's become: is lazy, turning the becommed object into a forwarding object to the other.
  The read-barrier is minimised by arranging that forwarding pointers will fail a method cache
  probe, since notionally objects' internals are accessed only via sending messages to them,
  the exception is primitives that access the internals of the non-receiver argument(s).
  To avoid a read barrier on inst var fetch we scan the receivers in the stack zone and follow
  any forwarded ones.  This is way cheaper than scanning all of memory as in the old become.
 
  Override to handle machine code frames, and to handle the lack of an explicit read barrier on super sends.
  With most super send implementations (not Newspeak's absent super bytecodes) self, the receiver of the
  super send, is pushed before any arguments.  So if self is becommed during argument marshalling, e.g.
  super doSomethingWith: (self become: self somethingElse)
  then a stale forwarded reference to self could be left on the stack.  In the StackInterpreter we deal with this
  with an explicit read barrier on supersend.  In the CoInterpreter we deal with it by following all non-argument
  stack contents."
  | theIPPtr |
  <inline: false>
  <var: #thePage type: #'StackPage *'>
  <var: #theSP type: #'char *'>
  <var: #theFP type: #'char *'>
  <var: #offset type: #'char *'>
  <var: #callerFP type: #'char *'>
  <var: #theIPPtr type: #usqInt>
 
  self externalWriteBackHeadFramePointers.
 
  (theBecomeEffectsFlags anyMask: BecameCompiledMethodFlag) ifTrue:
  [(objectMemory isForwarded: method) ifTrue:
  [theIPPtr := instructionPointer - method.
  method := objectMemory followForwarded: method.
  instructionPointer := method + theIPPtr].
  (objectMemory isOopForwarded: newMethod) ifTrue:
  [newMethod := objectMemory followForwarded: newMethod]].
 
  self assert: stackPage ~= 0.
  0 to: numStackPages - 1 do:
  [:i| | thePage theSP theFP callerFP oop offset |
  thePage := stackPages stackPageAt: i.
  thePage isFree ifFalse:
  [theSP := thePage headSP.
  theFP := thePage  headFP.
  "Skip the instruction pointer on top of stack of inactive pages."
  thePage = stackPage
  ifTrue: [theIPPtr := 0]
  ifFalse:
  [theIPPtr := theSP asUnsignedInteger.
  theSP := theSP + objectMemory wordSize].
  [self assert: (thePage addressIsInPage: theFP).
   self assert: (theIPPtr = 0 or: [thePage addressIsInPage: theIPPtr asVoidPointer]).
+  offset := theFP + (self frameStackedReceiverOffset: theFP).
-  offset := self frameStackedReceiverOffset: theFP.
   [theSP <= offset] whileTrue:
  [oop := stackPages longAt: theSP.
  (objectMemory isOopForwarded: oop) ifTrue:
  [stackPages longAt: theSP put: (objectMemory followForwarded: oop)].
  theSP := theSP + objectMemory wordSize].
   ((self frameHasContext: theFP)
    and: [(objectMemory isForwarded: (self frameContext: theFP))]) ifTrue:
  [stackPages
  longAt: theFP + FoxThisContext
  put: (objectMemory followForwarded: (self frameContext: theFP))].
  (self isMachineCodeFrame: theFP)
  ifTrue:
  [oop := stackPages longAt: theFP + FoxMFReceiver.
  (objectMemory isOopForwarded: oop) ifTrue:
  [stackPages
  longAt: theFP + FoxMFReceiver
  put: (objectMemory followForwarded: oop)].
  oop := (self mframeHomeMethod: theFP) methodObject.
  self assert: (objectMemory isForwarded: oop) not]
  ifFalse:
  [oop := stackPages longAt: theFP + FoxIFReceiver.
  (objectMemory isOopForwarded: oop) ifTrue:
  [stackPages
  longAt: theFP + FoxIFReceiver
  put: (objectMemory followForwarded: oop)].
  oop := self iframeMethod: theFP.
  (objectMemory isForwarded: oop) ifTrue:
  [| newOop delta |
  newOop := objectMemory followForwarded: oop.
  delta := newOop - oop.
  (theIPPtr ~= 0
   and: [(stackPages longAt: theIPPtr) > oop]) ifTrue:
  [stackPages
  longAt: theIPPtr
  put: (stackPages longAt: theIPPtr) + delta].
  stackPages
  longAt: theFP + FoxIFSavedIP
  put: (stackPages longAt: theFP + FoxIFSavedIP) + delta.
  stackPages
  longAt: theFP + FoxMethod
  put: (oop := newOop)]].
   (callerFP := self frameCallerFP: theFP) ~= 0] whileTrue:
  [theIPPtr := (theFP + FoxCallerSavedIP) asUnsignedInteger.
  theSP := theIPPtr + objectMemory wordSize.
  theFP := callerFP].
  "And finally follow the saved context and the caller context."
  theSP := thePage baseAddress - objectMemory wordSize.
  [theSP <= thePage baseAddress] whileTrue:
  [oop := stackPages longAt: theSP.
  (objectMemory isForwarded: oop) ifTrue:
  [stackPages longAt: theSP put: (objectMemory followForwarded: oop)].
  theSP := theSP + objectMemory wordSize]]]!

 
On 2 April 2015 at 17:51,  <[hidden email]> wrote:
That's not something you read every day in a Squeak commit message!

(In response to anyone wishing to turn the above into a flame war
about static typing vs not, please think about how my two current
favourite languages are F# and Smalltalk. And then don't try start a
war :) )

frank