Vm-dev June 2015

vm-dev@lists.squeakfoundation.org

28 participants
149 discussions

Critical OSPP fix (was: OSProcess and lost SIGCHLD)
by David T. Lewis 12 Jun '15

12 Jun '15

Eliot, Esteban: Thiery Goubier has identified and fixed a critical bug in OSProcessPlugin. The issue was improper use of vfork() in a situation where fork() should be used. I apparently made this mistake many years ago, and I can't think of any good excuse for it. But I am very happy that Thiery has figured it out and fixed it after all this time :-) The fix is in VMConstruction-Plugins-OSProcessPlugin-dtl.40 and updated trunk SVN sources. It is important that we get this fix into the oscog and Pharo branches of OSPP, particularly because Thierry is running a Pharo VM and he needs the updates for work that he is doing there. Thierry provided the fix in the attached MCZ, which is relative to VMConstruction-Plugins-OSProcessPlugin.oscog-EstebanLorenzano.43 from the Pharo repository. This is derived from the oscog branch of OSPP, maybe a bit out of date but that is not important WRT this change. @Eliot: My suggestion would be to update to methods in UnixOSProcessPlugin method category 'primitives - fork and exec' to match the latest in the main branch. Alternatively you can copy the logic from #primitiveForkExec into the ##forkAndExecInDirectory: in your oscog branch (that method no longer exists in my main branch). The relevant snippet is: pid := self fork. "cCode: 'fork()' " pid < 0 ifTrue: [ self perror: 'fork'. ^self primitiveFail ]. pid = 0 ifFalse: [ "Normal return to Smalltalk - this is the old parent process." "Enable the timer again before resuming Smalltalk." self cCode: 'setitimer (ITIMER_REAL, &saveIntervalTimer, 0L)'. interpreterProxy pop: 10; pushInteger: pid "Pop 9 arguments plus receiver, push pid."] ifTrue: [ "This is the new child process" ... @Esteban: You will probably want to follow Eliot's branch, but you can provide an immediate fix for Pharo by using Thierry's MCZ attached. Dave On Thu, Jun 11, 2015 at 09:08:16PM +0200, Thierry Goubier wrote: > Le 11/06/2015 20:07, David T. Lewis a ?crit : > >Thank you! > > > >I am traveling, will follow up as soon as I am able. > > No worries, it will take a while to percolate to the final users. > > I'm testing it and I now have a nice result: if you enter a non-existent > target directory for the fork, you will get the chdir error message on > the stderr pipe inside Pharo :) > > Thierry > > >Dave > > > >>Ok, here is a VMConstruction-Plugins-OSProcessPlugin.oscog mcz... Only > >>changes are in UnixOSProcessPlugin>>#forkAndExecInDirectory: . I'm using > >>Esteban's version of the plugin as ancestor. > >> > >>I have an account now on squeaksource, at TppG :) > >> > >>Thierry > >> > >>2015-06-11 16:32 GMT+02:00 Thierry Goubier <thierry.goubier(a)gmail.com>: > >> > >>> > >>> > >>>2015-06-11 15:35 GMT+02:00 Thierry Goubier <thierry.goubier(a)gmail.com>: > >>> > >>>>I'm in the slang, and I have a question: > >>>> > >>>>Does it makes sense to call a primitiveFail in the child process after > >>>>the fork? The parent will never get it, isn't it, and the child will > >>>>exit > >>>>immediately (and only return its exit status). > >>>> > >>>>(I suspect I didn't get the message 'non existent directory' because > >>>>the > >>>>primitiveFailFor: reset errno and hence the perror("chdir") prints > >>>>nothing) > >>>> > >>>Wrong, I got the perror, but couldn't make sense of it. > >>> > >>>OSProcess should return an error if a fork returns a pid of -1, and > >>>never > >>>let the process run or read data from the pipes. > >>> > >>>The question about primitiveFail in the child still holds :) > >>> > >>>I made the change in the UnixOSProcessPlugin in slang, on the pharo-vm > >>>distrib; however, there are differences with your version > >>>(VMConstruction-Plugins-OSProcessPlugin.oscog-eem.42), I'll have a look > >>>at > >>>backporting them. > >>> > >>>Thierry > >>> > >> > > > >

3 6

Critical OSPP fix (was: OSProcess and lost SIGCHLD)
by Max Leske 12 Jun '15

12 Jun '15

Hi Dave, AFAICT this problem only exists in newer versions of the OSProcess Plugin (there’s no #forkAndExecInDirectory in my Pharo 1.3 image). So does this only affect images with that message running on Cog? I’m running Pharo 1.3 on SqueakVM 4.0.3. Just want to make sure that this isn’t something I could backport. Cheers, Max > On 12 Jun 2015, at 04:26, vm-dev-request(a)lists.squeakfoundation.org wrote: > > Eliot, Esteban: > > Thiery Goubier has identified and fixed a critical bug in OSProcessPlugin. The > issue was improper use of vfork() in a situation where fork() should be used. I > apparently made this mistake many years ago, and I can't think of any good excuse > for it. But I am very happy that Thiery has figured it out and fixed it after all > this time :-) > > The fix is in VMConstruction-Plugins-OSProcessPlugin-dtl.40 and updated trunk > SVN sources. > > It is important that we get this fix into the oscog and Pharo branches of OSPP, > particularly because Thierry is running a Pharo VM and he needs the updates for > work that he is doing there. > > Thierry provided the fix in the attached MCZ, which is relative to > VMConstruction-Plugins-OSProcessPlugin.oscog-EstebanLorenzano.43 from the Pharo > repository. This is derived from the oscog branch of OSPP, maybe a bit out of > date but that is not important WRT this change. > > @Eliot: My suggestion would be to update to methods in UnixOSProcessPlugin method > category 'primitives - fork and exec' to match the latest in the main branch. Alternatively > you can copy the logic from #primitiveForkExec into the ##forkAndExecInDirectory: in > your oscog branch (that method no longer exists in my main branch). The relevant > snippet is: > > pid := self fork. "cCode: 'fork()' " > pid < 0 > ifTrue: [ self perror: 'fork'. > ^self primitiveFail ]. > pid = 0 > ifFalse: > [ "Normal return to Smalltalk - this is the old parent process." > "Enable the timer again before resuming Smalltalk." > self cCode: 'setitimer (ITIMER_REAL, &saveIntervalTimer, 0L)'. > interpreterProxy pop: 10; pushInteger: pid > "Pop 9 arguments plus receiver, push pid."] > ifTrue: > [ "This is the new child process" > ... > > @Esteban: You will probably want to follow Eliot's branch, but you can provide > an immediate fix for Pharo by using Thierry's MCZ attached. > > Dave

2 1

Re: [Vm-dev] Critical OSPP fix (was: OSProcess and lost SIGCHLD)
by Esteban Lorenzano 12 Jun '15

12 Jun '15

of course :) > On 12 Jun 2015, at 13:10, Thierry Goubier <thierry.goubier(a)gmail.com> wrote: > > Hi Esteban, > > Can I do a pull request on that one? > > There are a few things I'd like to see changed apart from the fork to vfork change, to improve some of the error handling. As the code is now, it is impossible, from Pharo, to make the difference between a git commit with no data to commit and a fail in the chdir. > > Thierry > > 2015-06-12 11:55 GMT+02:00 Esteban Lorenzano <estebanlm(a)gmail.com <mailto:estebanlm@gmail.com>>: > btw… I cherry picked the change for oscog branch, but since I do not have rights I cannot push it back (another argument agains multiple separated repositories) > > Esteban > > > On 12 Jun 2015, at 04:26, David T. Lewis <lewis(a)mail.msen.com <mailto:lewis@mail.msen.com>> wrote: > > > > Eliot, Esteban: > > > > Thiery Goubier has identified and fixed a critical bug in OSProcessPlugin. The > > issue was improper use of vfork() in a situation where fork() should be used. I > > apparently made this mistake many years ago, and I can't think of any good excuse > > for it. But I am very happy that Thiery has figured it out and fixed it after all > > this time :-) > > > > The fix is in VMConstruction-Plugins-OSProcessPlugin-dtl.40 and updated trunk > > SVN sources. > > > > It is important that we get this fix into the oscog and Pharo branches of OSPP, > > particularly because Thierry is running a Pharo VM and he needs the updates for > > work that he is doing there. > > > > Thierry provided the fix in the attached MCZ, which is relative to > > VMConstruction-Plugins-OSProcessPlugin.oscog-EstebanLorenzano.43 from the Pharo > > repository. This is derived from the oscog branch of OSPP, maybe a bit out of > > date but that is not important WRT this change. > > > > @Eliot: My suggestion would be to update to methods in UnixOSProcessPlugin method > > category 'primitives - fork and exec' to match the latest in the main branch. Alternatively > > you can copy the logic from #primitiveForkExec into the ##forkAndExecInDirectory: in > > your oscog branch (that method no longer exists in my main branch). The relevant > > snippet is: > > > > pid := self fork. "cCode: 'fork()' " > > pid < 0 > > ifTrue: [ self perror: 'fork'. > > ^self primitiveFail ]. > > pid = 0 > > ifFalse: > > [ "Normal return to Smalltalk - this is the old parent process." > > "Enable the timer again before resuming Smalltalk." > > self cCode: 'setitimer (ITIMER_REAL, &saveIntervalTimer, 0L)'. > > interpreterProxy pop: 10; pushInteger: pid > > "Pop 9 arguments plus receiver, push pid."] > > ifTrue: > > [ "This is the new child process" > > ... > > > > @Esteban: You will probably want to follow Eliot's branch, but you can provide > > an immediate fix for Pharo by using Thierry's MCZ attached. > > > > Dave > > > > > > On Thu, Jun 11, 2015 at 09:08:16PM +0200, Thierry Goubier wrote: > >> Le 11/06/2015 20:07, David T. Lewis a ?crit : > >>> Thank you! > >>> > >>> I am traveling, will follow up as soon as I am able. > >> > >> No worries, it will take a while to percolate to the final users. > >> > >> I'm testing it and I now have a nice result: if you enter a non-existent > >> target directory for the fork, you will get the chdir error message on > >> the stderr pipe inside Pharo :) > >> > >> Thierry > >> > >>> Dave > >>> > >>>> Ok, here is a VMConstruction-Plugins-OSProcessPlugin.oscog mcz... Only > >>>> changes are in UnixOSProcessPlugin>>#forkAndExecInDirectory: . I'm using > >>>> Esteban's version of the plugin as ancestor. > >>>> > >>>> I have an account now on squeaksource, at TppG :) > >>>> > >>>> Thierry > >>>> > >>>> 2015-06-11 16:32 GMT+02:00 Thierry Goubier <thierry.goubier(a)gmail.com <mailto:thierry.goubier@gmail.com>>: > >>>> > >>>>> > >>>>> > >>>>> 2015-06-11 15:35 GMT+02:00 Thierry Goubier <thierry.goubier(a)gmail.com <mailto:thierry.goubier@gmail.com>>: > >>>>> > >>>>>> I'm in the slang, and I have a question: > >>>>>> > >>>>>> Does it makes sense to call a primitiveFail in the child process after > >>>>>> the fork? The parent will never get it, isn't it, and the child will > >>>>>> exit > >>>>>> immediately (and only return its exit status). > >>>>>> > >>>>>> (I suspect I didn't get the message 'non existent directory' because > >>>>>> the > >>>>>> primitiveFailFor: reset errno and hence the perror("chdir") prints > >>>>>> nothing) > >>>>>> > >>>>> Wrong, I got the perror, but couldn't make sense of it. > >>>>> > >>>>> OSProcess should return an error if a fork returns a pid of -1, and > >>>>> never > >>>>> let the process run or read data from the pipes. > >>>>> > >>>>> The question about primitiveFail in the child still holds :) > >>>>> > >>>>> I made the change in the UnixOSProcessPlugin in slang, on the pharo-vm > >>>>> distrib; however, there are differences with your version > >>>>> (VMConstruction-Plugins-OSProcessPlugin.oscog-eem.42), I'll have a look > >>>>> at > >>>>> backporting them. > >>>>> > >>>>> Thierry > >>>>> > >>>> > >>> > >>> > > <VMConstruction-Plugins-OSProcessPlugin.oscog-ThierryGoubier.44.mcz> > >

1 0

VM Maker: VMMaker.oscog-eem.1350.mcz
by commits＠source.squeak.org 12 Jun '15

12 Jun '15

Eliot Miranda uploaded a new version of VMMaker to project VM Maker: http://source.squeak.org/VMMaker/VMMaker.oscog-eem.1350.mcz ==================== Summary ==================== Name: VMMaker.oscog-eem.1350 Author: eem Time: 11 June 2015, 5:54:31.583 pm UUID: ae606b2c-4dc1-4c8f-9f69-793010abbd03 Ancestors: VMMaker.oscog-eem.1349 ARM Cogit: Move the calculation of which address to annotate for an annotated instruction into the instruction, allowing CogOutOfLineLiteralsARMCompiler to annotate the out-of-line literal, rather than the instruction following, and implement literal update on GC for out-of-line literals. Slang: Eliminate blank lines coming from conditional dead code elimination. =============== Diff against VMMaker.oscog-eem.1349 =============== Item was added: + ----- Method: CogAbstractInstruction>>mapEntryAddress (in category 'generate machine code') ----- + mapEntryAddress + "Typically map entries apply to the end of an instruction, for two reasons: + a) to cope with literals embedded in variable-length instructions, since, e.g. + on x86, the literal typically comes at the end of the instruction. + b) in-line cache detection is based on return addresses, which are typically + to the instruction following a call." + <inline: true> + ^address + machineCodeSize! Item was added: + ----- Method: CogOutOfLineLiteralsARMCompiler>>mapEntryAddress (in category 'generate machine code') ----- + mapEntryAddress + "Typically map entries apply to the end of an instruction, for two reasons: + a) to cope with literals embedded in variable-length instructions, since, e.g. + on x86, the literal typically comes at the end of the instruction. + b) in-line cache detection is based on return addresses, which are typically + to the instruction following a call. + But with out-of-line literals it is more convenient to annotate the literal itself." + <inline: true> + ^opcode = Literal + ifTrue: [address] + ifFalse: [address + machineCodeSize]! Item was changed: ----- Method: Cogit>>checkIfValidOopRef:pc:cogMethod: (in category 'garbage collection') ----- checkIfValidOopRef: annotation pc: mcpc cogMethod: cogMethod "Check for a valid object reference, if any, at a map entry. Answer a code unique to each error for debugging." <var: #mcpc type: #'char *'> <var: #nsSendCache type: #'NSSendCache *'> annotation = IsObjectReference ifTrue: [| literal | + literal := literalsManager fetchLiteralAtAnnotatedAddress: mcpc asUnsignedInteger using: backEnd. - literal := backEnd literalBeforeFollowingAddress: mcpc asInteger. (objectRepresentation checkValidOopReference: literal) ifFalse: [coInterpreter print: 'object ref leak in CM '; printHex: cogMethod asInteger; print: ' @ '; printHex: mcpc asInteger; cr. ^1]]. self cppIf: NewspeakVM ifTrue: [annotation = IsNSSendCall ifTrue: [| nsSendCache enclosingObject | nsSendCache := self nsSendCacheFromReturnAddress: mcpc asInteger. [(objectRepresentation checkValidOopReference: nsSendCache selector) ifFalse: [coInterpreter print: 'selector leak in CM '; printHex: cogMethod asInteger; print: ' @ '; printHex: mcpc asInteger; cr. ^1]]. (enclosingObject := nsSendCache enclosingObject) ~= 0 ifTrue: [[(objectRepresentation checkValidOopReference: enclosingObject) ifFalse: [coInterpreter print: 'enclosing object leak in CM '; printHex: cogMethod asInteger; print: ' @ '; printHex: mcpc asInteger; cr. ^1]]]]]. (self isPureSendAnnotation: annotation) ifTrue: [| entryPoint selectorOrCacheTag offset | entryPoint := backEnd callTargetFromReturnAddress: mcpc asInteger. entryPoint <= methodZoneBase ifTrue: [offset := entryPoint] ifFalse: [self offsetAndSendTableFor: entryPoint annotation: annotation into: [:off :table| offset := off]]. selectorOrCacheTag := backEnd inlineCacheTagAt: mcpc asInteger. (entryPoint > methodZoneBase and: [offset ~= cmNoCheckEntryOffset and: [(self cCoerceSimple: entryPoint - offset to: #'CogMethod *') cmType ~= CMOpenPIC]]) ifTrue: "linked non-super send, cacheTag is a cacheTag" [(objectRepresentation validInlineCacheTag: selectorOrCacheTag) ifFalse: [coInterpreter print: 'cache tag leak in CM '; printHex: cogMethod asInteger; print: ' @ '; printHex: mcpc asInteger; cr. ^1]] ifFalse: "unlinked send or super send; cacheTag is a selector" [(objectRepresentation checkValidOopReference: selectorOrCacheTag) ifFalse: [coInterpreter print: 'selector leak in CM '; printHex: cogMethod asInteger; print: ' @ '; printHex: mcpc asInteger; cr. ^1]]]. ^0 "keep scanning"! Item was changed: ----- Method: Cogit>>checkIfValidOopRefAndTarget:pc:cogMethod: (in category 'garbage collection') ----- checkIfValidOopRefAndTarget: annotation pc: mcpc cogMethod: cogMethod "Check for a valid object reference, if any, at a map entry. Answer a code unique to each error for debugging." <var: #mcpc type: #'char *'> <var: #nsSendCache type: #'NSSendCache *'> | literal entryPoint | annotation = IsObjectReference ifTrue: + [literal := literalsManager fetchLiteralAtAnnotatedAddress: mcpc asUnsignedInteger using: backEnd. - [literal := backEnd literalBeforeFollowingAddress: mcpc asInteger. (self asserta: (objectRepresentation checkValidOopReference: literal)) ifFalse: [^1]. ((objectRepresentation couldBeObject: literal) and: [objectMemory isReallyYoungObject: literal]) ifTrue: [(self asserta: (self cCoerceSimple: cogMethod to: #'CogMethod *') cmRefersToYoung) ifFalse: [^2]]]. self cppIf: NewspeakVM ifTrue: [annotation = IsNSSendCall ifTrue: [| nsSendCache classTag enclosingObject nsTargetMethod | nsSendCache := self nsSendCacheFromReturnAddress: mcpc asInteger. (self asserta: (objectRepresentation checkValidOopReference: nsSendCache selector)) ifFalse: [^9]. classTag := nsSendCache classTag. (self asserta: (classTag = 0 or: [objectRepresentation validInlineCacheTag: classTag])) ifFalse: [^10]. enclosingObject := nsSendCache enclosingObject. (self asserta: (enclosingObject = 0 or: [objectRepresentation checkValidOopReference: enclosingObject])) ifFalse: [^11]. entryPoint := nsSendCache target. entryPoint ~= 0 ifTrue: [ nsTargetMethod := self cCoerceSimple: entryPoint - cmNoCheckEntryOffset to: #'CogMethod *'. (self asserta: (nsTargetMethod cmType = CMMethod)) ifFalse: [^12]]]]. (self isPureSendAnnotation: annotation) ifTrue: [(self asserta: (self cCoerceSimple: cogMethod to: #'CogMethod *') cmType = CMMethod) ifFalse: [^3]. self offsetCacheTagAndCouldBeObjectAt: mcpc annotation: annotation into: [:offset :cacheTag :tagCouldBeObject| tagCouldBeObject ifTrue: [(objectRepresentation couldBeObject: cacheTag) ifTrue: [(self asserta: (objectRepresentation checkValidOopReference: cacheTag)) ifFalse: [^4]] ifFalse: [(self asserta: (objectRepresentation validInlineCacheTag: cacheTag)) ifFalse: [^5]]. ((objectRepresentation couldBeObject: cacheTag) and: [objectMemory isReallyYoungObject: cacheTag]) ifTrue: [(self asserta: (self cCoerceSimple: cogMethod to: #'CogMethod *') cmRefersToYoung) ifFalse: [^6]]] ifFalse: [(self asserta: (objectRepresentation validInlineCacheTag: cacheTag)) ifFalse: [^7]]]. entryPoint := backEnd callTargetFromReturnAddress: mcpc asInteger. entryPoint > methodZoneBase ifTrue: ["It's a linked send; find which kind." self targetMethodAndSendTableFor: entryPoint annotation: annotation into: [:targetMethod :sendTable| (self asserta: (targetMethod cmType = CMMethod or: [targetMethod cmType = CMClosedPIC or: [targetMethod cmType = CMOpenPIC]])) ifFalse: [^8]]]]. ^0 "keep scanning"! Item was changed: ----- Method: Cogit>>generateMapAt:start: (in category 'method map') ----- generateMapAt: addressOrNull start: startAddress "Generate the method map at addressrNull (or compute it if addressOrNull is null). Answer the length of the map in byes. Each entry in the map is in two parts. In the least signficant bits are a displacement of how far from the start or previous entry, unless it is an IsAnnotationExtension byte, in which case those bits are the extension. In the most signficant bits are the type of annotation at the point reached. A null byte ends the map." | length location | <var: #instruction type: #'AbstractInstruction *'> length := 0. location := startAddress. 0 to: opcodeIndex - 1 do: [:i| | instruction mcpc delta maxDelta mapEntry | instruction := self abstractInstructionAt: i. instruction annotation ifNotNil: [:annotation| + literalsManager assertValidAnnotation: annotation for: instruction. + mcpc := instruction mapEntryAddress. - self flag: 'if this is moved into e.g. CogAbstractInstruction>>annotationAddress then e.g. a push const can annotate the lit synth instr, not the reg push'. - mcpc := instruction address + instruction machineCodeSize. [(delta := mcpc - location / backEnd codeGranularity) > DisplacementMask] whileTrue: [maxDelta := (delta min: MaxX2NDisplacement) bitClear: DisplacementMask. self assert: maxDelta >> AnnotationShift <= DisplacementMask. addressOrNull ifNotNil: [objectMemory byteAt: addressOrNull - length put: maxDelta >> AnnotationShift + DisplacementX2N. self traceMap: IsDisplacementX2N instruction: instruction byte: maxDelta >> AnnotationShift + DisplacementX2N at: addressOrNull - length for: mcpc]. location := location + (maxDelta * backEnd codeGranularity). length := length + 1]. addressOrNull ifNotNil: [mapEntry := delta + ((annotation min: IsSendCall) << AnnotationShift). objectMemory byteAt: addressOrNull - length put: mapEntry. self traceMap: annotation instruction: instruction byte: mapEntry at: addressOrNull - length for: mcpc]. location := location + (delta * backEnd codeGranularity). length := length + 1. annotation > IsSendCall ifTrue: "Add the necessary IsAnnotationExtension" [addressOrNull ifNotNil: [mapEntry := IsAnnotationExtension << AnnotationShift + (annotation - IsSendCall). objectMemory byteAt: addressOrNull - length put: mapEntry. self traceMap: annotation instruction: instruction byte: mapEntry at: addressOrNull - length for: mcpc]. length := length + 1]]]. addressOrNull ifNotNil: [objectMemory byteAt: addressOrNull - length put: MapEnd. self traceMap: MapEnd instruction: nil byte: MapEnd at: addressOrNull - length for: 0]. ^length + 1! Item was changed: ----- Method: Cogit>>markLiterals:pc:method: (in category 'garbage collection') ----- markLiterals: annotation pc: mcpc method: cogMethod "Mark and trace literals. Additionally in Newspeak, void push implicits that have unmarked classes." <var: #mcpc type: #'char *'> <var: #nsSendCache type: #'NSSendCache *'> | literal | annotation = IsObjectReference ifTrue: + [literal := literalsManager fetchLiteralAtAnnotatedAddress: mcpc asUnsignedInteger using: backEnd. - [literal := backEnd literalBeforeFollowingAddress: mcpc asUnsignedInteger. (objectRepresentation markAndTraceLiteral: literal in: (self cCoerceSimple: cogMethod to: #'CogMethod *') atpc: mcpc asUnsignedInteger) ifTrue: [codeModified := true]]. self cppIf: NewspeakVM ifTrue: [annotation = IsNSSendCall ifTrue: [| nsSendCache sel eo | nsSendCache := self nsSendCacheFromReturnAddress: mcpc asInteger. sel := nsSendCache selector. (objectMemory isForwarded: sel) ifFalse: [objectMemory markAndTrace: sel] ifTrue: [sel := objectMemory followForwarded: literal. nsSendCache selector: sel. self markAndTraceUpdatedLiteral: sel in: (self cCoerceSimple: cogMethod to: #'CogMethod *')]. eo := nsSendCache enclosingObject. eo ~= 0 ifTrue: [(objectMemory isForwarded: eo) ifFalse: [objectMemory markAndTrace: eo] ifTrue: [eo := objectMemory followForwarded: literal. nsSendCache enclosingObject: eo. self markAndTraceUpdatedLiteral: eo in: (self cCoerceSimple: cogMethod to: #'CogMethod *')]]]]. (self isPureSendAnnotation: annotation) ifTrue: [self offsetCacheTagAndCouldBeObjectAt: mcpc annotation: annotation into: [:entryPoint :cacheTag :tagCouldBeObj | tagCouldBeObj ifTrue: [(objectRepresentation markAndTraceCacheTagLiteral: cacheTag in: (self cCoerceSimple: cogMethod to: #'CogMethod *') atpc: mcpc asUnsignedInteger) ifTrue: ["cacheTag is selector" codeModified := true]]]]. ^0 "keep scanning"! Item was changed: ----- Method: Cogit>>markLiteralsAndUnlinkIfUnmarkedSend:pc:method: (in category 'garbage collection') ----- markLiteralsAndUnlinkIfUnmarkedSend: annotation pc: mcpc method: cogMethod "Mark and trace literals. Unlink sends that have unmarked cache tags or targets." <var: #mcpc type: #'char *'> <var: #nsSendCache type: #'NSSendCache *'> | literal | annotation = IsObjectReference ifTrue: + [literal := literalsManager fetchLiteralAtAnnotatedAddress: mcpc asUnsignedInteger using: backEnd. - [literal := backEnd literalBeforeFollowingAddress: mcpc asUnsignedInteger. (objectRepresentation markAndTraceLiteral: literal in: (self cCoerceSimple: cogMethod to: #'CogMethod *') atpc: mcpc asUnsignedInteger) ifTrue: [codeModified := true]]. self cppIf: NewspeakVM ifTrue: [annotation = IsNSSendCall ifTrue: [| nsSendCache entryPoint targetMethod sel eo | nsSendCache := self nsSendCacheFromReturnAddress: mcpc asInteger. entryPoint := nsSendCache target. entryPoint ~= 0 ifTrue: "Send is linked" [targetMethod := entryPoint - cmNoCheckEntryOffset. (self markAndTraceOrFreeCogMethod: targetMethod firstVisit: targetMethod asUnsignedInteger > mcpc asUnsignedInteger) ifTrue: [self voidNSSendCache: nsSendCache]]. sel := nsSendCache selector. (objectMemory isForwarded: sel) ifFalse: [objectMemory markAndTrace: sel] ifTrue: [sel := objectMemory followForwarded: literal. nsSendCache selector: sel. self markAndTraceUpdatedLiteral: sel in: (self cCoerceSimple: cogMethod to: #'CogMethod *')]. eo := nsSendCache enclosingObject. eo ~= 0 ifTrue: [(objectMemory isForwarded: eo) ifFalse: [objectMemory markAndTrace: eo] ifTrue: [eo := objectMemory followForwarded: literal. nsSendCache enclosingObject: eo. self markAndTraceUpdatedLiteral: eo in: (self cCoerceSimple: cogMethod to: #'CogMethod *')]]]]. (self isPureSendAnnotation: annotation) ifTrue: [self offsetCacheTagAndCouldBeObjectAt: mcpc annotation: annotation into: [:entryPoint :cacheTag :tagCouldBeObj | | cacheTagMarked | cacheTagMarked := tagCouldBeObj and: [objectRepresentation cacheTagIsMarked: cacheTag]. entryPoint > methodZoneBase ifTrue: "It's a linked send." [self targetMethodAndSendTableFor: entryPoint annotation: annotation into: [:targetMethod :sendTable| (cacheTagMarked not or: [self markAndTraceOrFreeCogMethod: targetMethod firstVisit: targetMethod asUnsignedInteger > mcpc asUnsignedInteger]) ifTrue: ["Either the cacheTag is unmarked (e.g. new class) or the target has been freed (because it is unmarked), so unlink the send." self unlinkSendAt: mcpc targetMethod: targetMethod sendTable: sendTable. objectRepresentation markAndTraceLiteral: targetMethod selector in: targetMethod at: (self addressOf: targetMethod selector put: [:val| targetMethod selector: val])]]] ifFalse: "cacheTag is selector" [(objectRepresentation markAndTraceCacheTagLiteral: cacheTag in: (self cCoerceSimple: cogMethod to: #'CogMethod *') atpc: mcpc asUnsignedInteger) ifTrue: [codeModified := true]]]]. ^0 "keep scanning"! Item was changed: ----- Method: Cogit>>markYoungObjects:pc:method: (in category 'garbage collection') ----- markYoungObjects: annotation pc: mcpc method: cogMethod "Mark and trace young literals." <var: #mcpc type: #'char *'> <var: #nsSendCache type: #'NSSendCache *'> | literal | annotation = IsObjectReference ifTrue: + [literal := literalsManager fetchLiteralAtAnnotatedAddress: mcpc asUnsignedInteger using: backEnd. - [literal := backEnd literalBeforeFollowingAddress: mcpc asInteger. objectRepresentation markAndTraceLiteralIfYoung: literal]. self cppIf: NewspeakVM ifTrue: [annotation = IsNSSendCall ifTrue: [| nsSendCache | nsSendCache := self nsSendCacheFromReturnAddress: mcpc asInteger. objectRepresentation markAndTraceLiteralIfYoung: nsSendCache selector. nsSendCache enclosingObject ~= 0 ifTrue: [objectRepresentation markAndTraceLiteralIfYoung: nsSendCache enclosingObject]]]. (self isPureSendAnnotation: annotation) ifTrue: [self offsetCacheTagAndCouldBeObjectAt: mcpc annotation: annotation into: [:entryPoint :cacheTag :tagCouldBeObj | tagCouldBeObj ifTrue: [objectRepresentation markAndTraceLiteralIfYoung: cacheTag]]]. ^0 "keep scanning"! Item was changed: ----- Method: Cogit>>remapIfObjectRef:pc:hasYoung: (in category 'garbage collection') ----- remapIfObjectRef: annotation pc: mcpc hasYoung: hasYoungPtr <var: #mcpc type: #'char *'> <var: #targetMethod type: #'CogMethod *'> <var: #nsSendCache type: #'NSSendCache *'> annotation = IsObjectReference ifTrue: [| literal mappedLiteral | + literal := literalsManager fetchLiteralAtAnnotatedAddress: mcpc asUnsignedInteger using: backEnd. - literal := backEnd literalBeforeFollowingAddress: mcpc asInteger. (objectRepresentation couldBeObject: literal) ifTrue: [mappedLiteral := objectRepresentation remapObject: literal. literal ~= mappedLiteral ifTrue: + [literalsManager storeLiteral: mappedLiteral atAnnotatedAddress: mcpc asUnsignedInteger using: backEnd. - [backEnd storeLiteral: mappedLiteral beforeFollowingAddress: mcpc asInteger. codeModified := true]. (hasYoungPtr ~= 0 and: [objectMemory isYoung: mappedLiteral]) ifTrue: [(self cCoerceSimple: hasYoungPtr to: #'sqInt *') at: 0 put: true]]]. self cppIf: NewspeakVM ifTrue: [annotation = IsNSSendCall ifTrue: [| nsSendCache oop mappedOop | nsSendCache := self nsSendCacheFromReturnAddress: mcpc asInteger. oop := nsSendCache selector. mappedOop := objectRepresentation remapObject: oop. oop ~= mappedOop ifTrue: [nsSendCache selector: mappedOop. (hasYoungPtr ~= 0 and: [objectMemory isYoung: mappedOop]) ifTrue: [(self cCoerceSimple: hasYoungPtr to: #'sqInt *') at: 0 put: true]]. oop := nsSendCache enclosingObject. oop ~= 0 ifTrue: [ mappedOop := objectRepresentation remapObject: oop. oop ~= mappedOop ifTrue: [nsSendCache enclosingObject: mappedOop. (hasYoungPtr ~= 0 and: [objectMemory isYoung: mappedOop]) ifTrue: [(self cCoerceSimple: hasYoungPtr to: #'sqInt *') at: 0 put: true]]]. ^0 "keep scanning"]]. (self isPureSendAnnotation: annotation) ifTrue: [self offsetCacheTagAndCouldBeObjectAt: mcpc annotation: annotation into: [:entryPoint :cacheTag :tagCouldBeObj | | mappedCacheTag | (tagCouldBeObj and: [objectRepresentation couldBeObject: cacheTag]) ifTrue: [mappedCacheTag := objectRepresentation remapObject: cacheTag. cacheTag ~= mappedCacheTag ifTrue: [backEnd rewriteInlineCacheTag: mappedCacheTag at: mcpc asInteger. codeModified := true]. (hasYoungPtr ~= 0 and: [objectMemory isYoung: mappedCacheTag]) ifTrue: [(self cCoerceSimple: hasYoungPtr to: #'sqInt *') at: 0 put: true]]. hasYoungPtr ~= 0 ifTrue: ["Since the unlinking routines may rewrite the cacheTag to the send's selector, and since they don't have the cogMethod to hand and can't add it to youngReferrers, the method must remain in youngReferrers if the targetMethod's selector is young." entryPoint > methodZoneBase ifTrue: "It's a linked send." [self targetMethodAndSendTableFor: entryPoint annotation: annotation into: [:targetMethod :ignored| (objectMemory isYoung: targetMethod selector) ifTrue: [(self cCoerceSimple: hasYoungPtr to: #'sqInt *') at: 0 put: true]]]]]]. ^0 "keep scanning"! Item was added: + ----- Method: InLineLiteralsManager>>assertValidAnnotation:for: (in category 'generate machine code') ----- + assertValidAnnotation: annotation for: instruction + <var: #instruction type: #'AbstractInstruction *'> + <inline: true>! Item was added: + ----- Method: InLineLiteralsManager>>fetchLiteralAtAnnotatedAddress:using: (in category 'garbage collection') ----- + fetchLiteralAtAnnotatedAddress: address using: instruction + "Normally literals are embedded in instructions and the annotation is at the start of + the following instruction, to cope with literals embedded in variable-length instructions, + since, e.g. on x86, the literal typically comes at the end of the instruction." + <var: 'instruction' type: #'AbstractInstruction *'> + <inline: true> + ^instruction literalBeforeFollowingAddress: address! Item was added: + ----- Method: InLineLiteralsManager>>storeLiteral:atAnnotatedAddress:using: (in category 'garbage collection') ----- + storeLiteral: literal atAnnotatedAddress: address using: instruction + "Normally literals are embedded in instructions and the annotation is at the start of + the following instruction, to cope with literals embedded in variable-length instructions, + since, e.g. on x86, the literal typically comes at the end of the instruction." + <var: 'address' type: #usqInt> + <var: 'instruction' type: #'AbstractInstruction *'> + <inline: true> + ^instruction storeLiteral: literal beforeFollowingAddress: address! Item was changed: VMClass subclass: #OutOfLineLiteralsManager + instanceVariableNames: 'cogit objectMemory firstOpcodeIndex nextLiteralIndex lastDumpedLiteralIndex literals literalsSize' - instanceVariableNames: 'cogit firstOpcodeIndex nextLiteralIndex lastDumpedLiteralIndex literals literalsSize' classVariableNames: '' poolDictionaries: 'CogCompilationConstants CogRTLOpcodes' category: 'VMMaker-JIT'! !OutOfLineLiteralsManager commentStamp: 'eem 6/7/2015 12:10' prior: 0! An OutOfLineLiteralsManager manages the dumping of literals for backends that wat to keep literals out-of-line, accessed by pc-relative addressing. Instance Variables cogit: <Cogit>! Item was added: + ----- Method: OutOfLineLiteralsManager>>assertValidAnnotation:for: (in category 'generate machine code') ----- + assertValidAnnotation: annotation for: instruction + "Insist that the IsObjectReference applies only to out-of-line literals." + <var: #instruction type: #'AbstractInstruction *'> + <inline: true> + self assert: (annotation ~= cogit getIsObjectReference or: [instruction opcode = Literal])! Item was changed: ----- Method: OutOfLineLiteralsManager>>cogit: (in category 'initialization') ----- cogit: aCogit <doNotGenerate> cogit := aCogit. + objectMemory := aCogit objectMemory. literalsSize := 0! Item was added: + ----- Method: OutOfLineLiteralsManager>>fetchLiteralAtAnnotatedAddress:using: (in category 'garbage collection') ----- + fetchLiteralAtAnnotatedAddress: address using: instruction + "With out-of-line literals, the IsObjectReference annotation refers to + the start of the literal and hence access the memory directly." + <var: 'instruction' type: #'AbstractInstruction *'> + <inline: true> + ^objectMemory longAt: address! Item was added: + ----- Method: OutOfLineLiteralsManager>>storeLiteral:atAnnotatedAddress:using: (in category 'garbage collection') ----- + storeLiteral: literal atAnnotatedAddress: address using: instruction + "With out-of-line literals, the IsObjectReference annotation refers to + the start of the literal and hence access the memory directly." + <var: 'address' type: #usqInt> + <var: 'instruction' type: #'AbstractInstruction *'> + <inline: true> + objectMemory longAt: address put: literal! Item was changed: ----- Method: TStmtListNode>>emitCCodeOn:prependToEnd:level:generator: (in category 'C code generation') ----- emitCCodeOn: aStream prependToEnd: aNodeOrNil level: level generator: aCodeGen self emitCCommentOn: aStream level: level. statements withIndexDo: [:s :idx| s isStmtList ifFalse: [s emitCCommentOn: aStream level: level]. aStream peekLast ~~ Character tab ifTrue: [aStream tab: level]. (aNodeOrNil notNil and: [idx = statements size]) ifTrue: [s emitCCodeOn: aStream prependToEnd: aNodeOrNil level: level generator: aCodeGen] ifFalse: [s emitCCodeOn: aStream level: level generator: aCodeGen]. (self stream: aStream endsWithAnyOf: '};') ifFalse: [s needsTrailingSemicolon ifTrue: [aStream nextPut: $;]]. + aStream peekLast ~~ Character cr ifTrue: + [aStream cr]]. - aStream cr]. !

