<div dir="ltr">Hello,<div><br></div><div>Nice job Tim with the closedPIC logic.<br><div><br></div><div>In the Sista JIT, you changed the way the type information from the closed PICs is extracted. Eliot wrote that and I don't understand it very well. I will compile a new VM and try to see if your code works. However I will do that next week as I am at Smalltalks right now.</div><div><br></div><div>By the way, what kind of machine use MIPS processor these days ? I saw the backend in mainstream VMs such as V8 so I guess the port makes sense but I am just wondering who use that.</div></div></div><div class="gmail_extra"><br><div class="gmail_quote">2015-11-11 16:28 GMT-03:00 Eliot Miranda <span dir="ltr"><<a href="mailto:eliot.miranda@gmail.com" target="_blank">eliot.miranda@gmail.com</a>></span>:<br><blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex"> <br><div dir="ltr">Bravo Tim! Such a nice improvement. Thank you!</div><div class="gmail_extra"><br><div class="gmail_quote">On Fri, Nov 6, 2015 at 12:08 PM, <span dir="ltr"><<a href="mailto:commits@source.squeak.org" target="_blank">commits@source.squeak.org</a>></span> wrote:<br><blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex"><br>
tim Rowledge uploaded a new version of VMMaker to project VM Maker:<br>
<a href="http://source.squeak.org/VMMaker/VMMaker.oscog-tpr.1511.mcz" rel="noreferrer" target="_blank">http://source.squeak.org/VMMaker/VMMaker.oscog-tpr.1511.mcz</a><br>
<br>
==================== Summary ====================<br>
<br>
Name: VMMaker.oscog-tpr.1511<br>
Author: tpr<br>
Time: 6 November 2015, 1:08:47.44 pm<br>
UUID: c040c1b1-b67f-45ec-973e-4ffd34322ea5<br>
Ancestors: VMMaker.oscog-eem.1510<br>
<br>
Merge in a fairly large change to closed PICs; they are no longer compiled each time we make on or extend one, but rather copied from a prototype and updated as needed.<br>
Take a look at <a href="http://wiki.squeak.org/squeak/6205" rel="noreferrer" target="_blank">http://wiki.squeak.org/squeak/6205</a> for some explanations.<br>
<br>
Oh, and fix the div/mod simulation so it actually works. This makes simulating the stdio reading test images actually work on ARM.<br>
<br>
Clement - there is a single Sista related change in here that may or may not break things for you ;-)<br>
<br>
=============== Diff against VMMaker.oscog-eem.1510 ===============<br>
<br>
Item was changed:<br>
----- Method: CogARMCompiler>>aeabiDiv:Mod: (in category 'simulation') -----<br>
aeabiDiv: dividend Mod: divisor<br>
"simulate the __aeabi_idivmod call"<br>
<doNotGenerate><br>
+ |result top bottom|<br>
- |result|<br>
<br>
+ top:= dividend signedIntFromLong.<br>
+ bottom := divisor signedIntFromLong.<br>
+<br>
+ cogit processor r0: (result :=(top quo: bottom) signedIntToLong).<br>
+ cogit processor r1: (top rem: bottom) signedIntToLong.<br>
- cogit processor r0: (result :=dividend quo: divisor).<br>
- cogit processor r1: (dividend rem: divisor).<br>
^result!<br>
<br>
Item was changed:<br>
----- Method: CogARMCompiler>>callTargetFromReturnAddress: (in category 'inline cacheing') -----<br>
callTargetFromReturnAddress: callSiteReturnAddress<br>
"Answer the address that the call immediately preceding callSiteReturnAddress will jump to."<br>
"this is also used by #jumpLongTargetBeforeFollowingAddress:."<br>
| callDistance call |<br>
call := self instructionBeforeAddress: callSiteReturnAddress.<br>
self assert: ((self instructionIsB: call) or: [self instructionIsBL: call]).<br>
callDistance := self extractOffsetFromBL: call.<br>
+ ^callSiteReturnAddress + 4 "this is the pc's +8 offset, - the 4 byte correction for the previous instruction address" + callDistance signedIntFromLong!<br>
- ^callSiteReturnAddress + 4 + callDistance signedIntFromLong!<br>
<br>
Item was changed:<br>
----- Method: CogARMCompiler>>computeMaximumSize (in category 'generate machine code') -----<br>
computeMaximumSize<br>
"Because we don't use Thumb, each ARM instruction has 4 bytes. Many<br>
abstract opcodes need more than one instruction. Instructions that refer<br>
to constants and/or literals depend on literals being stored in-line or out-of-line.<br>
<br>
N.B. The ^N forms are to get around the bytecode compiler's long branch<br>
limits which are exceeded when each case jumps around the otherwise."<br>
<br>
opcode<br>
caseOf: {<br>
"Noops & Pseudo Ops"<br>
[Label] -> [^0].<br>
[Literal] -> [^4].<br>
[AlignmentNops] -> [^(operands at: 0) - 4].<br>
[Fill16] -> [^4].<br>
[Fill32] -> [^4].<br>
[FillFromWord] -> [^4].<br>
[Nop] -> [^4].<br>
"Control"<br>
[Call] -> [^4].<br>
[CallFull] -> [^self literalLoadInstructionBytes + 4].<br>
[JumpR] -> [^4].<br>
[Jump] -> [^4].<br>
[JumpFull] -> [^self literalLoadInstructionBytes + 4].<br>
[JumpLong] -> [^4].<br>
[JumpZero] -> [^4].<br>
[JumpNonZero] -> [^4].<br>
[JumpNegative] -> [^4].<br>
[JumpNonNegative] -> [^4].<br>
[JumpOverflow] -> [^4].<br>
[JumpNoOverflow] -> [^4].<br>
[JumpCarry] -> [^4].<br>
[JumpNoCarry] -> [^4].<br>
[JumpLess] -> [^4].<br>
[JumpGreaterOrEqual] -> [^4].<br>
[JumpGreater] -> [^4].<br>
[JumpLessOrEqual] -> [^4].<br>
[JumpBelow] -> [^4].<br>
[JumpAboveOrEqual] -> [^4].<br>
[JumpAbove] -> [^4].<br>
[JumpBelowOrEqual] -> [^4].<br>
[JumpLongZero] -> [^4].<br>
[JumpLongNonZero] -> [^4].<br>
[JumpFPEqual] -> [^8].<br>
[JumpFPNotEqual] -> [^8].<br>
[JumpFPLess] -> [^8].<br>
[JumpFPGreaterOrEqual]-> [^8].<br>
[JumpFPGreater] -> [^8].<br>
[JumpFPLessOrEqual] -> [^8].<br>
[JumpFPOrdered] -> [^8].<br>
[JumpFPUnordered] -> [^8].<br>
[RetN] -> [^(operands at: 0) = 0 ifTrue: [4] ifFalse: [8]].<br>
[Stop] -> [^4].<br>
<br>
"Arithmetic"<br>
[AddCqR] -> [^self rotateable8bitSignedImmediate: (operands at: 0)<br>
ifTrue: [:r :i :n| 4]<br>
ifFalse: [self literalLoadInstructionBytes + 4]].<br>
[AndCqR] -> [^self rotateable8bitBitwiseImmediate: (operands at: 0)<br>
ifTrue: [:r :i :n| 4]<br>
ifFalse:<br>
[self literalLoadInstructionBytes = 4<br>
ifTrue: [8]<br>
ifFalse:<br>
[1 << (operands at: 0) highBit = ((operands at: 0) + 1)<br>
ifTrue: [8]<br>
ifFalse: [self literalLoadInstructionBytes + 4]]]].<br>
[AndCqRR] -> [^self rotateable8bitBitwiseImmediate: (operands at: 0)<br>
ifTrue: [:r :i :n| 4]<br>
ifFalse:<br>
[self literalLoadInstructionBytes = 4<br>
ifTrue: [8]<br>
ifFalse:<br>
[1 << (operands at: 0) highBit = ((operands at: 0) + 1)<br>
ifTrue: [8]<br>
ifFalse: [self literalLoadInstructionBytes + 4]]]].<br>
[CmpCqR] -> [^self rotateable8bitSignedImmediate: (operands at: 0)<br>
ifTrue: [:r :i :n| 4]<br>
ifFalse: [self literalLoadInstructionBytes + 4]].<br>
[OrCqR] -> [^self rotateable8bitImmediate: (operands at: 0)<br>
ifTrue: [:r :i| 4]<br>
ifFalse: [self literalLoadInstructionBytes + 4]].<br>
[SubCqR] -> [^self rotateable8bitSignedImmediate: (operands at: 0)<br>
ifTrue: [:r :i :n| 4]<br>
ifFalse: [self literalLoadInstructionBytes + 4]].<br>
[TstCqR] -> [^self rotateable8bitImmediate: (operands at: 0)<br>
ifTrue: [:r :i| 4]<br>
ifFalse: [self literalLoadInstructionBytes + 4]].<br>
[XorCqR] -> [^self rotateable8bitBitwiseImmediate: (operands at: 0)<br>
ifTrue: [:r :i :n| 4]<br>
ifFalse:<br>
[self literalLoadInstructionBytes = 4<br>
ifTrue: [8]<br>
ifFalse:<br>
[1 << (operands at: 0) highBit = ((operands at: 0) + 1)<br>
ifTrue: [8]<br>
ifFalse: [self literalLoadInstructionBytes + 4]]]].<br>
[AddCwR] -> [^self literalLoadInstructionBytes + 4].<br>
[AndCwR] -> [^self literalLoadInstructionBytes + 4].<br>
[CmpCwR] -> [^self literalLoadInstructionBytes + 4].<br>
[OrCwR] -> [^self literalLoadInstructionBytes + 4].<br>
[SubCwR] -> [^self literalLoadInstructionBytes + 4].<br>
[XorCwR] -> [^self literalLoadInstructionBytes + 4].<br>
[AddRR] -> [^4].<br>
[AndRR] -> [^4].<br>
[CmpRR] -> [^4].<br>
[OrRR] -> [^4].<br>
[XorRR] -> [^4].<br>
[SubRR] -> [^4].<br>
[NegateR] -> [^4].<br>
[LoadEffectiveAddressMwrR]<br>
-> [^self rotateable8bitImmediate: (operands at: 0)<br>
ifTrue: [:r :i| 4]<br>
ifFalse: [self literalLoadInstructionBytes + 4]].<br>
<br>
[LogicalShiftLeftCqR] -> [^4].<br>
[LogicalShiftRightCqR] -> [^4].<br>
[ArithmeticShiftRightCqR] -> [^4].<br>
[LogicalShiftLeftRR] -> [^4].<br>
[LogicalShiftRightRR] -> [^4].<br>
[ArithmeticShiftRightRR] -> [^4].<br>
[AddRdRd] -> [^4].<br>
[CmpRdRd] -> [^4].<br>
[SubRdRd] -> [^4].<br>
[MulRdRd] -> [^4].<br>
[DivRdRd] -> [^4].<br>
[SqrtRd] -> [^4].<br>
"ARM Specific Arithmetic"<br>
[SMULL] -> [^4].<br>
[MSR] -> [^4].<br>
[CMPSMULL] -> [^4]. "special compare for genMulR:R: usage"<br>
"Data Movement"<br>
[MoveCqR] -> [^self literalLoadInstructionBytes = 4<br>
ifTrue: [self literalLoadInstructionBytes]<br>
ifFalse:<br>
[self rotateable8bitBitwiseImmediate: (operands at: 0)<br>
ifTrue: [:r :i :n| 4]<br>
ifFalse: [self literalLoadInstructionBytes]]].<br>
[MoveCwR] -> [^self literalLoadInstructionBytes = 4<br>
ifTrue: [self literalLoadInstructionBytes]<br>
ifFalse:<br>
[(self inCurrentCompilation: (operands at: 0))<br>
ifTrue: [4]<br>
ifFalse: [self literalLoadInstructionBytes]]].<br>
[MoveRR] -> [^4].<br>
[MoveRdRd] -> [^4].<br>
[MoveAwR] -> [^(self isAddressRelativeToVarBase: (operands at: 0))<br>
ifTrue: [4]<br>
ifFalse: [self literalLoadInstructionBytes + 4]].<br>
[MoveRAw] -> [^(self isAddressRelativeToVarBase: (operands at: 1))<br>
ifTrue: [4]<br>
ifFalse: [self literalLoadInstructionBytes + 4]].<br>
+ [MoveAbR] -> [^(self isAddressRelativeToVarBase: (operands at: 0))<br>
+ ifTrue: [4]<br>
+ ifFalse: [self literalLoadInstructionBytes + 4]].<br>
+ [MoveRAb] -> [^(self isAddressRelativeToVarBase: (operands at: 1))<br>
+ ifTrue: [4]<br>
+ ifFalse: [self literalLoadInstructionBytes + 4]].<br>
[MoveRMwr] -> [^self is12BitValue: (operands at: 1)<br>
ifTrue: [:u :i| 4]<br>
ifFalse: [self literalLoadInstructionBytes + 4]].<br>
[MoveRdM64r] -> [^self literalLoadInstructionBytes + 4].<br>
[MoveMbrR] -> [^self is12BitValue: (operands at: 0)<br>
ifTrue: [:u :i| 4]<br>
ifFalse: [self literalLoadInstructionBytes + 4]].<br>
[MoveRMbr] -> [^self is12BitValue: (operands at: 1)<br>
ifTrue: [:u :i| 4]<br>
ifFalse: [self literalLoadInstructionBytes + 4]].<br>
[MoveM16rR] -> [^self rotateable8bitImmediate: (operands at: 0)<br>
ifTrue: [:r :i| 4]<br>
ifFalse: [self literalLoadInstructionBytes + 4]].<br>
[MoveM64rRd] -> [^self literalLoadInstructionBytes + 4].<br>
[MoveMwrR] -> [^self is12BitValue: (operands at: 0)<br>
ifTrue: [:u :i| 4]<br>
ifFalse: [self literalLoadInstructionBytes + 4]].<br>
[MoveXbrRR] -> [^4].<br>
[MoveRXbrR] -> [^4].<br>
[MoveXwrRR] -> [^4].<br>
[MoveRXwrR] -> [^4].<br>
[PopR] -> [^4].<br>
[PushR] -> [^4].<br>
[PushCw] -> [^self literalLoadInstructionBytes = 4<br>
ifTrue: [self literalLoadInstructionBytes + 4]<br>
ifFalse:<br>
[(self inCurrentCompilation: (operands at: 0))<br>
ifTrue: [8]<br>
ifFalse:<br>
[self rotateable8bitBitwiseImmediate: (operands at: 0)<br>
ifTrue: [:r :i :n| 8]<br>
ifFalse: [self literalLoadInstructionBytes + 4]]]].<br>
[PushCq] -> [^self literalLoadInstructionBytes = 4<br>
ifTrue: [self literalLoadInstructionBytes + 4]<br>
ifFalse:<br>
[self rotateable8bitBitwiseImmediate: (operands at: 0)<br>
ifTrue: [:r :i :n| 8]<br>
ifFalse: [self literalLoadInstructionBytes + 4]]].<br>
[PrefetchAw] -> [^(self isAddressRelativeToVarBase: (operands at: 0))<br>
ifTrue: [4]<br>
ifFalse: [self literalLoadInstructionBytes + 4]].<br>
"Conversion"<br>
[ConvertRRd] -> [^8].<br>
}.<br>
^0 "to keep C compiler quiet"<br>
!<br>
<br>
Item was added:<br>
+ ----- Method: CogARMCompiler>>concretizeMoveAbR (in category 'generate machine code - concretize') -----<br>
+ concretizeMoveAbR<br>
+ "Will get inlined into concretizeAt: switch."<br>
+ <inline: true><br>
+ | srcAddr destReg instrOffset|<br>
+ srcAddr := operands at: 0.<br>
+ destReg := self concreteRegister: (operands at: 1).<br>
+ (self isAddressRelativeToVarBase: srcAddr) ifTrue:<br>
+ [self machineCodeAt: 0 put: (self ldrb: destReg rn: ConcreteVarBaseReg plus: 1 imm: srcAddr - cogit varBaseAddress).<br>
+ ^machineCodeSize := 4].<br>
+ "load the address into ConcreteIPReg"<br>
+ instrOffset := self moveCw: srcAddr intoR: ConcreteIPReg.<br>
+ "We *could* overwrite the last instruction above with a LDR a, b, last-byte-of-srcAddr BUT that would break if we change to loading literals instead of forming long constants"<br>
+ self machineCodeAt: instrOffset put: (self ldrb: destReg rn: ConcreteIPReg plus: 1 imm: 0).<br>
+ ^machineCodeSize := instrOffset + 4!<br>
<br>
Item was added:<br>
+ ----- Method: CogARMCompiler>>concretizeMoveRAb (in category 'generate machine code - concretize') -----<br>
+ concretizeMoveRAb<br>
+ "Will get inlined into concretizeAt: switch."<br>
+ "LEA ConcreteIPReg<br>
+ strb srcReg, [ConcreteIPReg]"<br>
+ <inline: true><br>
+ | srcReg destAddr instrOffset|<br>
+ srcReg := self concreteRegister: (operands at: 0).<br>
+ destAddr := operands at: 1.<br>
+ (self isAddressRelativeToVarBase: destAddr) ifTrue:<br>
+ [self machineCodeAt: 0 put: (self strb: srcReg rn: ConcreteVarBaseReg plus: 1 imm: destAddr - cogit varBaseAddress).<br>
+ ^machineCodeSize := 4].<br>
+ "load the address into ConcreteIPReg"<br>
+ instrOffset := self moveCw: destAddr intoR: ConcreteIPReg.<br>
+ "We *could* overwrite the last instruction above with a LDR a, b, last-byte-of-srcAddr BUT that would break if we change to loading literals instead of forming long constants"<br>
+ self machineCodeAt: instrOffset put: (self strb: srcReg rn: ConcreteIPReg plus: 1 imm: 0).<br>
+ ^machineCodeSize := instrOffset + 4!<br>
<br>
Item was changed:<br>
----- Method: CogARMCompiler>>dispatchConcretize (in category 'generate machine code') -----<br>
dispatchConcretize<br>
"Attempt to generate concrete machine code for the instruction at address.<br>
This is the inner dispatch of concretizeAt: actualAddress which exists only<br>
to get around the branch size limits in the SqueakV3 (blue book derived)<br>
bytecode set."<br>
<returnTypeC: #void><br>
conditionOrNil ifNotNil:<br>
[self concretizeConditionalInstruction.<br>
^self].<br>
<br>
opcode caseOf: {<br>
"Noops & Pseudo Ops"<br>
[Label] -> [^self concretizeLabel].<br>
[Literal] -> [^self concretizeLiteral].<br>
[AlignmentNops] -> [^self concretizeAlignmentNops].<br>
[Fill16] -> [^self concretizeFill16].<br>
[Fill32] -> [^self concretizeFill32].<br>
[FillFromWord] -> [^self concretizeFillFromWord].<br>
[Nop] -> [^self concretizeNop].<br>
"Control"<br>
[Call] -> [^self concretizeCall]. "call code within code space"<br>
[CallFull] -> [^self concretizeCallFull]. "call code anywhere in address space"<br>
[JumpR] -> [^self concretizeJumpR].<br>
[JumpFull] -> [^self concretizeJumpFull]."jump within address space"<br>
[JumpLong] -> [^self concretizeConditionalJump: AL]."jumps witihn code space"<br>
[JumpLongZero] -> [^self concretizeConditionalJump: EQ].<br>
[JumpLongNonZero] -> [^self concretizeConditionalJump: NE].<br>
[Jump] -> [^self concretizeConditionalJump: AL].<br>
[JumpZero] -> [^self concretizeConditionalJump: EQ].<br>
[JumpNonZero] -> [^self concretizeConditionalJump: NE].<br>
[JumpNegative] -> [^self concretizeConditionalJump: MI].<br>
[JumpNonNegative] -> [^self concretizeConditionalJump: PL].<br>
[JumpOverflow] -> [^self concretizeConditionalJump: VS].<br>
[JumpNoOverflow] -> [^self concretizeConditionalJump: VC].<br>
[JumpCarry] -> [^self concretizeConditionalJump: CS].<br>
[JumpNoCarry] -> [^self concretizeConditionalJump: CC].<br>
[JumpLess] -> [^self concretizeConditionalJump: LT].<br>
[JumpGreaterOrEqual] -> [^self concretizeConditionalJump: GE].<br>
[JumpGreater] -> [^self concretizeConditionalJump: GT].<br>
[JumpLessOrEqual] -> [^self concretizeConditionalJump: LE].<br>
[JumpBelow] -> [^self concretizeConditionalJump: CC]. "unsigned lower"<br>
[JumpAboveOrEqual] -> [^self concretizeConditionalJump: CS]. "unsigned greater or equal"<br>
[JumpAbove] -> [^self concretizeConditionalJump: HI].<br>
[JumpBelowOrEqual] -> [^self concretizeConditionalJump: LS].<br>
[JumpFPEqual] -> [^self concretizeFPConditionalJump: EQ].<br>
[JumpFPNotEqual] -> [^self concretizeFPConditionalJump: NE].<br>
[JumpFPLess] -> [^self concretizeFPConditionalJump: LT].<br>
[JumpFPGreaterOrEqual] -> [^self concretizeFPConditionalJump: GE].<br>
[JumpFPGreater] -> [^self concretizeFPConditionalJump: GT].<br>
[JumpFPLessOrEqual] -> [^self concretizeFPConditionalJump: LE].<br>
[JumpFPOrdered] -> [^self concretizeFPConditionalJump: VC].<br>
[JumpFPUnordered] -> [^self concretizeFPConditionalJump: VS].<br>
[RetN] -> [^self concretizeRetN].<br>
[Stop] -> [^self concretizeStop].<br>
"Arithmetic"<br>
[AddCqR] -> [^self concretizeNegateableDataOperationCqR: AddOpcode].<br>
[AndCqR] -> [^self concretizeInvertibleDataOperationCqR: AndOpcode].<br>
[AndCqRR] -> [^self concretizeAndCqRR].<br>
[CmpCqR] -> [^self concretizeNegateableDataOperationCqR: CmpOpcode].<br>
[OrCqR] -> [^self concretizeDataOperationCqR: OrOpcode].<br>
[SubCqR] -> [^self concretizeSubCqR].<br>
[TstCqR] -> [^self concretizeTstCqR].<br>
[XorCqR] -> [^self concretizeInvertibleDataOperationCqR: XorOpcode].<br>
[AddCwR] -> [^self concretizeDataOperationCwR: AddOpcode].<br>
[AndCwR] -> [^self concretizeDataOperationCwR: AndOpcode].<br>
[CmpCwR] -> [^self concretizeDataOperationCwR: CmpOpcode].<br>
[OrCwR] -> [^self concretizeDataOperationCwR: OrOpcode].<br>
[SubCwR] -> [^self concretizeDataOperationCwR: SubOpcode].<br>
[XorCwR] -> [^self concretizeDataOperationCwR: XorOpcode].<br>
[AddRR] -> [^self concretizeDataOperationRR: AddOpcode].<br>
[AndRR] -> [^self concretizeDataOperationRR: AndOpcode].<br>
[CmpRR] -> [^self concretizeDataOperationRR: CmpOpcode].<br>
[OrRR] -> [^self concretizeDataOperationRR: OrOpcode].<br>
[SubRR] -> [^self concretizeDataOperationRR: SubOpcode].<br>
[XorRR] -> [^self concretizeDataOperationRR: XorOpcode].<br>
[AddRdRd] -> [^self concretizeAddRdRd].<br>
[CmpRdRd] -> [^self concretizeCmpRdRd].<br>
[DivRdRd] -> [^self concretizeDivRdRd].<br>
[MulRdRd] -> [^self concretizeMulRdRd].<br>
[SubRdRd] -> [^self concretizeSubRdRd].<br>
[SqrtRd] -> [^self concretizeSqrtRd].<br>
[NegateR] -> [^self concretizeNegateR].<br>
[LoadEffectiveAddressMwrR] -> [^self concretizeLoadEffectiveAddressMwrR].<br>
[ArithmeticShiftRightCqR] -> [^self concretizeArithmeticShiftRightCqR].<br>
[LogicalShiftRightCqR] -> [^self concretizeLogicalShiftRightCqR].<br>
[LogicalShiftLeftCqR] -> [^self concretizeLogicalShiftLeftCqR].<br>
[ArithmeticShiftRightRR] -> [^self concretizeArithmeticShiftRightRR].<br>
[LogicalShiftLeftRR] -> [^self concretizeLogicalShiftLeftRR].<br>
[LogicalShiftRightRR] -> [^self concretizeLogicalShiftRightRR].<br>
"ARM Specific Arithmetic"<br>
[SMULL] -> [^self concretizeSMULL] .<br>
[CMPSMULL] -> [^self concretizeCMPSMULL].<br>
[MSR] -> [^self concretizeMSR].<br>
"Data Movement"<br>
[MoveCqR] -> [^self concretizeMoveCqR].<br>
[MoveCwR] -> [^self concretizeMoveCwR].<br>
[MoveRR] -> [^self concretizeMoveRR].<br>
[MoveAwR] -> [^self concretizeMoveAwR].<br>
[MoveRAw] -> [^self concretizeMoveRAw].<br>
+ [MoveAbR] -> [^self concretizeMoveAbR].<br>
+ [MoveRAb] -> [^self concretizeMoveRAb].<br>
[MoveMbrR] -> [^self concretizeMoveMbrR].<br>
[MoveRMbr] -> [^self concretizeMoveRMbr].<br>
[MoveM16rR] -> [^self concretizeMoveM16rR].<br>
[MoveM64rRd] -> [^self concretizeMoveM64rRd].<br>
[MoveMwrR] -> [^self concretizeMoveMwrR].<br>
[MoveXbrRR] -> [^self concretizeMoveXbrRR].<br>
[MoveRXbrR] -> [^self concretizeMoveRXbrR].<br>
[MoveXwrRR] -> [^self concretizeMoveXwrRR].<br>
[MoveRXwrR] -> [^self concretizeMoveRXwrR].<br>
[MoveRMwr] -> [^self concretizeMoveRMwr].<br>
[MoveRdM64r] -> [^self concretizeMoveRdM64r].<br>
[PopR] -> [^self concretizePopR].<br>
[PushR] -> [^self concretizePushR].<br>
[PushCq] -> [^self concretizePushCq].<br>
[PushCw] -> [^self concretizePushCw].<br>
[PrefetchAw] -> [^self concretizePrefetchAw].<br>
"Conversion"<br>
[ConvertRRd] -> [^self concretizeConvertRRd]}!<br>
<br>
Item was added:<br>
+ ----- Method: CogARMCompiler>>instructionAddressBefore: (in category 'inline cacheing') -----<br>
+ instructionAddressBefore: followingAddress<br>
+ "Answer the instruction address immediately preceding followingAddress."<br>
+ <inline: true><br>
+ ^followingAddress -4!<br>
<br>
Item was changed:<br>
----- Method: CogARMCompiler>>instructionBeforeAddress: (in category 'inline cacheing') -----<br>
instructionBeforeAddress: followingAddress<br>
"Answer the instruction immediately preceding followingAddress."<br>
<inline: true><br>
+ ^objectMemory longAt: (self instructionAddressBefore: followingAddress)!<br>
- ^objectMemory longAt: followingAddress -4!<br>
<br>
Item was changed:<br>
----- Method: CogARMCompiler>>loadLiteralByteSize (in category 'accessing') -----<br>
loadLiteralByteSize<br>
+ "Answer the byte size of a MoveCwR opcode's corresponding machine code. On ARM this is a single instruction pc-relative register load - unless we have made a mistake and not turned on the out of line literals manager"<br>
+ ^4!<br>
- "Answer the byte size of a MoveCwR opcode's corresponding machine code"<br>
- ^16!<br>
<br>
Item was changed:<br>
----- Method: CogARMCompiler>>relocateCallBeforeReturnPC:by: (in category 'inline cacheing') -----<br>
relocateCallBeforeReturnPC: retpc by: delta<br>
| instr distanceDiv4 |<br>
self assert: delta \\ 4 = 0.<br>
delta ~= 0 ifTrue:<br>
[instr := self instructionBeforeAddress: retpc.<br>
self assert: ((self instructionIsB: instr) or: [self instructionIsBL: instr]).<br>
distanceDiv4 := instr bitAnd: 16rFFFFFF.<br>
distanceDiv4 := distanceDiv4 + (delta // 4).<br>
+ objectMemory longAt: (self instructionAddressBefore: retpc ) put: ((instr bitAnd: 16rFF000000) bitOr: (distanceDiv4 bitAnd: 16rFFFFFF))]!<br>
- objectMemory longAt: retpc - 4 put: ((instr bitAnd: 16rFF000000) bitOr: (distanceDiv4 bitAnd: 16rFFFFFF))]!<br>
<br>
Item was added:<br>
+ ----- Method: CogARMCompiler>>rewriteCPICJumpAt:target: (in category 'inline cacheing') -----<br>
+ rewriteCPICJumpAt: callSiteReturnAddress target: callTargetAddress<br>
+ "Rewrite a jump instruction to call a different target. This variant is used to reset the<br>
+ jumps in the prototype CPIC to suit each use,.<br>
+ Answer the extent of the code change which is used to compute the range of the icache to flush."<br>
+ <var: #callSiteReturnAddress type: #usqInt><br>
+ <var: #callTargetAddress type: #usqInt><br>
+ ^self rewriteTransferAt: callSiteReturnAddress target: callTargetAddress!<br>
<br>
Item was changed:<br>
----- Method: CogARMCompiler>>rewriteCallAt:target: (in category 'inline cacheing') -----<br>
rewriteCallAt: callSiteReturnAddress target: callTargetAddress<br>
"Rewrite a call instruction to call a different target. This variant is used to link PICs<br>
+ in ceSendMiss et al,.<br>
+ Answer the extent of the code change which is used to compute the range of the icache to flush."<br>
- in ceSendMiss et al, and to rewrite cached primitive calls. Answer the extent of<br>
- the code change which is used to compute the range of the icache to flush."<br>
<var: #callSiteReturnAddress type: #usqInt><br>
<var: #callTargetAddress type: #usqInt><br>
+ ^self rewriteTransferAt: callSiteReturnAddress target: callTargetAddress!<br>
- | callDistance call |<br>
- "self cCode: ''<br>
- inSmalltalk: [cogit disassembleFrom: callSiteReturnAddress - 10 to: callSiteReturnAddress - 1]."<br>
- false<br>
- ifTrue: [self assert: callTargetAddress >= cogit minCallAddress]<br>
- ifFalse: [callTargetAddress >= cogit minCallAddress ifFalse:<br>
- [self error: 'linking callsite to invalid address']].<br>
- callDistance := (callTargetAddress - (callSiteReturnAddress + 8 "pc offset"- 4 "return offset")) signedIntToLong.<br>
- self assert: (self isInImmediateJumpRange: callDistance). "we don't support long call updates, yet"<br>
- call := self bl: callDistance.<br>
- objectMemory longAt: callSiteReturnAddress - 4 put: call.<br>
-<br>
- self assert: (self callTargetFromReturnAddress: callSiteReturnAddress) signedIntToLong = callTargetAddress.<br>
- "self cCode: ''<br>
- inSmalltalk: [cogit disassembleFrom: callSiteReturnAddress - 10 to: callSiteReturnAddress - 1]."<br>
- ^4!<br>
<br>
Item was changed:<br>
----- Method: CogARMCompiler>>rewriteCallFullAt:target: (in category 'inline cacheing') -----<br>
rewriteCallFullAt: callSiteReturnAddress target: callTargetAddress<br>
"Rewrite a callFull instruction to jump to a different target. This variant<br>
+ is used to rewrite cached primitive calls where we load the target address into ip<br>
+ and use the 'blx ip' instruction for the actual call.<br>
+ Answer the extent of the<br>
- is used to rewrite cached primitive calls. Answer the extent of the<br>
code change which is used to compute the range of the icache to flush."<br>
<inline: true><br>
^self<br>
rewriteFullTransferAt: callSiteReturnAddress<br>
target: callTargetAddress<br>
expectedInstruction: 16rE12FFF3C!<br>
<br>
Item was changed:<br>
----- Method: CogARMCompiler>>rewriteJumpFullAt:target: (in category 'inline cacheing') -----<br>
rewriteJumpFullAt: callSiteReturnAddress target: callTargetAddress<br>
"Rewrite a full jump instruction to jump to a different target. This variant<br>
+ is used to rewrite cached primitive calls where we load the target address into ip<br>
+ and use the 'bx ip' instruction for the actual jump.<br>
+ Answer the extent of the<br>
- is used to rewrite cached primitive calls. Answer the extent of the<br>
code change which is used to compute the range of the icache to flush."<br>
<inline: true><br>
^self<br>
rewriteFullTransferAt: callSiteReturnAddress<br>
target: callTargetAddress<br>
expectedInstruction: 16rE12FFF1C!<br>
<br>
Item was added:<br>
+ ----- Method: CogARMCompiler>>rewriteJumpLongAt:target: (in category 'inline cacheing') -----<br>
+ rewriteJumpLongAt: callSiteReturnAddress target: callTargetAddress<br>
+ "Rewrite a jump instruction to call a different target. This variant is used to reset the<br>
+ jumps in the prototype CPIC to suit each use,.<br>
+ Answer the extent of the code change which is used to compute the range of the icache to flush."<br>
+ <var: #callSiteReturnAddress type: #usqInt><br>
+ <var: #callTargetAddress type: #usqInt><br>
+ ^self rewriteTransferAt: callSiteReturnAddress target: callTargetAddress!<br>
<br>
Item was added:<br>
+ ----- Method: CogARMCompiler>>rewriteTransferAt:target: (in category 'inline cacheing') -----<br>
+ rewriteTransferAt: callSiteReturnAddress target: callTargetAddress<br>
+ "Rewrite a call/jump instruction to call a different target. This variant is used to link PICs<br>
+ in ceSendMiss et al, and to rewrite call/jumps in CPICs.<br>
+ Answer the extent of<br>
+ the code change which is used to compute the range of the icache to flush."<br>
+ <var: #callSiteReturnAddress type: #usqInt><br>
+ <var: #callTargetAddress type: #usqInt><br>
+ | callDistance instr |<br>
+ "for debug - [cogit disassembleFrom: callSiteReturnAddress - 10 to: callSiteReturnAddress - 1]."<br>
+ false<br>
+ ifTrue: [self assert: callTargetAddress >= cogit minCallAddress]<br>
+ ifFalse: [callTargetAddress >= cogit minCallAddress ifFalse:<br>
+ [self error: 'linking callsite to invalid address']].<br>
+<br>
+ callDistance := (callTargetAddress - (callSiteReturnAddress + 8 "pc offset"- 4 "return offset")) signedIntToLong.<br>
+ self assert: (self isInImmediateJumpRange: callDistance). "we don't support long call updates, yet"<br>
+<br>
+ instr := self instructionBeforeAddress: callSiteReturnAddress.<br>
+ self assert: ((self instructionIsB: instr) or: [self instructionIsBL: instr]).<br>
+<br>
+ objectMemory longAt: (self instructionAddressBefore: callSiteReturnAddress) put: ((instr bitAnd: 16rFF000000) bitOr: (callDistance // 4 bitAnd: 16rFFFFFF)).<br>
+<br>
+ self assert: (self callTargetFromReturnAddress: callSiteReturnAddress) signedIntToLong = callTargetAddress.<br>
+<br>
+ ^4!<br>
<br>
Item was added:<br>
+ ----- Method: CogAbstractInstruction>>rewriteCPICCaseAt:tag:objRef:target: (in category 'inline cacheing') -----<br>
+ rewriteCPICCaseAt: followingAddress tag: newTag objRef: newObjRef target: newTarget<br>
+ "rewrite the three values involved in a CPIC case. Used by the create & extend cpcic methods"<br>
+ self subclassResponsibility<br>
+ !<br>
<br>
Item was added:<br>
+ ----- Method: CogIA32Compiler>>rewriteCPICCaseAt:tag:objRef:target: (in category 'inline cacheing') -----<br>
+ rewriteCPICCaseAt: followingAddress tag: newTag objRef: newObjRef target: newTarget<br>
+ "rewrite the three values involved in a CPIC case. Used by the create & extend cpcic methods"<br>
+<br>
+ "IA32 CPIC cases are<br>
+ cmpl $0x newTag, %eax<br>
+ movl $0x newObjRef, %ebx<br>
+ jz .+0x newTarget (0x00010924)<br>
+ "<br>
+ "rewite the tag via the first ldr"<br>
+ self storeLiteral: newTag beforeFollowingAddress: (followingAddress -11).<br>
+<br>
+ "write the obj ref/operand via the second ldr"<br>
+ self storeLiteral: newObjRef beforeFollowingAddress: (followingAddress - 6).<br>
+<br>
+ "write the jump address for the new target address"<br>
+ self rewriteJumpLongAt: followingAddress target: newTarget!<br>
<br>
Item was added:<br>
+ ----- Method: CogIA32Compiler>>rewriteCPICJumpAt:target: (in category 'inline cacheing') -----<br>
+ rewriteCPICJumpAt: callSiteReturnAddress target: callTargetAddress<br>
+ "Rewrite the short jump instruction to jump to a new cpic case target. "<br>
+ <var: #callSiteReturnAddress type: #usqInt><br>
+ <var: #callTargetAddress type: #usqInt><br>
+ | callDistance |<br>
+ callDistance := (callTargetAddress - callSiteReturnAddress) signedIntToLong.<br>
+ self assert: (callDistance < 256).<br>
+ objectMemory<br>
+ byteAt: callSiteReturnAddress - 1 put: (callDistance bitAnd: 16rFF).<br>
+ "self cCode: ''<br>
+ inSmalltalk: [cogit disassembleFrom: callSiteReturnAddress - 10 to: callSiteReturnAddress - 1]."<br>
+ ^2!<br>
<br>
Item was changed:<br>
----- Method: CogInLineLiteralsARMCompiler>>rewriteInlineCacheAt:tag:target: (in category 'inline cacheing') -----<br>
rewriteInlineCacheAt: callSiteReturnAddress tag: cacheTag target: callTargetAddress<br>
"Rewrite an inline cache to call a different target for a new tag. This variant is used<br>
to link unlinked sends in ceSend:to:numArgs: et al. Answer the extent of the code<br>
change which is used to compute the range of the icache to flush."<br>
<var: #callSiteReturnAddress type: #usqInt><br>
<var: #callTargetAddress type: #usqInt><br>
| call callDistance |<br>
false<br>
ifTrue: [self assert: callTargetAddress >= cogit minCallAddress]<br>
ifFalse: [callTargetAddress >= cogit minCallAddress ifFalse:<br>
[self error: 'linking callsite to invalid address']].<br>
callDistance := (callTargetAddress - (callSiteReturnAddress + 8 "pc offset"- 4 "return offset")) signedIntToLong.<br>
self assert: (self isInImmediateJumpRange: callDistance). "we don't support long call updates here"<br>
call := self bl: callDistance.<br>
+ objectMemory longAt: (self instructionAddressBefore: callSiteReturnAddress ) put: call.<br>
+ self insert32BitOperand: cacheTag into4InstructionsPreceding: (self instructionAddressBefore: callSiteReturnAddress ).<br>
- objectMemory longAt: callSiteReturnAddress - 4 put: call.<br>
- self insert32BitOperand: cacheTag into4InstructionsPreceding: callSiteReturnAddress - 4.<br>
self assert: (self callTargetFromReturnAddress: callSiteReturnAddress) signedIntToLong = callTargetAddress.<br>
+ self assert: (self extract32BitOperandFrom4InstructionsPreceding: (self instructionAddressBefore: callSiteReturnAddress )) = cacheTag.<br>
- self assert: (self extract32BitOperandFrom4InstructionsPreceding: callSiteReturnAddress - 4) = cacheTag.<br>
"self cCode: ''<br>
inSmalltalk: [cogit disassembleFrom: callSiteReturnAddress - 20 to: callSiteReturnAddress - 1]."<br>
^20!<br>
<br>
Item was changed:<br>
----- Method: CogMethod>>containsAddress: (in category 'testing') -----<br>
containsAddress: anAddress<br>
+ "is anAddress within my bounds; not a test of addresses referred to within instructions in the method"<br>
<inline: true><br>
^self asUnsignedInteger <= anAddress asUnsignedInteger<br>
and: [self asUnsignedInteger + self blockSize >= anAddress asUnsignedInteger]!<br>
<br>
Item was changed:<br>
----- Method: CogMethodZone>>printOpenPICList (in category 'accessing') -----<br>
printOpenPICList<br>
<api><br>
| openPIC |<br>
<var: #openPIC type: #'CogMethod *'><br>
openPIC := openPICList.<br>
[openPIC == nil] whileFalse:<br>
+ [coInterpreter printCogMethod: openPIC.<br>
- [self printCogMethod: openPIC.<br>
openPIC := self cCoerceSimple: openPIC nextOpenPIC to: #'CogMethod *']!<br>
<br>
Item was added:<br>
+ ----- Method: CogOutOfLineLiteralsARMCompiler>>literalBeforeFollowingAddress: (in category 'inline cacheing') -----<br>
+ literalBeforeFollowingAddress: followingAddress<br>
+ "Return the literal referenced by the instruction immediately preceding followingAddress."<br>
+ ^objectMemory longAt: (self pcRelativeAddressAt: (self instructionAddressBefore: followingAddress))!<br>
<br>
Item was added:<br>
+ ----- Method: CogOutOfLineLiteralsARMCompiler>>rewriteCPICCaseAt:tag:objRef:target: (in category 'inline cacheing') -----<br>
+ rewriteCPICCaseAt: followingAddress tag: newTag objRef: newObjRef target: newTarget<br>
+ "rewrite the three values involved in a CPIC case. Used by the create & extend cpcic methods"<br>
+<br>
+ "ARM CPIC cases are<br>
+ ldr TempReg, [pc relative -> tag]<br>
+ cmp TempReg0, TempReg<br>
+ ldr SendNumArgs, [pc relative -> obj ref]<br>
+ beq target"<br>
+ "rewite the tag via the first ldr"<br>
+ objectMemory longAt: (self pcRelativeAddressAt: followingAddress - 16) put: newTag.<br>
+<br>
+ "write the obj ref/operand via the second ldr"<br>
+ objectMemory longAt: (self pcRelativeAddressAt: followingAddress - 8) put: newObjRef.<br>
+<br>
+ "write the jump address for the new target address"<br>
+ self rewriteJumpLongAt: followingAddress target: newTarget!<br>
<br>
Item was changed:<br>
----- Method: CogOutOfLineLiteralsARMCompiler>>rewriteFullTransferAt:target:expectedInstruction: (in category 'inline cacheing') -----<br>
rewriteFullTransferAt: callSiteReturnAddress target: callTargetAddress expectedInstruction: expectedInstruction<br>
"Rewrite a CallFull or JumpFull instruction to transfer to a different target.<br>
+ This variant is used to rewrite cached primitive calls where we load the target address into ip<br>
+ and use the 'bx ip' or 'blx ip' instruction for the actual jump or call.<br>
+ Answer the extent<br>
- This variant is used to rewrite cached primitive calls. Answer the extent<br>
of the code change which is used to compute the range of the icache to flush."<br>
<var: #callSiteReturnAddress type: #usqInt><br>
<var: #callTargetAddress type: #usqInt><br>
self assert: (self instructionBeforeAddress: callSiteReturnAddress) = expectedInstruction.<br>
objectMemory longAt: (self pcRelativeAddressAt: callSiteReturnAddress - 8) put: callTargetAddress.<br>
"self cCode: ''<br>
inSmalltalk: [cogit disassembleFrom: callSiteReturnAddress - 8 to: (self pcRelativeAddressAt: callSiteReturnAddress - 8)]."<br>
^0!<br>
<br>
Item was changed:<br>
----- Method: CogOutOfLineLiteralsARMCompiler>>rewriteInlineCacheAt:tag:target: (in category 'inline cacheing') -----<br>
rewriteInlineCacheAt: callSiteReturnAddress tag: cacheTag target: callTargetAddress<br>
"Rewrite an inline cache to call a different target for a new tag. This variant is used<br>
to link unlinked sends in ceSend:to:numArgs: et al. Answer the extent of the code<br>
change which is used to compute the range of the icache to flush."<br>
<var: #callSiteReturnAddress type: #usqInt><br>
<var: #callTargetAddress type: #usqInt><br>
| call callDistance |<br>
callTargetAddress >= cogit minCallAddress ifFalse:<br>
[self error: 'linking callsite to invalid address'].<br>
callDistance := (callTargetAddress - (callSiteReturnAddress + 8 "pc offset"- 4 "return offset")) signedIntToLong.<br>
self assert: (self isInImmediateJumpRange: callDistance). "we don't support long call updates here"<br>
call := self bl: callDistance.<br>
objectMemory<br>
+ longAt: (self instructionAddressBefore: callSiteReturnAddress ) put: call;<br>
- longAt: callSiteReturnAddress - 4 put: call;<br>
longAt: (self pcRelativeAddressAt: callSiteReturnAddress - 8) put: cacheTag.<br>
self assert: (self inlineCacheTagAt: callSiteReturnAddress) = cacheTag.<br>
"self cCode: ''<br>
inSmalltalk: [cogit disassembleFrom: callSiteReturnAddress - 8 to: (self pcRelativeAddressAt: callSiteReturnAddress - 8)]."<br>
^4!<br>
<br>
Item was changed:<br>
----- Method: CogOutOfLineLiteralsARMCompiler>>storeLiteral:beforeFollowingAddress: (in category 'inline cacheing') -----<br>
storeLiteral: literal beforeFollowingAddress: followingAddress<br>
"Rewrite the literal in the instruction immediately preceding followingAddress."<br>
+ objectMemory longAt: (self pcRelativeAddressAt: (self instructionAddressBefore: followingAddress )) put: literal!<br>
- objectMemory longAt: (self pcRelativeAddressAt: followingAddress - 4) put: literal!<br>
<br>
Item was changed:<br>
CogClass subclass: #Cogit<br>
+ 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 methodLabel stackCheckLabel blockEntryLabel blockEntryNoContextSwitch blockNoContextSwitchOffset stackOverflowCall sendMiss missOffset entryPointMask checkedEntryAlignment uncheckedEntryAlignment cmEntryOffset entry cmNoCheckEntryOffset noCheckEntry picMNUAbort picInterpretAbort endCPICCase0 endCPICCase1 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 extA extB tempOop numIRCs indexOfIRC theIRCs implicitReceiverSendTrampolines cogMethodSurrogateClass cogBlockMethodSurrogateClass nsSendCacheSurrogateClass CStackPointer CFramePointer cPICPrototype cPICEndOfCodeOffset cPICEndOfCodeLabel maxCPICCases'<br>
- 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 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 extA extB tempOop numIRCs indexOfIRC theIRCs implicitReceiverSendTrampolines cogMethodSurrogateClass cogBlockMethodSurrogateClass nsSendCacheSurrogateClass CStackPointer CFramePointer'<br>
classVariableNames: 'AltBlockCreationBytecodeSize AltFirstSpecialSelector AltNSSendIsPCAnnotated AltNumSpecialSelectors 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 NumSpecialSelectors NumTrampolines ProcessorClass'<br>
poolDictionaries: 'CogCompilationConstants CogMethodConstants CogRTLOpcodes VMBasicConstants VMBytecodeConstants VMObjectIndices VMStackFrameOffsets'<br>
category: 'VMMaker-JIT'!<br>
Cogit class<br>
instanceVariableNames: 'generatorTable primitiveTable'!<br>
<br>
!Cogit commentStamp: 'eem 4/6/2015 15:56' prior: 0!<br>
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<br>
<br>
StackToRegisterMappingCogit genAndDis: (Integer >> #benchFib)<br>
<br>
I have concrete subclasses that implement different levels of optimization:<br>
SimpleStackBasedCogit is the simplest code generator.<br>
<br>
StackToRegisterMappingCogit is the current production code generator It defers pushing operands<br>
to the stack until necessary and implements a register-based calling convention for low-arity sends.<br>
<br>
StackToRegisterMappingCogit is an experimental code generator with support for counting<br>
conditional branches, intended to support adaptive optimization.<br>
<br>
coInterpreter <CoInterpreterSimulator><br>
the VM's interpreter with which I cooperate<br>
methodZoneManager <CogMethodZoneManager><br>
the manager of the machine code zone<br>
objectRepresentation <CogObjectRepresentation><br>
the object used to generate object accesses<br>
processor <BochsIA32Alien|?><br>
the simulator that executes the IA32/x86 machine code I generate when simulating execution in Smalltalk<br>
simulatedTrampolines <Dictionary of Integer -> MessageSend><br>
the dictionary mapping trap jump addresses to run-time routines used to warp from simulated machine code in to the Smalltalk run-time.<br>
simulatedVariableGetters <Dictionary of Integer -> MessageSend><br>
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.<br>
simulatedVariableSetters <Dictionary of Integer -> MessageSend><br>
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.<br>
printRegisters printInstructions clickConfirm <Boolean><br>
flags controlling debug printing and code simulation<br>
breakPC <Integer><br>
machine code pc breakpoint<br>
cFramePointer cStackPointer <Integer><br>
the variables representing the C stack & frame pointers, which must change on FFI callback and return<br>
selectorOop <sqInt><br>
the oop of the methodObj being compiled<br>
methodObj <sqInt><br>
the bytecode method being compiled<br>
initialPC endPC <Integer><br>
the start and end pcs of the methodObj being compiled<br>
methodOrBlockNumArgs <Integer><br>
argument count of current method or block being compiled<br>
needsFrame <Boolean><br>
whether methodObj or block needs a frame to execute<br>
primitiveIndex <Integer><br>
primitive index of current method being compiled<br>
methodLabel <CogAbstractOpcode><br>
label for the method header<br>
blockEntryLabel <CogAbstractOpcode><br>
label for the start of the block dispatch code<br>
stackOverflowCall <CogAbstractOpcode><br>
label for the call of ceStackOverflow in the method prolog<br>
sendMissCall <CogAbstractOpcode><br>
label for the call of ceSICMiss in the method prolog<br>
entryOffset <Integer><br>
offset of method entry code from start (header) of method<br>
entry <CogAbstractOpcode><br>
label for the first instruction of the method entry code<br>
noCheckEntryOffset <Integer><br>
offset of the start of a method proper (after the method entry code) from start (header) of method<br>
noCheckEntry <CogAbstractOpcode><br>
label for the first instruction of start of a method proper<br>
fixups <Array of <AbstractOpcode Label | nil>><br>
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<br>
abstractOpcodes <Array of <AbstractOpcode>><br>
the code generated when compiling methodObj<br>
byte0 byte1 byte2 byte3 <Integer><br>
individual bytes of current bytecode being compiled in methodObj<br>
bytecodePointer <Integer><br>
bytecode pc (same as Smalltalk) of the current bytecode being compiled<br>
opcodeIndex <Integer><br>
the index of the next free entry in abstractOpcodes (this code is translated into C where OrderedCollection et al do not exist)<br>
numAbstractOpcodes <Integer><br>
the number of elements in abstractOpcocdes<br>
blockStarts <Array of <BlockStart>><br>
the starts of blocks in the current method<br>
blockCount<br>
the index into blockStarts as they are being noted, and hence eventually the total number of blocks in the current method<br>
labelCounter <Integer><br>
a nicety for numbering labels not needed in the production system but probably not expensive enough to worry about<br>
ceStackOverflowTrampoline <Integer><br>
ceSend0ArgsTrampoline <Integer><br>
ceSend1ArgsTrampoline <Integer><br>
ceSend2ArgsTrampoline <Integer><br>
ceSendNArgsTrampoline <Integer><br>
ceSendSuper0ArgsTrampoline <Integer><br>
ceSendSuper1ArgsTrampoline <Integer><br>
ceSendSuper2ArgsTrampoline <Integer><br>
ceSendSuperNArgsTrampoline <Integer><br>
ceSICMissTrampoline <Integer><br>
ceCPICMissTrampoline <Integer><br>
ceStoreCheckTrampoline <Integer><br>
ceReturnToInterpreterTrampoline <Integer><br>
ceBaseFrameReturnTrampoline <Integer><br>
ceSendMustBeBooleanTrampoline <Integer><br>
ceClosureCopyTrampoline <Integer><br>
the various trampolines (system-call-like jumps from machine code to the run-time).<br>
See Cogit>>generateTrampolines for the mapping from trampoline to run-time<br>
routine and then read the run-time routine for a funcitonal description.<br>
ceEnterCogCodePopReceiverReg <Integer><br>
the enilopmart (jump from run-time to machine-code)<br>
methodZoneBase <Integer><br>
!<br>
Cogit class<br>
instanceVariableNames: 'generatorTable primitiveTable'!<br>
<br>
Item was changed:<br>
----- Method: Cogit class>>declareCVarsIn: (in category 'translation') -----<br>
declareCVarsIn: aCCodeGenerator<br>
#( 'coInterpreter' 'objectMemory' 'methodZone' 'objectRepresentation'<br>
'cogBlockMethodSurrogateClass' 'cogMethodSurrogateClass' 'nsSendCacheSurrogateClass'<br>
'threadManager' 'processor' 'lastNInstructions' 'simulatedAddresses'<br>
'simulatedTrampolines' 'simulatedVariableGetters' 'simulatedVariableSetters'<br>
'printRegisters' 'printInstructions' 'clickConfirm' 'singleStep') do:<br>
[:simulationVariableNotNeededForRealVM|<br>
aCCodeGenerator removeVariable: simulationVariableNotNeededForRealVM].<br>
NewspeakVM ifFalse:<br>
[#( 'selfSendTrampolines' 'dynamicSuperSendTrampolines'<br>
'implicitReceiverSendTrampolines' 'outerSendTrampolines'<br>
'ceEnclosingObjectTrampoline' 'numIRCs' 'indexOfIRC' 'theIRCs') do:<br>
[:variableNotNeededInNormalVM|<br>
aCCodeGenerator removeVariable: variableNotNeededInNormalVM]].<br>
aCCodeGenerator removeConstant: #COGMTVM. "this should be defined at compile time"<br>
aCCodeGenerator<br>
addHeaderFile:'<stddef.h>'; "for e.g. offsetof"<br>
addHeaderFile:'"sqCogStackAlignment.h"';<br>
addHeaderFile:'"dispdbg.h"'; "must precede cointerp.h & cogit.h otherwise NoDbgRegParms gets screwed up"<br>
addHeaderFile:'"cogmethod.h"'.<br>
NewspeakVM ifTrue:<br>
[aCCodeGenerator addHeaderFile:'"nssendcache.h"'].<br>
aCCodeGenerator<br>
addHeaderFile:'#if COGMTVM';<br>
addHeaderFile:'"cointerpmt.h"';<br>
addHeaderFile:'#else';<br>
addHeaderFile:'"cointerp.h"';<br>
addHeaderFile:'#endif';<br>
addHeaderFile:'"cogit.h"'.<br>
aCCodeGenerator<br>
var: #ceGetSP<br>
declareC: 'unsigned long (*ceGetSP)(void)';<br>
var: #ceCaptureCStackPointers<br>
declareC: 'void (*ceCaptureCStackPointers)(void)';<br>
var: #ceEnterCogCodePopReceiverReg<br>
declareC: 'void (*ceEnterCogCodePopReceiverReg)(void)';<br>
var: #realCEEnterCogCodePopReceiverReg<br>
declareC: 'void (*realCEEnterCogCodePopReceiverReg)(void)';<br>
var: #ceCallCogCodePopReceiverReg<br>
declareC: 'void (*ceCallCogCodePopReceiverReg)(void)';<br>
var: #realCECallCogCodePopReceiverReg<br>
declareC: 'void (*realCECallCogCodePopReceiverReg)(void)';<br>
var: #ceCallCogCodePopReceiverAndClassRegs<br>
declareC: 'void (*ceCallCogCodePopReceiverAndClassRegs)(void)';<br>
var: #realCECallCogCodePopReceiverAndClassRegs<br>
declareC: 'void (*realCECallCogCodePopReceiverAndClassRegs)(void)';<br>
var: #ceFlushICache<br>
declareC: 'static void (*ceFlushICache)(unsigned long from, unsigned long to)';<br>
var: #ceCheckFeaturesFunction<br>
declareC: 'static unsigned long (*ceCheckFeaturesFunction)(void)';<br>
var: #ceTryLockVMOwner<br>
declareC: 'unsigned long (*ceTryLockVMOwner)(void)';<br>
var: #ceUnlockVMOwner<br>
declareC: 'void (*ceUnlockVMOwner)(void)';<br>
var: #postCompileHook<br>
declareC: 'void (*postCompileHook)(CogMethod *)';<br>
var: #openPICList declareC: 'CogMethod *openPICList = 0';<br>
var: #maxMethodBefore type: #'CogBlockMethod *'.<br>
aCCodeGenerator<br>
declareVar: 'aMethodLabel' type: #'AbstractInstruction'; "Has to come lexicographically before backEnd & methodLabel"<br>
var: #backEnd declareC: 'AbstractInstruction * const backEnd = &aMethodLabel';<br>
var: #methodLabel declareC: 'AbstractInstruction * const methodLabel = &aMethodLabel'.<br>
self declareC: #(abstractOpcodes stackCheckLabel<br>
blockEntryLabel blockEntryNoContextSwitch<br>
stackOverflowCall sendMiss<br>
entry noCheckEntry selfSendEntry dynSuperEntry<br>
+ picMNUAbort picInterpretAbort endCPICCase0 endCPICCase1 cPICEndOfCodeLabel)<br>
- picMNUAbort picInterpretAbort endCPICCase0 endCPICCase1)<br>
as: #'AbstractInstruction *'<br>
in: aCCodeGenerator.<br>
aCCodeGenerator<br>
declareVar: #blockStarts type: #'BlockStart *';<br>
declareVar: #fixups type: #'BytecodeFixup *'.<br>
aCCodeGenerator<br>
var: #ordinarySendTrampolines<br>
declareC: 'sqInt ordinarySendTrampolines[NumSendTrampolines]';<br>
var: #superSendTrampolines<br>
declareC: 'sqInt superSendTrampolines[NumSendTrampolines]';<br>
var: #directedSuperSendTrampolines<br>
declareC: 'sqInt directedSuperSendTrampolines[NumSendTrampolines]';<br>
var: #selfSendTrampolines<br>
declareC: 'sqInt selfSendTrampolines[NumSendTrampolines]';<br>
var: #dynamicSuperSendTrampolines<br>
declareC: 'sqInt dynamicSuperSendTrampolines[NumSendTrampolines]';<br>
var: #implicitReceiverSendTrampolines<br>
declareC: 'sqInt implicitReceiverSendTrampolines[NumSendTrampolines]';<br>
var: #outerSendTrampolines<br>
declareC: 'sqInt outerSendTrampolines[NumSendTrampolines]';<br>
var: #trampolineAddresses<br>
declareC: 'static char *trampolineAddresses[NumTrampolines*2]';<br>
var: #objectReferencesInRuntime<br>
declareC: 'static usqInt objectReferencesInRuntime[NumObjRefsInRuntime]';<br>
var: #labelCounter<br>
type: #int;<br>
var: #traceFlags<br>
declareC: 'int traceFlags = 8 /* prim trace log on by default */';<br>
var: #cStackAlignment<br>
declareC: 'const int cStackAlignment = STACK_ALIGN_BYTES'.<br>
aCCodeGenerator<br>
declareVar: #CFramePointer type: #'void *';<br>
declareVar: #CStackPointer type: #'void *';<br>
declareVar: #minValidCallAddress type: #'unsigned long';<br>
declareVar: #debugPrimCallStackOffset type: #'unsigned long'.<br>
aCCodeGenerator vmClass generatorTable ifNotNil:<br>
[:bytecodeGenTable|<br>
aCCodeGenerator<br>
var: #generatorTable<br>
declareC: 'static BytecodeDescriptor generatorTable[', bytecodeGenTable size, ']',<br>
(self tableInitializerFor: bytecodeGenTable<br>
in: aCCodeGenerator);<br>
var: #primitiveGeneratorTable<br>
declareC: 'static PrimitiveDescriptor primitiveGeneratorTable[MaxCompiledPrimitiveIndex+1]',<br>
(self tableInitializerFor: aCCodeGenerator vmClass primitiveTable<br>
in: aCCodeGenerator)].<br>
"In C the abstract opcode names clash with the Smalltak generator syntactic sugar.<br>
Most of the syntactic sugar is inlined, but alas some remains. Rename the syntactic<br>
sugar to avoid the clash."<br>
(self organization listAtCategoryNamed: #'abstract instructions') do:<br>
[:s|<br>
aCCodeGenerator addSelectorTranslation: s to: 'g', (aCCodeGenerator cFunctionNameFor: s)].<br>
aCCodeGenerator addSelectorTranslation: #halt: to: 'haltmsg'!<br>
<br>
Item was changed:<br>
----- Method: Cogit>>addressOfEndOfCase:inCPIC: (in category 'in-line cacheing') -----<br>
+ addressOfEndOfCase: n inCPIC: cPIC<br>
+ "calculate the end of the n'th case statement - which is complicated because we have case 1 right at the top of our CPIC and then build up from the last one. Yes I know this sounds strange, but trust me - I'm an Engineer, we do things backwards all the emit"<br>
+<br>
- addressOfEndOfCase: n inCPIC: cPIC<br>
- "N.B. zero-relative"<br>
<var: #cPIC type: #'CogMethod *'><br>
+ self assert: (n >= 1and: [n <= maxCPICCases]).<br>
+ n = 1<br>
+ ifTrue: [^ cPIC asInteger + firstCPICCaseOffset]<br>
+ ifFalse: [^ cPIC asInteger + firstCPICCaseOffset + (maxCPICCases + 1 - n * cPICCaseSize)]!<br>
- ^cPIC asInteger + firstCPICCaseOffset + (n * cPICCaseSize)!<br>
<br>
Item was changed:<br>
----- Method: Cogit>>cPIC:HasTarget: (in category 'in-line cacheing') -----<br>
cPIC: cPIC HasTarget: targetMethod<br>
+ "Are any of the jumps from this CPIC to targetMethod?"<br>
<var: #cPIC type: #'CogMethod *'><br>
<var: #targetMethod type: #'CogMethod *'><br>
| pc target |<br>
target := targetMethod asUnsignedInteger + cmNoCheckEntryOffset.<br>
pc := cPIC asInteger + firstCPICCaseOffset.<br>
+ "Since this is a fast test doing simple compares we don't need to care that some<br>
+ cases have nonsense addresses in there. Just zip on through"<br>
1 to: cPIC cPICNumCases do:<br>
[:i|<br>
+ target = (backEnd jumpLongTargetBeforeFollowingAddress: pc) ifTrue:<br>
- target = (literalsManager cPICCase: i jumpTargetBefore: pc) ifTrue:<br>
[^true].<br>
pc := pc + cPICCaseSize].<br>
^false!<br>
<br>
Item was changed:<br>
----- Method: Cogit>>cPICHasForwardedClass: (in category 'in-line cacheing') -----<br>
+ cPICHasForwardedClass: cPIC<br>
+ "The first case in a CPIC doesn't have a class reference so we need only step over actually usd subsequent cases."<br>
- cPICHasForwardedClass: cPIC<br>
- <var: #cPIC type: #'CogMethod *'><br>
| pc |<br>
+ <var: #cPIC type: #'CogMethod *'><br>
+ "start by finding the address of the topmost case, the cPICNumCases'th one"<br>
+ pc := (self addressOfEndOfCase: cPIC cPICNumCases inCPIC: cPIC)<br>
+ - backEnd jumpLongConditionalByteSize.<br>
+ 2 to: cPIC cPICNumCases do:<br>
+ [:i | | classIndex |<br>
+ classIndex := literalsManager classRefInClosedPICAt: pc.<br>
+ (objectMemory isForwardedClassIndex: classIndex)<br>
+ ifTrue: [^ true].<br>
+ "since we started at the top, we can just add the case size each time to move on to the next case"<br>
+ pc := pc + cPICCaseSize].<br>
+ ^ false!<br>
- pc := cPIC asUnsignedInteger<br>
- + firstCPICCaseOffset<br>
- + cPICCaseSize<br>
- - backEnd jumpLongConditionalByteSize.<br>
- 2 to: cPIC cPICNumCases do:<br>
- [:i| | classIndex |<br>
- classIndex := literalsManager classRefInClosedPICAt: pc.<br>
- (objectMemory isForwardedClassIndex: classIndex) ifTrue:<br>
- [^true].<br>
- pc := pc + cPICCaseSize].<br>
- ^false!<br>
<br>
Item was changed:<br>
----- Method: Cogit>>cPICHasFreedTargets: (in category 'in-line cacheing') -----<br>
cPICHasFreedTargets: cPIC<br>
+ "scan the CPIC for target methods that have been freed. "<br>
<var: #cPIC type: #'CogMethod *'><br>
| pc entryPoint targetMethod |<br>
<var: #targetMethod type: #'CogMethod *'><br>
+<br>
- pc := cPIC asInteger + firstCPICCaseOffset.<br>
1 to: cPIC cPICNumCases do:<br>
[:i|<br>
+ pc := self addressOfEndOfCase: i inCPIC: cPIC.<br>
+ entryPoint := backEnd jumpLongTargetBeforeFollowingAddress: pc.<br>
- entryPoint := literalsManager cPICCase: i jumpTargetBefore: pc.<br>
"Find target from jump. Ignore jumps to the interpret and MNU calls within this PIC"<br>
(cPIC containsAddress: entryPoint) ifFalse:<br>
[targetMethod := self cCoerceSimple: entryPoint - cmNoCheckEntryOffset to: #'CogMethod *'.<br>
self assert: (targetMethod cmType = CMMethod or: [targetMethod cmType = CMFree]).<br>
targetMethod cmType = CMFree ifTrue:<br>
+ [^true]]].<br>
- [^true]].<br>
- pc := pc + cPICCaseSize].<br>
^false!<br>
<br>
Item was changed:<br>
----- Method: Cogit>>ceCPICMiss:receiver: (in category 'in-line cacheing') -----<br>
ceCPICMiss: cPIC receiver: receiver<br>
"Code entry closed PIC miss. A send has fallen<br>
through a closed (finite) polymorphic inline cache.<br>
Either extend it or patch the send site to an open PIC.<br>
The stack looks like:<br>
receiver<br>
args<br>
sp=> sender return address"<br>
<var: #cPIC type: #'CogMethod *'><br>
<api><br>
| outerReturn newTargetMethodOrNil errorSelectorOrNil cacheTag result |<br>
self cCode: ''<br>
inSmalltalk:<br>
[cPIC isInteger ifTrue:<br>
[^self ceCPICMiss: (self cogMethodSurrogateAt: cPIC) receiver: receiver]].<br>
(objectMemory isOopForwarded: receiver) ifTrue:<br>
[^coInterpreter ceSendFromInLineCacheMiss: cPIC].<br>
outerReturn := coInterpreter stackTop.<br>
self deny: (backEnd inlineCacheTagAt: outerReturn) = self picAbortDiscriminatorValue.<br>
+ cPIC cPICNumCases < maxCPICCases<br>
- cPIC cPICNumCases < numPICCases<br>
ifTrue:<br>
[self lookup: cPIC selector<br>
for: receiver<br>
methodAndErrorSelectorInto:<br>
[:method :errsel|<br>
newTargetMethodOrNil := method.<br>
errorSelectorOrNil := errsel]]<br>
ifFalse: [newTargetMethodOrNil := errorSelectorOrNil := nil].<br>
"We assume lookupAndCog:for: will *not* reclaim the method zone"<br>
self assert: outerReturn = coInterpreter stackTop.<br>
cacheTag := objectRepresentation inlineCacheTagForInstance: receiver.<br>
+ (cPIC cPICNumCases >= maxCPICCases<br>
- (cPIC cPICNumCases >= numPICCases<br>
or: [(errorSelectorOrNil notNil and: [errorSelectorOrNil ~= SelectorDoesNotUnderstand])<br>
or: [(objectRepresentation inlineCacheTagIsYoung: cacheTag)<br>
or: [newTargetMethodOrNil isNil<br>
or: [objectMemory isYoung: newTargetMethodOrNil]]]]) ifTrue:<br>
[result := self patchToOpenPICFor: cPIC selector<br>
numArgs: cPIC cmNumArgs<br>
receiver: receiver.<br>
self assert: result not. "If patchToOpenPICFor:.. returns we're out of code memory"<br>
^coInterpreter ceSendFromInLineCacheMiss: cPIC].<br>
"Now extend the PIC with the new case."<br>
self cogExtendPIC: cPIC<br>
CaseNMethod: newTargetMethodOrNil<br>
tag: cacheTag<br>
isMNUCase: errorSelectorOrNil = SelectorDoesNotUnderstand.<br>
"Jump back into the pic at its entry in case this is an MNU."<br>
coInterpreter<br>
executeCogPIC: cPIC<br>
fromLinkedSendWithReceiver: receiver<br>
andCacheTag: (backEnd inlineCacheTagAt: outerReturn).<br>
"NOTREACHED"<br>
^nil!<br>
<br>
Item was changed:<br>
----- Method: Cogit>>checkValidObjectReferencesInClosedPIC: (in category 'garbage collection') -----<br>
checkValidObjectReferencesInClosedPIC: cPIC<br>
<var: #cPIC type: #'CogMethod *'><br>
| ok pc |<br>
ok := true.<br>
pc := cPIC asInteger + firstCPICCaseOffset.<br>
+<br>
+ "first we check the obj ref at the beginning of the CPIC"<br>
(self checkMaybeObjRefInClosedPIC: (literalsManager objRefInClosedPICAt: pc - backEnd jumpLongByteSize)) ifFalse:<br>
[self print: 'object leak in CPIC '; printHex: cPIC asInteger;<br>
print: ' @ '; printHex: pc - backEnd jumpLongByteSize; cr.<br>
ok := false].<br>
+<br>
+ "Next we step over each case that is in use. We find the end address of the cPICNumCases'th case and can then just step forward by the case size thereafter"<br>
+ pc := self addressOfEndOfCase: cPIC cPICNumCases inCPIC: cPIC.<br>
+<br>
+ "For each case we check any object reference at the end address - sizeof(conditional instruction) and then increment the end address by case size"<br>
- pc := pc + cPICCaseSize.<br>
2 to: cPIC cPICNumCases do:<br>
[:i|<br>
objectRepresentation inlineCacheTagsMayBeObjects ifTrue:<br>
[(self checkMaybeObjRefInClosedPIC: (literalsManager classRefInClosedPICAt: pc - backEnd jumpLongConditionalByteSize)) ifFalse:<br>
[self print: 'object leak in CPIC '; printHex: cPIC asInteger;<br>
print: ' @ '; printHex: pc - backEnd jumpLongConditionalByteSize - backEnd loadLiteralByteSize; cr.<br>
ok := false]].<br>
(self checkMaybeObjRefInClosedPIC: (literalsManager objRefInClosedPICAt: pc - backEnd jumpLongConditionalByteSize)) ifFalse:<br>
[self print: 'object leak in CPIC '; printHex: cPIC asInteger;<br>
print: ' @ '; printHex: pc - backEnd jumpLongConditionalByteSize; cr.<br>
ok := false].<br>
pc := pc + cPICCaseSize].<br>
^ok!<br>
<br>
Item was changed:<br>
----- Method: Cogit>>closedPICRefersToUnmarkedObject: (in category 'garbage collection') -----<br>
</blockquote></div></div><br>...<br><br>[Message tronqué] </blockquote></div><br></div>