1 0

ARM Cog progress
by tim Rowledge 12 Jun '15

12 Jun '15

We can now run the ARM cog/spur system on a Pi 2; it’s debug compiled and lots of asserts fail, and it exits quite aggressively when you upset it, but - actual real compiled code, running on an actual ARM machine, using the actual morphic ui to do actual stuff. 3+4 does indeed = elephant. 100 factorial is a very long number. 1 tinyBenchmarks is utterly meaningless (gcc debug settings + lots of expensive runtime asserts) but still reports 120mbc/s and 7m sends/s or about 4x the stack vm. Happy-happy. tim -- tim Rowledge; tim(a)rowledge.org; http://www.rowledge.org/tim Useful Latin Phrases:- Quantum materiae materietur marmota monax si marmota monax materiam possit materiari? = How much wood would a woodchuck chuck if a woodchuck could chuck wood?

11 39

VM Maker: VMMaker.oscog-eem.1349.mcz
by commits＠source.squeak.org 12 Jun '15

12 Jun '15

Eliot Miranda uploaded a new version of VMMaker to project VM Maker: http://source.squeak.org/VMMaker/VMMaker.oscog-eem.1349.mcz ==================== Summary ==================== Name: VMMaker.oscog-eem.1349 Author: eem Time: 11 June 2015, 3:30:12.807 pm UUID: c4bacc64-8f85-425f-b5b9-47504c99cabe Ancestors: VMMaker.oscog-eem.1348 Slang: Modify prototype output so that non-static functions are declared as extern. This to try and cure Cog crashes on compilers such as clang 3.4. Relax the isNil: warning for prevInstIsPCAnnotated; accept simple struct send receivers. =============== Diff against VMMaker.oscog-eem.1347 =============== Item was changed: ----- Method: CCodeGenerator>>generateIfNilAsArgument:on:indent: (in category 'C translation') ----- generateIfNilAsArgument: msgNode on: aStream indent: level "Generate the C code for this message onto the given stream." (self isNilConstantReceiverOf: msgNode) ifFalse: [aStream nextPutAll: '(!!('. msgNode receiver emitCCodeAsArgumentOn: aStream level: 0 generator: self. aStream nextPut: $); crtab: level + 1; nextPut: $?; space. msgNode args last emitCCodeAsArgumentOn: aStream level: level + 2 generator: self. aStream crtab: level + 1; nextPut: $:; space. msgNode receiver emitCCodeAsArgumentOn: aStream level: 0 generator: self. + (msgNode receiver isLeaf + or: [msgNode receiver isSend + and: [(msgNode receiver isStructSendIn: self) + and: [msgNode receiver receiver isLeaf]]]) ifFalse: - msgNode receiver isLeaf ifFalse: [logger cr; nextPutAll: 'sending ifNil: to non-leaf in '; nextPutAll: currentMethod selector]. aStream nextPut: $)] ifTrue: [msgNode args first emitCCodeAsArgumentOn: aStream level: level generator: self]! Item was changed: ----- Method: CogARMCompiler>>inverseOpcodeFor: (in category 'generate machine code - support') ----- + inverseOpcodeFor: armOpcode - inverseOpcodeFor: opcode "Several of the opcodes are inverses. Answer the inverse for an opcode if it has one. See Table A3-2 in sec A3.4 Data-processing instructions of the AARM." + ^armOpcode caseOf: { - ^opcode caseOf: { [AddOpcode] -> [SubOpcode]. [AndOpcode] -> [BicOpcode]. [BicOpcode] -> [AndOpcode]. [CmpOpcode] -> [CmpNotOpcode]. [MoveOpcode] -> [MoveNotOpcode]. [MoveNotOpcode] -> [MoveOpcode]. [SubOpcode] -> [AddOpcode] } otherwise: [self error: 'opcode has no inverse']! Item was changed: ----- Method: Cogit class>>ancilliaryClasses: (in category 'translation') ----- ancilliaryClasses: options ProcessorClass ifNil: [Cogit initializeMiscConstants]. + ^(self activeCompilerClass withAllSuperclasses copyUpThrough: CogAbstractInstruction), + { CogMethodZone. - ^{ CogMethodZone. CogBlockStart. CogBytecodeDescriptor. CogBytecodeFixup. CogPrimitiveDescriptor. CogBlockMethod. + CogMethod. + self activeCompilerClass literalsManagerClass}, - CogMethod }, - (self activeCompilerClass withAllSuperclasses copyUpThrough: CogAbstractInstruction), ((options at: #NewspeakVM ifAbsent: [false]) ifTrue: [{NewspeakCogMethod. NSSendCache}] ifFalse: [#()])! Item was changed: ----- Method: Cogit class>>declareCVarsIn: (in category 'translation') ----- declareCVarsIn: aCCodeGenerator #( 'coInterpreter' 'objectMemory' 'methodZone' 'objectRepresentation' 'cogBlockMethodSurrogateClass' 'cogMethodSurrogateClass' 'nsSendCacheSurrogateClass' 'threadManager' 'processor' 'lastNInstructions' 'simulatedAddresses' 'simulatedTrampolines' 'simulatedVariableGetters' 'simulatedVariableSetters' 'printRegisters' 'printInstructions' 'clickConfirm' 'singleStep') do: [:simulationVariableNotNeededForRealVM| aCCodeGenerator removeVariable: simulationVariableNotNeededForRealVM]. NewspeakVM ifFalse: [#( 'selfSendTrampolines' 'dynamicSuperSendTrampolines' 'implicitReceiverSendTrampolines' 'outerSendTrampolines' 'ceEnclosingObjectTrampoline' 'numIRCs' 'indexOfIRC' 'theIRCs') do: [:variableNotNeededInNormalVM| aCCodeGenerator removeVariable: variableNotNeededInNormalVM]]. aCCodeGenerator removeConstant: #COGMTVM. "this should be defined at compile time" aCCodeGenerator addHeaderFile:'<stddef.h>'; "for e.g. offsetof" addHeaderFile:'"sqCogStackAlignment.h"'; addHeaderFile:'"dispdbg.h"'; "must preceed cointerp.h & cogit.h otherwise NoDbgRegParms gets screwed up" addHeaderFile:'"cogmethod.h"'. NewspeakVM ifTrue: [aCCodeGenerator addHeaderFile:'"nssendcache.h"']. aCCodeGenerator addHeaderFile:'#if COGMTVM'; addHeaderFile:'"cointerpmt.h"'; addHeaderFile:'#else'; addHeaderFile:'"cointerp.h"'; addHeaderFile:'#endif'; addHeaderFile:'"cogit.h"'. aCCodeGenerator var: #ceGetSP declareC: 'unsigned long (*ceGetSP)(void)'; var: #ceCaptureCStackPointers declareC: 'void (*ceCaptureCStackPointers)(void)'; var: #ceEnterCogCodePopReceiverReg declareC: 'void (*ceEnterCogCodePopReceiverReg)(void)'; var: #realCEEnterCogCodePopReceiverReg declareC: 'void (*realCEEnterCogCodePopReceiverReg)(void)'; var: #ceCallCogCodePopReceiverReg declareC: 'void (*ceCallCogCodePopReceiverReg)(void)'; var: #realCECallCogCodePopReceiverReg declareC: 'void (*realCECallCogCodePopReceiverReg)(void)'; var: #ceCallCogCodePopReceiverAndClassRegs declareC: 'void (*ceCallCogCodePopReceiverAndClassRegs)(void)'; var: #realCECallCogCodePopReceiverAndClassRegs declareC: 'void (*realCECallCogCodePopReceiverAndClassRegs)(void)'; var: #ceFlushICache declareC: 'static void (*ceFlushICache)(unsigned long from, unsigned long to)'; var: #ceCheckFeaturesFunction declareC: 'static unsigned long (*ceCheckFeaturesFunction)(void)'; var: #ceTryLockVMOwner declareC: 'unsigned long (*ceTryLockVMOwner)(void)'; var: #ceUnlockVMOwner declareC: 'void (*ceUnlockVMOwner)(void)'; var: #postCompileHook declareC: 'void (*postCompileHook)(CogMethod *, void *)'; var: #openPICList declareC: 'CogMethod *openPICList = 0'; var: #maxMethodBefore type: #'CogBlockMethod *'. aCCodeGenerator declareVar: 'aMethodLabel' type: #'AbstractInstruction'; "Has to come lexicographically before backEnd & methodLabel" var: #backEnd declareC: 'AbstractInstruction * const backEnd = &aMethodLabel'; var: #methodLabel declareC: 'AbstractInstruction * const methodLabel = &aMethodLabel'; var: #primInvokeLabel type: #'AbstractInstruction *'. self declareC: #(abstractOpcodes stackCheckLabel blockEntryLabel blockEntryNoContextSwitch stackOverflowCall sendMiss entry noCheckEntry selfSendEntry dynSuperEntry picMNUAbort picInterpretAbort endCPICCase0 endCPICCase1) as: #'AbstractInstruction *' in: aCCodeGenerator. aCCodeGenerator - declareVar: #annotations type: #'InstructionAnnotation *'; declareVar: #blockStarts type: #'BlockStart *'; declareVar: #fixups type: #'BytecodeFixup *'. aCCodeGenerator var: #ordinarySendTrampolines declareC: 'sqInt ordinarySendTrampolines[NumSendTrampolines]'; var: #superSendTrampolines declareC: 'sqInt superSendTrampolines[NumSendTrampolines]'; var: #directedSuperSendTrampolines declareC: 'sqInt directedSuperSendTrampolines[NumSendTrampolines]'; var: #selfSendTrampolines declareC: 'sqInt selfSendTrampolines[NumSendTrampolines]'; var: #dynamicSuperSendTrampolines declareC: 'sqInt dynamicSuperSendTrampolines[NumSendTrampolines]'; var: #implicitReceiverSendTrampolines declareC: 'sqInt implicitReceiverSendTrampolines[NumSendTrampolines]'; var: #outerSendTrampolines declareC: 'sqInt outerSendTrampolines[NumSendTrampolines]'; var: #trampolineAddresses declareC: 'static char *trampolineAddresses[NumTrampolines*2]'; var: #objectReferencesInRuntime declareC: 'static sqInt objectReferencesInRuntime[NumObjRefsInRuntime]'; var: #labelCounter type: #int; var: #traceFlags declareC: 'int traceFlags = 8 /* prim trace log on by default */'; var: #cStackAlignment declareC: 'const int cStackAlignment = STACK_ALIGN_BYTES'. aCCodeGenerator declareVar: #CFramePointer type: #'void *'; declareVar: #CStackPointer type: #'void *'; declareVar: #minValidCallAddress type: #'unsigned long'; declareVar: #debugPrimCallStackOffset type: #'unsigned long'. aCCodeGenerator vmClass generatorTable ifNotNil: [:bytecodeGenTable| aCCodeGenerator var: #generatorTable declareC: 'static BytecodeDescriptor generatorTable[', bytecodeGenTable size, ']', (self tableInitializerFor: bytecodeGenTable in: aCCodeGenerator); var: #primitiveGeneratorTable declareC: 'static PrimitiveDescriptor primitiveGeneratorTable[MaxCompiledPrimitiveIndex+1]', (self tableInitializerFor: aCCodeGenerator vmClass primitiveTable in: aCCodeGenerator)]. "In C the abstract opcode names clash with the Smalltak generator syntactic sugar. Most of the syntactic sugar is inlined, but alas some remains. Rename the syntactic sugar to avoid the clash." (self organization listAtCategoryNamed: #'abstract instructions') do: [:s| aCCodeGenerator addSelectorTranslation: s to: 'g', (aCCodeGenerator cFunctionNameFor: s)]. aCCodeGenerator addSelectorTranslation: #halt: to: 'haltmsg'! Item was changed: ----- Method: Cogit class>>isNonArgumentImplicitReceiverVariableName: (in category 'translation') ----- isNonArgumentImplicitReceiverVariableName: aString ^#('cogit' 'coInterpreter' + 'methodZone' 'literalsManager' - 'methodZone' 'objectMemory' 'objectRepresentation' 'manager') includes: aString! Item was changed: ----- Method: Cogit>>DumpJumpLong: (in category 'abstract instructions') ----- DumpJumpLong: jumpTarget "Convenience conflation of JumpLong: & dumpLiterals for PIC generation. Literals must be dumped early and often to keep each PIC case the same size." <inline: true> <returnTypeC: #'AbstractInstruction *'> | inst | <var: 'inst' type: #'AbstractInstruction *'> inst := self gen: JumpLong operand: jumpTarget asInteger. + literalsManager dumpLiterals: false. - literalsManager dumpLiterals. ^inst! Item was changed: ----- Method: Cogit>>DumpJumpLongZero: (in category 'abstract instructions') ----- DumpJumpLongZero: jumpTarget "Convenience conflation of JumpLongZero: & dumpLiterals for PIC generation. Literals must be dumped early and often to keep each PIC case the same size." <inline: true> <returnTypeC: #'AbstractInstruction *'> | inst | <var: 'inst' type: #'AbstractInstruction *'> inst := self gen: JumpLongZero operand: jumpTarget asInteger. + literalsManager dumpLiterals: false. - literalsManager dumpLiterals. ^inst! Item was changed: ----- Method: Cogit>>computeMaximumSizes (in category 'generate machine code') ----- computeMaximumSizes "This pass assigns maximum sizes to all abstract instructions and eliminates jump fixups. It hence assigns the maximum address an instruction will occur at which allows the next pass to conservatively size jumps." <inline: false> <var: #abstractInstruction type: #'AbstractInstruction *'> | relativeAddress | + literalsManager dumpLiterals: false. - literalsManager dumpLiterals. relativeAddress := 0. 0 to: opcodeIndex - 1 do: [:i| | abstractInstruction | abstractInstruction := self abstractInstructionAt: i. abstractInstruction address: relativeAddress; maxSize: abstractInstruction computeMaximumSize. relativeAddress := relativeAddress + abstractInstruction maxSize]! Item was changed: ----- Method: Cogit>>gen:literal: (in category 'compile abstract instructions') ----- gen: opcode "<Integer>" literal: operand "<Integer|CogAbstractInstruction>" "Literals are constants that either represent objects on the heap that may get updated by the garbage collector, or pc-relative spans that may get changed by code compaction, and must hence always be encoded in a form that allows updating to refer to a different value." <inline: true> <returnTypeC: #'AbstractInstruction *'> - <var: #abstractInstruction type: #'AbstractInstruction *'> ^literalsManager checkLiteral: operand forInstruction: (self gen: opcode operand: operand)! Item was changed: ----- Method: Cogit>>gen:literal:operand: (in category 'compile abstract instructions') ----- gen: opcode "<Integer>" literal: operandOne "<Integer>" operand: operandTwo "<Integer|CogAbstractInstruction>" "Literals are constants that either represent objects on the heap that may get updated by the garbage collector, or pc-relative spans that may get changed by code compaction, and must hence always be encoded in a form that allows updating to refer to a different value." <inline: true> <returnTypeC: #'AbstractInstruction *'> - <var: #abstractInstruction type: #'AbstractInstruction *'> ^literalsManager checkLiteral: operandOne forInstruction: (self gen: opcode operand: operandOne operand: operandTwo)! Item was changed: ----- Method: Cogit>>gen:operand:literal: (in category 'compile abstract instructions') ----- gen: opcode "<Integer>" operand: operandOne "<Integer|CogAbstractInstruction>" literal: operandTwo "<Integer>" "Literals are constants that either represent objects on the heap that may get updated by the garbage collector, or pc-relative spans that may get changed by code compaction, and must hence always be encoded in a form that allows updating to refer to a different value." <inline: true> <returnTypeC: #'AbstractInstruction *'> - <var: #abstractInstruction type: #'AbstractInstruction *'> ^literalsManager checkLiteral: operandTwo forInstruction: (self gen: opcode operand: operandOne operand: operandTwo)! Item was changed: ----- Method: Cogit>>gen:operand:quickConstant: (in category 'compile abstract instructions') ----- gen: opcode "<Integer>" operand: operandOne "<Integer|CogAbstractInstruction>" quickConstant: operandTwo "Integer>" "Quick constants are those the back end is free to encode as compactly as possible." <inline: true> <returnTypeC: #'AbstractInstruction *'> - <var: #abstractInstruction type: #'AbstractInstruction *'> ^literalsManager checkQuickConstant: operandTwo forInstruction: (self gen: opcode operand: operandOne operand: operandTwo)! Item was changed: ----- Method: Cogit>>gen:operand:quickConstant:operand: (in category 'compile abstract instructions') ----- gen: opcode "<Integer>" operand: operandOne "<Integer|CogAbstractInstruction>" quickConstant: operandTwo "<Integer>" operand: operandThree "<Integer|CogAbstractInstruction>" "Quick constants are those the back end is free to encode as compactly as possible.""<Integer|CogAbstractInstruction>" <inline: true> <returnTypeC: #'AbstractInstruction *'> - <var: #abstractInstruction type: #'AbstractInstruction *'> ^literalsManager checkQuickConstant: operandTwo forInstruction: (self gen: opcode operand: operandOne operand: operandTwo operand: operandThree)! Item was changed: ----- Method: Cogit>>gen:quickConstant: (in category 'compile abstract instructions') ----- gen: opcode "<Integer>" quickConstant: operand "<Integer>" "Quick constants are those the back end is free to encode as compactly as possible." <inline: true> <returnTypeC: #'AbstractInstruction *'> - <var: #abstractInstruction type: #'AbstractInstruction *'> ^literalsManager checkQuickConstant: operand forInstruction: (self gen: opcode operand: operand)! Item was changed: ----- Method: Cogit>>gen:quickConstant:operand: (in category 'compile abstract instructions') ----- gen: opcode "<Integer>" quickConstant: operandOne "<Integer>" operand: operandTwo "<Integer|CogAbstractInstruction>" "Quick constants are those the back end is free to encode as compactly as possible." <inline: true> <returnTypeC: #'AbstractInstruction *'> - <var: #abstractInstruction type: #'AbstractInstruction *'> ^literalsManager checkQuickConstant: operandOne forInstruction: (self gen: opcode operand: operandOne operand: operandTwo)! Item was changed: ----- Method: Cogit>>gen:quickConstant:operand:operand: (in category 'compile abstract instructions') ----- gen: opcode "<Integer>" quickConstant: operandOne "<Integer>" operand: operandTwo "<Integer|CogAbstractInstruction>" operand: operandThree "<Integer|CogAbstractInstruction>" "Quick constants are those the back end is free to encode as compactly as possible.""<Integer|CogAbstractInstruction>" <inline: true> <returnTypeC: #'AbstractInstruction *'> - <var: #abstractInstruction type: #'AbstractInstruction *'> ^literalsManager checkQuickConstant: operandOne forInstruction: (self gen: opcode operand: operandOne operand: operandTwo operand: operandThree)! Item was changed: ----- Method: Cogit>>gen:uniqueLiteral:operand: (in category 'compile abstract instructions') ----- gen: opcode "<Integer>" uniqueLiteral: operandOne "<Integer>" operand: operandTwo "<Integer|CogAbstractInstruction>" "Literals are constants that either represent objects on the heap that may get updated by the garbage collector, or pc-relative spans that may get changed by code compaction, and must hence always be encoded in a form that allows updating to refer to a different value." <inline: true> <returnTypeC: #'AbstractInstruction *'> - <var: #abstractInstruction type: #'AbstractInstruction *'> ^literalsManager uniqueLiteral: operandOne forInstruction: (self gen: opcode operand: operandOne operand: operandTwo)! Item was changed: ----- Method: Cogit>>maybeDumpLiterals: (in category 'compile abstract instructions') ----- maybeDumpLiterals: descriptor <inline: true> <var: #descriptor type: #'BytecodeDescriptor *'> ((literalsManager mustDumpLiterals: opcodeIndex) or: [descriptor isUnconditionalBranch or: [descriptor isReturn]]) ifTrue: + [literalsManager dumpLiterals: (descriptor isUnconditionalBranch + or: [descriptor isReturn]) not]! - [literalsManager dumpLiterals]! Item was removed: - ----- Method: InLineLiteralsManager>>dumpLiterals (in category 'compile abstract instructions') ----- - dumpLiterals - <inline: true>! Item was added: + ----- Method: InLineLiteralsManager>>dumpLiterals: (in category 'compile abstract instructions') ----- + dumpLiterals: generateBranchAround + <inline: true>! Item was changed: ----- Method: InLineLiteralsManager>>mustDumpLiterals: (in category 'testing') ----- + mustDumpLiterals: currentOpcodeIndex - mustDumpLiterals: opcodeIndex <inline: true> ^false! Item was removed: - ----- Method: OutOfLineLiteralsManager>>dumpLiterals (in category 'compile abstract instructions') ----- - dumpLiterals - "Output all pending literal instructions, making the originals dependents of the generated ones - so that a later pass will copy the address of each generated literl inst to its original in literals, - and hence allow the instruction using the literal to compute the correct address.." - | litInst | - <var: 'litInst' type: #'AbstractInstruction *'> - lastDumpedLiteralIndex to: nextLiteralIndex - 1 do: - [:i| - litInst := self literalInstructionAt: i. - (cogit gen: Literal operand: (litInst operands at: 0)) dependent: litInst]. - firstOpcodeIndex := cogit getOpcodeIndex. - lastDumpedLiteralIndex := nextLiteralIndex! Item was added: + ----- Method: OutOfLineLiteralsManager>>dumpLiterals: (in category 'compile abstract instructions') ----- + dumpLiterals: generateBranchAround + "Output all pending literal instructions, making the originals dependents of the generated ones + so that a later pass will copy the address of each generated literl inst to its original in literals, + and hence allow the instruction using the literal to compute the correct address.." + | jump litInst | + <var: 'jump' type: #'AbstractInstruction *'> + <var: 'litInst' type: #'AbstractInstruction *'> + + generateBranchAround ifTrue: + [jump := cogit Jump: 0]. + lastDumpedLiteralIndex to: nextLiteralIndex - 1 do: + [:i| + litInst := self literalInstructionAt: i. + (cogit gen: Literal operand: (litInst operands at: 0)) dependent: litInst]. + generateBranchAround ifTrue: + [jump jmpTarget: cogit Label]. + + firstOpcodeIndex := cogit getOpcodeIndex. + lastDumpedLiteralIndex := nextLiteralIndex! Item was changed: ----- Method: OutOfLineLiteralsManager>>mustDumpLiterals: (in category 'testing') ----- + mustDumpLiterals: currentOpcodeIndex - mustDumpLiterals: opcodeIndex <inline: true> + ^currentOpcodeIndex >= firstOpcodeIndex + and: [currentOpcodeIndex - firstOpcodeIndex >= cogit backEnd outOfLineLiteralOpcodeLimit]! - ^cogit getOpcodeIndex >= firstOpcodeIndex - and: [cogit getOpcodeIndex - firstOpcodeIndex >= cogit backEnd outOfLineLiteralOpcodeLimit]! Item was changed: ----- Method: TMethod>>emitCFunctionPrototype:generator:isPrototype: (in category 'C code generation') ----- emitCFunctionPrototype: aStream generator: aCodeGen isPrototype: isPrototype "<Boolean>" "Emit a C function header for this method onto the given stream." export ifTrue:[aStream nextPutAll: 'EXPORT('; nextPutAll: returnType; nextPut: $)] ifFalse: + [self isStatic + ifTrue: [aStream nextPutAll: 'static '] + ifFalse: + [isPrototype ifTrue: + [aStream nextPutAll: 'extern ']]. - [self isStatic ifTrue:[aStream nextPutAll: 'static ']. (isPrototype or: [inline ~~ #always]) ifFalse: [aStream nextPutAll: 'inline ']. aStream nextPutAll: returnType]. isPrototype ifTrue: [aStream space] ifFalse: [aStream cr]. (returnType last = $) and: [returnType includesSubString: (aCodeGen cFunctionNameFor: selector)]) ifTrue: ["Hack fix for e.g. <returnTypeC: 'void (*setInterruptCheckChain(void (*aFunction)(void)))()'>" ^self]. aStream nextPutAll: (aCodeGen cFunctionNameFor: selector); nextPut: $(. args isEmpty ifTrue: [aStream nextPutAll: #void] ifFalse: [args do: [:arg| aStream nextPutAll: (self declarationAt: arg)] separatedBy: [ aStream nextPutAll: ', ' ]]. aStream nextPut: $)!

1 0

VM Maker: VMMaker.oscog-eem.1347.mcz
by commits＠source.squeak.org 11 Jun '15

11 Jun '15

Eliot Miranda uploaded a new version of VMMaker to project VM Maker: http://source.squeak.org/VMMaker/VMMaker.oscog-eem.1347.mcz ==================== Summary ==================== Name: VMMaker.oscog-eem.1347 Author: eem Time: 11 June 2015, 12:49:55.335 pm UUID: 2a1037d4-068d-465f-871f-673a04dd7e0f Ancestors: VMMaker.oscog-eem.1346 Fix the blunder with shared out-of-line literals; the out-of-line literal for an in-line send cache must be unique. Fix genQuickReturnConst for out-of-line literals. =============== Diff against VMMaker.oscog-eem.1346 =============== Item was changed: ----- Method: CogInLineLiteralsARMCompiler>>rewriteInlineCacheAt:tag:target: (in category 'inline cacheing') ----- rewriteInlineCacheAt: callSiteReturnAddress tag: cacheTag target: callTargetAddress "Rewrite an inline cache to call a different target for a new tag. This variant is used to link unlinked sends in ceSend:to:numArgs: et al. Answer the extent of the code change which is used to compute the range of the icache to flush." - - "chacheTag contains an oop to the selector which need be loaded before jumping" <var: #callSiteReturnAddress type: #usqInt> <var: #callTargetAddress type: #usqInt> | call callDistance | false ifTrue: [self assert: callTargetAddress >= cogit minCallAddress] ifFalse: [callTargetAddress >= cogit minCallAddress ifFalse: [self error: 'linking callsite to invalid address']]. callDistance := (callTargetAddress - (callSiteReturnAddress + 8 "pc offset"- 4 "return offset")) signedIntToLong. self assert: (self isInImmediateJumpRange: callDistance). "we don't support long call updates here" call := self bl: callDistance. objectMemory longAt: callSiteReturnAddress - 4 put: call. self insert32BitOperand: cacheTag into4InstructionsPreceeding: callSiteReturnAddress - 4. self assert: (self callTargetFromReturnAddress: callSiteReturnAddress) signedIntToLong = callTargetAddress. self assert: (self extract32BitOperandFrom4InstructionsPreceeding: callSiteReturnAddress - 4) = cacheTag. "self cCode: '' inSmalltalk: [cogit disassembleFrom: callSiteReturnAddress - 20 to: callSiteReturnAddress - 1]." ^20! Item was changed: ----- Method: CogOutOfLineLiteralsARMCompiler>>inlineCacheTagAt: (in category 'inline cacheing') ----- + inlineCacheTagAt: address - inlineCacheTagAt: address ^objectMemory longAt: (self pcRelativeAddressAt: address - 8)! Item was added: + ----- Method: CogOutOfLineLiteralsARMCompiler>>isSharable (in category 'generate machine code') ----- + isSharable + "Hack: To know if a literal should be unique (not shared) mark the second operand." + <inline: true> + self assert: opcode = Literal. + ^(operands at: 1) isNil! Item was added: + ----- Method: CogOutOfLineLiteralsARMCompiler>>isUnique (in category 'generate machine code') ----- + isUnique + "Hack: To know if a literal should be unique (not shared) mark the second operand." + <inline: true> + self assert: opcode = Literal. + ^(operands at: 1) notNil! Item was changed: ----- Method: CogOutOfLineLiteralsARMCompiler>>literalOpcodeIndex (in category 'generate machine code') ----- literalOpcodeIndex "Hack: To know how far away a literal is from its referencing instruction we store its opcodeIndex, or -1, if as yet unassigned, in the second operand of the literal." <inline: true> + self assert: opcode = Literal. ^operands at: 2! Item was added: + ----- Method: CogOutOfLineLiteralsARMCompiler>>rewriteInlineCacheAt:tag:target: (in category 'inline cacheing') ----- + rewriteInlineCacheAt: callSiteReturnAddress tag: cacheTag target: callTargetAddress + "Rewrite an inline cache to call a different target for a new tag. This variant is used + to link unlinked sends in ceSend:to:numArgs: et al. Answer the extent of the code + change which is used to compute the range of the icache to flush." + <var: #callSiteReturnAddress type: #usqInt> + <var: #callTargetAddress type: #usqInt> + | call callDistance | + callTargetAddress >= cogit minCallAddress ifFalse: + [self error: 'linking callsite to invalid address']. + callDistance := (callTargetAddress - (callSiteReturnAddress + 8 "pc offset"- 4 "return offset")) signedIntToLong. + self assert: (self isInImmediateJumpRange: callDistance). "we don't support long call updates here" + call := self bl: callDistance. + objectMemory + longAt: callSiteReturnAddress - 4 put: call; + longAt: (self pcRelativeAddressAt: callSiteReturnAddress - 8) put: cacheTag. + self assert: (self inlineCacheTagAt: callSiteReturnAddress) = cacheTag. + "self cCode: '' + inSmalltalk: [cogit disassembleFrom: callSiteReturnAddress - 20 to: callSiteReturnAddress - 1]." + ^4! Item was added: + ----- Method: CogOutOfLineLiteralsARMCompiler>>setIsUnique (in category 'generate machine code') ----- + setIsUnique + "Hack: To know if a literal should be unique (not shared) mark the second operand." + <inline: true> + self assert: opcode = Literal. + ^operands at: 1 put: true! Item was changed: ----- Method: CogOutOfLineLiteralsARMCompiler>>setLiteralOpcodeIndex: (in category 'generate machine code') ----- setLiteralOpcodeIndex: index "Hack: To know how far away a literal is from its referencing instruction we store its opcodeIndex, or -1, if as yet unassigned, in the second operand of the literal." <inline: true> + self assert: opcode = Literal. ^operands at: 2 put: index! Item was added: + ----- Method: Cogit>>MoveUniqueCw:R: (in category 'abstract instructions') ----- + MoveUniqueCw: wordConstant R: reg + "If the backEnd is using out-of-line literals then those for inline caches cannot be shared, and + this method ensures the instruction has its own unique label. If the backEnd is using + in-line literals then the literal is unique anyway and this is equivalent to MoveCw:R:" + <inline: true> + <returnTypeC: #'AbstractInstruction *'> + ^self gen: MoveCwR uniqueLiteral: wordConstant operand: reg! Item was changed: ----- Method: Cogit>>cogExtendPIC:CaseNMethod:tag:isMNUCase: (in category 'in-line cacheing') ----- cogExtendPIC: cPIC CaseNMethod: caseNMethod tag: caseNTag isMNUCase: isMNUCase "Extend the cPIC with the supplied case. If caseNMethod is cogged dispatch direct to its unchecked entry-point. If caseNMethod is not cogged, jump to the fast interpreter dispatch, and if isMNUCase then dispatch to fast MNU invocation and mark the cPIC as having the MNU case for cache flushing." <var: #cPIC type: #'CogMethod *'> | operand target address size end | "stack allocate the various collections so that they are effectively garbage collected on return." coInterpreter compilationBreak: cPIC selector point: (objectMemory numBytesOf: cPIC selector) isMNUCase: isMNUCase. + self allocateOpcodes: 8 bytecodes: 0. - self allocateOpcodes: 5 bytecodes: 0. literalsManager resetLiterals: 5. methodLabel address: cPIC asUnsignedInteger; dependent: nil. "for pc-relative MoveCw: cPIC R: ClassReg" self assert: (objectRepresentation inlineCacheTagIsYoung: caseNTag) not. "Caller patches to open pic if caseNMethod is young." self assert: (caseNMethod notNil and: [(objectMemory isYoung: caseNMethod) not]). (isMNUCase not and: [coInterpreter methodHasCogMethod: caseNMethod]) ifTrue: [operand := 0. target := (coInterpreter cogMethodOf: caseNMethod) asInteger + cmNoCheckEntryOffset] ifFalse: [operand := caseNMethod. isMNUCase ifTrue: [cPIC cpicHasMNUCase: true. target := cPIC asInteger + (self sizeof: CogMethod)] ifFalse: [target := cPIC asInteger + self picInterpretAbortOffset]]. self CmpCw: caseNTag R: TempReg. + self MoveUniqueCw: operand R: SendNumArgsReg. - self MoveCw: operand R: SendNumArgsReg. self DumpJumpLongZero: target. self MoveCw: cPIC asUnsignedInteger R: ClassReg. self JumpLong: (self cPICMissTrampolineFor: cPIC cmNumArgs). self computeMaximumSizes. address := self addressOfEndOfCase: cPIC cPICNumCases - 1 inCPIC: cPIC. size := self generateInstructionsAt: address. end := self outputInstructionsAt: address. processor flushICacheFrom: cPIC asUnsignedInteger to: cPIC asUnsignedInteger + closedPICSize. cPIC cPICNumCases: cPIC cPICNumCases + 1. ^0! Item was changed: ----- Method: Cogit>>compileCPIC:Case0:Case1Method:tag:isMNUCase:numArgs: (in category 'in-line cacheing') ----- compileCPIC: cPIC Case0: case0CogMethod Case1Method: case1Method tag: case1Tag isMNUCase: isMNUCase numArgs: numArgs "Compile the code for a two-case PIC for case0CogMethod and case1Method,case1Tag. The tag for case0CogMethod is at the send site and so doesn't need to be generated. case1Method may be any of - a Cog method; jump to its unchecked entry-point - a CompiledMethod; jump to the ceInterpretFromPIC trampoline - nil; call ceMNUFromPIC" <var: #cPIC type: #'CogMethod *'> | operand targetEntry jumpNext | <var: #case0CogMethod type: #'CogMethod *'> <var: #targetEntry type: #'void *'> <var: #jumpNext type: #'AbstractInstruction *'> self assert: case1Method notNil. self compilePICAbort: numArgs. self assert: (objectRepresentation inlineCacheTagIsYoung: case1Tag) not. (isMNUCase not and: [coInterpreter methodHasCogMethod: case1Method]) ifTrue: [operand := 0. targetEntry := ((coInterpreter cogMethodOf: case1Method) asInteger + cmNoCheckEntryOffset) asVoidPointer] ifFalse: "We do not scavenge PICs, hence we cannot cache the MNU method if it is in new space." [operand := (case1Method isNil or: [objectMemory isYoungObject: case1Method]) ifTrue: [0] ifFalse: [case1Method]. targetEntry := case1Method isNil ifTrue: [picMNUAbort] ifFalse: [picInterpretAbort]]. jumpNext := self compileCPICEntry. + self MoveUniqueCw: 0 R: SendNumArgsReg. - self MoveCw: 0 R: SendNumArgsReg. self DumpJumpLong: case0CogMethod asInteger + cmNoCheckEntryOffset. endCPICCase0 := self CmpCw: case1Tag R: TempReg. jumpNext jmpTarget: endCPICCase0. + self MoveUniqueCw: operand R: SendNumArgsReg. - self MoveCw: operand R: SendNumArgsReg. self DumpJumpLongZero: (isMNUCase ifTrue: [picMNUAbort] ifFalse: [targetEntry]) asInteger. endCPICCase1 := self MoveCw: cPIC asUnsignedInteger R: ClassReg. self JumpLong: (self cPICMissTrampolineFor: numArgs). ^0 ! Item was changed: ----- Method: Cogit>>compileClosedPICPrototype (in category 'in-line cacheing') ----- compileClosedPICPrototype "Compile the abstract instructions for a full closed PIC used to initialize closedPICSize. The loads into SendNumArgsReg are those for optional method objects which may be used in MNU cases." <inline: true> | numArgs jumpNext | <var: #jumpNext type: #'AbstractInstruction *'> numArgs := 0. self compilePICAbort: numArgs. jumpNext := self compileCPICEntry. + self MoveUniqueCw: 16r5EAF00D R: SendNumArgsReg. - self MoveCw: 16r5EAF00D R: SendNumArgsReg. self DumpJumpLong: methodZoneBase + 16rCA5E10. jumpNext jmpTarget: (endCPICCase0 := self Label). 1 to: numPICCases - 1 do: [:h| self CmpCw: 16rBABE1F15+h R: TempReg. + self MoveUniqueCw: 16rBADA550 + h R: SendNumArgsReg. - self MoveCw: 16rBADA550 + h R: SendNumArgsReg. self DumpJumpLongZero: 16rCA5E10 + (h * 16). h = 1 ifTrue: [endCPICCase1 := self Label]]. self MoveCw: methodLabel address R: ClassReg. self JumpLong: (self cPICMissTrampolineFor: numArgs). ^0! Item was changed: ----- Method: Cogit>>compileMNUCPIC:methodOperand:numArgs: (in category 'in-line cacheing') ----- compileMNUCPIC: cPIC methodOperand: methodOperand numArgs: numArgs "Compile the code for a one-case MNU PIC that calls ceMNUFromPIC for case0Tag The tag for case0 is at the send site and so doesn't need to be generated." <var: #cPIC type: #'CogMethod *'> | jumpNext operand | <var: #jumpNext type: #'AbstractInstruction *'> self compilePICAbort: numArgs. jumpNext := self compileCPICEntry. "We do not scavenge PICs, hence we cannot cache the MNU method if it is in new space." operand := (methodOperand isNil or: [objectMemory isYoungObject: methodOperand]) ifTrue: [0] ifFalse: [methodOperand]. + self MoveUniqueCw: operand R: SendNumArgsReg. - self MoveCw: operand R: SendNumArgsReg. self DumpJumpLong: picMNUAbort asInteger. jumpNext jmpTarget: (self MoveCw: cPIC asUnsignedInteger R: ClassReg). self JumpLong: (self cPICMissTrampolineFor: numArgs). ^0 ! Item was added: + ----- Method: Cogit>>gen:uniqueLiteral:operand: (in category 'compile abstract instructions') ----- + gen: opcode "<Integer>" uniqueLiteral: operandOne "<Integer>" operand: operandTwo "<Integer|CogAbstractInstruction>" + "Literals are constants that either represent objects on the heap that may get updated by + the garbage collector, or pc-relative spans that may get changed by code compaction, and + must hence always be encoded in a form that allows updating to refer to a different value." + <inline: true> + <returnTypeC: #'AbstractInstruction *'> + <var: #abstractInstruction type: #'AbstractInstruction *'> + ^literalsManager + uniqueLiteral: operandOne + forInstruction: (self gen: opcode operand: operandOne operand: operandTwo)! Item was added: + ----- Method: InLineLiteralsManager>>uniqueLiteral:forInstruction: (in category 'compile abstract instructions') ----- + uniqueLiteral: literal forInstruction: anInstruction + <var: #anInstruction type: #'AbstractInstruction *'> + <returnTypeC: #'AbstractInstruction *'> + <inline: true> + ^anInstruction! Item was added: + ----- Method: OutOfLineLiteralsManager>>allocateLiteral: (in category 'compile abstract instructions') ----- + allocateLiteral: aLiteral + "Allocate a n unsharable Literal instruction for the literal and answer it." + <returnTypeC: #'AbstractInstruction *'> + <inline: true> + | litInst | + <var: 'litInst' type: #'AbstractInstruction *'> + nextLiteralIndex >= literalsSize ifTrue: + [self allocateLiterals: literalsSize + 8]. + litInst := self literalInstructionAt: nextLiteralIndex. + litInst + opcode: Literal; + operand0: aLiteral; + setIsUnique; + setLiteralOpcodeIndex: -1. "means as-yet-unassigned; see literalInstructionInRange:" + nextLiteralIndex := nextLiteralIndex + 1. + "Record the opcodeIndex of the first dependent instructuon (the first instruction that references an out-of-line literal)" + firstOpcodeIndex > cogit getOpcodeIndex ifTrue: + [firstOpcodeIndex := cogit getOpcodeIndex - 1]. + ^litInst! Item was changed: ----- Method: OutOfLineLiteralsManager>>locateLiteral: (in category 'compile abstract instructions') ----- locateLiteral: aLiteral "Search for a Literal instruction that is in-range and answer it. Otherwise allocate a new Literal instruction for the literal and answer it." <returnTypeC: #'AbstractInstruction *'> <inline: false> | litInst | <var: 'litInst' type: #'AbstractInstruction *'> 0 to: nextLiteralIndex - 1 do: [:i| litInst := self literalInstructionAt: i. ((litInst operands at: 0) = aLiteral + and: [litInst isSharable + and: [self literalInstructionInRange: litInst]]) ifTrue: - and: [self literalInstructionInRange: litInst]) ifTrue: [^litInst]]. nextLiteralIndex >= literalsSize ifTrue: [self allocateLiterals: literalsSize + 8]. litInst := self literalInstructionAt: nextLiteralIndex. litInst opcode: Literal; operand0: aLiteral; setLiteralOpcodeIndex: -1. "means as-yet-unassigned; see literalInstructionInRange:" nextLiteralIndex := nextLiteralIndex + 1. "Record the opcodeIndex of the first dependent instructuon (the first instruction that references an out-of-line literal)" firstOpcodeIndex > cogit getOpcodeIndex ifTrue: [firstOpcodeIndex := cogit getOpcodeIndex - 1]. ^litInst! Item was added: + ----- Method: OutOfLineLiteralsManager>>uniqueLiteral:forInstruction: (in category 'compile abstract instructions') ----- + uniqueLiteral: literal forInstruction: anInstruction + <var: #anInstruction type: #'AbstractInstruction *'> + <returnTypeC: #'AbstractInstruction *'> + <inline: true> + self assert: anInstruction usesOutOfLineLiteral. + anInstruction dependent: (self allocateLiteral: literal). + ^anInstruction! Item was changed: ----- Method: SimpleStackBasedCogit>>genQuickReturnConst (in category 'primitive generators') ----- genQuickReturnConst <api> "because selected by CoInterpreter>>quickPrimitiveGeneratorFor:" | constant | constant := coInterpreter quickPrimitiveConstantFor: primitiveIndex. self annotate: + ((objectRepresentation isImmediate: constant) + ifTrue: [self MoveCq: constant R: ReceiverResultReg] + ifFalse: [self MoveCw: constant R: ReceiverResultReg]) - (self gen: ((objectRepresentation isImmediate: constant) - ifTrue: [MoveCqR] - ifFalse: [MoveCwR]) - operand: constant - operand: ReceiverResultReg) objRef: constant. ^self genUpArrowReturn! Item was changed: ----- Method: SimpleStackBasedCogit>>genSend:numArgs:sendTable: (in category 'bytecode generator support') ----- genSend: selector numArgs: numArgs sendTable: sendTable <inline: false> <var: #sendTable type: #'sqInt *'> | annotation | (objectMemory isYoung: selector) ifTrue: [hasYoungReferent := true]. self assert: needsFrame. annotation := self annotationForSendTable: sendTable. self assert: (numArgs between: 0 and: 255). "say" self assert: (objectMemory addressCouldBeOop: selector). self MoveMw: numArgs * objectMemory wordSize r: SPReg R: ReceiverResultReg. "Deal with stale super sends; see SpurMemoryManager's class comment." (self annotationIsForUncheckedEntryPoint: annotation) ifTrue: [objectRepresentation genEnsureOopInRegNotForwarded: ReceiverResultReg scratchReg: TempReg]. "0 through (NumSendTrampolines - 2) numArgs sends have the arg count implciti in the trampoline. The last send trampoline (NumSendTrampolines - 1) passes numArgs in SendNumArgsReg." numArgs >= (NumSendTrampolines - 1) ifTrue: [self MoveCq: numArgs R: SendNumArgsReg]. (BytecodeSetHasDirectedSuperSend and: [annotation = IsDirectedSuperSend]) ifTrue: [self genMoveConstant: tempOop R: TempReg]. + self MoveUniqueCw: selector R: ClassReg. - self MoveCw: selector R: ClassReg. (self Call: (sendTable at: (numArgs min: NumSendTrampolines - 1))) annotation: annotation. self PushR: ReceiverResultReg. ^0! Item was changed: ----- Method: SimpleStackBasedCogit>>genSendAbsentImplicitOrOuter:numArgs:depth:sendTable: (in category 'bytecode generators') ----- genSendAbsentImplicitOrOuter: selector numArgs: numArgs depth: depth sendTable: sendTable <var: #sendTable type: #'sqInt *'> | nsSendCache | (objectMemory isYoung: selector) ifTrue: [hasYoungReferent := true]. nsSendCache := theIRCs + (NumOopsPerNSC * objectMemory bytesPerOop * indexOfIRC). indexOfIRC := indexOfIRC + 1. self assert: (objectMemory isInOldSpace: nsSendCache). self initializeNSSendCache: nsSendCache selector: selector numArgs: numArgs depth: depth. "This leaves the method receiver on the stack, which might not be the implicit receiver. But the lookup trampoline will establish the on-stack receiver once it locates it." self marshallAbsentReceiverSendArguments: numArgs. "Load the cache last so it is a fixed distance from the call." + self MoveUniqueCw: nsSendCache R: SendNumArgsReg. - self MoveCw: nsSendCache R: SendNumArgsReg. self CallNewspeakSend: (sendTable at: (numArgs min: NumSendTrampolines - 1)). self PushR: ReceiverResultReg. ^0! Item was changed: ----- Method: StackToRegisterMappingCogit>>genMarshalledSend:numArgs:sendTable: (in category 'bytecode generator support') ----- genMarshalledSend: selector numArgs: numArgs sendTable: sendTable <inline: false> <var: #sendTable type: #'sqInt *'> | annotation | (objectMemory isYoung: selector) ifTrue: [hasYoungReferent := true]. self assert: needsFrame. annotation := self annotationForSendTable: sendTable. "Deal with stale super sends; see SpurMemoryManager's class comment." (self annotationIsForUncheckedEntryPoint: annotation) ifTrue: [objectRepresentation genEnsureOopInRegNotForwarded: ReceiverResultReg scratchReg: TempReg]. "0 through (NumSendTrampolines - 2) numArgs sends have the arg count implciti in the trampoline. The last send trampoline (NumSendTrampolines - 1) passes numArgs in SendNumArgsReg." numArgs >= (NumSendTrampolines - 1) ifTrue: [self MoveCq: numArgs R: SendNumArgsReg]. (BytecodeSetHasDirectedSuperSend and: [annotation = IsDirectedSuperSend]) ifTrue: [self genMoveConstant: tempOop R: TempReg]. + self MoveUniqueCw: selector R: ClassReg. - self MoveCw: selector R: ClassReg. (self Call: (sendTable at: (numArgs min: NumSendTrampolines - 1))) annotation: annotation. optStatus isReceiverResultRegLive: false. ^self ssPushRegister: ReceiverResultReg! Item was changed: ----- Method: StackToRegisterMappingCogit>>genSendAbsentImplicitOrOuter:numArgs:depth:sendTable: (in category 'bytecode generators') ----- genSendAbsentImplicitOrOuter: selector numArgs: numArgs depth: depth sendTable: sendTable <var: #sendTable type: #'sqInt *'> | nsSendCache | (objectMemory isYoung: selector) ifTrue: [hasYoungReferent := true]. nsSendCache := theIRCs + (NumOopsPerNSC * objectMemory bytesPerOop * indexOfIRC). indexOfIRC := indexOfIRC + 1. self assert: (objectMemory isInOldSpace: nsSendCache). self initializeNSSendCache: nsSendCache selector: selector numArgs: numArgs depth: depth. self ssAllocateCallReg: SendNumArgsReg. "This may leave the method receiver on the stack, which might not be the implicit receiver. But the lookup trampoline will establish an on-stack receiver once it locates it." self marshallAbsentReceiverSendArguments: numArgs. "Load the cache last so it is a fixed distance from the call." + self MoveUniqueCw: nsSendCache R: SendNumArgsReg. - self MoveCw: nsSendCache R: SendNumArgsReg. self CallNewspeakSend: (sendTable at: (numArgs min: NumSendTrampolines - 1)). optStatus isReceiverResultRegLive: false. self ssPushRegister: ReceiverResultReg. ^0!

1 0

VM Maker: VMMaker.oscog-eem.1346.mcz
by commits＠source.squeak.org 11 Jun '15

11 Jun '15

Eliot Miranda uploaded a new version of VMMaker to project VM Maker: http://source.squeak.org/VMMaker/VMMaker.oscog-eem.1346.mcz ==================== Summary ==================== Name: VMMaker.oscog-eem.1346 Author: eem Time: 10 June 2015, 6:11:01.157 pm UUID: 899ace24-f7ff-42f5-9652-f95e532a1bb8 Ancestors: VMMaker.oscog-eem.1345 Cogit: Move annotations into instructions, where they sit more naturally anyway. But doing so makes it trivial to move annotations from the instructions referencing out-of-line literals to the literals themselves. Hence nuke CogInstructionAnnotation. Update usesOutOfLineLiteral to reflect the changes in computeMaximumSizes & dispatchConcretize to be accurate in identifying insttructions that use oolls =============== Diff against VMMaker.oscog-eem.1345 =============== Item was changed: ----- Method: CogARMCompiler class>>filteredInstVarNames (in category 'translation') ----- filteredInstVarNames "Edit such that conditionOrNil is amongst the char size vars opcode machineCodeSize and maxSize." ^(super filteredInstVarNames copyWithout: 'conditionOrNil') + copyReplaceFrom: 5 to: 4 with: #('conditionOrNil')! - copyReplaceFrom: 4 to: 3 with: #('conditionOrNil')! Item was removed: - ----- Method: CogARMCompiler class>>instVarNamesAndTypesForTranslationDo: (in category 'translation') ----- - instVarNamesAndTypesForTranslationDo: aBinaryBlock - "enumerate aBinaryBlock with the names and C type strings for the inst vars to include in an AbstractInstruction struct." - "{CogAbstractInstruction. CogIA32Compiler. CogARMCompiler} do: - [:c| Transcript print: c; cr. c printTypedefOn: Transcript]" - (self filteredInstVarNames copyWithout: 'machineCode'), #('machineCode') do: - [:ivn| - ivn ~= 'bcpc' ifTrue: - [aBinaryBlock - value: ivn - value: (ivn caseOf: { - ['address'] -> [#'unsigned long']. - ['machineCode'] -> [{#'unsigned long'. '[', self basicNew machineCodeWords printString, ']'}]. - ['operands'] -> [{#'unsigned long'. '[', NumOperands, ']'}]. - ['dependent'] -> ['struct _AbstractInstruction *']} - otherwise: - [#'unsigned char'])]]! Item was added: + ----- Method: CogARMCompiler class>>machineCodeDeclaration (in category 'translation') ----- + machineCodeDeclaration + "Answer the declaration for the machineCode array." + ^{#'unsigned long'. '[', self basicNew machineCodeWords printString, ']'}! Item was changed: ----- Method: CogARMCompiler>>computeMaximumSize (in category 'generate machine code') ----- computeMaximumSize "Because we don't use Thumb, each ARM instruction has 4 bytes. Many abstract opcodes need more than one instruction. Instructions that refer to constants and/or literals depend on literals being stored in-line or out-of-line. N.B. The ^N forms are to get around the bytecode compiler's long branch limits which are exceeded when each case jumps around the otherwise." opcode caseOf: { "Noops & Pseudo Ops" [Label] -> [^0]. [Literal] -> [^4]. [AlignmentNops] -> [^(operands at: 0) - 4]. [Fill16] -> [^4]. [Fill32] -> [^4]. [FillFromWord] -> [^4]. [Nop] -> [^4]. "Control" [Call] -> [^4]. [CallFull] -> [^self literalLoadInstructionBytes + 4]. [JumpR] -> [^4]. [Jump] -> [^4]. [JumpFull] -> [^self literalLoadInstructionBytes + 4]. [JumpLong] -> [^4]. [JumpZero] -> [^4]. [JumpNonZero] -> [^4]. [JumpNegative] -> [^4]. [JumpNonNegative] -> [^4]. [JumpOverflow] -> [^4]. [JumpNoOverflow] -> [^4]. [JumpCarry] -> [^4]. [JumpNoCarry] -> [^4]. [JumpLess] -> [^4]. [JumpGreaterOrEqual] -> [^4]. [JumpGreater] -> [^4]. [JumpLessOrEqual] -> [^4]. [JumpBelow] -> [^4]. [JumpAboveOrEqual] -> [^4]. [JumpAbove] -> [^4]. [JumpBelowOrEqual] -> [^4]. [JumpLongZero] -> [^4]. [JumpLongNonZero] -> [^4]. [JumpFPEqual] -> [^8]. [JumpFPNotEqual] -> [^8]. [JumpFPLess] -> [^8]. [JumpFPGreaterOrEqual]-> [^8]. [JumpFPGreater] -> [^8]. [JumpFPLessOrEqual] -> [^8]. [JumpFPOrdered] -> [^8]. [JumpFPUnordered] -> [^8]. [RetN] -> [^(operands at: 0) = 0 ifTrue: [4] ifFalse: [8]]. [Stop] -> [^4]. "Arithmetic" [AddCqR] -> [^self rotateable8bitSignedImmediate: (operands at: 0) ifTrue: [:r :i :n| 4] ifFalse: [self literalLoadInstructionBytes + 4]]. [AndCqR] -> [^self rotateable8bitBitwiseImmediate: (operands at: 0) ifTrue: [:r :i :n| 4] ifFalse: [self literalLoadInstructionBytes = 4 ifTrue: [8] ifFalse: [1 << (operands at: 0) highBit = ((operands at: 0) + 1) ifTrue: [8] ifFalse: [self literalLoadInstructionBytes + 4]]]]. [AndCqRR] -> [^self rotateable8bitBitwiseImmediate: (operands at: 0) ifTrue: [:r :i :n| 4] ifFalse: [self literalLoadInstructionBytes = 4 ifTrue: [8] ifFalse: [1 << (operands at: 0) highBit = ((operands at: 0) + 1) ifTrue: [8] ifFalse: [self literalLoadInstructionBytes + 4]]]]. [CmpCqR] -> [^self rotateable8bitSignedImmediate: (operands at: 0) ifTrue: [:r :i :n| 4] ifFalse: [self literalLoadInstructionBytes + 4]]. [OrCqR] -> [^self rotateable8bitImmediate: (operands at: 0) ifTrue: [:r :i| 4] ifFalse: [self literalLoadInstructionBytes + 4]]. [SubCqR] -> [^self rotateable8bitSignedImmediate: (operands at: 0) ifTrue: [:r :i :n| 4] ifFalse: [self literalLoadInstructionBytes + 4]]. [TstCqR] -> [^self rotateable8bitImmediate: (operands at: 0) ifTrue: [:r :i| 4] ifFalse: [self literalLoadInstructionBytes + 4]]. [XorCqR] -> [^self rotateable8bitBitwiseImmediate: (operands at: 0) ifTrue: [:r :i :n| 4] ifFalse: [self literalLoadInstructionBytes = 4 ifTrue: [8] ifFalse: [1 << (operands at: 0) highBit = ((operands at: 0) + 1) ifTrue: [8] ifFalse: [self literalLoadInstructionBytes + 4]]]]. [AddCwR] -> [^self literalLoadInstructionBytes + 4]. [AndCwR] -> [^self literalLoadInstructionBytes + 4]. [CmpCwR] -> [^self literalLoadInstructionBytes + 4]. [OrCwR] -> [^self literalLoadInstructionBytes + 4]. [SubCwR] -> [^self literalLoadInstructionBytes + 4]. [XorCwR] -> [^self literalLoadInstructionBytes + 4]. [AddRR] -> [^4]. [AndRR] -> [^4]. [CmpRR] -> [^4]. [OrRR] -> [^4]. [XorRR] -> [^4]. [SubRR] -> [^4]. [NegateR] -> [^4]. [LoadEffectiveAddressMwrR] -> [^self rotateable8bitImmediate: (operands at: 0) ifTrue: [:r :i| 4] ifFalse: [self literalLoadInstructionBytes + 4]]. [LogicalShiftLeftCqR] -> [^4]. [LogicalShiftRightCqR] -> [^4]. [ArithmeticShiftRightCqR] -> [^4]. [LogicalShiftLeftRR] -> [^4]. [LogicalShiftRightRR] -> [^4]. [ArithmeticShiftRightRR] -> [^4]. [AddRdRd] -> [^4]. [CmpRdRd] -> [^4]. [SubRdRd] -> [^4]. [MulRdRd] -> [^4]. [DivRdRd] -> [^4]. [SqrtRd] -> [^4]. "ARM Specific Arithmetic" [SMULL] -> [^4]. [MSR] -> [^4]. [CMPSMULL] -> [^4]. "special compare for genMulR:R: usage" "Data Movement" [MoveCqR] -> [^self literalLoadInstructionBytes = 4 ifTrue: [self literalLoadInstructionBytes] ifFalse: + [self rotateable8bitBitwiseImmediate: (operands at: 0) + ifTrue: [:r :i :n| 4] + ifFalse: [self literalLoadInstructionBytes]]]. - [self rotateable8bitImmediate: (operands at: 0) - ifTrue: [:r :i| 4] - ifFalse: - [| val invVal | - invVal := (val := operands at: 0) < 0 ifTrue: [-1 - val] ifFalse: [val bitInvert32]. - self rotateable8bitImmediate: invVal - ifTrue: [:r :i| 4] - ifFalse: [self literalLoadInstructionBytes]]]]. [MoveCwR] -> [^self literalLoadInstructionBytes = 4 ifTrue: [self literalLoadInstructionBytes] ifFalse: [((self isAnInstruction: (operands at: 0)) "i.e. a label, which by definition will be in the current compilation." or: [cogit addressIsInCurrentCompilation: (operands at: 0)]) ifTrue: [4] ifFalse: [self literalLoadInstructionBytes]]]. [MoveRR] -> [^4]. [MoveRdRd] -> [^4]. [MoveAwR] -> [^(self isAddressRelativeToVarBase: (operands at: 0)) ifTrue: [4] ifFalse: [self literalLoadInstructionBytes + 4]]. [MoveRAw] -> [^(self isAddressRelativeToVarBase: (operands at: 1)) ifTrue: [4] ifFalse: [self literalLoadInstructionBytes + 4]]. [MoveRMwr] -> [^self is12BitValue: (operands at: 1) ifTrue: [:u :i| 4] ifFalse: [self literalLoadInstructionBytes + 4]]. [MoveRdM64r] -> [^self literalLoadInstructionBytes + 4]. [MoveMbrR] -> [^self is12BitValue: (operands at: 0) ifTrue: [:u :i| 4] ifFalse: [self literalLoadInstructionBytes + 4]]. [MoveRMbr] -> [^self is12BitValue: (operands at: 1) ifTrue: [:u :i| 4] ifFalse: [self literalLoadInstructionBytes + 4]]. [MoveM16rR] -> [^self rotateable8bitImmediate: (operands at: 0) ifTrue: [:r :i| 4] ifFalse: [self literalLoadInstructionBytes + 4]]. [MoveM64rRd] -> [^self literalLoadInstructionBytes + 4]. [MoveMwrR] -> [^self is12BitValue: (operands at: 0) ifTrue: [:u :i| 4] ifFalse: [self literalLoadInstructionBytes + 4]]. [MoveXbrRR] -> [^4]. [MoveRXbrR] -> [^4]. [MoveXwrRR] -> [^4]. [MoveRXwrR] -> [^4]. [PopR] -> [^4]. [PushR] -> [^4]. [PushCw] -> [^self literalLoadInstructionBytes = 4 ifTrue: [self literalLoadInstructionBytes + 4] ifFalse: [((self isAnInstruction: (operands at: 0)) "i.e. a label, which by definition will be in the current compilation." or: [cogit addressIsInCurrentCompilation: (operands at: 0)]) ifTrue: [8] ifFalse: [self literalLoadInstructionBytes + 4]]]. [PushCq] -> [^self literalLoadInstructionBytes = 4 ifTrue: [self literalLoadInstructionBytes + 4] ifFalse: + [self rotateable8bitBitwiseImmediate: (operands at: 0) + ifTrue: [:r :i :n| 8] + ifFalse: [self literalLoadInstructionBytes + 4]]]. - [self rotateable8bitImmediate: (operands at: 0) - ifTrue: [:r :i| 8] - ifFalse: - [| val invVal | - invVal := (val := operands at: 0) < 0 ifTrue: [-1 - val] ifFalse: [val bitInvert32]. - self rotateable8bitImmediate: invVal - ifTrue: [:r :i| 8] - ifFalse: [self literalLoadInstructionBytes + 4]]]]. [PrefetchAw] -> [^(self isAddressRelativeToVarBase: (operands at: 0)) ifTrue: [4] ifFalse: [self literalLoadInstructionBytes + 4]]. "Conversion" [ConvertRRd] -> [^4]. }. ^0 "to keep C compiler quiet" ! Item was changed: ----- Method: CogARMCompiler>>concretizePushCq (in category 'generate machine code - concretize') ----- concretizePushCq "Will get inlined into concretizeAt: switch." <inline: true> + | word instrOffset | - | word instrOffset| word := operands at: 0. self + rotateable8bitBitwiseImmediate: word + ifTrue: + [:rot :immediate :invert| + self machineCodeAt: 0 + put: (invert + ifTrue: [self mvn: ConcreteIPReg imm: immediate ror: rot] + ifFalse: [self mov: ConcreteIPReg imm: immediate ror: rot]). - rotateable8bitImmediate: word - ifTrue: [:rot :immediate | - self machineCodeAt: 0 put: (self mov: ConcreteIPReg imm: immediate ror: rot). instrOffset := 4] + ifFalse: + [instrOffset := self moveCw: word intoR: ConcreteIPReg]. - ifFalse:[|invVal| - word <0 - ifTrue:[invVal := -1 - word] - ifFalse:[invVal := word bitInvert32]. - self rotateable8bitImmediate: invVal - ifTrue: [ :rot :immediate | - self machineCodeAt: 0 put: (self mvn: ConcreteIPReg imm: immediate ror: rot). - instrOffset := 4] - ifFalse: [instrOffset := self moveCw: word intoR: ConcreteIPReg]]. self machineCodeAt: instrOffset put: (self pushR: ConcreteIPReg). ^machineCodeSize := instrOffset + 4! Item was changed: VMStructType subclass: #CogAbstractInstruction + instanceVariableNames: 'opcode machineCodeSize maxSize annotation machineCode operands address dependent cogit objectMemory bcpc' - instanceVariableNames: 'opcode machineCodeSize maxSize machineCode operands address dependent cogit objectMemory bcpc' classVariableNames: 'NumOperands' poolDictionaries: 'CogCompilationConstants CogRTLOpcodes' category: 'VMMaker-JIT'! !CogAbstractInstruction commentStamp: 'eem 4/21/2015 09:12' prior: 0! I am an abstract instruction generated by the Cogit. I am subsequently concretized to machine code for the current processor. A sequence of concretized CogAbstractInstructions are concatenated to form the code for a CogMethod. I am an abstract class. My concrete subclasses concretize to the machine code of a specific processor. Instance Variables address: <Integer> bcpc: <Integer> cogit: <Cogit> dependent: <AbstractInstruction|nil> machineCode: <CArray on: (ByteArray|Array)> machineCodeSize: <Integer> maxSize: <Integer> objectMemory: <NewCoObjectMemory|SpurCoMemoryManager etc> opcode: <Integer> operands: <CArray on: Array> address - the address at which the instruction will be generated bcpc - the bytecode pc for which the instruction was generated; simulation only cogit - the Cogit assembling the receiver; simulation only dependent - a reference to another instruction which depends on the receiver, if any; in C this is a pointer machineCode - the array of machine code the receiver generates when concretized machineCodeSize - the size of machineCode in bytes maxSize - the maximum size of machine code that the current instruction will generate, in bytes objectMemory - the memory manager for the system; simulation only opcode - the opcode for the receiver which defines which abstract opcode it represents; see CogRTLOpcodes class>>initialize and CogAbstractInstruction subclass initialize methods operands - the array containing any operands the instruction may have; the opcode defines implicitly how many operands are consdered! Item was changed: ----- Method: CogAbstractInstruction class>>instVarNamesAndTypesForTranslationDo: (in category 'translation') ----- instVarNamesAndTypesForTranslationDo: aBinaryBlock "enumerate aBinaryBlock with the names and C type strings for the inst vars to include in an AbstractInstruction struct." "{CogAbstractInstruction. CogIA32Compiler. CogARMCompiler} do: [:c| Transcript print: c; cr. c printTypedefOn: Transcript]" - | machineCodeBytes | - machineCodeBytes := self == CogAbstractInstruction - ifTrue: [0] - ifFalse: [self basicNew machineCodeBytes]. (self filteredInstVarNames copyWithout: 'machineCode'), #('machineCode') do: [:ivn| ivn ~= 'bcpc' ifTrue: [aBinaryBlock value: ivn value: (ivn caseOf: { ['address'] -> [#'unsigned long']. + ['machineCode'] -> [self machineCodeDeclaration]. - ['machineCode'] -> [{#'unsigned char'. '[', machineCodeBytes printString, ']'}]. ['operands'] -> [{#'unsigned long'. '[', NumOperands, ']'}]. ['dependent'] -> ['struct _AbstractInstruction *']} otherwise: [#'unsigned char'])]]! Item was added: + ----- Method: CogAbstractInstruction class>>machineCodeDeclaration (in category 'translation') ----- + machineCodeDeclaration + "Answer a dummy declaration. Subclasses will override to provgide the real one." + ^#(#'unsigned char' '[4]')! Item was added: + ----- Method: CogAbstractInstruction>>annotation (in category 'accessing') ----- + annotation + ^annotation! Item was added: + ----- Method: CogAbstractInstruction>>annotation: (in category 'accessing') ----- + annotation: aByte + ^annotation := aByte! Item was added: + ----- Method: CogIA32Compiler class>>machineCodeDeclaration (in category 'translation') ----- + machineCodeDeclaration + "Answer the declaration for the machineCode array." + ^{#'unsigned char'. '[', self basicNew machineCodeBytes printString, ']'}! Item was removed: - VMStructType subclass: #CogInstructionAnnotation - instanceVariableNames: 'annotation instruction' - classVariableNames: '' - poolDictionaries: '' - category: 'VMMaker-JIT'! - - !CogInstructionAnnotation commentStamp: '<historical>' prior: 0! - I am an annotation for a specific generated instruction. I add information such as "this is an instruction corresponding to a bytecode pc", "this is an instruction containing an object reference", etc.! Item was removed: - ----- Method: CogInstructionAnnotation class>>byteSizeForSimulator: (in category 'simulation only') ----- - byteSizeForSimulator: aVMClass - "Answer an approximation of the byte size of an AbstractInstruction struct. - This is for estimating the alloca in allocateOpcodes:bytecodes:ifFail:" - ^self instSize * (aVMClass sizeof: #'void *')! Item was removed: - ----- Method: CogInstructionAnnotation class>>instVarNamesAndTypesForTranslationDo: (in category 'translation') ----- - instVarNamesAndTypesForTranslationDo: aBinaryBlock - "enumerate aBinaryBlock with the names and C type strings for the inst vars to include in a CogInstructionAnnotation struct." - - self allInstVarNames do: - [:ivn| - aBinaryBlock - value: ivn - value: (ivn = 'instruction' - ifTrue: [#'AbstractInstruction *'] - ifFalse: [#sqInt])]! Item was removed: - ----- Method: CogInstructionAnnotation class>>structTypeName (in category 'translation') ----- - structTypeName - ^self name allButFirst: 3 "Drop initial Cog"! Item was removed: - ----- Method: CogInstructionAnnotation>>annotation (in category 'accessing') ----- - annotation - "Answer the value of annotation" - - ^ annotation! Item was removed: - ----- Method: CogInstructionAnnotation>>annotation: (in category 'accessing') ----- - annotation: anObject - "Set the value of annotation" - - annotation := anObject! Item was removed: - ----- Method: CogInstructionAnnotation>>instruction (in category 'accessing') ----- - instruction - "Answer the value of instruction" - <returnTypeC: #'AbstractInstruction *'> - ^instruction! Item was removed: - ----- Method: CogInstructionAnnotation>>instruction: (in category 'accessing') ----- - instruction: anObject - "Set the value of instruction" - - instruction := anObject! Item was removed: - ----- Method: CogInstructionAnnotation>>printStateOn: (in category 'printing') ----- - printStateOn: aStream - <doNotGenerate> - annotation ifNotNil: - [aStream - space; nextPut: $(; - nextPutAll: (Cogit annotationConstantNames at: annotation + 1); - space; print: instruction; nextPut: $)]! Item was changed: ----- Method: CogOutOfLineLiteralsARMCompiler>>concretizeLiteral (in category 'generate machine code') ----- concretizeLiteral + "Generate an out-of-line literal. Copy the value and any annotation from the stand-in in the literals manager." | literalAsInstruction literal | <var: #jumpTarget type: #'AbstractInstruction *'> literalAsInstruction := cogit cCoerceSimple: (operands at: 0) to: #'AbstractInstruction *'. literal := (self isAnInstruction: literalAsInstruction) ifTrue: [literalAsInstruction address] ifFalse: [self cCode: [literalAsInstruction asUnsignedInteger] inSmalltalk: [literalAsInstruction]]. self assert: (dependent notNil and: [dependent opcode = Literal and: [dependent address = address]]). + dependent annotation ifNotNil: + [self assert: annotation isNil. + annotation := dependent annotation]. self machineCodeAt: 0 put: literal! Item was changed: ----- Method: CogOutOfLineLiteralsARMCompiler>>sizePCDependentInstructionAt: (in category 'generate machine code') ----- sizePCDependentInstructionAt: eventualAbsoluteAddress "Size a jump and set its address. The target may be another instruction or an absolute address. On entry the address inst var holds our virtual address. On exit address is set to eventualAbsoluteAddress, which is where this instruction will be output. The span of a jump to a following instruction is therefore between that instruction's address and this instruction's address ((which are both still their virtual addresses), but the span of a jump to a preceeding instruction or to an absolute address is between that instruction's address (which by now is its eventual absolute address) or absolute address and eventualAbsoluteAddress. + ARM is simple; the 26-bit call/jump range means no short jumps. This + routine only has to determine the targets of jumps, not determine sizes. - ARM is simple; the 26-bit call/jump range means no short jumps. This routine - only has to determine the targets of jumps, not determine sizes." + This version also deals with out-of-line literals. If this is the real literal, + update the stand-in in literalsManager with the address (because instructions + referring to the literal are referring to the stand-in). If this is annotated with + IsObjectReference transfer the annotation to the stand-in, whence it will be + transferred to the real literal, simplifying update of literals." + opcode = AlignmentNops ifTrue: [| alignment | address := eventualAbsoluteAddress. alignment := operands at: 0. ^machineCodeSize := (eventualAbsoluteAddress + (alignment - 1) bitAnd: alignment negated) - eventualAbsoluteAddress]. self assert: (self isJump or: [opcode = Call or: [opcode = CallFull or: [dependent notNil and: [dependent opcode = Literal]]]]). self isJump ifTrue: [self resolveJumpTarget]. address := eventualAbsoluteAddress. + (dependent notNil and: [dependent opcode = Literal]) ifTrue: + [opcode = Literal ifTrue: + [dependent address: address]. + annotation = cogit getIsObjectReference ifTrue: + [dependent annotation: annotation. + annotation := nil]]. - (opcode = Literal and: [dependent notNil and: [dependent opcode = Literal]]) ifTrue: - [dependent address: address]. ^machineCodeSize := maxSize! Item was changed: ----- Method: CogOutOfLineLiteralsARMCompiler>>usesOutOfLineLiteral (in category 'testing') ----- usesOutOfLineLiteral "Answer if the receiver uses an out-of-line literal. Needs only to work for the opcodes created with gen:literal:operand: et al." opcode caseOf: { [CallFull] -> [^true]. [JumpFull] -> [^true]. "Arithmetic" [AddCqR] -> [^self rotateable8bitSignedImmediate: (operands at: 0) ifTrue: [:r :i :n| false] ifFalse: [true]]. + [AndCqR] -> [^self rotateable8bitBitwiseImmediate: (operands at: 0) + ifTrue: [:r :i :n| false] + ifFalse: [1 << (operands at: 0) highBit ~= ((operands at: 0) + 1)]]. + [AndCqRR] -> [^self rotateable8bitBitwiseImmediate: (operands at: 0) + ifTrue: [:r :i :n| false] + ifFalse: [1 << (operands at: 0) highBit ~= ((operands at: 0) + 1)]]. + [CmpCqR] -> [^self rotateable8bitSignedImmediate: (operands at: 0) ifTrue: [:r :i :n| false] ifFalse: [true]]. - [AndCqR] -> [^self rotateable8bitImmediate: (operands at: 0) ifTrue: [:r :i| false] ifFalse: [true]]. - [AndCqRR] -> [^self rotateable8bitImmediate: (operands at: 0) ifTrue: [:r :i| false] ifFalse: [true]]. - [CmpCqR] -> [^self rotateable8bitImmediate: (operands at: 0) ifTrue: [:r :i| false] ifFalse: [true]]. [OrCqR] -> [^self rotateable8bitImmediate: (operands at: 0) ifTrue: [:r :i| false] ifFalse: [true]]. + [SubCqR] -> [^self rotateable8bitSignedImmediate: (operands at: 0) ifTrue: [:r :i :n| false] ifFalse: [true]]. - [SubCqR] -> [^self rotateable8bitImmediate: (operands at: 0) ifTrue: [:r :i| false] ifFalse: [true]]. [TstCqR] -> [^self rotateable8bitImmediate: (operands at: 0) ifTrue: [:r :i| false] ifFalse: [true]]. + [XorCqR] -> [^self rotateable8bitBitwiseImmediate: (operands at: 0) ifTrue: [:r :i :n| false] ifFalse: [true]]. - [XorCqR] -> [^self rotateable8bitImmediate: (operands at: 0) ifTrue: [:r :i| false] ifFalse: [true]]. [AddCwR] -> [^true]. [AndCwR] -> [^true]. [CmpCwR] -> [^true]. [OrCwR] -> [^true]. [SubCwR] -> [^true]. [XorCwR] -> [^true]. [LoadEffectiveAddressMwrR] -> [^self rotateable8bitImmediate: (operands at: 0) ifTrue: [:r :i| false] ifFalse: [true]]. "Data Movement" [MoveCqR] -> [^self rotateable8bitImmediate: (operands at: 0) ifTrue: [:r :i| false] ifFalse: [true]]. [MoveCwR] -> [^((self isAnInstruction: (operands at: 0)) "i.e. a label, which by definition will be in the current compilation." or: [cogit addressIsInCurrentCompilation: (operands at: 0)]) not]. [MoveAwR] -> [^(self isAddressRelativeToVarBase: (operands at: 0)) ifTrue: [false] ifFalse: [true]]. [MoveRAw] -> [^(self isAddressRelativeToVarBase: (operands at: 1)) ifTrue: [false] ifFalse: [true]]. [MoveRMwr] -> [^self is12BitValue: (operands at: 1) ifTrue: [:u :i| false] ifFalse: [true]]. [MoveRdM64r] -> [^self is12BitValue: (operands at: 1) ifTrue: [:u :i| false] ifFalse: [true]]. [MoveMbrR] -> [^self is12BitValue: (operands at: 0) ifTrue: [:u :i| false] ifFalse: [true]]. [MoveRMbr] -> [^self is12BitValue: (operands at: 1) ifTrue: [:u :i| false] ifFalse: [true]]. [MoveM16rR] -> [^self rotateable8bitImmediate: (operands at: 0) ifTrue: [:r :i| false] ifFalse: [true]]. [MoveM64rRd] -> [^self is12BitValue: (operands at: 0) ifTrue: [:u :i| false] ifFalse: [true]]. [MoveMwrR] -> [^self is12BitValue: (operands at: 0) ifTrue: [:u :i| false] ifFalse: [true]]. [PushCw] -> [^((self isAnInstruction: (operands at: 0)) "i.e. a label, which by definiion will be in the current compilation." or: [cogit addressIsInCurrentCompilation: (operands at: 0)]) not]. [PushCq] -> [^self rotateable8bitImmediate: (operands at: 0) ifTrue: [:r :i| false] ifFalse: [true]]. [PrefetchAw] -> [^(self isAddressRelativeToVarBase: (operands at: 0)) ifTrue: [false] ifFalse: [true]]. } otherwise: [self assert: false]. ^false "to keep C compiler quiet" ! Item was changed: CogClass subclass: #Cogit + instanceVariableNames: 'coInterpreter objectMemory objectRepresentation processor threadManager methodZone methodZoneBase codeBase minValidCallAddress lastNInstructions simulatedAddresses simulatedTrampolines simulatedVariableGetters simulatedVariableSetters printRegisters printInstructions compilationTrace clickConfirm breakPC breakBlock singleStep guardPageSize traceFlags traceStores breakMethod methodObj initialPC endPC methodOrBlockNumArgs inBlock needsFrame hasYoungReferent primitiveIndex backEnd literalsManager callerSavedRegMask postCompileHook primInvokeLabel methodLabel stackCheckLabel blockEntryLabel blockEntryNoContextSwitch blockNoContextSwitchOffset stackOverflowCall sendMiss missOffset entryPointMask checkedEntryAlignment uncheckedEntryAlignment cmEntryOffset entry cmNoCheckEntryOffset noCheckEntry picMNUAbort picInterpretAbort endCPICCase0 endCPICCase1 numPICCases firstCPICCaseOffset cPICCaseSize cPICEndSize closedPICSize openPICSize fixups abstractOpcodes generatorTable primitiveGeneratorTable byte0 byte1 byte2 byte3 bytecodePC bytecodeSetOffset opcodeIndex numAbstractOpcodes blockStarts blockCount labelCounter cStackAlignment expectedSPAlignment expectedFPAlignment codeModified maxLitIndex ceMethodAbortTrampoline cePICAbortTrampoline ceCheckForInterruptTrampoline ceCPICMissTrampoline ceReturnToInterpreterTrampoline ceBaseFrameReturnTrampoline ceSendMustBeBooleanAddTrueTrampoline ceSendMustBeBooleanAddFalseTrampoline ceCannotResumeTrampoline ceEnterCogCodePopReceiverReg ceCallCogCodePopReceiverReg ceCallCogCodePopReceiverAndClassRegs cePrimReturnEnterCogCode cePrimReturnEnterCogCodeProfiling ceNonLocalReturnTrampoline ceFetchContextInstVarTrampoline ceStoreContextInstVarTrampoline ceEnclosingObjectTrampoline ceCaptureCStackPointers ceFlushICache ceCheckFeaturesFunction ceTraceLinkedSendTrampoline ceTraceBlockActivationTrampoline ceTraceStoreTrampoline ceGetSP ordinarySendTrampolines superSendTrampolines directedSuperSendTrampolines dynamicSuperSendTrampolines outerSendTrampolines selfSendTrampolines firstSend lastSend realCEEnterCogCodePopReceiverReg realCECallCogCodePopReceiverReg realCECallCogCodePopReceiverAndClassRegs trampolineTableIndex trampolineAddresses objectReferencesInRuntime runtimeObjectRefIndex cFramePointerInUse debugPrimCallStackOffset ceTryLockVMOwner ceUnlockVMOwner cogMethodSurrogateClass cogBlockMethodSurrogateClass extA extB numIRCs indexOfIRC theIRCs implicitReceiverSendTrampolines nsSendCacheSurrogateClass tempOop' - instanceVariableNames: 'coInterpreter objectMemory objectRepresentation processor threadManager methodZone methodZoneBase codeBase minValidCallAddress lastNInstructions simulatedAddresses simulatedTrampolines simulatedVariableGetters simulatedVariableSetters printRegisters printInstructions compilationTrace clickConfirm breakPC breakBlock singleStep guardPageSize traceFlags traceStores breakMethod methodObj initialPC endPC methodOrBlockNumArgs inBlock needsFrame hasYoungReferent primitiveIndex backEnd literalsManager callerSavedRegMask postCompileHook primInvokeLabel methodLabel stackCheckLabel blockEntryLabel blockEntryNoContextSwitch blockNoContextSwitchOffset stackOverflowCall sendMiss missOffset entryPointMask checkedEntryAlignment uncheckedEntryAlignment cmEntryOffset entry cmNoCheckEntryOffset noCheckEntry picMNUAbort picInterpretAbort endCPICCase0 endCPICCase1 numPICCases firstCPICCaseOffset cPICCaseSize cPICEndSize closedPICSize openPICSize fixups abstractOpcodes annotations generatorTable primitiveGeneratorTable byte0 byte1 byte2 byte3 bytecodePC bytecodeSetOffset opcodeIndex numAbstractOpcodes annotationIndex blockStarts blockCount labelCounter cStackAlignment expectedSPAlignment expectedFPAlignment codeModified maxLitIndex ceMethodAbortTrampoline cePICAbortTrampoline ceCheckForInterruptTrampoline ceCPICMissTrampoline ceReturnToInterpreterTrampoline ceBaseFrameReturnTrampoline ceSendMustBeBooleanAddTrueTrampoline ceSendMustBeBooleanAddFalseTrampoline ceCannotResumeTrampoline ceEnterCogCodePopReceiverReg ceCallCogCodePopReceiverReg ceCallCogCodePopReceiverAndClassRegs cePrimReturnEnterCogCode cePrimReturnEnterCogCodeProfiling ceNonLocalReturnTrampoline ceFetchContextInstVarTrampoline ceStoreContextInstVarTrampoline ceEnclosingObjectTrampoline ceCaptureCStackPointers ceFlushICache ceCheckFeaturesFunction ceTraceLinkedSendTrampoline ceTraceBlockActivationTrampoline ceTraceStoreTrampoline ceGetSP ordinarySendTrampolines superSendTrampolines directedSuperSendTrampolines dynamicSuperSendTrampolines outerSendTrampolines selfSendTrampolines firstSend lastSend realCEEnterCogCodePopReceiverReg realCECallCogCodePopReceiverReg realCECallCogCodePopReceiverAndClassRegs trampolineTableIndex trampolineAddresses objectReferencesInRuntime runtimeObjectRefIndex cFramePointerInUse debugPrimCallStackOffset ceTryLockVMOwner ceUnlockVMOwner cogMethodSurrogateClass cogBlockMethodSurrogateClass extA extB numIRCs indexOfIRC theIRCs implicitReceiverSendTrampolines nsSendCacheSurrogateClass tempOop' classVariableNames: 'AltBlockCreationBytecodeSize AltFirstSpecialSelector AltNSSendIsPCAnnotated AnnotationConstantNames AnnotationShift AnnotationsWithBytecodePCs BlockCreationBytecodeSize Debug DisplacementMask DisplacementX2N EagerInstructionDecoration FirstAnnotation FirstSpecialSelector HasBytecodePC IsAbsPCReference IsAnnotationExtension IsDirectedSuperSend IsDisplacementX2N IsNSDynamicSuperSend IsNSImplicitReceiverSend IsNSSelfSend IsNSSendCall IsObjectReference IsRelativeCall IsSendCall IsSuperSend MapEnd MaxCompiledPrimitiveIndex MaxStackAllocSize MaxX2NDisplacement NSCClassTagIndex NSCEnclosingObjectIndex NSCNumArgsIndex NSCSelectorIndex NSCTargetIndex NSSendIsPCAnnotated NumObjRefsInRuntime NumOopsPerNSC NumTrampolines ProcessorClass' poolDictionaries: 'CogCompilationConstants CogMethodConstants CogRTLOpcodes VMBasicConstants VMBytecodeConstants VMObjectIndices VMStackFrameOffsets' category: 'VMMaker-JIT'! Cogit class instanceVariableNames: 'generatorTable primitiveTable'! !Cogit commentStamp: 'eem 4/6/2015 15:56' prior: 0! I am the code generator for the Cog VM. My job is to produce machine code versions of methods for faster execution and to manage inline caches for faster send performance. I can be tested in the current image using my class-side in-image compilation facilities. e.g. try StackToRegisterMappingCogit genAndDis: (Integer >> #benchFib) I have concrete subclasses that implement different levels of optimization: SimpleStackBasedCogit is the simplest code generator. StackToRegisterMappingCogit is the current production code generator It defers pushing operands to the stack until necessary and implements a register-based calling convention for low-arity sends. StackToRegisterMappingCogit is an experimental code generator with support for counting conditional branches, intended to support adaptive optimization. coInterpreter <CoInterpreterSimulator> the VM's interpreter with which I cooperate methodZoneManager <CogMethodZoneManager> the manager of the machine code zone objectRepresentation <CogObjectRepresentation> the object used to generate object accesses processor <BochsIA32Alien|?> the simulator that executes the IA32/x86 machine code I generate when simulating execution in Smalltalk simulatedTrampolines <Dictionary of Integer -> MessageSend> the dictionary mapping trap jump addresses to run-time routines used to warp from simulated machine code in to the Smalltalk run-time. simulatedVariableGetters <Dictionary of Integer -> MessageSend> the dictionary mapping trap read addresses to variables in run-time objects used to allow simulated machine code to read variables in the Smalltalk run-time. simulatedVariableSetters <Dictionary of Integer -> MessageSend> the dictionary mapping trap write addresses to variables in run-time objects used to allow simulated machine code to write variables in the Smalltalk run-time. printRegisters printInstructions clickConfirm <Boolean> flags controlling debug printing and code simulation breakPC <Integer> machine code pc breakpoint cFramePointer cStackPointer <Integer> the variables representing the C stack & frame pointers, which must change on FFI callback and return selectorOop <sqInt> the oop of the methodObj being compiled methodObj <sqInt> the bytecode method being compiled initialPC endPC <Integer> the start and end pcs of the methodObj being compiled methodOrBlockNumArgs <Integer> argument count of current method or block being compiled needsFrame <Boolean> whether methodObj or block needs a frame to execute primitiveIndex <Integer> primitive index of current method being compiled methodLabel <CogAbstractOpcode> label for the method header blockEntryLabel <CogAbstractOpcode> label for the start of the block dispatch code stackOverflowCall <CogAbstractOpcode> label for the call of ceStackOverflow in the method prolog sendMissCall <CogAbstractOpcode> label for the call of ceSICMiss in the method prolog entryOffset <Integer> offset of method entry code from start (header) of method entry <CogAbstractOpcode> label for the first instruction of the method entry code noCheckEntryOffset <Integer> offset of the start of a method proper (after the method entry code) from start (header) of method noCheckEntry <CogAbstractOpcode> label for the first instruction of start of a method proper fixups <Array of <AbstractOpcode Label | nil>> the labels for forward jumps that will be fixed up when reaching the relevant bytecode. fixup shas one element per byte in methodObj's bytecode abstractOpcodes <Array of <AbstractOpcode>> the code generated when compiling methodObj byte0 byte1 byte2 byte3 <Integer> individual bytes of current bytecode being compiled in methodObj bytecodePointer <Integer> bytecode pc (same as Smalltalk) of the current bytecode being compiled opcodeIndex <Integer> the index of the next free entry in abstractOpcodes (this code is translated into C where OrderedCollection et al do not exist) numAbstractOpcodes <Integer> the number of elements in abstractOpcocdes blockStarts <Array of <BlockStart>> the starts of blocks in the current method blockCount the index into blockStarts as they are being noted, and hence eventually the total number of blocks in the current method labelCounter <Integer> a nicety for numbering labels not needed in the production system but probably not expensive enough to worry about ceStackOverflowTrampoline <Integer> ceSend0ArgsTrampoline <Integer> ceSend1ArgsTrampoline <Integer> ceSend2ArgsTrampoline <Integer> ceSendNArgsTrampoline <Integer> ceSendSuper0ArgsTrampoline <Integer> ceSendSuper1ArgsTrampoline <Integer> ceSendSuper2ArgsTrampoline <Integer> ceSendSuperNArgsTrampoline <Integer> ceSICMissTrampoline <Integer> ceCPICMissTrampoline <Integer> ceStoreCheckTrampoline <Integer> ceReturnToInterpreterTrampoline <Integer> ceBaseFrameReturnTrampoline <Integer> ceSendMustBeBooleanTrampoline <Integer> ceClosureCopyTrampoline <Integer> the various trampolines (system-call-like jumps from machine code to the run-time). See Cogit>>generateTrampolines for the mapping from trampoline to run-time routine and then read the run-time routine for a funcitonal description. ceEnterCogCodePopReceiverReg <Integer> the enilopmart (jump from run-time to machine-code) methodZoneBase <Integer> ! Cogit class instanceVariableNames: 'generatorTable primitiveTable'! Item was changed: ----- Method: Cogit class>>ancilliaryClasses: (in category 'translation') ----- ancilliaryClasses: options ProcessorClass ifNil: [Cogit initializeMiscConstants]. ^{ CogMethodZone. CogBlockStart. CogBytecodeDescriptor. CogBytecodeFixup. - CogInstructionAnnotation. CogPrimitiveDescriptor. CogBlockMethod. CogMethod }, (self activeCompilerClass withAllSuperclasses copyUpThrough: CogAbstractInstruction), ((options at: #NewspeakVM ifAbsent: [false]) ifTrue: [{NewspeakCogMethod. NSSendCache}] ifFalse: [#()])! Item was changed: ----- Method: Cogit>>allocateOpcodes:bytecodes: (in category 'initialization') ----- allocateOpcodes: numberOfAbstractOpcodes bytecodes: numberOfBytecodes "Allocate the various arrays needed to compile abstract instructions. This needs to be a macro since the arrays are alloca'ed (stack allocated) to ensure their being freed when compilation is done. Notionally we only need as many fixups as there are bytecodes. But we reuse fixups to record pc-dependent instructions in generateInstructionsAt: and so need at least as many as there are abstract opcodes. N.B. We do one single alloca to save embarrassing C optimizers that generate incorrect code as both gcc and the intel compiler do on x86." <cmacro: '(numberOfAbstractOpcodes,numberOfBytecodes) do { \ int opcodeSize = sizeof(AbstractInstruction) * (numAbstractOpcodes = (numberOfAbstractOpcodes)); \ int fixupSize = sizeof(BytecodeFixup) * numAbstractOpcodes; \ + abstractOpcodes = alloca(opcodeSize + fixupSize); \ - int annotationSize = sizeof(InstructionAnnotation) * ((numAbstractOpcodes + 3) / 4); \ - abstractOpcodes = alloca(opcodeSize + fixupSize + annotationSize); \ bzero(abstractOpcodes, opcodeSize + fixupSize); \ fixups = (void *)((char *)abstractOpcodes + opcodeSize); \ + opcodeIndex = labelCounter = 0; \ - annotations = (void *)((char *)fixups + fixupSize); \ - opcodeIndex = labelCounter = annotationIndex = 0; \ } while (0)'> numAbstractOpcodes := numberOfAbstractOpcodes. abstractOpcodes := CArrayAccessor on: ((1 to: numAbstractOpcodes) collect: [:ign| CogCompilerClass for: self]). fixups := CArrayAccessor on: ((1 to: numAbstractOpcodes) collect: [:ign| self bytecodeFixupClass new]). + opcodeIndex := labelCounter := 0! - annotations := CArrayAccessor on: - ((1 to: numAbstractOpcodes + 3 // 4) collect: - [:ign| CogInstructionAnnotation new]). - opcodeIndex := labelCounter := annotationIndex := 0! Item was changed: ----- Method: Cogit>>allocateOpcodes:bytecodes:ifFail: (in category 'initialization') ----- allocateOpcodes: numberOfAbstractOpcodes bytecodes: numberOfBytecodes ifFail: failBlock "Allocate the various arrays needed to compile abstract instructions. This needs to be a macro since the arrays are alloca'ed (stack allocated) to ensure their being freed when compilation is done. Notionally we only need as many fixups as there are bytecodes. But we reuse fixups to record pc-dependent instructions in generateInstructionsAt: and so need at least as many as there are abstract opcodes. N.B. We do one single alloca to save embarrassing C optimizers that generate incorrect code as both gcc and the intel compiler do on x86." <cmacro: '(numberOfAbstractOpcodes,numberOfBytecodes,failBlock) do { \ int opcodeSize = sizeof(AbstractInstruction) * (numAbstractOpcodes = (numberOfAbstractOpcodes)); \ int fixupSize = sizeof(BytecodeFixup) * numAbstractOpcodes; \ + int allocSize = opcodeSize + fixupSize; \ - int annotationSize = sizeof(InstructionAnnotation) * ((numAbstractOpcodes + 3) / 4); \ - int allocSize = opcodeSize + fixupSize + annotationSize; \ if (allocSize > MaxStackAllocSize) failBlock; \ abstractOpcodes = alloca(allocSize); \ bzero(abstractOpcodes, opcodeSize + fixupSize); \ fixups = (void *)((char *)abstractOpcodes + opcodeSize); \ + opcodeIndex = labelCounter = 0; \ - annotations = (void *)((char *)fixups + fixupSize); \ - opcodeIndex = labelCounter = annotationIndex = 0; \ } while (0)'> + | opcodeSize fixupSize allocSize | - | opcodeSize fixupSize annotationSize allocSize | opcodeSize := (self sizeof: CogAbstractInstruction) * numberOfAbstractOpcodes. fixupSize := (self sizeof: CogBytecodeFixup) * numberOfAbstractOpcodes. + allocSize := opcodeSize + fixupSize. - annotationSize := (self sizeof: CogInstructionAnnotation) * ((numberOfAbstractOpcodes + 3) / 4). - allocSize := opcodeSize + fixupSize + annotationSize. allocSize > MaxStackAllocSize ifTrue: [^failBlock value]. numAbstractOpcodes := numberOfAbstractOpcodes. abstractOpcodes := CArrayAccessor on: ((1 to: numAbstractOpcodes) collect: [:ign| CogCompilerClass for: self]). fixups := CArrayAccessor on: ((1 to: numAbstractOpcodes) collect: [:ign| self bytecodeFixupClass new]). + opcodeIndex := labelCounter := 0! - annotations := CArrayAccessor on: - ((1 to: numAbstractOpcodes + 3 // 4) collect: - [:ign| CogInstructionAnnotation new]). - opcodeIndex := labelCounter := annotationIndex := 0! Item was changed: ----- Method: Cogit>>annotate:objRef: (in category 'method map') ----- annotate: abstractInstruction objRef: anOop <var: #abstractInstruction type: #'AbstractInstruction *'> <returnTypeC: #'AbstractInstruction *'> (objectRepresentation shouldAnnotateObjectReference: anOop) ifTrue: [(objectMemory isYoungObject: anOop) ifTrue: [hasYoungReferent := true]. + abstractInstruction annotation: IsObjectReference]. - ^self annotate: abstractInstruction with: IsObjectReference]. ^abstractInstruction! Item was removed: - ----- Method: Cogit>>annotate:with: (in category 'method map') ----- - annotate: abstractInstruction with: annotationFlag "<Integer>" - <var: #abstractInstruction type: #'AbstractInstruction *'> - <returnTypeC: #'AbstractInstruction *'> - | annotation | - <var: #annotation type: #'InstructionAnnotation *'> - annotation := self addressOf: (annotations at: annotationIndex). - annotationIndex := annotationIndex + 1. - annotation - instruction: abstractInstruction; - annotation: annotationFlag. - ^abstractInstruction! Item was changed: ----- Method: Cogit>>annotateAbsolutePCRef: (in category 'method map') ----- annotateAbsolutePCRef: abstractInstruction <var: #abstractInstruction type: #'AbstractInstruction *'> <returnTypeC: #'AbstractInstruction *'> <inline: true> + abstractInstruction annotation: IsAbsPCReference. + ^abstractInstruction! - ^self annotate: abstractInstruction with: IsAbsPCReference! Item was changed: ----- Method: Cogit>>annotateBytecode: (in category 'method map') ----- annotateBytecode: abstractInstruction <var: #abstractInstruction type: #'AbstractInstruction *'> <returnTypeC: #'AbstractInstruction *'> <inline: true> + abstractInstruction annotation: HasBytecodePC. + ^abstractInstruction! - ^self annotate: abstractInstruction with: HasBytecodePC! Item was changed: ----- Method: Cogit>>annotateCall: (in category 'method map') ----- annotateCall: abstractInstruction <var: #abstractInstruction type: #'AbstractInstruction *'> <returnTypeC: #'AbstractInstruction *'> <inline: true> + abstractInstruction annotation: IsRelativeCall. + ^abstractInstruction! - ^self annotate: abstractInstruction with: IsRelativeCall! Item was changed: ----- Method: Cogit>>annotateNewspeakSend: (in category 'method map') ----- annotateNewspeakSend: abstractInstruction <var: #abstractInstruction type: #'AbstractInstruction *'> <returnTypeC: #'AbstractInstruction *'> <inline: true> + abstractInstruction annotation: IsNSSendCall. + ^abstractInstruction! - ^self annotate: abstractInstruction with: IsNSSendCall! Item was changed: ----- Method: Cogit>>generateMapAt:start: (in category 'method map') ----- generateMapAt: addressOrNull start: startAddress "Generate the method map at addressrNull (or compute it if addressOrNull is null). Answer the length of the map in byes. Each entry in the map is in two parts. In the least signficant bits are a displacement of how far from the start or previous entry, unless it is an IsAnnotationExtension byte, in which case those bits are the extension. In the most signficant bits are the type of annotation at the point reached. A null byte ends the map." | length location | + <var: #instruction type: #'AbstractInstruction *'> - <var: #annotation type: #'InstructionAnnotation *'> length := 0. location := startAddress. + 0 to: opcodeIndex - 1 do: + [:i| | instruction mcpc delta maxDelta mapEntry | + instruction := self abstractInstructionAt: i. + instruction annotation ifNotNil: + [:annotation| + self flag: 'if this is moved into e.g. CogAbstractInstruction>>annotationAddress then e.g. a push const can annotate the lit synth instr, not the reg push'. + mcpc := instruction address + instruction machineCodeSize. + [(delta := mcpc - location / backEnd codeGranularity) > DisplacementMask] whileTrue: + [maxDelta := (delta min: MaxX2NDisplacement) bitClear: DisplacementMask. + self assert: maxDelta >> AnnotationShift <= DisplacementMask. + addressOrNull ifNotNil: + [objectMemory + byteAt: addressOrNull - length + put: maxDelta >> AnnotationShift + DisplacementX2N. + self traceMap: IsDisplacementX2N + instruction: instruction + byte: maxDelta >> AnnotationShift + DisplacementX2N + at: addressOrNull - length + for: mcpc]. + location := location + (maxDelta * backEnd codeGranularity). + length := length + 1]. - 0 to: annotationIndex - 1 do: - [:i| | annotation mcpc delta maxDelta mapEntry | - annotation := self addressOf: (annotations at: i). - mcpc := annotation instruction address + annotation instruction machineCodeSize. - [(delta := mcpc - location / backEnd codeGranularity) > DisplacementMask] whileTrue: - [maxDelta := (delta min: MaxX2NDisplacement) bitClear: DisplacementMask. - self assert: maxDelta >> AnnotationShift <= DisplacementMask. addressOrNull ifNotNil: + [mapEntry := delta + ((annotation min: IsSendCall) << AnnotationShift). - [objectMemory - byteAt: addressOrNull - length - put: maxDelta >> AnnotationShift + DisplacementX2N. - self traceMap: IsDisplacementX2N - byte: maxDelta >> AnnotationShift + DisplacementX2N - at: addressOrNull - length - for: mcpc]. - location := location + (maxDelta * backEnd codeGranularity). - length := length + 1]. - addressOrNull ifNotNil: - [mapEntry := delta + ((annotation annotation min: IsSendCall) << AnnotationShift). - objectMemory byteAt: addressOrNull - length put: mapEntry. - self traceMap: annotation - byte: mapEntry - at: addressOrNull - length - for: mcpc]. - location := location + (delta * backEnd codeGranularity). - length := length + 1. - annotation annotation > IsSendCall ifTrue: "Add the necessary IsAnnotationExtension" - [addressOrNull ifNotNil: - [mapEntry := IsAnnotationExtension << AnnotationShift + (annotation annotation - IsSendCall). objectMemory byteAt: addressOrNull - length put: mapEntry. self traceMap: annotation + instruction: instruction + byte: mapEntry + at: addressOrNull - length + for: mcpc]. + location := location + (delta * backEnd codeGranularity). + length := length + 1. + annotation > IsSendCall ifTrue: "Add the necessary IsAnnotationExtension" + [addressOrNull ifNotNil: + [mapEntry := IsAnnotationExtension << AnnotationShift + (annotation - IsSendCall). + objectMemory byteAt: addressOrNull - length put: mapEntry. + self traceMap: annotation + instruction: instruction + byte: mapEntry + at: addressOrNull - length + for: mcpc]. + length := length + 1]]]. - byte: mapEntry - at: addressOrNull - length - for: mcpc]. - length := length + 1]]. addressOrNull ifNotNil: [objectMemory byteAt: addressOrNull - length put: MapEnd. self traceMap: MapEnd + instruction: nil + byte: MapEnd + at: addressOrNull - length + for: 0]. - byte: MapEnd - at: addressOrNull - length - for: 0]. ^length + 1! Item was added: + ----- Method: Cogit>>getIsObjectReference (in category 'method map') ----- + getIsObjectReference + <cmacro: '() IsObjectReference'> + ^IsObjectReference! Item was changed: ----- Method: Cogit>>recordRunTimeObjectReferences (in category 'initialization') ----- recordRunTimeObjectReferences + <var: #instruction type: #'AbstractInstruction *'> + 0 to: opcodeIndex - 1 do: + [:i| | instruction | + instruction := self abstractInstructionAt: i. + instruction annotation = IsObjectReference ifTrue: - | annotation | - <var: #annotation type: #'InstructionAnnotation *'> - 0 to: annotationIndex - 1 do: - [:i| - annotation := self addressOf: (annotations at: i). - annotation annotation = IsObjectReference ifTrue: [self assert: runtimeObjectRefIndex < NumObjRefsInRuntime. self assert: hasYoungReferent not. hasYoungReferent ifTrue: [self error: 'attempt to generate run-time routine containing young object reference. Cannot initialize Cogit run-time.']. objectReferencesInRuntime at: runtimeObjectRefIndex + put: (instruction address + instruction machineCodeSize) asInteger. + runtimeObjectRefIndex := runtimeObjectRefIndex + 1]]! - put: (annotation instruction address + annotation instruction machineCodeSize) asInteger. - runtimeObjectRefIndex := runtimeObjectRefIndex + 1]]. - annotationIndex := 0! Item was removed: - ----- Method: Cogit>>traceMap:byte:at:for: (in category 'method map') ----- - traceMap: annotation byte: byte at: address for: mcpc - <cmacro: '(ig,no,re,d) 0'> - | s code bytecode | - (compilationTrace anyMask: 16) ifTrue: - [code := annotation isInteger ifTrue: [annotation] ifFalse: [annotation annotation]. - (s := coInterpreter transcript) - ensureCr; - print: code; nextPut: $/; nextPutAll: byte hex; space; - nextPutAll: address hex; space; nextPutAll: mcpc hex; space; - nextPutAll: (AnnotationConstantNames detect: [:name| (Cogit classPool at: name ifAbsent: []) = code]); cr; flush. - (annotation isInteger not - and: [annotation instruction bcpc isInteger]) ifTrue: - [s tab; print: annotation instruction bcpc; nextPut: $/. - annotation instruction bcpc printOn: s base: 16. - s space. - annotation instruction printStateOn: s. - s space. - bytecode := objectMemory fetchByte: annotation instruction bcpc ofObject: methodObj. - bytecode := bytecode + (self bytecodeSetOffsetForHeader: (objectMemory methodHeaderOf: methodObj)). - (self generatorAt: bytecode) printStateOn: s. - s cr; flush]]! Item was added: + ----- Method: Cogit>>traceMap:instruction:byte:at:for: (in category 'method map') ----- + traceMap: annotation instruction: instruction byte: byte at: address for: mcpc + <cmacro: '(ig,no,r,e,d) 0'> + | s bytecode | + (compilationTrace anyMask: 16) ifTrue: + [(s := coInterpreter transcript) + ensureCr; + print: annotation; nextPut: $/; nextPutAll: byte hex; space; + nextPutAll: address hex; space; nextPutAll: mcpc hex; space; + nextPutAll: (AnnotationConstantNames detect: [:name| (Cogit classPool at: name ifAbsent: []) = annotation]); cr; flush. + (instruction notNil + and: [instruction bcpc isInteger]) ifTrue: + [s tab; print: instruction bcpc; nextPut: $/. + instruction bcpc printOn: s base: 16. + s space. + instruction printStateOn: s. + s space. + bytecode := objectMemory fetchByte: instruction bcpc ofObject: methodObj. + bytecode := bytecode + (self bytecodeSetOffsetForHeader: (objectMemory methodHeaderOf: methodObj)). + (self generatorAt: bytecode) printStateOn: s. + s cr; flush]]! Item was changed: ----- Method: SimpleStackBasedCogit>>genSend:numArgs:sendTable: (in category 'bytecode generator support') ----- genSend: selector numArgs: numArgs sendTable: sendTable <inline: false> <var: #sendTable type: #'sqInt *'> | annotation | (objectMemory isYoung: selector) ifTrue: [hasYoungReferent := true]. self assert: needsFrame. annotation := self annotationForSendTable: sendTable. self assert: (numArgs between: 0 and: 255). "say" self assert: (objectMemory addressCouldBeOop: selector). self MoveMw: numArgs * objectMemory wordSize r: SPReg R: ReceiverResultReg. "Deal with stale super sends; see SpurMemoryManager's class comment." (self annotationIsForUncheckedEntryPoint: annotation) ifTrue: [objectRepresentation genEnsureOopInRegNotForwarded: ReceiverResultReg scratchReg: TempReg]. "0 through (NumSendTrampolines - 2) numArgs sends have the arg count implciti in the trampoline. The last send trampoline (NumSendTrampolines - 1) passes numArgs in SendNumArgsReg." numArgs >= (NumSendTrampolines - 1) ifTrue: [self MoveCq: numArgs R: SendNumArgsReg]. (BytecodeSetHasDirectedSuperSend and: [annotation = IsDirectedSuperSend]) ifTrue: [self genMoveConstant: tempOop R: TempReg]. self MoveCw: selector R: ClassReg. + (self Call: (sendTable at: (numArgs min: NumSendTrampolines - 1))) annotation: annotation. - self annotate: (self Call: (sendTable at: (numArgs min: NumSendTrampolines - 1))) - with: annotation. self PushR: ReceiverResultReg. ^0! Item was changed: ----- Method: SistaStackToRegisterMappingCogit>>compileBlockBodies (in category 'compile abstract instructions') ----- compileBlockBodies "override to maintain counterIndex when recompiling blocks; sigh." <inline: false> | result compiledBlocksCount blockStart savedNeedsFrame savedNumArgs savedNumTemps + initialStackPtr initialOpcodeIndex initialCounterIndex initialIndexOfIRC | - initialStackPtr initialOpcodeIndex initialAnnotationIndex initialCounterIndex initialIndexOfIRC | <var: #blockStart type: #'BlockStart *'> self assert: blockCount > 0. "scanBlock: in compileBlockEntry: sets both of these appropriately for each block." savedNeedsFrame := needsFrame. savedNumArgs := methodOrBlockNumArgs. savedNumTemps := methodOrBlockNumTemps. inBlock := true. compiledBlocksCount := 0. [compiledBlocksCount < blockCount] whileTrue: [blockStart := self blockStartAt: compiledBlocksCount. self scanBlock: blockStart. initialOpcodeIndex := opcodeIndex. - initialAnnotationIndex := annotationIndex. initialCounterIndex := counterIndex. self cppIf: #NewspeakVM ifTrue: [initialIndexOfIRC := indexOfIRC]. [self compileBlockEntry: blockStart. initialStackPtr := simStackPtr. (result := self compileAbstractInstructionsFrom: blockStart startpc + (self pushNilSize: methodObj numInitialNils: blockStart numInitialNils) through: blockStart startpc + blockStart span - 1) < 0 ifTrue: [^result]. "If the final simStackPtr is less than the initial simStackPtr then scanBlock: over- estimated the number of initial nils (because it assumed one or more pushNils to produce an operand were pushNils to initialize temps. This is very rare, so + compensate by checking, adjusting numInitialNils and recompiling the block body. + N.B. No need to reinitialize the literalsManager because it answers existing literals." - compensate by checking, adjusting numInitialNils and recompiling the block body." initialStackPtr = simStackPtr] whileFalse: [self assert: initialStackPtr > simStackPtr. blockStart numInitialNils: blockStart numInitialNils + simStackPtr - initialStackPtr. blockStart fakeHeader dependent: nil. self reinitializeFixupsFrom: blockStart startpc + blockStart numInitialNils through: blockStart startpc + blockStart span - 1. self cCode: 'bzero(abstractOpcodes + initialOpcodeIndex, (opcodeIndex - initialOpcodeIndex) * sizeof(AbstractInstruction))' inSmalltalk: [initialOpcodeIndex to: opcodeIndex - 1 do: [:i| abstractOpcodes at: i put: (CogCompilerClass for: self)]]. opcodeIndex := initialOpcodeIndex. - annotationIndex := initialAnnotationIndex. counterIndex := initialCounterIndex. self cppIf: #NewspeakVM ifTrue: [indexOfIRC := initialIndexOfIRC]]. compiledBlocksCount := compiledBlocksCount + 1]. needsFrame := savedNeedsFrame. methodOrBlockNumArgs := savedNumArgs. methodOrBlockNumTemps := savedNumTemps. ^0! Item was changed: ----- Method: StackToRegisterMappingCogit>>compileBlockBodies (in category 'compile abstract instructions') ----- compileBlockBodies <inline: false> | result compiledBlocksCount blockStart savedNeedsFrame savedNumArgs savedNumTemps + initialStackPtr initialOpcodeIndex initialIndexOfIRC | - initialStackPtr initialOpcodeIndex initialAnnotationIndex initialIndexOfIRC | <var: #blockStart type: #'BlockStart *'> self assert: blockCount > 0. "scanBlock: in compileBlockEntry: sets both of these appropriately for each block." savedNeedsFrame := needsFrame. savedNumArgs := methodOrBlockNumArgs. savedNumTemps := methodOrBlockNumTemps. inBlock := true. compiledBlocksCount := 0. [compiledBlocksCount < blockCount] whileTrue: [blockStart := self blockStartAt: compiledBlocksCount. self scanBlock: blockStart. initialOpcodeIndex := opcodeIndex. - initialAnnotationIndex := annotationIndex. self cppIf: #NewspeakVM ifTrue: [initialIndexOfIRC := indexOfIRC]. [self compileBlockEntry: blockStart. initialStackPtr := simStackPtr. (result := self compileAbstractInstructionsFrom: blockStart startpc + (self pushNilSize: methodObj numInitialNils: blockStart numInitialNils) through: blockStart startpc + blockStart span - 1) < 0 ifTrue: [^result]. "If the final simStackPtr is less than the initial simStackPtr then scanBlock: over- estimated the number of initial nils (because it assumed one or more pushNils to produce an operand were pushNils to initialize temps. This is very rare, so + compensate by checking, adjusting numInitialNils and recompiling the block body. + N.B. No need to reinitialize the literalsManager because it answers existing literals." - compensate by checking, adjusting numInitialNils and recompiling the block body." initialStackPtr = simStackPtr] whileFalse: [self assert: initialStackPtr > simStackPtr. blockStart numInitialNils: blockStart numInitialNils + simStackPtr - initialStackPtr. blockStart fakeHeader dependent: nil. self reinitializeFixupsFrom: blockStart startpc + blockStart numInitialNils through: blockStart startpc + blockStart span - 1. self cCode: 'bzero(abstractOpcodes + initialOpcodeIndex, (opcodeIndex - initialOpcodeIndex) * sizeof(AbstractInstruction))' inSmalltalk: [initialOpcodeIndex to: opcodeIndex - 1 do: [:i| abstractOpcodes at: i put: (CogCompilerClass for: self)]]. opcodeIndex := initialOpcodeIndex. - annotationIndex := initialAnnotationIndex. self cppIf: #NewspeakVM ifTrue: [indexOfIRC := initialIndexOfIRC]]. compiledBlocksCount := compiledBlocksCount + 1]. needsFrame := savedNeedsFrame. methodOrBlockNumArgs := savedNumArgs. methodOrBlockNumTemps := savedNumTemps. ^0! Item was changed: ----- Method: StackToRegisterMappingCogit>>genMarshalledSend:numArgs:sendTable: (in category 'bytecode generator support') ----- genMarshalledSend: selector numArgs: numArgs sendTable: sendTable <inline: false> <var: #sendTable type: #'sqInt *'> | annotation | (objectMemory isYoung: selector) ifTrue: [hasYoungReferent := true]. self assert: needsFrame. annotation := self annotationForSendTable: sendTable. "Deal with stale super sends; see SpurMemoryManager's class comment." (self annotationIsForUncheckedEntryPoint: annotation) ifTrue: [objectRepresentation genEnsureOopInRegNotForwarded: ReceiverResultReg scratchReg: TempReg]. "0 through (NumSendTrampolines - 2) numArgs sends have the arg count implciti in the trampoline. The last send trampoline (NumSendTrampolines - 1) passes numArgs in SendNumArgsReg." numArgs >= (NumSendTrampolines - 1) ifTrue: [self MoveCq: numArgs R: SendNumArgsReg]. (BytecodeSetHasDirectedSuperSend and: [annotation = IsDirectedSuperSend]) ifTrue: [self genMoveConstant: tempOop R: TempReg]. self MoveCw: selector R: ClassReg. + (self Call: (sendTable at: (numArgs min: NumSendTrampolines - 1))) annotation: annotation. - self annotate: (self Call: (sendTable at: (numArgs min: NumSendTrampolines - 1))) - with: annotation. optStatus isReceiverResultRegLive: false. ^self ssPushRegister: ReceiverResultReg! Item was changed: ----- Method: StackToRegisterMappingCogit>>prevInstIsPCAnnotated (in category 'testing') ----- prevInstIsPCAnnotated + | prevIndex prevInst | - | annotation prevIndex prevInst | - <var: #annotation type: #'InstructionAnnotation *'> <var: #prevInst type: #'AbstractInstruction *'> + opcodeIndex > 0 ifFalse: - annotationIndex > 0 ifFalse: [^false]. - annotation := self addressOf: (annotations at: annotationIndex - 1). - (self isPCMappedAnnotation: annotation annotation) ifFalse: - [^false]. prevIndex := opcodeIndex - 1. [prevIndex <= 0 ifTrue: [^false]. prevInst := self abstractInstructionAt: prevIndex. + (self isPCMappedAnnotation: (prevInst annotation ifNil: [0])) ifTrue: - annotation instruction = prevInst ifTrue: [^true]. prevInst opcode = Label] whileTrue: [prevIndex := prevIndex - 1]. ^false!

1 0

VM Maker: VMMaker.oscog-eem.1345.mcz
by commits＠source.squeak.org 11 Jun '15

11 Jun '15

Eliot Miranda uploaded a new version of VMMaker to project VM Maker: http://source.squeak.org/VMMaker/VMMaker.oscog-eem.1345.mcz ==================== Summary ==================== Name: VMMaker.oscog-eem.1345 Author: eem Time: 10 June 2015, 4:26:07.813 pm UUID: b1992ade-70ba-4fbd-9b02-c2cb4a119370 Ancestors: VMMaker.oscog-eem.1344 Implement finding the inline cache tag with ARM out-of-line literals. =============== Diff against VMMaker.oscog-eem.1344 =============== Item was added: + ----- Method: CogOutOfLineLiteralsARMCompiler>>inlineCacheTagAt: (in category 'inline cacheing') ----- + inlineCacheTagAt: address + ^objectMemory longAt: (self pcRelativeAddressAt: address - 8)! Item was added: + ----- Method: CogOutOfLineLiteralsARMCompiler>>pcRelativeAddressAt: (in category 'inline cacheing') ----- + pcRelativeAddressAt: address + "Extract the address of the ldr rX, [pc, #NNN] instruction at address" + | inst offset | + inst := objectMemory longAt: address. + self assert: (inst bitAnd: 16rFF5F0000) = (self ldr: 0 rn: PC plus: 0 imm: 0). + offset := inst bitAnd: 16rFFF. + ^address + 8 + ((inst anyMask: 1 << 23) + ifTrue: [offset] + ifFalse: [offset negated])!

1 0

VM Maker: VMMaker.oscog-eem.1344.mcz
by commits＠source.squeak.org 11 Jun '15

11 Jun '15

Eliot Miranda uploaded a new version of VMMaker to project VM Maker: http://source.squeak.org/VMMaker/VMMaker.oscog-eem.1344.mcz ==================== Summary ==================== Name: VMMaker.oscog-eem.1344 Author: eem Time: 10 June 2015, 3:17:31.452 pm UUID: 020ff2e2-0424-44b9-9fde-7bfbe945d1ad Ancestors: VMMaker.oscog-cb.1343 Cogit: Get code generation working for CogOutOfLineLiteralsARMCompiler. Fix initialization of methodLabel in Introduce DumpJumpLong[Zero]: for convenient PIC wirting where the literals need to be dumped in consistent places to keep PIC cases the same size. Fix isAnInstruction for labels (methodLabel) and use it to guard addressIsInCurrentCompilation: calls where a label is involved. For better initialization of literal management use zeroOpcodeIndex everywhere opcodeIndex is initialized, and have it reset literals. And have computeMaximumSizes dump literals. Move the assignment of maxSize out of computeMaximumSize and into computeMaximumSizes for concision. ARM Cogit: Introduce some more abstractions for rotateable constants so that it is easier to relate computeMaximumSize and dispatchConcetize in CogARMCompiler. Provide more opcode names and use them, and use inverseOpcodeFor: to calculate the inverse opcode when the inverse constant is used. Revise ARM getDefaultCogCodeSize given better estimates of relative code sizes. Simplify isPICDependent to eliminate Calls, which are not pc-dependent (ince they always call out of the current compilaiton). Simulator: Safety in instruction printing, and spotting literals in disassembly. Slang: Fix ancilliaryClasses: given the deeper CogAbstractInstruction hierarchy on ARM. =============== Diff against VMMaker.oscog-cb.1343 =============== Item was changed: ----- Method: AbstractInstructionTests>>generateInstructions (in category 'generating machine code') ----- generateInstructions "See Cogit>>computeMaximumSizes, generateInstructionsAt: & outputInstructionsAt:. This is a pure Smalltalk (non-Slang) version of that trio of methods." | address pcDependentInstructions instructions | address := 0. pcDependentInstructions := OrderedCollection new. opcodes do: [:abstractInstruction| + abstractInstruction + address: address; + maxSize: abstractInstruction computeMaximumSize. - abstractInstruction address: address. - abstractInstruction computeMaximumSize. address := address + abstractInstruction maxSize]. address := 0. opcodes do: [:abstractInstruction| abstractInstruction isPCDependent ifTrue: [abstractInstruction sizePCDependentInstructionAt: address. pcDependentInstructions addLast: abstractInstruction. address := address + abstractInstruction machineCodeSize] ifFalse: [address := abstractInstruction concretizeAt: address]]. pcDependentInstructions do: [:abstractInstruction| abstractInstruction concretizeAt: abstractInstruction address]. instructions := ByteArray new: address. address := 0. opcodes do: [:abstractInstruction| self assert: abstractInstruction address = address. 0 to: abstractInstruction machineCodeSize - 1 do: [:j| instructions at: address + 1 put: (abstractInstruction machineCode at: j). address := address + 1]]. ^instructions! Item was changed: CogAbstractInstruction subclass: #CogARMCompiler instanceVariableNames: 'conditionOrNil' + classVariableNames: 'AL AddOpcode AndOpcode BicOpcode CArg0Reg CArg1Reg CArg2Reg CArg3Reg CC CMPSMULL CPSRReg CS CmpNotOpcode CmpOpcode ConcreteIPReg ConcreteVarBaseReg EQ GE GT HI LDMFD LE LR LS LT MI MRS MSR MoveNotOpcode MoveOpcode NE OrOpcode OverflowFlag PC PL R0 R1 R10 R11 R12 R2 R3 R4 R5 R6 R7 R8 R9 RsbOpcode SMLALOpcode SMULL SP STMFD SubOpcode TstOpcode VC VS XorOpcode' - classVariableNames: 'AL AddOpcode AndOpcode BICCqR BicOpcode CArg0Reg CArg1Reg CArg2Reg CArg3Reg CC CMPSMULL CPSRReg CS CmpOpcode ConcreteIPReg ConcreteVarBaseReg EQ GE GT HI LDMFD LE LR LS LT MI MRS MSR MoveNotOpcode MoveOpcode NE OrOpcode OverflowFlag PC PL R0 R1 R10 R11 R12 R2 R3 R4 R5 R6 R7 R8 R9 RsbOpcode SMLALOpcode SMULL SP STMFD SubOpcode TstOpcode VC VS XorOpcode' poolDictionaries: '' category: 'VMMaker-JIT'! !CogARMCompiler commentStamp: 'lw 8/23/2012 19:38' prior: 0! I generate ARM instructions from CogAbstractInstructions. For reference see http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.set.architectur… The Architecture Reference Manual used is that of version 5, which includes some version 6 instructions. Of those, only pld is used(for PrefetchAw). This class does not take any special action to flush the instruction cache on instruction-modification.! Item was changed: ----- Method: CogARMCompiler class>>initialize (in category 'class initialization') ----- initialize "Initialize various ARM instruction-related constants." "CogARMCompiler initialize" | specificOpcodes refs | super initialize. self ~~ CogARMCompiler ifTrue: [^self]. R0 := 0. R1 := 1. R2 := 2. R3 := 3. R4 := 4. R5 := 5. R6 := 6. R7 := 7. R8 := 8. R9 := 9. R10 := 10. R11 := 11. R12 := 12. SP := 13. LR := 14. PC := 15. CArg0Reg := 0. CArg1Reg := 1. CArg2Reg := 2. CArg3Reg := 3. ConcreteVarBaseReg := 10. ConcreteIPReg := 12. "IP, The Intra-Procedure-call scratch register." "Condition Codes. Note that cc=16rF is NOT ALLOWED as a condition; it specifies an extension instruction. See e.g.ARM_ARM v5 DDI01001.pdf A3.2.1" EQ := 0. NE := 1. CS := 2. CC := 3. MI := 4. PL := 5. VS := 6. VC := 7. HI := 8. LS := 9. GE := 10. LT := 11. GT := 12. LE := 13. AL := 14. + "Table A3-2 in sec A3.4 Data-processing instructions of the AARM." AddOpcode := 4. AndOpcode := 0. BicOpcode := 14. CmpOpcode := 10. + CmpNotOpcode := 11. MoveOpcode := 13. MoveNotOpcode := 15. OrOpcode := 12. RsbOpcode := 3. SMLALOpcode := 7. SubOpcode := 2. TstOpcode := 8. XorOpcode := 1. CPSRReg := 16. OverflowFlag := 1 << 28. "Specific instructions" LastRTLCode isNil ifTrue: [CogRTLOpcodes initialize]. specificOpcodes := #(SMULL MSR MRS LDMFD STMFD CMPSMULL). refs := (thisContext method literals select: [:l| l isVariableBinding and: [classPool includesKey: l key]]) collect: [:ea| ea key]. (classPool keys reject: [:k| (specificOpcodes includes: k) or: [refs includes: k]]) do: [:k| Undeclared declare: k from: classPool]. specificOpcodes withIndexDo: [:classVarName :value| self classPool declare: classVarName from: Undeclared; at: classVarName put: value + LastRTLCode - 1]! Item was changed: ----- Method: CogARMCompiler>>bics:rn:imm:ror: (in category 'ARM convenience instructions') ----- bics: destReg rn: srcReg imm: immediate ror: rot "Remember the ROR is doubled by the cpu so use 30>>1 etc BICS destReg, srcReg, #immediate ROR #rot" + ^self type: 1 op: BicOpcode set: 1 rn: srcReg rd: destReg shifterOperand: ((rot>>1) <<8 bitOr: immediate)! - ^self type: 1 op: 14 set: 1 rn: srcReg rd: destReg shifterOperand: ((rot>>1) <<8 bitOr: immediate)! Item was changed: ----- Method: CogARMCompiler>>computeMaximumSize (in category 'generate machine code') ----- computeMaximumSize + "Because we don't use Thumb, each ARM instruction has 4 bytes. Many + abstract opcodes need more than one instruction. Instructions that refer + to constants and/or literals depend on literals being stored in-line or out-of-line. - "Because we don't use Thumb, each ARM instruction has 4 bytes. Many abstract opcodes need more than one instruction. - Instructions that refer to constants and/or literals depend on literals being stored in-line or out-of-line." + N.B. The ^N forms are to get around the bytecode compiler's long branch + limits which are exceeded when each case jumps around the otherwise." + opcode caseOf: { "Noops & Pseudo Ops" + [Label] -> [^0]. + [Literal] -> [^4]. + [AlignmentNops] -> [^(operands at: 0) - 4]. + [Fill16] -> [^4]. + [Fill32] -> [^4]. + [FillFromWord] -> [^4]. + [Nop] -> [^4]. - [Label] -> [^maxSize := 0]. - [Literal] -> [^maxSize := 4]. - [AlignmentNops] -> [^maxSize := (operands at: 0) - 4]. - [Fill16] -> [^maxSize := 4]. - [Fill32] -> [^maxSize := 4]. - [FillFromWord] -> [^maxSize := 4]. - [Nop] -> [^maxSize := 4]. "Control" + [Call] -> [^4]. + [CallFull] -> [^self literalLoadInstructionBytes + 4]. + [JumpR] -> [^4]. + [Jump] -> [^4]. + [JumpFull] -> [^self literalLoadInstructionBytes + 4]. + [JumpLong] -> [^4]. + [JumpZero] -> [^4]. + [JumpNonZero] -> [^4]. + [JumpNegative] -> [^4]. + [JumpNonNegative] -> [^4]. + [JumpOverflow] -> [^4]. + [JumpNoOverflow] -> [^4]. + [JumpCarry] -> [^4]. + [JumpNoCarry] -> [^4]. + [JumpLess] -> [^4]. + [JumpGreaterOrEqual] -> [^4]. + [JumpGreater] -> [^4]. + [JumpLessOrEqual] -> [^4]. + [JumpBelow] -> [^4]. + [JumpAboveOrEqual] -> [^4]. + [JumpAbove] -> [^4]. + [JumpBelowOrEqual] -> [^4]. + [JumpLongZero] -> [^4]. + [JumpLongNonZero] -> [^4]. + [JumpFPEqual] -> [^8]. + [JumpFPNotEqual] -> [^8]. + [JumpFPLess] -> [^8]. + [JumpFPGreaterOrEqual]-> [^8]. + [JumpFPGreater] -> [^8]. + [JumpFPLessOrEqual] -> [^8]. + [JumpFPOrdered] -> [^8]. + [JumpFPUnordered] -> [^8]. + [RetN] -> [^(operands at: 0) = 0 ifTrue: [4] ifFalse: [8]]. + [Stop] -> [^4]. - [Call] -> [^maxSize := 4]. - [CallFull] -> [^maxSize := self literalLoadInstructionBytes + 4]. - [JumpR] -> [^maxSize := 4]. - [Jump] -> [^maxSize := 4]. - [JumpFull] -> [^maxSize := self literalLoadInstructionBytes + 4]. - [JumpLong] -> [^maxSize := 4]. - [JumpZero] -> [^maxSize := 4]. - [JumpNonZero] -> [^maxSize := 4]. - [JumpNegative] -> [^maxSize := 4]. - [JumpNonNegative] -> [^maxSize := 4]. - [JumpOverflow] -> [^maxSize := 4]. - [JumpNoOverflow] -> [^maxSize := 4]. - [JumpCarry] -> [^maxSize := 4]. - [JumpNoCarry] -> [^maxSize := 4]. - [JumpLess] -> [^maxSize := 4]. - [JumpGreaterOrEqual] -> [^maxSize := 4]. - [JumpGreater] -> [^maxSize := 4]. - [JumpLessOrEqual] -> [^maxSize := 4]. - [JumpBelow] -> [^maxSize := 4]. - [JumpAboveOrEqual] -> [^maxSize := 4]. - [JumpAbove] -> [^maxSize := 4]. - [JumpBelowOrEqual] -> [^maxSize := 4]. - [JumpLongZero] -> [^maxSize := 4]. - [JumpLongNonZero] -> [^maxSize := 4]. - [JumpFPEqual] -> [^maxSize := 8]. - [JumpFPNotEqual] -> [^maxSize := 8]. - [JumpFPLess] -> [^maxSize := 8]. - [JumpFPGreaterOrEqual]-> [^maxSize := 8]. - [JumpFPGreater] -> [^maxSize := 8]. - [JumpFPLessOrEqual] -> [^maxSize := 8]. - [JumpFPOrdered] -> [^maxSize := 8]. - [JumpFPUnordered] -> [^maxSize := 8]. - [RetN] -> [^maxSize := (operands at: 0) = 0 ifTrue: [4] ifFalse: [8]]. - [Stop] -> [^maxSize := 4]. "Arithmetic" + [AddCqR] -> [^self rotateable8bitSignedImmediate: (operands at: 0) + ifTrue: [:r :i :n| 4] + ifFalse: [self literalLoadInstructionBytes + 4]]. + [AndCqR] -> [^self rotateable8bitBitwiseImmediate: (operands at: 0) + ifTrue: [:r :i :n| 4] + ifFalse: + [self literalLoadInstructionBytes = 4 + ifTrue: [8] + ifFalse: + [1 << (operands at: 0) highBit = ((operands at: 0) + 1) + ifTrue: [8] + ifFalse: [self literalLoadInstructionBytes + 4]]]]. + [AndCqRR] -> [^self rotateable8bitBitwiseImmediate: (operands at: 0) + ifTrue: [:r :i :n| 4] + ifFalse: + [self literalLoadInstructionBytes = 4 + ifTrue: [8] + ifFalse: + [1 << (operands at: 0) highBit = ((operands at: 0) + 1) + ifTrue: [8] + ifFalse: [self literalLoadInstructionBytes + 4]]]]. + [CmpCqR] -> [^self rotateable8bitSignedImmediate: (operands at: 0) + ifTrue: [:r :i :n| 4] + ifFalse: [self literalLoadInstructionBytes + 4]]. - [AddCqR] -> [^self rotateable8bitImmediate: (operands at: 0) - ifTrue: [:r :i| maxSize := 4] - ifFalse: - [self rotateable8bitImmediate: (operands at: 0) negated - ifTrue: [:r :i| maxSize := 4] - ifFalse: [maxSize := self literalLoadInstructionBytes + 4]]]. - [AndCqR] -> [^self rotateable8bitImmediate: (operands at: 0) - ifTrue: [:r :i| maxSize := 4] - ifFalse: [maxSize := self literalLoadInstructionBytes + 4]]. - [AndCqRR] -> [^self rotateable8bitImmediate: (operands at: 0) - ifTrue: [:r :i| maxSize := 4] - ifFalse: - [| val invVal | - invVal := (val := operands at: 0) < 0 ifTrue: [-1 - val] ifFalse: [val bitInvert32]. - self rotateable8bitImmediate: invVal - ifTrue: [:r :i| maxSize := 4] - ifFalse: [maxSize := self literalLoadInstructionBytes + 4]]]. - [CmpCqR] -> [^self rotateable8bitImmediate: (operands at: 0) - ifTrue: [:r :i| maxSize := 4] - ifFalse: [maxSize := self literalLoadInstructionBytes + 4]]. [OrCqR] -> [^self rotateable8bitImmediate: (operands at: 0) + ifTrue: [:r :i| 4] + ifFalse: [self literalLoadInstructionBytes + 4]]. + [SubCqR] -> [^self rotateable8bitSignedImmediate: (operands at: 0) + ifTrue: [:r :i :n| 4] + ifFalse: [self literalLoadInstructionBytes + 4]]. - ifTrue: [:r :i| maxSize := 4] - ifFalse: [maxSize := self literalLoadInstructionBytes + 4]]. - [SubCqR] -> [^self rotateable8bitImmediate: (operands at: 0) - ifTrue: [:r :i| maxSize := 4] - ifFalse: - [self rotateable8bitImmediate: (operands at: 0) negated - ifTrue: [:r :i| maxSize := 4] - ifFalse: [maxSize := self literalLoadInstructionBytes + 4]]]. [TstCqR] -> [^self rotateable8bitImmediate: (operands at: 0) + ifTrue: [:r :i| 4] + ifFalse: [self literalLoadInstructionBytes + 4]]. + [XorCqR] -> [^self rotateable8bitBitwiseImmediate: (operands at: 0) + ifTrue: [:r :i :n| 4] + ifFalse: + [self literalLoadInstructionBytes = 4 + ifTrue: [8] + ifFalse: + [1 << (operands at: 0) highBit = ((operands at: 0) + 1) + ifTrue: [8] + ifFalse: [self literalLoadInstructionBytes + 4]]]]. + [AddCwR] -> [^self literalLoadInstructionBytes + 4]. + [AndCwR] -> [^self literalLoadInstructionBytes + 4]. + [CmpCwR] -> [^self literalLoadInstructionBytes + 4]. + [OrCwR] -> [^self literalLoadInstructionBytes + 4]. + [SubCwR] -> [^self literalLoadInstructionBytes + 4]. + [XorCwR] -> [^self literalLoadInstructionBytes + 4]. + [AddRR] -> [^4]. + [AndRR] -> [^4]. + [CmpRR] -> [^4]. + [OrRR] -> [^4]. + [XorRR] -> [^4]. + [SubRR] -> [^4]. + [NegateR] -> [^4]. - ifTrue: [:r :i| maxSize := 4] - ifFalse: [maxSize := self literalLoadInstructionBytes + 4]]. - [XorCqR] -> [^self rotateable8bitImmediate: (operands at: 0) - ifTrue: [:r :i| maxSize := 4] - ifFalse: [maxSize := self literalLoadInstructionBytes + 4]]. - [AddCwR] -> [^maxSize := self literalLoadInstructionBytes + 4]. - [AndCwR] -> [^maxSize := self literalLoadInstructionBytes + 4]. - [CmpCwR] -> [^maxSize := self literalLoadInstructionBytes + 4]. - [OrCwR] -> [^maxSize := self literalLoadInstructionBytes + 4]. - [SubCwR] -> [^maxSize := self literalLoadInstructionBytes + 4]. - [XorCwR] -> [^maxSize := self literalLoadInstructionBytes + 4]. - [AddRR] -> [^maxSize := 4]. - [AndRR] -> [^maxSize := 4]. - [CmpRR] -> [^maxSize := 4]. - [OrRR] -> [^maxSize := 4]. - [XorRR] -> [^maxSize := 4]. - [SubRR] -> [^maxSize := 4]. - [NegateR] -> [^maxSize := 4]. [LoadEffectiveAddressMwrR] -> [^self rotateable8bitImmediate: (operands at: 0) + ifTrue: [:r :i| 4] + ifFalse: [self literalLoadInstructionBytes + 4]]. - ifTrue: [:r :i| maxSize := 4] - ifFalse: [maxSize := self literalLoadInstructionBytes + 4]]. + [LogicalShiftLeftCqR] -> [^4]. + [LogicalShiftRightCqR] -> [^4]. + [ArithmeticShiftRightCqR] -> [^4]. + [LogicalShiftLeftRR] -> [^4]. + [LogicalShiftRightRR] -> [^4]. + [ArithmeticShiftRightRR] -> [^4]. + [AddRdRd] -> [^4]. + [CmpRdRd] -> [^4]. + [SubRdRd] -> [^4]. + [MulRdRd] -> [^4]. + [DivRdRd] -> [^4]. + [SqrtRd] -> [^4]. - [LogicalShiftLeftCqR] -> [^maxSize := 4]. - [LogicalShiftRightCqR] -> [^maxSize := 4]. - [ArithmeticShiftRightCqR] -> [^maxSize := 4]. - [LogicalShiftLeftRR] -> [^maxSize := 4]. - [LogicalShiftRightRR] -> [^maxSize := 4]. - [ArithmeticShiftRightRR] -> [^maxSize := 4]. - [AddRdRd] -> [^maxSize := 4]. - [CmpRdRd] -> [^maxSize := 4]. - [SubRdRd] -> [^maxSize := 4]. - [MulRdRd] -> [^maxSize := 4]. - [DivRdRd] -> [^maxSize := 4]. - [SqrtRd] -> [^maxSize := 4]. "ARM Specific Arithmetic" + [SMULL] -> [^4]. + [MSR] -> [^4]. + [CMPSMULL] -> [^4]. "special compare for genMulR:R: usage" - [SMULL] -> [^maxSize := 4]. - [MSR] -> [^maxSize := 4]. - [CMPSMULL] -> [^maxSize := 4]. "special compare for genMulR:R: usage" "Data Movement" [MoveCqR] -> [^self literalLoadInstructionBytes = 4 + ifTrue: [self literalLoadInstructionBytes] - ifTrue: [maxSize := self literalLoadInstructionBytes] ifFalse: [self rotateable8bitImmediate: (operands at: 0) + ifTrue: [:r :i| 4] - ifTrue: [:r :i| maxSize := 4] ifFalse: [| val invVal | invVal := (val := operands at: 0) < 0 ifTrue: [-1 - val] ifFalse: [val bitInvert32]. self rotateable8bitImmediate: invVal + ifTrue: [:r :i| 4] + ifFalse: [self literalLoadInstructionBytes]]]]. + [MoveCwR] -> [^self literalLoadInstructionBytes = 4 + ifTrue: [self literalLoadInstructionBytes] + ifFalse: + [((self isAnInstruction: (operands at: 0)) "i.e. a label, which by definition will be in the current compilation." + or: [cogit addressIsInCurrentCompilation: (operands at: 0)]) + ifTrue: [4] + ifFalse: [self literalLoadInstructionBytes]]]. + [MoveRR] -> [^4]. + [MoveRdRd] -> [^4]. + [MoveAwR] -> [^(self isAddressRelativeToVarBase: (operands at: 0)) - ifTrue: [:r :i| maxSize := 4] - ifFalse: [maxSize := self literalLoadInstructionBytes]]]]. - [MoveCwR] -> [^maxSize := self literalLoadInstructionBytes]. - [MoveRR] -> [^maxSize := 4]. - [MoveRdRd] -> [^maxSize := 4]. - [MoveAwR] -> [^maxSize := (self isAddressRelativeToVarBase: (operands at: 0)) ifTrue: [4] ifFalse: [self literalLoadInstructionBytes + 4]]. + [MoveRAw] -> [^(self isAddressRelativeToVarBase: (operands at: 1)) - [MoveRAw] -> [^maxSize := (self isAddressRelativeToVarBase: (operands at: 1)) ifTrue: [4] ifFalse: [self literalLoadInstructionBytes + 4]]. [MoveRMwr] -> [^self is12BitValue: (operands at: 1) + ifTrue: [:u :i| 4] + ifFalse: [self literalLoadInstructionBytes + 4]]. + [MoveRdM64r] -> [^self literalLoadInstructionBytes + 4]. - ifTrue: [:u :i| maxSize := 4] - ifFalse: [maxSize := self literalLoadInstructionBytes + 4]]. - [MoveRdM64r] -> [^maxSize := self literalLoadInstructionBytes + 4]. [MoveMbrR] -> [^self is12BitValue: (operands at: 0) + ifTrue: [:u :i| 4] + ifFalse: [self literalLoadInstructionBytes + 4]]. - ifTrue: [:u :i| maxSize := 4] - ifFalse: [maxSize := self literalLoadInstructionBytes + 4]]. [MoveRMbr] -> [^self is12BitValue: (operands at: 1) + ifTrue: [:u :i| 4] + ifFalse: [self literalLoadInstructionBytes + 4]]. - ifTrue: [:u :i| maxSize := 4] - ifFalse: [maxSize := self literalLoadInstructionBytes + 4]]. [MoveM16rR] -> [^self rotateable8bitImmediate: (operands at: 0) + ifTrue: [:r :i| 4] + ifFalse: [self literalLoadInstructionBytes + 4]]. + [MoveM64rRd] -> [^self literalLoadInstructionBytes + 4]. - ifTrue: [:r :i| maxSize := 4] - ifFalse: [maxSize := self literalLoadInstructionBytes + 4]]. - [MoveM64rRd] -> [^maxSize := self literalLoadInstructionBytes + 4]. [MoveMwrR] -> [^self is12BitValue: (operands at: 0) + ifTrue: [:u :i| 4] + ifFalse: [self literalLoadInstructionBytes + 4]]. + [MoveXbrRR] -> [^4]. + [MoveRXbrR] -> [^4]. + [MoveXwrRR] -> [^4]. + [MoveRXwrR] -> [^4]. + [PopR] -> [^4]. + [PushR] -> [^4]. + [PushCw] -> [^self literalLoadInstructionBytes = 4 + ifTrue: [self literalLoadInstructionBytes + 4] + ifFalse: + [((self isAnInstruction: (operands at: 0)) "i.e. a label, which by definition will be in the current compilation." + or: [cogit addressIsInCurrentCompilation: (operands at: 0)]) + ifTrue: [8] + ifFalse: [self literalLoadInstructionBytes + 4]]]. - ifTrue: [:u :i| maxSize := 4] - ifFalse: [maxSize := self literalLoadInstructionBytes + 4]]. - [MoveXbrRR] -> [^maxSize := 4]. - [MoveRXbrR] -> [^maxSize := 4]. - [MoveXwrRR] -> [^maxSize := 4]. - [MoveRXwrR] -> [^maxSize := 4]. - [PopR] -> [^maxSize := 4]. - [PushR] -> [^maxSize := 4]. - [PushCw] -> [^maxSize := self literalLoadInstructionBytes + 4]. [PushCq] -> [^self literalLoadInstructionBytes = 4 + ifTrue: [self literalLoadInstructionBytes + 4] - ifTrue: [maxSize := self literalLoadInstructionBytes + 4] ifFalse: [self rotateable8bitImmediate: (operands at: 0) + ifTrue: [:r :i| 8] - ifTrue: [:r :i| maxSize := 8] ifFalse: [| val invVal | invVal := (val := operands at: 0) < 0 ifTrue: [-1 - val] ifFalse: [val bitInvert32]. self rotateable8bitImmediate: invVal + ifTrue: [:r :i| 8] + ifFalse: [self literalLoadInstructionBytes + 4]]]]. + [PrefetchAw] -> [^(self isAddressRelativeToVarBase: (operands at: 0)) + ifTrue: [4] + ifFalse: [self literalLoadInstructionBytes + 4]]. - ifTrue: [:r :i| maxSize := 8] - ifFalse: [maxSize := self literalLoadInstructionBytes + 4]]]]. - [PrefetchAw] -> [^maxSize := (self isAddressRelativeToVarBase: (operands at: 1)) - ifTrue: [4] - ifFalse: [self literalLoadInstructionBytes + 4]]. "Conversion" + [ConvertRRd] -> [^4]. - [ConvertRRd] -> [^maxSize := 4]. }. ^0 "to keep C compiler quiet" ! Item was removed: - ----- Method: CogARMCompiler>>concretizeAddCqR (in category 'generate machine code - concretize') ----- - concretizeAddCqR - "Will get inlined into concretizeAt: switch." - "Try whether the quick constant is a small negative number. If it is, optimize." - <inline: true> - self rotateable8bitImmediate: (operands at: 0) - 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 rotateable8bitImmediate: (operands at: 0) negated - 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: [^self concretizeDataOperationCwR: AddOpcode]]. - ^0 "to keep Slang happy"! Item was removed: - ----- Method: CogARMCompiler>>concretizeAndCqR (in category 'generate machine code - concretize') ----- - concretizeAndCqR - "Will get inlined into concretizeAt: switch." - "AND is very important since it's used to mask all sorts of flags in the jit. We take special care to try to find fast ways to make the masks" - <inline: true> - |val| - val := operands at: 0. - self rotateable8bitImmediate: val - ifTrue: [ :rot :immediate | | reg | - reg := self concreteRegister: (operands at: 1). - self machineCodeAt: 0 put: (self ands: reg rn: reg imm: immediate ror: rot). - ^machineCodeSize := 4] - ifFalse: [ - "see if the constant bit-inverted makes a quick value and if so BIC it instead - If the value is -ve, we 2s complement it instead" - |invVal| - val <0 - ifTrue:[invVal := -1 - val] - ifFalse:[invVal := val bitInvert32]. - self rotateable8bitImmediate: invVal - ifTrue: [ :rot :immediate | |reg| - reg := self concreteRegister: (operands at: 1). - self machineCodeAt: 0 put: (self bics: reg rn: reg imm: immediate ror: rot). - ^machineCodeSize := 4] - ifFalse: ["let's try to see if the constant can be made from a simple shift of 0xFFFFFFFF" - |hb reg| - reg := self concreteRegister: (operands at: 1). - hb := (operands at: 0) highBit. - 1 << hb = (val +1) - ifTrue: [ "MVN temp reg, 0, making 0xffffffff" - self machineCodeAt: 0 put:(self mvn: ConcreteIPReg imm: 0 ror: 0). - "Then AND reg, temp reg, lsr #(32-hb)" - self machineCodeAt: 4 put:(self dataOpType: AndOpcode rd: reg rn: reg rm: ConcreteIPReg lsr: (32-hb )). - ^machineCodeSize :=8] - ifFalse: [^self concretizeDataOperationCwR: AndOpcode]]]. - ^0 "to keep Slang happy"! Item was changed: ----- Method: CogARMCompiler>>concretizeAndCqRR (in category 'generate machine code - concretize') ----- concretizeAndCqRR "Will get inlined into concretizeAt: switch." + "AND is very important since it's used to mask all sorts of flags in the jit. We take special care to try to find compact ways to make the masks" - "AND is very important since it's used to mask all sorts of flags in the jit. We take special care to try to find fast ways to make the masks" <inline: true> | val srcReg dstReg | val := operands at: 0. srcReg := self concreteRegister: (operands at: 1). dstReg := self concreteRegister: (operands at: 2). + self rotateable8bitBitwiseImmediate: val - self rotateable8bitImmediate: val ifTrue: + [:rot :immediate :invert| + self machineCodeAt: 0 put: (invert + ifTrue: [self bics: dstReg rn: srcReg imm: immediate ror: rot] + ifFalse: [self ands: dstReg rn: srcReg imm: immediate ror: rot]). - [ :rot :immediate | - self machineCodeAt: 0 put: (self ands: dstReg rn: srcReg imm: immediate ror: rot). ^machineCodeSize := 4] + ifFalse: "let's try to see if the constant can be made from a simple shift of 0xFFFFFFFF" + [| hb | + hb := (operands at: 0) highBit. + 1 << hb = (val +1) + ifTrue: "MVN temp reg, 0, making 0xffffffff" + [self machineCodeAt: 0 put:(self mvn: ConcreteIPReg imm: 0 ror: 0). + "Then AND reg, temp reg, lsr #(32-hb)" + self machineCodeAt: 4 put: (self dataOpType: AndOpcode rd: dstReg rn: srcReg rm: ConcreteIPReg lsr: 32 - hb). + ^machineCodeSize := 8] + ifFalse: + [^self concretizeDataOperationCwR: AndOpcode]]. - ifFalse: - ["see if the constant bit-inverted makes a quick value and if so BIC it instead - If the value is -ve, we 2s complement it instead" - |invVal| - invVal := val < 0 - ifTrue:[-1 - val] - ifFalse:[val bitInvert32]. - self rotateable8bitImmediate: invVal - ifTrue: - [ :rot :immediate | - self machineCodeAt: 0 put: (self bics: dstReg rn: srcReg imm: immediate ror: rot). - ^machineCodeSize := 4] - ifFalse: "let's try to see if the constant can be made from a simple shift of 0xFFFFFFFF" - [| hb | - hb := (operands at: 0) highBit. - 1 << hb = (val +1) - ifTrue: "MVN temp reg, 0, making 0xffffffff" - [self machineCodeAt: 0 put:(self mvn: ConcreteIPReg imm: 0 ror: 0). - "Then AND reg, temp reg, lsr #(32-hb)" - self machineCodeAt: 4 put: (self dataOpType: AndOpcode rd: dstReg rn: srcReg rm: ConcreteIPReg lsr: 32 - hb). - ^machineCodeSize := 8] - ifFalse: - [^self concretizeDataOperationCwR: AndOpcode]]]. ^0 "to keep Slang happy"! Item was added: + ----- Method: CogARMCompiler>>concretizeInvertibleDataOperationCqR: (in category 'generate machine code - concretize') ----- + concretizeInvertibleDataOperationCqR: armOpcode + "Will get inlined into concretizeAt: switch." + "Xor == 1, And == 0, Or == 12, Bic == 14" + <inline: true> + | val rn | + val := operands at: 0. + rn := self concreteRegister: (operands at: 1). + self deny: opcode = CmpOpcode. + + self rotateable8bitBitwiseImmediate: val + ifTrue: + [:rot :immediate : invert| + self machineCodeAt: 0 + put: (self + type: 1 + op: (invert ifTrue: [self inverseOpcodeFor: armOpcode] ifFalse: [armOpcode]) + set: 1 + rn: rn + rd: rn + shifterOperand: (rot >> 1"in this usage we have to halve the rot value" << 8 bitOr: immediate)). + ^machineCodeSize := 4] + ifFalse: "let's try to see if the constant can be made from a simple shift of 0xFFFFFFFF" + [val > 0 ifTrue: + [| hb | + hb := val highBit. + 1 << hb = (val +1) ifTrue: "MVN temp, #0, making 0xffffffff" + [self machineCodeAt: 0 put: (self mvn: ConcreteIPReg imm: 0 ror: 0). + "Then armOpcode reg, temp reg, lsr #(32-hb)" + self machineCodeAt: 4 put: (self dataOpType: armOpcode rd: rn rn: rn rm: ConcreteIPReg lsr: 32 - hb). + ^machineCodeSize := 8]]. + ^self concretizeDataOperationCwR: armOpcode]. + ^0 "to keep Slang happy"! Item was added: + ----- Method: CogARMCompiler>>concretizeNegateableDataOperationCqR: (in category 'generate machine code - concretize') ----- + concretizeNegateableDataOperationCqR: armOpcode + "Will get inlined into concretizeAt: switch." + "4 == Add, 2 == Sub, 10 = Cmp" + <inline: true> + | val rd rn | + val := operands at: 0. + rn := self concreteRegister: (operands at: 1). + "Extra note - if ever a version of this code wants to NOT set the Set flag + - Cmp must always have it set or it will pretend to be a SMALALBT and Very Bad Things might happen." + rd := opcode = CmpOpcode ifTrue: [0] ifFalse: [rn]. + + self rotateable8bitSignedImmediate: val + ifTrue: + [:rot :immediate : negate| + self machineCodeAt: 0 + put: (self + type: 1 + op: (negate ifTrue: [self inverseOpcodeFor: armOpcode] ifFalse: [armOpcode]) + set: 1 + rn: rn + rd: rd + shifterOperand: (rot >> 1"in this usage we have to halve the rot value" << 8 bitOr: immediate)). + ^machineCodeSize := 4] + ifFalse: "let's try to see if the constant can be made from a simple shift of 0xFFFFFFFF" + [val > 0 ifTrue: + [| hb | + hb := val highBit. + 1 << hb = (val +1) ifTrue: "MVN temp, #0, making 0xffffffff" + [self machineCodeAt: 0 put:(self mvn: ConcreteIPReg imm: 0 ror: 0). + "Then armOpcode reg, temp reg, lsr #(32-hb)" + self machineCodeAt: 4 put:(self dataOpType: armOpcode rd: rd rn: rn rm: ConcreteIPReg lsr: 32 - hb). + ^machineCodeSize := 8]]. + ^self concretizeDataOperationCwR: armOpcode]. + ^0 "to keep Slang happy"! Item was changed: ----- Method: CogARMCompiler>>dispatchConcretize (in category 'generate machine code') ----- dispatchConcretize "Attempt to generate concrete machine code for the instruction at address. This is the inner dispatch of concretizeAt: actualAddress which exists only to get around the branch size limits in the SqueakV3 (blue book derived) bytecode set." <returnTypeC: #void> conditionOrNil ifNotNil: [self concretizeConditionalInstruction. ^self]. opcode caseOf: { "Noops & Pseudo Ops" [Label] -> [^self concretizeLabel]. [Literal] -> [^self concretizeLiteral]. [AlignmentNops] -> [^self concretizeAlignmentNops]. [Fill16] -> [^self concretizeFill16]. [Fill32] -> [^self concretizeFill32]. [FillFromWord] -> [^self concretizeFillFromWord]. [Nop] -> [^self concretizeNop]. "Control" [Call] -> [^self concretizeCall]. "call code within code space" [CallFull] -> [^self concretizeCallFull]. "call code anywhere in address space" [JumpR] -> [^self concretizeJumpR]. [JumpFull] -> [^self concretizeJumpFull]."jump within address space" [JumpLong] -> [^self concretizeConditionalJump: AL]."jumps witihn code space" [JumpLongZero] -> [^self concretizeConditionalJump: EQ]. [JumpLongNonZero] -> [^self concretizeConditionalJump: NE]. [Jump] -> [^self concretizeConditionalJump: AL]. [JumpZero] -> [^self concretizeConditionalJump: EQ]. [JumpNonZero] -> [^self concretizeConditionalJump: NE]. [JumpNegative] -> [^self concretizeConditionalJump: MI]. [JumpNonNegative] -> [^self concretizeConditionalJump: PL]. [JumpOverflow] -> [^self concretizeConditionalJump: VS]. [JumpNoOverflow] -> [^self concretizeConditionalJump: VC]. [JumpCarry] -> [^self concretizeConditionalJump: CS]. [JumpNoCarry] -> [^self concretizeConditionalJump: CC]. [JumpLess] -> [^self concretizeConditionalJump: LT]. [JumpGreaterOrEqual] -> [^self concretizeConditionalJump: GE]. [JumpGreater] -> [^self concretizeConditionalJump: GT]. [JumpLessOrEqual] -> [^self concretizeConditionalJump: LE]. [JumpBelow] -> [^self concretizeConditionalJump: CC]. "unsigned lower" [JumpAboveOrEqual] -> [^self concretizeConditionalJump: CS]. "unsigned greater or equal" [JumpAbove] -> [^self concretizeConditionalJump: HI]. [JumpBelowOrEqual] -> [^self concretizeConditionalJump: LS]. [JumpFPEqual] -> [^self concretizeFPConditionalJump: EQ]. [JumpFPNotEqual] -> [^self concretizeFPConditionalJump: NE]. [JumpFPLess] -> [^self concretizeFPConditionalJump: LT]. [JumpFPGreaterOrEqual] -> [^self concretizeFPConditionalJump: GE]. [JumpFPGreater] -> [^self concretizeFPConditionalJump: GT]. [JumpFPLessOrEqual] -> [^self concretizeFPConditionalJump: LE]. [JumpFPOrdered] -> [^self concretizeFPConditionalJump: VC]. [JumpFPUnordered] -> [^self concretizeFPConditionalJump: VS]. [RetN] -> [^self concretizeRetN]. [Stop] -> [^self concretizeStop]. "Arithmetic" + [AddCqR] -> [^self concretizeNegateableDataOperationCqR: AddOpcode]. + [AndCqR] -> [^self concretizeInvertibleDataOperationCqR: AndOpcode]. - [AddCqR] -> [^self concretizeAddCqR]. - [AddCwR] -> [^self concretizeDataOperationCwR: AddOpcode]. - [AddRR] -> [^self concretizeDataOperationRR: AddOpcode]. - [AddRdRd] -> [^self concretizeAddRdRd]. - [AndCqR] -> [^self concretizeAndCqR]. [AndCqRR] -> [^self concretizeAndCqRR]. + [CmpCqR] -> [^self concretizeNegateableDataOperationCqR: CmpOpcode]. + [OrCqR] -> [^self concretizeDataOperationCqR: OrOpcode]. + [SubCqR] -> [^self concretizeSubCqR]. + [TstCqR] -> [^self concretizeTstCqR]. + [XorCqR] -> [^self concretizeInvertibleDataOperationCqR: XorOpcode]. + [AddCwR] -> [^self concretizeDataOperationCwR: AddOpcode]. [AndCwR] -> [^self concretizeDataOperationCwR: AndOpcode]. - [AndRR] -> [^self concretizeDataOperationRR: AndOpcode]. - [CmpCqR] -> [^self concretizeDataOperationCqR: CmpOpcode]. [CmpCwR] -> [^self concretizeDataOperationCwR: CmpOpcode]. + [OrCwR] -> [^self concretizeDataOperationCwR: OrOpcode]. + [SubCwR] -> [^self concretizeDataOperationCwR: SubOpcode]. + [XorCwR] -> [^self concretizeDataOperationCwR: XorOpcode]. + [AddRR] -> [^self concretizeDataOperationRR: AddOpcode]. + [AndRR] -> [^self concretizeDataOperationRR: AndOpcode]. [CmpRR] -> [^self concretizeDataOperationRR: CmpOpcode]. + [OrRR] -> [^self concretizeDataOperationRR: OrOpcode]. + [SubRR] -> [^self concretizeDataOperationRR: SubOpcode]. + [XorRR] -> [^self concretizeDataOperationRR: XorOpcode]. + [AddRdRd] -> [^self concretizeAddRdRd]. [CmpRdRd] -> [^self concretizeCmpRdRd]. [DivRdRd] -> [^self concretizeDivRdRd]. [MulRdRd] -> [^self concretizeMulRdRd]. - [OrCqR] -> [^self concretizeDataOperationCqR: OrOpcode]. - [OrCwR] -> [^self concretizeDataOperationCwR: OrOpcode]. - [OrRR] -> [^self concretizeDataOperationRR: OrOpcode]. - [SubCqR] -> [^self concretizeSubCqR]. - [SubCwR] -> [^self concretizeDataOperationCwR: SubOpcode]. - [SubRR] -> [^self concretizeDataOperationRR: SubOpcode]. [SubRdRd] -> [^self concretizeSubRdRd]. [SqrtRd] -> [^self concretizeSqrtRd]. - [TstCqR] -> [^self concretizeTstCqR]. - [XorCqR] -> [^self concretizeDataOperationCqR: XorOpcode]. - [XorCwR] -> [^self concretizeDataOperationCwR: XorOpcode]. - [XorRR] -> [^self concretizeDataOperationRR: XorOpcode]. [NegateR] -> [^self concretizeNegateR]. [LoadEffectiveAddressMwrR] -> [^self concretizeLoadEffectiveAddressMwrR]. [ArithmeticShiftRightCqR] -> [^self concretizeArithmeticShiftRightCqR]. [LogicalShiftRightCqR] -> [^self concretizeLogicalShiftRightCqR]. [LogicalShiftLeftCqR] -> [^self concretizeLogicalShiftLeftCqR]. [ArithmeticShiftRightRR] -> [^self concretizeArithmeticShiftRightRR]. [LogicalShiftLeftRR] -> [^self concretizeLogicalShiftLeftRR]. [LogicalShiftRightRR] -> [^self concretizeLogicalShiftRightRR]. "ARM Specific Arithmetic" [SMULL] -> [^self concretizeSMULL] . [CMPSMULL] -> [^self concretizeCMPSMULL]. [MSR] -> [^self concretizeMSR]. "Data Movement" [MoveCqR] -> [^self concretizeMoveCqR]. [MoveCwR] -> [^self concretizeMoveCwR]. [MoveRR] -> [^self concretizeMoveRR]. [MoveAwR] -> [^self concretizeMoveAwR]. [MoveRAw] -> [^self concretizeMoveRAw]. [MoveMbrR] -> [^self concretizeMoveMbrR]. [MoveRMbr] -> [^self concretizeMoveRMbr]. [MoveM16rR] -> [^self concretizeMoveM16rR]. [MoveM64rRd] -> [^self concretizeMoveM64rRd]. [MoveMwrR] -> [^self concretizeMoveMwrR]. [MoveXbrRR] -> [^self concretizeMoveXbrRR]. [MoveRXbrR] -> [^self concretizeMoveRXbrR]. [MoveXwrRR] -> [^self concretizeMoveXwrRR]. [MoveRXwrR] -> [^self concretizeMoveRXwrR]. [MoveRMwr] -> [^self concretizeMoveRMwr]. [MoveRdM64r] -> [^self concretizeMoveRdM64r]. [PopR] -> [^self concretizePopR]. [PushR] -> [^self concretizePushR]. [PushCq] -> [^self concretizePushCq]. [PushCw] -> [^self concretizePushCw]. [PrefetchAw] -> [^self concretizePrefetchAw]. "Conversion" [ConvertRRd] -> [^self concretizeConvertRRd]}! Item was removed: - ----- Method: CogARMCompiler>>getDefaultCogCodeSize (in category 'accessing') ----- - getDefaultCogCodeSize - "Return the default number of bytes to allocate for native code at startup. - The actual value can be set via vmParameterAt: and/or a preference in the ini file." - <inline: true> - ^1024 * 1400! Item was added: + ----- Method: CogARMCompiler>>inverseOpcodeFor: (in category 'generate machine code - support') ----- + inverseOpcodeFor: opcode + "Several of the opcodes are inverses. Answer the inverse for an opcode if it has one. + See Table A3-2 in sec A3.4 Data-processing instructions of the AARM." + ^opcode caseOf: { + [AddOpcode] -> [SubOpcode]. + [AndOpcode] -> [BicOpcode]. + [BicOpcode] -> [AndOpcode]. + [CmpOpcode] -> [CmpNotOpcode]. + [MoveOpcode] -> [MoveNotOpcode]. + [MoveNotOpcode] -> [MoveOpcode]. + [SubOpcode] -> [AddOpcode] } + otherwise: [self error: 'opcode has no inverse']! Item was changed: ----- Method: CogARMCompiler>>loadCwInto: (in category 'generate machine code - support') ----- loadCwInto: destReg "Load the operand into the destination register, answering the size of the instructions generated to do so." | operand distance | operand := operands at: 0. + (self isAnInstruction: operand) ifTrue: + [operand := (cogit cCoerceSimple: operand to: #'AbstractInstruction *') address]. "First try and encode as a pc-relative reference..." (cogit addressIsInCurrentCompilation: operand) ifTrue: [distance := operand - (address + 8). + self rotateable8bitSignedImmediate: distance + ifTrue: + [:rot :immediate :negate| + self machineCodeAt: 0 put: (negate + ifTrue: [self sub: destReg rn: PC imm: immediate ror: rot] + ifFalse: [self add: destReg rn: PC imm: immediate ror: rot]). - self rotateable8bitImmediate: distance - ifTrue: [ :rot :immediate | - self machineCodeAt: 0 put: (self add: destReg rn: PC imm: immediate ror: rot). ^4] ifFalse: + [self deny: (self isAnInstruction: (operands at: 0))]]. + "If this fails, use the conventional literal load sequence." - [self rotateable8bitImmediate: distance negated - ifTrue: [ :rot :immediate | - self machineCodeAt: 0 put: (self sub: destReg rn: PC imm: immediate ror: rot). - ^4] - ifFalse: []]]. - "If this fails, use the conventional and painfully long 4 instruction sequence." ^self moveCw: operand intoR: destReg! Item was added: + ----- Method: CogARMCompiler>>rotateable8bitBitwiseImmediate:ifTrue:ifFalse: (in category 'testing') ----- + rotateable8bitBitwiseImmediate: constant ifTrue: trueAlternativeBlock ifFalse: falseAlternativeBlock + <inline: true> + "Invoke trueAlternativeBlock with shift, value and inverted if constant can be represented + by a possibly rotated 8-bit constant, otherwise invoke falseAlternativeBlock. For data + processing operands, there is the immediate shifter_operand variant, where an 8 bit value + is ring shifted _right_ by i. This is only suitable for quick constants (Cq), which won't change." + | value | + value := constant. + [(value bitAnd: 16rFF) = value ifTrue: + [^trueAlternativeBlock value: 0 value: value value: constant ~= value]. + 2 to: 30 by: 2 do: + [:i | + (value bitAnd: ((16rFF <<i bitAnd:16rFFFFFFFF) bitOr: 16rFF>>(32-i))) = value ifTrue: + [^trueAlternativeBlock + value: 32 - i + value: ((value >> i) bitOr: (value <<(32 - i) bitAnd:16rFFFFFFFF)) + value: constant ~= value]]. + value = constant] + whileTrue: + [value := constant < 0 + ifTrue:[-1 - constant] + ifFalse:[constant bitInvert32]]. + ^falseAlternativeBlock value! Item was added: + ----- Method: CogARMCompiler>>rotateable8bitSignedImmediate:ifTrue:ifFalse: (in category 'testing') ----- + rotateable8bitSignedImmediate: constant ifTrue: trueAlternativeBlock ifFalse: falseAlternativeBlock + <inline: true> + "Invoke trueAlternativeBlock with shift, value and negated if constant can be represented + by a possibly rotated 8-bit constant, otherwise invoke falseAlternativeBlock. For data + processing operands, there is the immediate shifter_operand variant, where an 8 bit value + is ring shifted _right_ by i. This is only suitable for quick constants (Cq), which won't change." + | value | + value := constant. + [(value bitAnd: 16rFF) = value ifTrue: + [^trueAlternativeBlock value: 0 value: value value: constant ~= value]. + 2 to: 30 by: 2 do: + [:i | + (value bitAnd: ((16rFF <<i bitAnd:16rFFFFFFFF) bitOr: 16rFF>>(32-i))) = value ifTrue: + [^trueAlternativeBlock + value: 32 - i + value: ((value >> i) bitOr: (value <<(32 - i) bitAnd:16rFFFFFFFF)) + value: constant ~= value]]. + value = constant and: [constant ~= 0]] + whileTrue: + [value := constant negated]. + ^falseAlternativeBlock value! Item was changed: ----- Method: CogARMCompiler>>tst:rn:imm:ror: (in category 'ARM convenience instructions') ----- tst: ignored rn: srcReg imm: immediate ror: rot " Remember the ROR is doubled by the cpu so use 30>>1 etc" "also note that TST has no destReg TST srcReg, #immediate ROR rot" + ^self type: 1 op: TstOpcode set: 1 rn: srcReg rd: 0 shifterOperand: ((rot>>1) <<8 bitOr: immediate)! - ^self type: 1 op: 8 set: 1 rn: srcReg rd: 0 shifterOperand: ((rot>>1) <<8 bitOr: immediate)! Item was changed: ----- Method: CogAbstractInstruction>>isAnInstruction: (in category 'testing') ----- isAnInstruction: addressOrInstruction <var: #addressOrInstruction type: #'AbstractInstruction *'> + <inline: true> + ^(cogit addressIsInInstructions: addressOrInstruction) + or: [addressOrInstruction == cogit methodLabel]! - ^cogit addressIsInInstructions: addressOrInstruction! Item was changed: ----- Method: CogAbstractInstruction>>printStateOn: (in category 'printing') ----- printStateOn: aStream | opcodeName orneryOperands format | <doNotGenerate> "Smalltalk-side only" opcode isNil ifTrue: [^self]. aStream space; nextPut: $(; nextPutAll: (opcodeName := self class nameForOpcode: opcode). orneryOperands := operands isCObjectAccessor ifTrue: [operands object] ifFalse: [operands]. (cogit isKindOf: Cogit) ifTrue: [format := CogRTLOpcodes printFormatForOpcodeName: opcodeName]. orneryOperands withIndexDo: [:operand :index| operand notNil ifTrue: [aStream space. index >= (orneryOperands identityIndexOf: nil ifAbsent: [orneryOperands size + 1]) ifTrue: [aStream print: index - 1; nextPut: $:]. (format notNil and: [(format at: index ifAbsent: nil) = $r]) ifTrue: [aStream nextPutAll: (self nameForRegister: operand)] ifFalse: [aStream print: operand. (operand isInteger and: [operand > 16 and: [opcode ~= Label]]) ifTrue: [(operand allMask: 16r80000000) ifTrue: [aStream nextPut: $/; print: operand signedIntFromLong]. aStream nextPut: $/. operand printOn: aStream base: 16]]]]. machineCodeSize ifNotNil: [(machineCodeSize between: 1 and: machineCode size) ifTrue: [0 to: machineCodeSize - 1 by: self codeGranularity do: [:i| aStream space. (self machineCodeAt: i) ifNil: [aStream nextPut: $.] + ifNotNil: + [:mc| + mc isInteger + ifTrue: [mc printOn: aStream base: 16] + ifFalse: [mc printOn: aStream]]]]]. - ifNotNil: [:mc| mc printOn: aStream base: 16]]]]. address ifNotNil: [aStream nextPut: $@. address printOn: aStream base: 16]. aStream nextPut: $)! Item was changed: ----- Method: CogIA32Compiler>>computeMaximumSize (in category 'generate machine code') ----- computeMaximumSize "Compute the maximum size for each opcode. This allows jump offsets to be determined, provided that all backward branches are long branches." + "N.B. The ^N forms are to get around the bytecode compiler's long branch - "N.B. The ^maxSize := N forms are to get around the compiler's long branch limits which are exceeded when each case jumps around the otherwise." opcode caseOf: { "Noops & Pseudo Ops" + [Label] -> [^0]. + [AlignmentNops] -> [^(operands at: 0) - 1]. + [Fill16] -> [^2]. + [Fill32] -> [^4]. + [FillFromWord] -> [^4]. + [Nop] -> [^1]. - [Label] -> [^maxSize := 0]. - [AlignmentNops] -> [^maxSize := (operands at: 0) - 1]. - [Fill16] -> [^maxSize := 2]. - [Fill32] -> [^maxSize := 4]. - [FillFromWord] -> [^maxSize := 4]. - [Nop] -> [^maxSize := 1]. "Specific Control/Data Movement" + [CDQ] -> [^1]. + [IDIVR] -> [^2]. + [IMULRR] -> [^3]. + [CPUID] -> [^2]. + [CMPXCHGAwR] -> [^7]. + [CMPXCHGMwrR] -> [^8]. + [LFENCE] -> [^3]. + [MFENCE] -> [^3]. + [SFENCE] -> [^3]. + [LOCK] -> [^1]. + [XCHGAwR] -> [^6]. + [XCHGMwrR] -> [^7]. + [XCHGRR] -> [^2]. - [CDQ] -> [^maxSize := 1]. - [IDIVR] -> [^maxSize := 2]. - [IMULRR] -> [^maxSize := 3]. - [CPUID] -> [^maxSize := 2]. - [CMPXCHGAwR] -> [^maxSize := 7]. - [CMPXCHGMwrR] -> [^maxSize := 8]. - [LFENCE] -> [^maxSize := 3]. - [MFENCE] -> [^maxSize := 3]. - [SFENCE] -> [^maxSize := 3]. - [LOCK] -> [^maxSize := 1]. - [XCHGAwR] -> [^maxSize := 6]. - [XCHGMwrR] -> [^maxSize := 7]. - [XCHGRR] -> [^maxSize := 2]. "Control" + [CallFull] -> [^5]. + [Call] -> [^5]. + [JumpR] -> [^2]. + [JumpFull] -> [self resolveJumpTarget. ^5]. + [JumpLong] -> [self resolveJumpTarget. ^5]. + [Jump] -> [self resolveJumpTarget. ^5]. + [JumpZero] -> [self resolveJumpTarget. ^6]. + [JumpNonZero] -> [self resolveJumpTarget. ^6]. + [JumpNegative] -> [self resolveJumpTarget. ^6]. + [JumpNonNegative] -> [self resolveJumpTarget. ^6]. + [JumpOverflow] -> [self resolveJumpTarget. ^6]. + [JumpNoOverflow] -> [self resolveJumpTarget. ^6]. + [JumpCarry] -> [self resolveJumpTarget. ^6]. + [JumpNoCarry] -> [self resolveJumpTarget. ^6]. + [JumpLess] -> [self resolveJumpTarget. ^6]. + [JumpGreaterOrEqual] -> [self resolveJumpTarget. ^6]. + [JumpGreater] -> [self resolveJumpTarget. ^6]. + [JumpLessOrEqual] -> [self resolveJumpTarget. ^6]. + [JumpBelow] -> [self resolveJumpTarget. ^6]. + [JumpAboveOrEqual] -> [self resolveJumpTarget. ^6]. + [JumpAbove] -> [self resolveJumpTarget. ^6]. + [JumpBelowOrEqual] -> [self resolveJumpTarget. ^6]. + [JumpLongZero] -> [self resolveJumpTarget. ^6]. + [JumpLongNonZero] -> [self resolveJumpTarget. ^6]. + [JumpFPEqual] -> [self resolveJumpTarget. ^6]. + [JumpFPNotEqual] -> [self resolveJumpTarget. ^6]. + [JumpFPLess] -> [self resolveJumpTarget. ^6]. + [JumpFPGreaterOrEqual] -> [self resolveJumpTarget. ^6]. + [JumpFPGreater] -> [self resolveJumpTarget. ^6]. + [JumpFPLessOrEqual] -> [self resolveJumpTarget. ^6]. + [JumpFPOrdered] -> [self resolveJumpTarget. ^6]. + [JumpFPUnordered] -> [self resolveJumpTarget. ^6]. + [RetN] -> [^(operands at: 0) = 0 ifTrue: [1] ifFalse: [3]]. + [Stop] -> [^1]. - [CallFull] -> [^maxSize := 5]. - [Call] -> [^maxSize := 5]. - [JumpR] -> [^maxSize := 2]. - [JumpFull] -> [self resolveJumpTarget. ^maxSize := 5]. - [JumpLong] -> [self resolveJumpTarget. ^maxSize := 5]. - [Jump] -> [self resolveJumpTarget. ^maxSize := 5]. - [JumpZero] -> [self resolveJumpTarget. ^maxSize := 6]. - [JumpNonZero] -> [self resolveJumpTarget. ^maxSize := 6]. - [JumpNegative] -> [self resolveJumpTarget. ^maxSize := 6]. - [JumpNonNegative] -> [self resolveJumpTarget. ^maxSize := 6]. - [JumpOverflow] -> [self resolveJumpTarget. ^maxSize := 6]. - [JumpNoOverflow] -> [self resolveJumpTarget. ^maxSize := 6]. - [JumpCarry] -> [self resolveJumpTarget. ^maxSize := 6]. - [JumpNoCarry] -> [self resolveJumpTarget. ^maxSize := 6]. - [JumpLess] -> [self resolveJumpTarget. ^maxSize := 6]. - [JumpGreaterOrEqual] -> [self resolveJumpTarget. ^maxSize := 6]. - [JumpGreater] -> [self resolveJumpTarget. ^maxSize := 6]. - [JumpLessOrEqual] -> [self resolveJumpTarget. ^maxSize := 6]. - [JumpBelow] -> [self resolveJumpTarget. ^maxSize := 6]. - [JumpAboveOrEqual] -> [self resolveJumpTarget. ^maxSize := 6]. - [JumpAbove] -> [self resolveJumpTarget. ^maxSize := 6]. - [JumpBelowOrEqual] -> [self resolveJumpTarget. ^maxSize := 6]. - [JumpLongZero] -> [self resolveJumpTarget. ^maxSize := 6]. - [JumpLongNonZero] -> [self resolveJumpTarget. ^maxSize := 6]. - [JumpFPEqual] -> [self resolveJumpTarget. ^maxSize := 6]. - [JumpFPNotEqual] -> [self resolveJumpTarget. ^maxSize := 6]. - [JumpFPLess] -> [self resolveJumpTarget. ^maxSize := 6]. - [JumpFPGreaterOrEqual] -> [self resolveJumpTarget. ^maxSize := 6]. - [JumpFPGreater] -> [self resolveJumpTarget. ^maxSize := 6]. - [JumpFPLessOrEqual] -> [self resolveJumpTarget. ^maxSize := 6]. - [JumpFPOrdered] -> [self resolveJumpTarget. ^maxSize := 6]. - [JumpFPUnordered] -> [self resolveJumpTarget. ^maxSize := 6]. - [RetN] -> [^maxSize := (operands at: 0) = 0 - ifTrue: [1] - ifFalse: [3]]. - [Stop] -> [^maxSize := 1]. "Arithmetic" + [AddCqR] -> [^(self isQuick: (operands at: 0)) - [AddCqR] -> [^maxSize := (self isQuick: (operands at: 0)) ifTrue: [3] ifFalse: [(self concreteRegister: (operands at: 1)) = EAX ifTrue: [5] ifFalse: [6]]]. + [AndCqR] -> [^(self isQuick: (operands at: 0)) - [AndCqR] -> [^maxSize := (self isQuick: (operands at: 0)) ifTrue: [3] ifFalse: [(self concreteRegister: (operands at: 1)) = EAX ifTrue: [5] ifFalse: [6]]]. + [CmpCqR] -> [^(self isQuick: (operands at: 0)) - [CmpCqR] -> [^maxSize := (self isQuick: (operands at: 0)) ifTrue: [3] ifFalse: [(self concreteRegister: (operands at: 1)) = EAX ifTrue: [5] ifFalse: [6]]]. + [OrCqR] -> [^(self isQuick: (operands at: 0)) - [OrCqR] -> [^maxSize := (self isQuick: (operands at: 0)) ifTrue: [3] ifFalse: [(self concreteRegister: (operands at: 1)) = EAX ifTrue: [5] ifFalse: [6]]]. + [SubCqR] -> [^(self isQuick: (operands at: 0)) - [SubCqR] -> [^maxSize := (self isQuick: (operands at: 0)) ifTrue: [3] ifFalse: [(self concreteRegister: (operands at: 1)) = EAX ifTrue: [5] ifFalse: [6]]]. + [TstCqR] -> [^((self isQuick: (operands at: 0)) and: [(self concreteRegister: (operands at: 1)) < 4]) - [TstCqR] -> [^maxSize := ((self isQuick: (operands at: 0)) and: [(self concreteRegister: (operands at: 1)) < 4]) ifTrue: [3] ifFalse: [(self concreteRegister: (operands at: 1)) = EAX ifTrue: [5] ifFalse: [6]]]. + [AddCwR] -> [^(self concreteRegister: (operands at: 1)) = EAX ifTrue: [5] ifFalse: [6]]. + [AndCwR] -> [^(self concreteRegister: (operands at: 1)) = EAX ifTrue: [5] ifFalse: [6]]. + [CmpCwR] -> [^(self concreteRegister: (operands at: 1)) = EAX ifTrue: [5] ifFalse: [6]]. + [OrCwR] -> [^(self concreteRegister: (operands at: 1)) = EAX ifTrue: [5] ifFalse: [6]]. + [SubCwR] -> [^(self concreteRegister: (operands at: 1)) = EAX ifTrue: [5] ifFalse: [6]]. + [XorCwR] -> [^(self concreteRegister: (operands at: 1)) = EAX ifTrue: [5] ifFalse: [6]]. + [AddRR] -> [^2]. + [AndRR] -> [^2]. + [CmpRR] -> [^2]. + [OrRR] -> [^2]. + [XorRR] -> [^2]. + [SubRR] -> [^2]. + [NegateR] -> [^2]. - [AddCwR] -> [^maxSize := (self concreteRegister: (operands at: 1)) = EAX - ifTrue: [5] - ifFalse: [6]]. - [AndCwR] -> [^maxSize := (self concreteRegister: (operands at: 1)) = EAX - ifTrue: [5] - ifFalse: [6]]. - [CmpCwR] -> [^maxSize := (self concreteRegister: (operands at: 1)) = EAX - ifTrue: [5] - ifFalse: [6]]. - [OrCwR] -> [^maxSize := (self concreteRegister: (operands at: 1)) = EAX - ifTrue: [5] - ifFalse: [6]]. - [SubCwR] -> [^maxSize := (self concreteRegister: (operands at: 1)) = EAX - ifTrue: [5] - ifFalse: [6]]. - [XorCwR] -> [^maxSize := (self concreteRegister: (operands at: 1)) = EAX - ifTrue: [5] - ifFalse: [6]]. - [AddRR] -> [^maxSize := 2]. - [AndRR] -> [^maxSize := 2]. - [CmpRR] -> [^maxSize := 2]. - [OrRR] -> [^maxSize := 2]. - [XorRR] -> [^maxSize := 2]. - [SubRR] -> [^maxSize := 2]. - [NegateR] -> [^maxSize := 2]. [LoadEffectiveAddressMwrR] + -> [^((self isQuick: (operands at: 0)) - -> [^maxSize := ((self isQuick: (operands at: 0)) ifTrue: [3] ifFalse: [6]) + ((self concreteRegister: (operands at: 1)) = ESP ifTrue: [1] ifFalse: [0])]. + [LogicalShiftLeftCqR] -> [^(operands at: 0) = 1 ifTrue: [2] ifFalse: [3]]. + [LogicalShiftRightCqR] -> [^(operands at: 0) = 1 ifTrue: [2] ifFalse: [3]]. + [ArithmeticShiftRightCqR] -> [^(operands at: 0) = 1 ifTrue: [2] ifFalse: [3]]. + [LogicalShiftLeftRR] -> [^self computeShiftRRSize]. + [LogicalShiftRightRR] -> [^self computeShiftRRSize]. + [ArithmeticShiftRightRR] -> [^self computeShiftRRSize]. + [AddRdRd] -> [^4]. + [CmpRdRd] -> [^4]. + [SubRdRd] -> [^4]. + [MulRdRd] -> [^4]. + [DivRdRd] -> [^4]. + [SqrtRd] -> [^4]. - [LogicalShiftLeftCqR] -> [^maxSize := (operands at: 0) = 1 - ifTrue: [2] - ifFalse: [3]]. - [LogicalShiftRightCqR] -> [^maxSize := (operands at: 0) = 1 - ifTrue: [2] - ifFalse: [3]]. - [ArithmeticShiftRightCqR] -> [^maxSize := (operands at: 0) = 1 - ifTrue: [2] - ifFalse: [3]]. - [LogicalShiftLeftRR] -> [self computeShiftRRSize]. - [LogicalShiftRightRR] -> [self computeShiftRRSize]. - [ArithmeticShiftRightRR] -> [self computeShiftRRSize]. - [AddRdRd] -> [^maxSize := 4]. - [CmpRdRd] -> [^maxSize := 4]. - [SubRdRd] -> [^maxSize := 4]. - [MulRdRd] -> [^maxSize := 4]. - [DivRdRd] -> [^maxSize := 4]. - [SqrtRd] -> [^maxSize := 4]. "Data Movement" + [MoveCqR] -> [^(operands at: 0) = 0 ifTrue: [2] ifFalse: [5]]. + [MoveCwR] -> [^5]. + [MoveRR] -> [^2]. + [MoveRdRd] -> [^4]. + [MoveAwR] -> [^(self concreteRegister: (operands at: 1)) = EAX ifTrue: [5] ifFalse: [6]]. + [MoveRAw] -> [^(self concreteRegister: (operands at: 0)) = EAX ifTrue: [5] ifFalse: [6]]. + [MoveRMwr] -> [^((self isQuick: (operands at: 1)) - [MoveCqR] -> [^maxSize := (operands at: 0) = 0 ifTrue: [2] ifFalse: [5]]. - [MoveCwR] -> [^maxSize := 5]. - [MoveRR] -> [^maxSize := 2]. - [MoveRdRd] -> [^maxSize := 4]. - [MoveAwR] -> [^maxSize := (self concreteRegister: (operands at: 1)) = EAX - ifTrue: [5] - ifFalse: [6]]. - [MoveRAw] -> [^maxSize := (self concreteRegister: (operands at: 0)) = EAX - ifTrue: [5] - ifFalse: [6]]. - [MoveRMwr] -> [^maxSize := ((self isQuick: (operands at: 1)) ifTrue: [3] ifFalse: [6]) + ((self concreteRegister: (operands at: 2)) = ESP ifTrue: [1] ifFalse: [0])]. + [MoveRdM64r] -> [^((self isQuick: (operands at: 1)) - [MoveRdM64r] -> [^maxSize := ((self isQuick: (operands at: 1)) ifTrue: [5] ifFalse: [8]) + ((self concreteRegister: (operands at: 2)) = ESP ifTrue: [1] ifFalse: [0])]. + [MoveMbrR] -> [^((self isQuick: (operands at: 0)) - [MoveMbrR] -> [^maxSize := ((self isQuick: (operands at: 0)) ifTrue: [4] ifFalse: [7]) + ((self concreteRegister: (operands at: 1)) = ESP ifTrue: [1] ifFalse: [0])]. + [MoveRMbr] -> [^((self isQuick: (operands at: 1)) - [MoveRMbr] -> [^maxSize := ((self isQuick: (operands at: 1)) ifTrue: [3] ifFalse: [6]) + ((self concreteRegister: (operands at: 2)) = ESP ifTrue: [1] ifFalse: [0])]. + [MoveM16rR] -> [^((self isQuick: (operands at: 0)) - [MoveM16rR] -> [^maxSize := ((self isQuick: (operands at: 0)) ifTrue: [4] ifFalse: [7]) + ((self concreteRegister: (operands at: 1)) = ESP ifTrue: [1] ifFalse: [0])]. + [MoveM64rRd] -> [^((self isQuick: (operands at: 0)) - [MoveM64rRd] -> [^maxSize := ((self isQuick: (operands at: 0)) ifTrue: [5] ifFalse: [8]) + ((self concreteRegister: (operands at: 1)) = ESP ifTrue: [1] ifFalse: [0])]. + [MoveMwrR] -> [^((self isQuick: (operands at: 0)) - [MoveMwrR] -> [^maxSize := ((self isQuick: (operands at: 0)) ifTrue: [3] ifFalse: [6]) + ((self concreteRegister: (operands at: 1)) = ESP ifTrue: [1] ifFalse: [0])]. [MoveXbrRR] -> [self assert: (self concreteRegister: (operands at: 0)) ~= ESP. + ^(self concreteRegister: (operands at: 1)) = EBP - ^maxSize := (self concreteRegister: (operands at: 1)) = EBP ifTrue: [5] ifFalse: [4]]. [MoveRXbrR] -> [self assert: (self concreteRegister: (operands at: 1)) ~= ESP. + ^((self concreteRegister: (operands at: 2)) = EBP - ^maxSize := ((self concreteRegister: (operands at: 2)) = EBP ifTrue: [4] ifFalse: [3]) + ((self concreteRegister: (operands at: 0)) >= 4 ifTrue: [2] ifFalse: [0])]. [MoveXwrRR] -> [self assert: (self concreteRegister: (operands at: 0)) ~= ESP. + ^(self concreteRegister: (operands at: 1)) = EBP - ^maxSize := (self concreteRegister: (operands at: 1)) = EBP ifTrue: [4] ifFalse: [3]]. [MoveRXwrR] -> [self assert: (self concreteRegister: (operands at: 1)) ~= ESP. + ^(self concreteRegister: (operands at: 2)) = EBP - ^maxSize := (self concreteRegister: (operands at: 2)) = EBP ifTrue: [4] ifFalse: [3]]. + [PopR] -> [^1]. + [PushR] -> [^1]. + [PushCq] -> [^(self isQuick: (operands at: 0)) ifTrue: [2] ifFalse: [5]]. + [PushCw] -> [^5]. + [PrefetchAw] -> [^self hasSSEInstructions ifTrue: [7] ifFalse: [0]]. - [PopR] -> [^maxSize := 1]. - [PushR] -> [^maxSize := 1]. - [PushCq] -> [^maxSize := (self isQuick: (operands at: 0)) ifTrue: [2] ifFalse: [5]]. - [PushCw] -> [^maxSize := 5]. - [PrefetchAw] -> [^maxSize := self hasSSEInstructions ifTrue: [7] ifFalse: [0]]. "Conversion" + [ConvertRRd] -> [^4] }. - [ConvertRRd] -> [^maxSize := 4] }. ^0 "to keep C compiler quiet"! Item was added: + ----- Method: CogInLineLiteralsARMCompiler>>getDefaultCogCodeSize (in category 'accessing') ----- + getDefaultCogCodeSize + "Return the default number of bytes to allocate for native code at startup. + The actual value can be set via vmParameterAt: and/or a preference in the ini file." + <inline: true> + ^1024 * 1536! Item was changed: ----- Method: CogInLineLiteralsARMCompiler>>isPCDependent (in category 'testing') ----- isPCDependent "Answer if the receiver is a pc-dependent instruction." + ^self isJump or: [opcode = AlignmentNops]! - ^self isJump or: [opcode = AlignmentNops or: [opcode = Call]]! Item was changed: ----- Method: CogOutOfLineLiteralsARMCompiler>>concretizeLiteral (in category 'generate machine code') ----- concretizeLiteral + | literalAsInstruction literal | + <var: #jumpTarget type: #'AbstractInstruction *'> + literalAsInstruction := cogit cCoerceSimple: (operands at: 0) to: #'AbstractInstruction *'. + literal := (self isAnInstruction: literalAsInstruction) + ifTrue: [literalAsInstruction address] + ifFalse: [self cCode: [literalAsInstruction asUnsignedInteger] + inSmalltalk: [literalAsInstruction]]. self assert: (dependent notNil and: [dependent opcode = Literal and: [dependent address = address]]). + self machineCodeAt: 0 put: literal! - self machineCodeAt: 0 put: (operands at: 0)! Item was added: + ----- Method: CogOutOfLineLiteralsARMCompiler>>getDefaultCogCodeSize (in category 'accessing') ----- + getDefaultCogCodeSize + "Return the default number of bytes to allocate for native code at startup. + The actual value can be set via vmParameterAt: and/or a preference in the ini file." + <inline: true> + ^1024 * 1280! Item was changed: ----- Method: CogOutOfLineLiteralsARMCompiler>>isPCDependent (in category 'testing') ----- isPCDependent "Answer if the receiver is a pc-dependent instruction. With out-of-line literals any instruction that refers to a literal depends on the address of the literal, so add them in addition to the jumps." + ^self isJump + or: [opcode = AlignmentNops + or: [dependent notNil and: [dependent opcode = Literal]]]! - ^self isJump or: [opcode = AlignmentNops or: [opcode = Call or: [dependent notNil and: [dependent opcode = Literal]]]]! Item was changed: ----- Method: CogOutOfLineLiteralsARMCompiler>>moveCw:intoR: (in category 'generate machine code - support') ----- moveCw: constant intoR: destReg "Emit a load of aWord into destReg. Answer the number of bytes of machine code generated. Literals are stored out-of-line; emit a LDR with the relevant offset." <var: 'constant' type: #usqInt> <inline: true> + self assert: (cogit addressIsInCurrentCompilation: dependent address). + self machineCodeAt: 0 + put: (self + ldr: destReg + rn: PC + plus: (dependent address >= (address + 8) ifTrue: [1] ifFalse: [0]) + imm: (dependent address - (address + 8)) abs). - self machineCodeAt: 0 put: (self ldr: destReg rn: PC plusImm: address - dependent address). ^machineCodeSize := 4! Item was added: + ----- Method: CogOutOfLineLiteralsARMCompiler>>outOfLineLiteralOpcodeLimit (in category 'compile abstract instructions') ----- + outOfLineLiteralOpcodeLimit + "The maximum offset in a LDR is 1<<12. Be conservative." + ^1<<(11-2)! Item was changed: ----- Method: CogOutOfLineLiteralsARMCompiler>>usesOutOfLineLiteral (in category 'testing') ----- usesOutOfLineLiteral "Answer if the receiver uses an out-of-line literal. Needs only to work for the opcodes created with gen:literal:operand: et al." opcode caseOf: { [CallFull] -> [^true]. [JumpFull] -> [^true]. "Arithmetic" + [AddCqR] -> [^self rotateable8bitSignedImmediate: (operands at: 0) ifTrue: [:r :i :n| false] ifFalse: [true]]. - [AddCqR] -> [^self rotateable8bitImmediate: (operands at: 0) ifTrue: [:r :i| false] ifFalse: [true]]. [AndCqR] -> [^self rotateable8bitImmediate: (operands at: 0) ifTrue: [:r :i| false] ifFalse: [true]]. [AndCqRR] -> [^self rotateable8bitImmediate: (operands at: 0) ifTrue: [:r :i| false] ifFalse: [true]]. [CmpCqR] -> [^self rotateable8bitImmediate: (operands at: 0) ifTrue: [:r :i| false] ifFalse: [true]]. [OrCqR] -> [^self rotateable8bitImmediate: (operands at: 0) ifTrue: [:r :i| false] ifFalse: [true]]. [SubCqR] -> [^self rotateable8bitImmediate: (operands at: 0) ifTrue: [:r :i| false] ifFalse: [true]]. [TstCqR] -> [^self rotateable8bitImmediate: (operands at: 0) ifTrue: [:r :i| false] ifFalse: [true]]. [XorCqR] -> [^self rotateable8bitImmediate: (operands at: 0) ifTrue: [:r :i| false] ifFalse: [true]]. [AddCwR] -> [^true]. [AndCwR] -> [^true]. [CmpCwR] -> [^true]. [OrCwR] -> [^true]. [SubCwR] -> [^true]. [XorCwR] -> [^true]. [LoadEffectiveAddressMwrR] -> [^self rotateable8bitImmediate: (operands at: 0) ifTrue: [:r :i| false] ifFalse: [true]]. "Data Movement" [MoveCqR] -> [^self rotateable8bitImmediate: (operands at: 0) ifTrue: [:r :i| false] ifFalse: [true]]. + [MoveCwR] -> [^((self isAnInstruction: (operands at: 0)) "i.e. a label, which by definition will be in the current compilation." + or: [cogit addressIsInCurrentCompilation: (operands at: 0)]) not]. - [MoveCwR] -> [^true]. [MoveAwR] -> [^(self isAddressRelativeToVarBase: (operands at: 0)) ifTrue: [false] ifFalse: [true]]. [MoveRAw] -> [^(self isAddressRelativeToVarBase: (operands at: 1)) ifTrue: [false] ifFalse: [true]]. [MoveRMwr] -> [^self is12BitValue: (operands at: 1) ifTrue: [:u :i| false] ifFalse: [true]]. + [MoveRdM64r] -> [^self is12BitValue: (operands at: 1) ifTrue: [:u :i| false] ifFalse: [true]]. - [MoveRdM64r] -> [^true]. [MoveMbrR] -> [^self is12BitValue: (operands at: 0) ifTrue: [:u :i| false] ifFalse: [true]]. [MoveRMbr] -> [^self is12BitValue: (operands at: 1) ifTrue: [:u :i| false] ifFalse: [true]]. [MoveM16rR] -> [^self rotateable8bitImmediate: (operands at: 0) ifTrue: [:r :i| false] ifFalse: [true]]. + [MoveM64rRd] -> [^self is12BitValue: (operands at: 0) ifTrue: [:u :i| false] ifFalse: [true]]. - [MoveM64rRd] -> [^true]. [MoveMwrR] -> [^self is12BitValue: (operands at: 0) ifTrue: [:u :i| false] ifFalse: [true]]. + [PushCw] -> [^((self isAnInstruction: (operands at: 0)) "i.e. a label, which by definiion will be in the current compilation." + or: [cogit addressIsInCurrentCompilation: (operands at: 0)]) not]. - [PushCw] -> [^true]. [PushCq] -> [^self rotateable8bitImmediate: (operands at: 0) ifTrue: [:r :i| false] ifFalse: [true]]. [PrefetchAw] -> [^(self isAddressRelativeToVarBase: (operands at: 0)) ifTrue: [false] ifFalse: [true]]. } otherwise: [self assert: false]. ^false "to keep C compiler quiet" ! Item was changed: ----- Method: Cogit class>>ancilliaryClasses: (in category 'translation') ----- ancilliaryClasses: options ProcessorClass ifNil: [Cogit initializeMiscConstants]. ^{ CogMethodZone. - CogAbstractInstruction. - self activeCompilerClass. CogBlockStart. CogBytecodeDescriptor. CogBytecodeFixup. CogInstructionAnnotation. CogPrimitiveDescriptor. CogBlockMethod. CogMethod }, + (self activeCompilerClass withAllSuperclasses copyUpThrough: CogAbstractInstruction), ((options at: #NewspeakVM ifAbsent: [false]) ifTrue: [{NewspeakCogMethod. NSSendCache}] ifFalse: [#()])! Item was changed: ----- Method: Cogit class>>initializeMiscConstants (in category 'class initialization') ----- initializeMiscConstants super initializeMiscConstants. Debug := initializationOptions at: #Debug ifAbsent: [false]. (initializationOptions includesKey: #EagerInstructionDecoration) ifTrue: [EagerInstructionDecoration := initializationOptions at: #EagerInstructionDecoration] ifFalse: + [EagerInstructionDecoration ifNil: - [EagerInstructionDecoration isNil ifTrue: [EagerInstructionDecoration := false]]. "speeds up single stepping but could lose fidelity" ProcessorClass := (initializationOptions at: #ISA ifAbsentPut: [#IA32]) caseOf: { [#IA32] -> [BochsIA32Alien]. [#ARMv5] -> [GdbARMAlien]. }. CogCompilerClass := self activeCompilerClass. "Our criterion for which methods to JIT is literal count. The default value is 60 literals or less." MaxLiteralCountForCompile := initializationOptions at: #MaxLiteralCountForCompile ifAbsent: [60]. "we special-case 0, 1 & 2 argument sends, N is numArgs >= 3" NumSendTrampolines := 4. "Currently not even the ceImplicitReceiverTrampoline contains object references." NumObjRefsInRuntime := 0. NSCSelectorIndex := (NSSendCache instVarNames indexOf: #selector) - 1. NSCNumArgsIndex := (NSSendCache instVarNames indexOf: #numArgs) - 1. NSCClassTagIndex := (NSSendCache instVarNames indexOf: #classTag) - 1. NSCEnclosingObjectIndex := (NSSendCache instVarNames indexOf: #enclosingObject) - 1. NSCTargetIndex := (NSSendCache instVarNames indexOf: #target) - 1. NumOopsPerNSC := NSSendCache instVarNames size. "Max size to alloca when compiling. Mac OS X 10.6.8 segfaults approaching 8Mb. Linux 2.6.9 segfaults above 11Mb. WIndows XP segfaults approaching 2Mb." MaxStackAllocSize := 1024 * 1024 * 3 / 2 ! Item was added: + ----- Method: Cogit>>DumpJumpLong: (in category 'abstract instructions') ----- + DumpJumpLong: jumpTarget + "Convenience conflation of JumpLong: & dumpLiterals for PIC generation. + Literals must be dumped early and often to keep each PIC case the same size." + <inline: true> + <returnTypeC: #'AbstractInstruction *'> + | inst | + <var: 'inst' type: #'AbstractInstruction *'> + inst := self gen: JumpLong operand: jumpTarget asInteger. + literalsManager dumpLiterals. + ^inst! Item was added: + ----- Method: Cogit>>DumpJumpLongZero: (in category 'abstract instructions') ----- + DumpJumpLongZero: jumpTarget + "Convenience conflation of JumpLongZero: & dumpLiterals for PIC generation. + Literals must be dumped early and often to keep each PIC case the same size." + <inline: true> + <returnTypeC: #'AbstractInstruction *'> + | inst | + <var: 'inst' type: #'AbstractInstruction *'> + inst := self gen: JumpLongZero operand: jumpTarget asInteger. + literalsManager dumpLiterals. + ^inst! Item was changed: ----- Method: Cogit>>cogExtendPIC:CaseNMethod:tag:isMNUCase: (in category 'in-line cacheing') ----- cogExtendPIC: cPIC CaseNMethod: caseNMethod tag: caseNTag isMNUCase: isMNUCase "Extend the cPIC with the supplied case. If caseNMethod is cogged dispatch direct to its unchecked entry-point. If caseNMethod is not cogged, jump to the fast interpreter dispatch, and if isMNUCase then dispatch to fast MNU invocation and mark the cPIC as having the MNU case for cache flushing." <var: #cPIC type: #'CogMethod *'> | operand target address size end | "stack allocate the various collections so that they are effectively garbage collected on return." coInterpreter compilationBreak: cPIC selector point: (objectMemory numBytesOf: cPIC selector) isMNUCase: isMNUCase. self allocateOpcodes: 5 bytecodes: 0. literalsManager resetLiterals: 5. methodLabel address: cPIC asUnsignedInteger; dependent: nil. "for pc-relative MoveCw: cPIC R: ClassReg" self assert: (objectRepresentation inlineCacheTagIsYoung: caseNTag) not. "Caller patches to open pic if caseNMethod is young." self assert: (caseNMethod notNil and: [(objectMemory isYoung: caseNMethod) not]). (isMNUCase not and: [coInterpreter methodHasCogMethod: caseNMethod]) ifTrue: [operand := 0. target := (coInterpreter cogMethodOf: caseNMethod) asInteger + cmNoCheckEntryOffset] ifFalse: [operand := caseNMethod. isMNUCase ifTrue: [cPIC cpicHasMNUCase: true. target := cPIC asInteger + (self sizeof: CogMethod)] ifFalse: [target := cPIC asInteger + self picInterpretAbortOffset]]. self CmpCw: caseNTag R: TempReg. self MoveCw: operand R: SendNumArgsReg. + self DumpJumpLongZero: target. - self JumpLongZero: target. self MoveCw: cPIC asUnsignedInteger R: ClassReg. self JumpLong: (self cPICMissTrampolineFor: cPIC cmNumArgs). self computeMaximumSizes. address := self addressOfEndOfCase: cPIC cPICNumCases - 1 inCPIC: cPIC. size := self generateInstructionsAt: address. end := self outputInstructionsAt: address. processor flushICacheFrom: cPIC asUnsignedInteger to: cPIC asUnsignedInteger + closedPICSize. cPIC cPICNumCases: cPIC cPICNumCases + 1. ^0! Item was changed: ----- Method: Cogit>>cogMNUPICSelector:receiver:methodOperand:numArgs: (in category 'in-line cacheing') ----- cogMNUPICSelector: selector receiver: rcvr methodOperand: methodOperand numArgs: numArgs <api> "Attempt to create a one-case PIC for an MNU. The tag for the case is at the send site and so doesn't need to be generated." <returnTypeC: #'CogMethod *'> | startAddress size end | ((objectMemory isYoung: selector) or: [(objectRepresentation inlineCacheTagForInstance: rcvr) = self picAbortDiscriminatorValue]) ifTrue: [^0]. coInterpreter compilationBreak: selector point: (objectMemory numBytesOf: selector) isMNUCase: true. self assert: endCPICCase0 notNil. startAddress := methodZone allocate: closedPICSize. startAddress = 0 ifTrue: [coInterpreter callForCogCompiledCodeCompaction. ^0]. "stack allocate the various collections so that they are effectively garbage collected on return." + self allocateOpcodes: numPICCases * 9 bytecodes: 0. - self allocateOpcodes: numPICCases * 7 bytecodes: 0. literalsManager resetLiterals: numPICCases * 2. methodLabel address: startAddress; dependent: nil. "for pc-relative MoveCw: cPIC R: ClassReg" self compileMNUCPIC: (self cCoerceSimple: startAddress to: #'CogMethod *') methodOperand: methodOperand numArgs: numArgs. self computeMaximumSizes. size := self generateInstructionsAt: startAddress + (self sizeof: CogMethod). end := self outputInstructionsAt: startAddress + (self sizeof: CogMethod). "The missOffset is the same as the interpretOffset. On RISCs it includes an additional instruction." self assert: missOffset = ((backEnd hasLinkRegister ifTrue: [backEnd callInstructionByteSize] ifFalse: [0]) + picInterpretAbort address + picInterpretAbort machineCodeSize - startAddress). self assert: startAddress + cmEntryOffset = entry address. ^self fillInCPICHeader: (self cCoerceSimple: startAddress to: #'CogMethod *') numArgs: numArgs numCases: 1 hasMNUCase: true selector: selector ! Item was changed: ----- Method: Cogit>>cogPICSelector:numArgs:Case0Method:Case1Method:tag:isMNUCase: (in category 'in-line cacheing') ----- cogPICSelector: selector numArgs: numArgs Case0Method: case0CogMethod Case1Method: case1MethodOrNil tag: case1Tag isMNUCase: isMNUCase "Attempt to create a two-case PIC for case0CogMethod and case1Method,case1Tag. The tag for case0CogMethod is at the send site and so doesn't need to be generated. case1Method may be any of - a Cog method; link to its unchecked entry-point - a CompiledMethod; link to ceInterpretMethodFromPIC: - a CompiledMethod; link to ceMNUFromPICMNUMethod:receiver:" <var: #case0CogMethod type: #'CogMethod *'> <returnTypeC: #'CogMethod *'> | startAddress size end | (objectMemory isYoung: selector) ifTrue: [^self cCoerceSimple: YoungSelectorInPIC to: #'CogMethod *']. coInterpreter compilationBreak: selector point: (objectMemory numBytesOf: selector) isMNUCase: isMNUCase. startAddress := methodZone allocate: closedPICSize. startAddress = 0 ifTrue: [^self cCoerceSimple: InsufficientCodeSpace to: #'CogMethod *']. "stack allocate the various collections so that they are effectively garbage collected on return." + self allocateOpcodes: numPICCases * 9 bytecodes: 0. - self allocateOpcodes: numPICCases * 7 bytecodes: 0. literalsManager resetLiterals: numPICCases * 2. methodLabel address: startAddress; dependent: nil. "for pc-relative MoveCw: cPIC R: ClassReg" self compileCPIC: (self cCoerceSimple: startAddress to: #'CogMethod *') Case0: case0CogMethod Case1Method: case1MethodOrNil tag: case1Tag isMNUCase: isMNUCase numArgs: numArgs. self computeMaximumSizes. size := self generateInstructionsAt: startAddress + (self sizeof: CogMethod). end := self outputInstructionsAt: startAddress + (self sizeof: CogMethod). "The missOffset is the same as the interpretOffset. On RISCs it includes an additional instruction." self assert: missOffset = ((backEnd hasLinkRegister ifTrue: [backEnd callInstructionByteSize] ifFalse: [0]) + picInterpretAbort address + picInterpretAbort machineCodeSize - startAddress). self assert: startAddress + cmEntryOffset = entry address. self assert: endCPICCase0 address = (startAddress + firstCPICCaseOffset). self assert: endCPICCase1 address = (startAddress + firstCPICCaseOffset + cPICCaseSize). ^self fillInCPICHeader: (self cCoerceSimple: startAddress to: #'CogMethod *') numArgs: numArgs numCases: 2 hasMNUCase: isMNUCase selector: selector ! Item was changed: ----- Method: Cogit>>compileCPIC:Case0:Case1Method:tag:isMNUCase:numArgs: (in category 'in-line cacheing') ----- compileCPIC: cPIC Case0: case0CogMethod Case1Method: case1Method tag: case1Tag isMNUCase: isMNUCase numArgs: numArgs "Compile the code for a two-case PIC for case0CogMethod and case1Method,case1Tag. The tag for case0CogMethod is at the send site and so doesn't need to be generated. case1Method may be any of - a Cog method; jump to its unchecked entry-point - a CompiledMethod; jump to the ceInterpretFromPIC trampoline - nil; call ceMNUFromPIC" <var: #cPIC type: #'CogMethod *'> | operand targetEntry jumpNext | <var: #case0CogMethod type: #'CogMethod *'> <var: #targetEntry type: #'void *'> <var: #jumpNext type: #'AbstractInstruction *'> self assert: case1Method notNil. self compilePICAbort: numArgs. self assert: (objectRepresentation inlineCacheTagIsYoung: case1Tag) not. (isMNUCase not and: [coInterpreter methodHasCogMethod: case1Method]) ifTrue: [operand := 0. targetEntry := ((coInterpreter cogMethodOf: case1Method) asInteger + cmNoCheckEntryOffset) asVoidPointer] ifFalse: "We do not scavenge PICs, hence we cannot cache the MNU method if it is in new space." [operand := (case1Method isNil or: [objectMemory isYoungObject: case1Method]) ifTrue: [0] ifFalse: [case1Method]. targetEntry := case1Method isNil ifTrue: [picMNUAbort] ifFalse: [picInterpretAbort]]. jumpNext := self compileCPICEntry. self MoveCw: 0 R: SendNumArgsReg. + self DumpJumpLong: case0CogMethod asInteger + cmNoCheckEntryOffset. - self JumpLong: case0CogMethod asInteger + cmNoCheckEntryOffset. endCPICCase0 := self CmpCw: case1Tag R: TempReg. jumpNext jmpTarget: endCPICCase0. self MoveCw: operand R: SendNumArgsReg. + self DumpJumpLongZero: (isMNUCase ifTrue: [picMNUAbort] ifFalse: [targetEntry]) asInteger. - self JumpLongZero: (isMNUCase ifTrue: [picMNUAbort] ifFalse: [targetEntry]) asInteger. endCPICCase1 := self MoveCw: cPIC asUnsignedInteger R: ClassReg. self JumpLong: (self cPICMissTrampolineFor: numArgs). ^0 ! Item was changed: ----- Method: Cogit>>compileClosedPICPrototype (in category 'in-line cacheing') ----- compileClosedPICPrototype "Compile the abstract instructions for a full closed PIC used to initialize closedPICSize. The loads into SendNumArgsReg are those for optional method objects which may be used in MNU cases." <inline: true> | numArgs jumpNext | <var: #jumpNext type: #'AbstractInstruction *'> numArgs := 0. self compilePICAbort: numArgs. jumpNext := self compileCPICEntry. self MoveCw: 16r5EAF00D R: SendNumArgsReg. + self DumpJumpLong: methodZoneBase + 16rCA5E10. - self JumpLong: methodZoneBase + 16rCA5E10. jumpNext jmpTarget: (endCPICCase0 := self Label). 1 to: numPICCases - 1 do: [:h| self CmpCw: 16rBABE1F15+h R: TempReg. self MoveCw: 16rBADA550 + h R: SendNumArgsReg. + self DumpJumpLongZero: 16rCA5E10 + (h * 16). - self JumpLongZero: 16rCA5E10 + (h * 16). h = 1 ifTrue: [endCPICCase1 := self Label]]. self MoveCw: methodLabel address R: ClassReg. self JumpLong: (self cPICMissTrampolineFor: numArgs). ^0! Item was changed: ----- Method: Cogit>>compileMNUCPIC:methodOperand:numArgs: (in category 'in-line cacheing') ----- compileMNUCPIC: cPIC methodOperand: methodOperand numArgs: numArgs "Compile the code for a one-case MNU PIC that calls ceMNUFromPIC for case0Tag The tag for case0 is at the send site and so doesn't need to be generated." <var: #cPIC type: #'CogMethod *'> | jumpNext operand | <var: #jumpNext type: #'AbstractInstruction *'> self compilePICAbort: numArgs. jumpNext := self compileCPICEntry. "We do not scavenge PICs, hence we cannot cache the MNU method if it is in new space." operand := (methodOperand isNil or: [objectMemory isYoungObject: methodOperand]) ifTrue: [0] ifFalse: [methodOperand]. self MoveCw: operand R: SendNumArgsReg. + self DumpJumpLong: picMNUAbort asInteger. - self JumpLong: picMNUAbort asInteger. jumpNext jmpTarget: (self MoveCw: cPIC asUnsignedInteger R: ClassReg). self JumpLong: (self cPICMissTrampolineFor: numArgs). ^0 ! Item was changed: ----- Method: Cogit>>computeMaximumSizes (in category 'generate machine code') ----- computeMaximumSizes "This pass assigns maximum sizes to all abstract instructions and eliminates jump fixups. It hence assigns the maximum address an instruction will occur at which allows the next pass to conservatively size jumps." <inline: false> <var: #abstractInstruction type: #'AbstractInstruction *'> | relativeAddress | + literalsManager dumpLiterals. relativeAddress := 0. 0 to: opcodeIndex - 1 do: [:i| | abstractInstruction | abstractInstruction := self abstractInstructionAt: i. + abstractInstruction + address: relativeAddress; + maxSize: abstractInstruction computeMaximumSize. + relativeAddress := relativeAddress + abstractInstruction maxSize]! - abstractInstruction address: relativeAddress. - abstractInstruction computeMaximumSize. - relativeAddress := relativeAddress + abstractInstruction maxSize]. - ! Item was changed: ----- Method: Cogit>>genCheckForInterruptsTrampoline (in category 'initialization') ----- genCheckForInterruptsTrampoline + self zeroOpcodeIndex. - opcodeIndex := 0. "if we have a link register we will assume that it does not get automatically pushed onto the stack and thus there is no need to pop it before saving to instructionPointerAddress" backEnd hasLinkRegister ifTrue: [self MoveR: LinkReg Aw: coInterpreter instructionPointerAddress] ifFalse: [self PopR: TempReg. "instruction pointer" self MoveR: TempReg Aw: coInterpreter instructionPointerAddress]. ^self genTrampolineFor: #ceCheckForInterrupts called: 'ceCheckForInterruptsTrampoline' numArgs: 0 arg: nil arg: nil arg: nil arg: nil saveRegs: false pushLinkReg: false resultReg: nil appendOpcodes: true! Item was changed: ----- Method: Cogit>>genEnilopmartFor:and:and:forCall:called: (in category 'initialization') ----- genEnilopmartFor: regArg1 and: regArg2 and: regArg3 forCall: forCall called: trampolineName "An enilopmart (the reverse of a trampoline) is a piece of code that makes the system-call-like transition from the C runtime into generated machine code. The desired arguments and entry-point are pushed on a stackPage's stack. The enilopmart pops off the values to be loaded into registers and then executes a return instruction to pop off the entry-point and jump to it. BEFORE AFTER (stacks grow down) whatever stackPointer -> whatever target address => reg1 = reg1val, etc reg1val pc = target address reg2val stackPointer -> reg3val" <var: #trampolineName type: #'char *'> <returnTypeC: #'void (*genEnilopmartForandandforCallcalled(sqInt regArg1, sqInt regArg2, sqInt regArg3, sqInt forCall, char *trampolineName))(void)'> | size endAddress enilopmart | + self zeroOpcodeIndex. - opcodeIndex := 0. backEnd maybeEstablishVarBase. "Must happen first; value may be used in genLoadStackPointers" backEnd genLoadStackPointers. regArg3 ifNotNil: [self PopR: regArg3]. regArg2 ifNotNil: [self PopR: regArg2]. self PopR: regArg1. self genEnilopmartReturn: forCall. - literalsManager dumpLiterals. self computeMaximumSizes. size := self generateInstructionsAt: methodZoneBase. endAddress := self outputInstructionsAt: methodZoneBase. self assert: methodZoneBase + size = endAddress. enilopmart := methodZoneBase. methodZoneBase := self alignUptoRoutineBoundary: endAddress. backEnd nopsFrom: endAddress to: methodZoneBase - 1. self recordGeneratedRunTime: trampolineName address: enilopmart. ^self cCoerceSimple: enilopmart to: #'void (*)(void)'! Item was changed: ----- Method: Cogit>>genMethodAbortTrampoline (in category 'initialization') ----- genMethodAbortTrampoline "Generate the abort for a method. This abort performs either a call of ceSICMiss: to handle a single-in-line cache miss or a call of ceStackOverflow: to handle a stack overflow. It distinguishes the two by testing ResultReceiverReg. If the register is zero then this is a stack-overflow because a) the receiver has already been pushed and so can be set to zero before calling the abort, and b) the receiver must always contain an object (and hence be non-zero) on SIC miss." | jumpSICMiss | <var: #jumpSICMiss type: #'AbstractInstruction *'> + self zeroOpcodeIndex. - opcodeIndex := 0. self CmpCq: 0 R: ReceiverResultReg. jumpSICMiss := self JumpNonZero: 0. "The abort sequencer has pushed the LinkReg a second time. Overwrite it with the right one." backEnd hasLinkRegister ifTrue: [self MoveR: LinkReg Mw: 0 r: SPReg]. self compileTrampolineFor: #ceStackOverflow: numArgs: 1 arg: SendNumArgsReg arg: nil arg: nil arg: nil saveRegs: false pushLinkReg: false "The LinkReg has already been set above." resultReg: nil. jumpSICMiss jmpTarget: self Label. ^self genTrampolineFor: #ceSICMiss: called: 'ceMethodAbort' numArgs: 1 arg: ReceiverResultReg arg: nil arg: nil arg: nil saveRegs: false pushLinkReg: true "Push the LinkReg for the ceMethodAbort call." resultReg: nil appendOpcodes: true! Item was changed: ----- Method: Cogit>>genNSSendTrampolineFor:numArgs:called: (in category 'initialization') ----- genNSSendTrampolineFor: aRoutine numArgs: numArgs called: aString "ReceiverResultReg: method receiver SendNumArgsReg: the NSSendCache cache" <option: #NewspeakVM> <var: #aRoutine type: #'void *'> <var: #aString type: #'char *'> | jumpMiss jumpItsTheReceiverStupid | <var: #jumpMiss type: #'AbstractInstruction *'> <var: #jumpItsTheReceiverStupid type: #'AbstractInstruction *'> + self zeroOpcodeIndex. - opcodeIndex := 0. objectRepresentation genGetInlineCacheClassTagFrom: ReceiverResultReg into: ClassReg forEntry: false. self MoveMw: NSCClassTagIndex * objectMemory wordSize r: SendNumArgsReg R: TempReg. self CmpR: ClassReg R: TempReg. jumpMiss := self JumpNonZero: 0. self MoveMw: NSCEnclosingObjectIndex * objectMemory wordSize r: SendNumArgsReg R: TempReg. self CmpCq: 0 R: TempReg. jumpItsTheReceiverStupid := self JumpZero: 0. self MoveR: TempReg R: ReceiverResultReg. "Now set the stacked receiver, if needed. If there are reg args this is not required; see genPushRegisterArgsForNumArgs:numArgs: below." (self numRegArgs = 0 or: [numArgs > self numRegArgs]) ifTrue: [numArgs >= (NumSendTrampolines - 1) ifTrue: "arbitrary argument count" [self MoveMw: NSCNumArgsIndex * objectMemory wordSize r: SendNumArgsReg R: TempReg. backEnd hasLinkRegister ifFalse: [self AddCq: 1 R: TempReg].. self MoveR: ReceiverResultReg Xwr: TempReg R: SPReg] ifFalse: "Known argument count" [self MoveR: TempReg Mw: (backEnd hasLinkRegister ifTrue: [0] ifFalse: [1]) + numArgs * objectMemory wordSize r: SPReg]]. jumpItsTheReceiverStupid jmpTarget: self Label. self MoveMw: NSCTargetIndex * objectMemory wordSize r: SendNumArgsReg R: TempReg. self JumpR: TempReg. jumpMiss jmpTarget: self Label. objectRepresentation genEnsureOopInRegNotForwarded: ReceiverResultReg scratchReg: TempReg updatingMw: FoxMFReceiver r: FPReg. self numRegArgs > 0 ifTrue: [backEnd genPushRegisterArgsForNumArgs: numArgs scratchReg: TempReg]. ^self genTrampolineFor: aRoutine called: aString numArgs: 2 arg: SendNumArgsReg "The NSSendCache" arg: ReceiverResultReg arg: nil arg: nil saveRegs: false pushLinkReg: true resultReg: ReceiverResultReg "Never happens?" appendOpcodes: true! Item was changed: ----- Method: Cogit>>genNonLocalReturnTrampoline (in category 'initialization') ----- genNonLocalReturnTrampoline + self zeroOpcodeIndex. - opcodeIndex := 0. "write the return address to the coInterpreter instructionPointerAddress; following the CallRT to this CISCs will have pushed it on the stack, so pop it first; RISCs will have it in their link register so just write it directly." backEnd hasLinkRegister ifTrue: [self MoveR: LinkReg Aw: coInterpreter instructionPointerAddress] ifFalse: [self PopR: TempReg. "instruction pointer" self MoveR: TempReg Aw: coInterpreter instructionPointerAddress]. ^self genTrampolineFor: #ceNonLocalReturn: called: 'ceNonLocalReturnTrampoline' numArgs: 1 arg: ReceiverResultReg arg: nil arg: nil arg: nil saveRegs: false pushLinkReg: false resultReg: nil appendOpcodes: true! Item was changed: ----- Method: Cogit>>genPICAbortTrampoline (in category 'initialization') ----- genPICAbortTrampoline "Generate the abort for a PIC. This abort performs either a call of ceInterpretMethodFromPIC:receiver: to handle invoking an uncogged target or a call of ceMNUFromPICMNUMethod:receiver: to handle an MNU dispatch in a closed PIC. It distinguishes the two by testing ClassReg. If the register is zero then this is an MNU." + self zeroOpcodeIndex. - opcodeIndex := 0. backEnd hasLinkRegister ifTrue: [self PushR: LinkReg]. ^self genInnerPICAbortTrampoline: 'cePICAbort'! Item was changed: ----- Method: Cogit>>generateClosedPICPrototype (in category 'initialization') ----- generateClosedPICPrototype "Generate the prototype ClosedPIC to determine how much space as full PIC takes. When we first allocate a closed PIC it only has one or two cases and we want to grow it. So we have to determine how big a full one is before hand." numPICCases := 6. "stack allocate the various collections so that they are effectively garbage collected on return." + self allocateOpcodes: numPICCases * 9 bytecodes: 0. - self allocateOpcodes: numPICCases * 7 bytecodes: 0. literalsManager resetLiterals: numPICCases * 2. methodLabel address: methodZoneBase; dependent: nil. "for pc-relative MoveCw: cPIC R: ClassReg" self compileClosedPICPrototype. self computeMaximumSizes. closedPICSize := (self sizeof: CogMethod) + (self generateInstructionsAt: methodZoneBase + (self sizeof: CogMethod)). firstCPICCaseOffset := endCPICCase0 address - methodZoneBase. cPICCaseSize := endCPICCase1 address - endCPICCase0 address. cPICEndSize := closedPICSize - (numPICCases - 1 * cPICCaseSize + firstCPICCaseOffset). closedPICSize := methodZone roundUpLength: closedPICSize. self assert: picInterpretAbort address = (methodLabel address + self picInterpretAbortOffset) "self cCode: '' inSmalltalk: [| end | end := self outputInstructionsAt: methodZoneBase + headerSize. self disassembleFrom: methodZoneBase + headerSize to: end - 1. self halt]"! Item was changed: ----- Method: Cogit>>generateCogMethod: (in category 'generate machine code') ----- generateCogMethod: selector "We handle jump sizing simply. First we make a pass that asks each instruction to compute its maximum size. Then we make a pass that sizes jumps based on the maxmimum sizes. Then we make a pass that fixes up jumps. When fixing up a jump the jump is not allowed to choose a smaller offset but must stick to the size set in the second pass." <returnTypeC: #'CogMethod *'> | codeSize headerSize mapSize totalSize startAddress result method | <var: #method type: #'CogMethod *'> headerSize := self sizeof: CogMethod. + methodLabel address: methodZone freeStart. - methodLabel address: headerSize negated. self computeMaximumSizes. methodLabel concretizeAt: methodZone freeStart. codeSize := self generateInstructionsAt: methodLabel address + headerSize. mapSize := self generateMapAt: nil start: methodLabel address + cmNoCheckEntryOffset. totalSize := methodZone roundUpLength: headerSize + codeSize + mapSize. totalSize > MaxMethodSize ifTrue: [^self cCoerceSimple: MethodTooBig to: #'CogMethod *']. startAddress := methodZone allocate: totalSize. startAddress = 0 ifTrue: [^self cCoerceSimple: InsufficientCodeSpace to: #'CogMethod *']. self assert: startAddress + cmEntryOffset = entry address. self assert: startAddress + cmNoCheckEntryOffset = noCheckEntry address. result := self outputInstructionsAt: startAddress + headerSize. self assert: startAddress + headerSize + codeSize = result. backEnd padIfPossibleWithNopsFrom: result to: startAddress + totalSize - mapSize. self generateMapAt: startAddress + totalSize - 1 start: startAddress + cmNoCheckEntryOffset. self fillInBlockHeadersAt: startAddress. method := self fillInMethodHeader: (self cCoerceSimple: startAddress to: #'CogMethod *') size: totalSize selector: selector. postCompileHook notNil ifTrue: [self perform: postCompileHook with: method with: primInvokeLabel. postCompileHook := nil]. ^method! Item was changed: ----- Method: Cogit>>generateVMOwnerLockFunctions (in category 'initialization') ----- generateVMOwnerLockFunctions | startAddress | <inline: false> self cppIf: COGMTVM ifTrue: [self allocateOpcodes: backEnd numLowLevelLockOpcodes bytecodes: 0. + self zeroOpcodeIndex. initialPC := 0. endPC := numAbstractOpcodes - 1. startAddress := methodZoneBase. backEnd generateLowLevelTryLock: coInterpreter vmOwnerLockAddress. self outputInstructionsForGeneratedRuntimeAt: startAddress. self recordGeneratedRunTime: 'ceTryLockVMOwner' address: startAddress. ceTryLockVMOwner := self cCoerceSimple: startAddress to: #'unsigned long (*)(void)'. + self zeroOpcodeIndex. - opcodeIndex := 0. - literalsManager resetLiterals: 1. initialPC := 0. endPC := numAbstractOpcodes - 1. startAddress := methodZoneBase. backEnd generateLowLevelUnlock: coInterpreter vmOwnerLockAddress. self outputInstructionsForGeneratedRuntimeAt: startAddress. self recordGeneratedRunTime: 'ceUnlockVMOwner' address: startAddress. ceUnlockVMOwner := self cCoerceSimple: startAddress to: #'void (*)(void)']! Item was changed: ----- Method: Cogit>>outputInstructionsForGeneratedRuntimeAt: (in category 'initialization') ----- outputInstructionsForGeneratedRuntimeAt: startAddress "Output instructions generated for one of the generated run-time routines, a trampoline, etc" | size endAddress | <inline: false> - literalsManager dumpLiterals. self computeMaximumSizes. + methodLabel address: startAddress. "for addressIsInCurrentCompilation:" size := self generateInstructionsAt: startAddress. endAddress := self outputInstructionsAt: startAddress. self assert: startAddress + size = endAddress. methodZoneBase := self alignUptoRoutineBoundary: endAddress. backEnd nopsFrom: endAddress to: methodZoneBase - 1. self cCode: '' inSmalltalk: [methodZone freeStart: methodZoneBase]. ^startAddress! Item was changed: ----- Method: OutOfLineLiteralsManager>>mustDumpLiterals: (in category 'testing') ----- mustDumpLiterals: opcodeIndex <inline: true> + ^cogit getOpcodeIndex >= firstOpcodeIndex + and: [cogit getOpcodeIndex - firstOpcodeIndex >= cogit backEnd outOfLineLiteralOpcodeLimit]! - ^cogit opcodeIndex >= firstOpcodeIndex - and: [cogit opcodeIndex - firstOpcodeIndex >= cogit backEnd outOfLineLiteralOpcodeLimit]! Item was changed: ----- Method: SimpleStackBasedCogit>>genMustBeBooleanTrampolineFor:called: (in category 'initialization') ----- genMustBeBooleanTrampolineFor: boolean called: trampolineName <var: #trampolineName type: #'char *'> <inline: false> + self zeroOpcodeIndex. - opcodeIndex := 0. "If the objectRepresentation does want true & false to be mobile then we need to record these addresses." self assert: (objectRepresentation shouldAnnotateObjectReference: boolean) not. self AddCq: boolean R: TempReg. ^self genTrampolineFor: #ceSendMustBeBoolean: called: trampolineName numArgs: 1 arg: TempReg arg: nil arg: nil arg: nil saveRegs: false pushLinkReg: true resultReg: nil appendOpcodes: true! Item was changed: ----- Method: SimpleStackBasedCogit>>genPrimReturnEnterCogCodeEnilopmart: (in category 'initialization') ----- genPrimReturnEnterCogCodeEnilopmart: profiling "Generate the substitute return code for an external or FFI primitive call. On success simply return, extracting numArgs from newMethod. On primitive failure call ceActivateFailingPrimitiveMethod: newMethod." | jmpSample continuePostSample jmpFail | <var: #jmpSample type: #'AbstractInstruction *'> <var: #continuePostSample type: #'AbstractInstruction *'> <var: #jmpFail type: #'AbstractInstruction *'> + self zeroOpcodeIndex. - opcodeIndex := 0. profiling ifTrue: ["Test nextProfileTick for being non-zero and call checkProfileTick: if so. N.B. nextProfileTick is 64-bits so 32-bit systems need to test both halves." objectMemory wordSize = 4 ifTrue: [self MoveAw: coInterpreter nextProfileTickAddress R: TempReg. self MoveAw: coInterpreter nextProfileTickAddress + objectMemory wordSize R: ClassReg. self OrR: TempReg R: ClassReg] ifFalse: [self MoveAw: coInterpreter nextProfileTickAddress R: TempReg. self CmpCq: 0 R: TempReg]. "If set, jump to record sample call." jmpSample := self JumpNonZero: 0. continuePostSample := self Label]. self maybeCompileAllocFillerCheck. "Test primitive failure" self MoveAw: coInterpreter primFailCodeAddress R: TempReg. self flag: 'ask concrete code gen if move sets condition codes?'. self CmpCq: 0 R: TempReg. jmpFail := self JumpNonZero: 0. "Switch back to the Smalltalk stack. Stack better be in either of these two states: success: stackPointer -> result (was receiver) arg1 ... argN return pc failure: receiver arg1 ... stackPointer -> argN return pc We push the instructionPointer to reestablish the return pc in the success case, but leave it to ceActivateFailingPrimitiveMethod: to do so in the failure case." backEnd hasLinkRegister ifTrue: [backEnd genLoadStackPointers. "Switch back to Smalltalk stack." backEnd hasPCRegister ifTrue: [self PopR: ReceiverResultReg. "Pop result from stack" self MoveAw: coInterpreter instructionPointerAddress R: PCReg] "Return" ifFalse: [self MoveMw: 0 r: SPReg R: ReceiverResultReg. "Fetch result from stack" self MoveAw: coInterpreter instructionPointerAddress R: LinkReg. "Get ret pc" self RetN: objectMemory wordSize]] "Return, popping result from stack" ifFalse: [self MoveAw: coInterpreter instructionPointerAddress R: ClassReg. "Get return pc" backEnd genLoadStackPointers. "Switch back to Smalltalk stack." self MoveMw: 0 r: SPReg R: ReceiverResultReg. "Fetch result from stack" self MoveR: ClassReg Mw: 0 r: SPReg. "Restore return pc" self RetN: 0]. "Return, popping result from stack" "Primitive failed. Invoke C code to build the frame and continue." jmpFail jmpTarget: (self MoveAw: coInterpreter newMethodAddress R: SendNumArgsReg). "Reload sp with CStackPointer; easier than popping args of checkProfileTick." self MoveAw: self cStackPointerAddress R: SPReg. self compileCallFor: #ceActivateFailingPrimitiveMethod: numArgs: 1 arg: SendNumArgsReg arg: nil arg: nil arg: nil resultReg: nil saveRegs: false. "On Spur ceActivateFailingPrimitiveMethod: may retry the primitive and return if successful. So continue by returning to the caller. Switch back to the Smalltalk stack. Stack should be in this state: success: stackPointer -> result (was receiver) arg1 ... argN return pc We can push the instructionPointer or load it into the LinkRegister to reestablish the return pc" self MoveAw: coInterpreter instructionPointerAddress R: (backEnd hasLinkRegister ifTrue: [LinkReg] ifFalse: [ClassReg]). backEnd genLoadStackPointers. backEnd hasLinkRegister ifTrue: [self MoveMw: 0 r: SPReg R: ReceiverResultReg] "Fetch result from stack" ifFalse: [self MoveMw: objectMemory wordSize r: SPReg R: ReceiverResultReg. "Fetch result from stack" self PushR: ClassReg]. "Restore return pc on CISCs" self RetN: objectMemory wordSize. "return to caller, popping receiver" profiling ifTrue: ["Call ceCheckProfileTick: to record sample and then continue. newMethod should be up-to-date. Need to save and restore the link reg around this call." jmpSample jmpTarget: self Label. backEnd saveAndRestoreLinkRegAround: [self CallFullRT: (self cCode: '(unsigned long)ceCheckProfileTick' inSmalltalk: [self simulatedTrampolineFor: #ceCheckProfileTick])]. self Jump: continuePostSample]! Item was changed: ----- Method: SistaStackToRegisterMappingCogit>>genMustBeBooleanTrampolineFor:called: (in category 'initialization') ----- genMustBeBooleanTrampolineFor: boolean called: trampolineName "This can be entered in one of two states, depending on SendNumArgsReg. See e.g. genJumpIf:to:. If SendNumArgsReg is non-zero then this has been entered via the initial test of the counter in the jump executed count (i.e. the counter has tripped). In this case TempReg contains the boolean to be tested and should not be offset, and ceCounterTripped should be invoked with the unoffset TempReg. If SendNumArgsReg is zero then this has been entered for must-be-boolean processing. TempReg has been offset by boolean and must be corrected and ceSendMustBeBoolean: invoked with the corrected value." <var: #trampolineName type: #'char *'> | jumpMBB | <var: #jumpMBB type: #'AbstractInstruction *'> <inline: false> + self zeroOpcodeIndex. - opcodeIndex := 0. self CmpCq: 0 R: SendNumArgsReg. jumpMBB := self JumpZero: 0. "Open-code self compileTrampolineFor: #ceCounterTripped: numArgs: 1 arg: TempReg ... so we can restore ResultReceiverReg." self genSmalltalkToCStackSwitch: true. self compileCallFor: #ceCounterTripped: numArgs: 1 arg: TempReg arg: nil arg: nil arg: nil resultReg: TempReg "(*)" saveRegs: false. "(*) For the case where the ceCounterTripped: call returns (e.g. because there's no callback selector installed), the call to the ceSendMustBeBooleanAddTrue/FalseTrampoline is followed by a jump back to the start of the counter/condition test sequence. For this case copy the C result to TempReg (the register that is tested), to reload it with the boolean to be tested." backEnd genLoadStackPointers. backEnd hasLinkRegister ifTrue: [self PopR: LinkReg]. "To keep ResultReceiverReg live if optStatus thiught it was, simply reload it from the frame pointer. This avoids having to reload it in the common case (counter does not trip) if it was live." self MoveMw: FoxMFReceiver r: FPReg R: ReceiverResultReg. self RetN: 0. "If the objectRepresentation does want true & false to be mobile then we need to record these addresses." self assert: (objectRepresentation shouldAnnotateObjectReference: boolean) not. jumpMBB jmpTarget: (self AddCq: boolean R: TempReg). ^self genTrampolineFor: #ceSendMustBeBoolean: called: trampolineName numArgs: 1 arg: TempReg arg: nil arg: nil arg: nil saveRegs: false pushLinkReg: true resultReg: nil appendOpcodes: true! Item was changed: ----- Method: StackToRegisterMappingCogit>>genCallPICEnilopmartNumArgs: (in category 'initialization') ----- genCallPICEnilopmartNumArgs: numArgs "Generate special versions of the ceCallCogCodePopReceiverAndClassRegs enilopmart that also pop register args from the stack to undo the pushing of register args in the abort/miss trampolines." <returnTypeC: 'void (*genCallPICEnilopmartNumArgs(sqInt numArgs))(void)'> | size endAddress enilopmart | + self zeroOpcodeIndex. - opcodeIndex := 0. backEnd maybeEstablishVarBase. "Must happen first; value may be used in genLoadStackPointers" backEnd genLoadStackPointers. self PopR: ClassReg. "cacheTag" self PopR: TempReg. "entry-point" self PopR: (backEnd hasLinkRegister ifTrue: [LinkReg] ifFalse: [SendNumArgsReg]). "retpc" numArgs > 0 ifTrue: [numArgs > 1 ifTrue: [self PopR: Arg1Reg. self assert: self numRegArgs = 2]. self PopR: Arg0Reg]. self PopR: ReceiverResultReg. backEnd hasLinkRegister ifFalse: [self PushR: SendNumArgsReg]. "retpc" self JumpR: TempReg. self computeMaximumSizes. size := self generateInstructionsAt: methodZoneBase. endAddress := self outputInstructionsAt: methodZoneBase. self assert: methodZoneBase + size = endAddress. enilopmart := methodZoneBase. methodZoneBase := self alignUptoRoutineBoundary: endAddress. backEnd nopsFrom: endAddress to: methodZoneBase - 1. self recordGeneratedRunTime: (self trampolineName: 'ceCallPIC' numRegArgs: numArgs) address: enilopmart. ^self cCoerceSimple: enilopmart to: #'void (*)(void)'! Item was changed: ----- Method: StackToRegisterMappingCogit>>genMethodAbortTrampolineFor: (in category 'initialization') ----- genMethodAbortTrampolineFor: numArgs "Generate the abort for a method. This abort performs either a call of ceSICMiss: to handle a single-in-line cache miss or a call of ceStackOverflow: to handle a stack overflow. It distinguishes the two by testing ResultReceiverReg. If the register is zero then this is a stack-overflow because a) the receiver has already been pushed and so can be set to zero before calling the abort, and b) the receiver must always contain an object (and hence be non-zero) on SIC miss." | jumpSICMiss | <var: #jumpSICMiss type: #'AbstractInstruction *'> + self zeroOpcodeIndex. - opcodeIndex := 0. self CmpCq: 0 R: ReceiverResultReg. jumpSICMiss := self JumpNonZero: 0. "The abort sequence has pushed the LinkReg a second time - because a stack overflow can only happen after building a frame, which pushes LinkReg anyway, and we still need to push LinkReg in case we get to this routine from a sendMissAbort. (On ARM there is a simpler way; use two separate abort calls since all instructions are 32-bits but on x86 the zero receiver reg, call methodAbort sequence is smaller; we may fix this one day). Overwrite that duplicate with the right one - the return address for the call to the abort trampoline. The only reason it matters is an assert in ceStackOverflow: uses it" backEnd hasLinkRegister ifTrue: [self MoveR: LinkReg Mw: 0 r: SPReg]. self compileTrampolineFor: #ceStackOverflow: numArgs: 1 arg: SendNumArgsReg arg: nil arg: nil arg: nil saveRegs: false pushLinkReg: false "The LinkReg has already been set above." resultReg: nil. jumpSICMiss jmpTarget: self Label. backEnd genPushRegisterArgsForAbortMissNumArgs: numArgs. ^self genTrampolineFor: #ceSICMiss: called: (self trampolineName: 'ceMethodAbort' numRegArgs: numArgs) numArgs: 1 arg: ReceiverResultReg arg: nil arg: nil arg: nil saveRegs: false pushLinkReg: false "The LinkReg will have been pushed in genPushRegisterArgsForAbortMissNumArgs: above." resultReg: nil appendOpcodes: true! Item was changed: ----- Method: StackToRegisterMappingCogit>>genPICAbortTrampolineFor: (in category 'initialization') ----- genPICAbortTrampolineFor: numArgs "Generate the abort for a PIC. This abort performs either a call of ceInterpretMethodFromPIC:receiver: to handle invoking an uncogged target or a call of ceMNUFromPICMNUMethod:receiver: to handle an MNU dispatch in a closed PIC. It distinguishes the two by testing ClassReg. If the register is zero then this is an MNU." + self zeroOpcodeIndex. - opcodeIndex := 0. backEnd genPushRegisterArgsForAbortMissNumArgs: numArgs. ^self genInnerPICAbortTrampoline: (self trampolineName: 'cePICAbort' numRegArgs: numArgs)! Item was changed: ----- Method: StackToRegisterMappingCogit>>genPICMissTrampolineFor: (in category 'initialization') ----- genPICMissTrampolineFor: numArgs <inline: false> | startAddress | startAddress := methodZoneBase. + self zeroOpcodeIndex. - opcodeIndex := 0. "N.B. a closed PIC jumps to the miss routine, not calls it, so there is only one retpc on the stack." backEnd genPushRegisterArgsForNumArgs: numArgs scratchReg: SendNumArgsReg. self genTrampolineFor: #ceCPICMiss:receiver: called: (self trampolineName: 'cePICMiss' numRegArgs: numArgs) numArgs: 2 arg: ClassReg arg: ReceiverResultReg arg: nil arg: nil saveRegs: false pushLinkReg: true resultReg: nil appendOpcodes: true. ^startAddress! Item was changed: ----- Method: StackToRegisterMappingCogit>>genSendTrampolineFor:numArgs:called:arg:arg:arg: (in category 'initialization') ----- genSendTrampolineFor: aRoutine numArgs: numArgs called: aString arg: regOrConst0 arg: regOrConst1 arg: regOrConst2 "Generate a trampoline with three arguments. Hack: a negative value indicates an abstract register, a non-negative value indicates a constant." <var: #aRoutine type: #'void *'> <var: #aString type: #'char *'> | startAddress | <inline: false> startAddress := methodZoneBase. + self zeroOpcodeIndex. - opcodeIndex := 0. backEnd genPushRegisterArgsForNumArgs: numArgs scratchReg: SendNumArgsReg. self genTrampolineFor: aRoutine called: aString numArgs: 3 arg: regOrConst0 arg: regOrConst1 arg: regOrConst2 arg: nil saveRegs: false pushLinkReg: true resultReg: nil appendOpcodes: true. ^startAddress! Item was changed: ----- Method: StackToRegisterMappingCogit>>genSendTrampolineFor:numArgs:called:arg:arg:arg:arg: (in category 'initialization') ----- genSendTrampolineFor: aRoutine numArgs: numArgs called: aString arg: regOrConst0 arg: regOrConst1 arg: regOrConst2 arg: regOrConst3 "Generate a trampoline with four arguments. Hack: a negative value indicates an abstract register, a non-negative value indicates a constant." <var: #aRoutine type: #'void *'> <var: #aString type: #'char *'> | startAddress | <inline: false> startAddress := methodZoneBase. + self zeroOpcodeIndex. - opcodeIndex := 0. backEnd genPushRegisterArgsForNumArgs: numArgs scratchReg: SendNumArgsReg. self genTrampolineFor: aRoutine called: aString numArgs: 4 arg: regOrConst0 arg: regOrConst1 arg: regOrConst2 arg: regOrConst3 saveRegs: false pushLinkReg: true resultReg: nil appendOpcodes: true. ^startAddress!

1 0

← Newer
1
...
9
10
11
12
13
14
15
Older →

Jump to page:

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

Vm-dev June 2015