Nicolas Cellier uploaded a new version of VMMaker to project VM Maker:
http://source.squeak.org/VMMaker/VMMaker.oscog-nice.1823.mcz
==================== Summary ====================
Name: VMMaker.oscog-nice.1823
Author: nice
Time: 20 April 2016, 2:07:36.545 am
UUID: e93f8c0f-a7f9-409d-ac57-f8ae88bb4342
Ancestors: VMMaker.oscog-eem.1822, VMMaker.oscog-nice.1813
Merge the LargeIntegersPlugin acceleration for type checking (VMMaker.oscog-nice.1813).
Add the missing simulation hooks for Spur.
These changes require svn sources for platforms/Cross/vm/sqVirtualMemory.[ch] rev 3673
=============== Diff against VMMaker.oscog-eem.1822 ===============
Item was changed:
----- Method: FFIPlugin>>ffiPushUnsignedLongLongOop: (in category 'callout support') -----
ffiPushUnsignedLongLongOop: oop
"Push a longlong type (e.g., a 64bit integer).
Note: Coercions from float are *not* supported."
| lowWord highWord length ptr |
<var: #ptr type:'unsigned char *'>
oop == interpreterProxy nilObject
ifTrue:[^self ffiPushUnsignedLong: 0 Long: 0.]. "@@: check this"
oop == interpreterProxy falseObject
ifTrue:[^self ffiPushUnsignedLong: 0 Long: 0].
oop == interpreterProxy trueObject
ifTrue:[^self ffiPushUnsignedLong: 0 Long: 1].
(interpreterProxy isIntegerObject: oop) ifTrue:[
lowWord := interpreterProxy integerValueOf: oop.
lowWord < 0 ifTrue:[^self ffiFail: FFIErrorCoercionFailed].
highWord := 0.
] ifFalse:[
+ (interpreterProxy isLargePositiveIntegerObject: oop)
- (interpreterProxy fetchClassOf: oop) = interpreterProxy classLargePositiveInteger
ifFalse:[^interpreterProxy primitiveFail].
(interpreterProxy isBytes: oop) ifFalse:[^self ffiFail: FFIErrorCoercionFailed].
length := interpreterProxy byteSizeOf: oop.
length > 8 ifTrue:[^self ffiFail: FFIErrorCoercionFailed].
lowWord := highWord := 0.
ptr := interpreterProxy firstIndexableField: oop.
0 to: (length min: 4)-1 do:[:i|
lowWord := lowWord + ((ptr at: i) << (i*8))].
0 to: (length-5) do:[:i|
highWord := highWord + ((ptr at: i+4) << (i*8))].
].
^self ffiPushUnsignedLong: lowWord Long: highWord.!
Item was changed:
----- Method: IA32ABIPlugin>>primAlienReplace (in category 'primitives-accessing') -----
primAlienReplace
"Copy some number of bytes from some source object starting at the index
into the receiver destination object from startIndex to stopIndex . The source
and destination may be Aliens or byte-indexable objects. The primitive wll have either
of the following signatures:
<Alien | indexableByteSubclass | indexableWordSubclass>
primReplaceFrom: start <Integer>
to: stop <Integer>
with: replacement <Alien | indexableByteSubclass | indexableWordSubclass | Integer>
startingAt: repStart <Integer> ^<self>
<primitive: 'primitiveAlienReplace' error: errorCode module: 'IA32ABI'>
<Anywhere>
primReplaceIn: dest <Alien | indexableByteSubclass | indexableWordSubclass>
from: start <Integer>
to: stop <Integer>
with: replacement <Alien | indexableByteSubclass | indexableWordSubclass | Integer>
startingAt: repStart <Integer> ^<self>
<primitive: 'primitiveAlienReplace' error: errorCode module: 'IA32ABI'>
"
| array start stop repl replStart dest src totalLength count |
<export: true>
array := interpreterProxy stackValue: 4.
start := interpreterProxy stackIntegerValue: 3.
stop := interpreterProxy stackIntegerValue: 2.
repl := interpreterProxy stackValue: 1.
replStart := interpreterProxy stackIntegerValue: 0.
(interpreterProxy failed
or: [(interpreterProxy isWordsOrBytes: array) not]) ifTrue:
[^interpreterProxy primitiveFailFor: PrimErrBadArgument].
(self isAlien: array)
ifTrue:
[totalLength := self sizeField: array.
dest := (self startOfData: array withSize: totalLength) + start - 1.
totalLength = 0 "no bounds checks for zero-sized (pointer) Aliens"
ifTrue: [totalLength := stop]
ifFalse: [totalLength := totalLength abs]]
ifFalse:
[totalLength := interpreterProxy byteSizeOf: array.
dest := (self startOfByteData: array) + start - 1].
(start >= 1 and: [start - 1 <= stop and: [stop <= totalLength]])
ifFalse: [^interpreterProxy primitiveFailFor: PrimErrBadIndex].
(interpreterProxy isIntegerObject: repl)
ifTrue:
[(interpreterProxy integerValueOf: repl) <= 0 ifTrue:
[^interpreterProxy primitiveFailFor: PrimErrBadArgument].
src := (interpreterProxy integerValueOf: repl) + replStart - 1]
ifFalse:
+ [(interpreterProxy isLargePositiveIntegerObject: repl)
- [(interpreterProxy fetchClassOf: repl) == interpreterProxy classLargePositiveInteger
ifTrue:
[src := (interpreterProxy positive32BitValueOf: repl) + replStart - 1.
interpreterProxy failed ifTrue:
[^interpreterProxy primitiveFailFor: PrimErrBadArgument]]
ifFalse:
[(self isAlien: repl)
ifTrue:
[totalLength := self sizeField: repl.
src := (self startOfData: repl withSize: totalLength) + replStart - 1.
totalLength = 0 "no bounds checks for zero-sized (pointer) Aliens"
ifTrue: [totalLength := stop - start + replStart]
ifFalse: [totalLength := totalLength abs]]
ifFalse:
[(interpreterProxy isWordsOrBytes: repl) ifFalse:
[^interpreterProxy primitiveFailFor: PrimErrBadArgument].
totalLength := interpreterProxy byteSizeOf: repl.
src := (self startOfByteData: repl) + replStart - 1].
(replStart >= 1 and: [stop - start + replStart <= totalLength]) ifFalse:
[^interpreterProxy primitiveFailFor: PrimErrBadIndex]]].
(interpreterProxy isOopImmutable: array) ifTrue:
[^interpreterProxy primitiveFailFor: PrimErrNoModification].
count := stop - start + 1.
self cCode: 'memmove((void *)dest,(void *)src,count)'
inSmalltalk:
[count := count + src + dest. "squash unused var compiler warnings"
self error: 'not implemented'].
interpreterProxy pop: interpreterProxy methodArgumentCount!
Item was added:
+ ----- Method: Integer class>>ccg:prolog:expr:index: (in category '*VMMaker-plugin generation') -----
+ ccg: cg prolog: aBlock expr: aString index: anInteger
+
+ ^cg ccgLoad: aBlock expr: aString asKindOfIntegerFrom: anInteger!
Item was added:
+ ----- Method: Interpreter>>isKindOfInteger: (in category 'plugin primitive support') -----
+ isKindOfInteger: oop
+ "Answer true if the oop is kind of Integer (Small or Large)."
+ <api>
+ <inline: true>
+ ^(self isIntegerObject: oop)
+ or: [self isLargeIntegerInstance: oop]!
Item was added:
+ ----- Method: Interpreter>>isLargeIntegerObject: (in category 'plugin primitive support') -----
+ isLargeIntegerObject: oop
+ ^(self isLargeIntegerInstance: oop)!
Item was added:
+ ----- Method: Interpreter>>isLargeNegativeIntegerObject: (in category 'plugin primitive support') -----
+ isLargeNegativeIntegerObject: oop
+ ^(self isInstanceOfClassLargeNegativeInteger: oop)!
Item was added:
+ ----- Method: Interpreter>>isLargePositiveIntegerObject: (in category 'plugin primitive support') -----
+ isLargePositiveIntegerObject: oop
+ ^(self isInstanceOfClassLargePositiveInteger: oop)!
Item was removed:
- ----- Method: InterpreterPrimitives>>isInstanceOfClassLargeNegativeInteger: (in category 'primitive support') -----
- isInstanceOfClassLargeNegativeInteger: oop
- <inline: true>
- "N.B. Because Slang always inlines is:instanceOf:compactClassIndex:
- (because is:instanceOf:compactClassIndex: has an inline: pragma) the
- phrase (objectMemory splObj: ClassLargeNegativeInteger) is expanded
- in-place and is _not_ evaluated if oop has a non-zero CompactClassIndex."
- ^objectMemory
- is: oop
- instanceOf: (objectMemory splObj: ClassLargeNegativeInteger)
- compactClassIndex: ClassLargeNegativeIntegerCompactIndex!
Item was removed:
- ----- Method: InterpreterPrimitives>>isInstanceOfClassLargePositiveInteger: (in category 'primitive support') -----
- isInstanceOfClassLargePositiveInteger: oop
- <inline: true>
- "N.B. Because Slang always inlines is:instanceOf:compactClassIndex:
- (because is:instanceOf:compactClassIndex: has an inline: pragma) the
- phrase (objectMemory splObj: ClassLargePositiveInteger) is expanded
- in-place and is _not_ evaluated if oop has a non-zero CompactClassIndex."
- ^objectMemory
- is: oop
- instanceOf: (objectMemory splObj: ClassLargePositiveInteger)
- compactClassIndex: ClassLargePositiveIntegerCompactIndex!
Item was added:
+ ----- Method: InterpreterProxy>>isKindOfInteger: (in category 'testing') -----
+ isKindOfInteger: objectOrientedPointer
+ ^objectOrientedPointer isInteger!
Item was added:
+ ----- Method: InterpreterProxy>>isLargeIntegerObject: (in category 'testing') -----
+ isLargeIntegerObject: objectOrientedPointer
+ ^objectOrientedPointer isKindOf: LargePositiveInteger!
Item was added:
+ ----- Method: InterpreterProxy>>isLargeNegativeIntegerObject: (in category 'testing') -----
+ isLargeNegativeIntegerObject: objectOrientedPointer
+ ^objectOrientedPointer isMemberOf: LargeNegativeInteger!
Item was added:
+ ----- Method: InterpreterProxy>>isLargePositiveIntegerObject: (in category 'testing') -----
+ isLargePositiveIntegerObject: objectOrientedPointer
+ ^objectOrientedPointer isMemberOf: LargePositiveInteger!
Item was changed:
----- Method: LargeIntegersPlugin>>digitAddLarge:with: (in category 'oop functions') -----
digitAddLarge: firstInteger with: secondInteger
"Does not need to normalize!!"
| over firstDigitLen secondDigitLen shortInt shortDigitLen longInt longDigitLen sum newSum neg |
<var: #over type: #'unsigned int'>
firstDigitLen := self digitSizeOfLargeInt: firstInteger.
secondDigitLen := self digitSizeOfLargeInt: secondInteger.
+ neg := interpreterProxy isLargeNegativeIntegerObject: firstInteger.
- neg := (interpreterProxy fetchClassOf: firstInteger)
- = interpreterProxy classLargeNegativeInteger.
firstDigitLen <= secondDigitLen
ifTrue:
[shortInt := firstInteger.
shortDigitLen := firstDigitLen.
longInt := secondInteger.
longDigitLen := secondDigitLen]
ifFalse:
[shortInt := secondInteger.
shortDigitLen := secondDigitLen.
longInt := firstInteger.
longDigitLen := firstDigitLen].
" sum := Integer new: len neg: firstInteger negative."
self remapOop: #(shortInt longInt ) in: [sum := self createLargeIntegerNeg: neg digitLength: longDigitLen].
over := self
cDigitAdd: (self pointerToFirstDigitOfLargeInt: shortInt)
len: shortDigitLen
with: (self pointerToFirstDigitOfLargeInt: longInt)
len: longDigitLen
into: (self pointerToFirstDigitOfLargeInt: sum).
over > 0
ifTrue:
["sum := sum growby: 1."
self remapOop: sum in: [newSum := self createLargeIntegerNeg: neg byteLength: longDigitLen * 4 + 1].
self
cDigitCopyFrom: (self pointerToFirstDigitOfLargeInt: sum)
to: (self pointerToFirstDigitOfLargeInt: newSum)
len: longDigitLen.
sum := newSum.
"C index!!"
self cDigitOf: (self pointerToFirstDigitOfLargeInt: sum)
at: longDigitLen put: over]
ifFalse:
[sum := neg
ifTrue: [self normalizeNegative: sum]
ifFalse: [self normalizePositive: sum]].
^ sum!
Item was changed:
----- Method: LargeIntegersPlugin>>digitBitLogic:with:opIndex: (in category 'oop functions') -----
digitBitLogic: firstInteger with: secondInteger opIndex: opIx
"Bit logic here is only implemented for positive integers or Zero;
if rec or arg is negative, it fails."
| firstLarge secondLarge firstLen secondLen shortLen shortLarge longLen longLarge result |
(interpreterProxy isIntegerObject: firstInteger)
ifTrue:
[(interpreterProxy integerValueOf: firstInteger)
< 0 ifTrue: [^ interpreterProxy primitiveFail].
"convert it to a not normalized LargeInteger"
self remapOop: secondInteger in: [firstLarge := self createLargeFromSmallInteger: firstInteger]]
ifFalse:
+ [(interpreterProxy isLargePositiveIntegerObject: firstInteger) ifFalse: [^ interpreterProxy primitiveFail].
- [(interpreterProxy fetchClassOf: firstInteger)
- = interpreterProxy classLargeNegativeInteger ifTrue: [^ interpreterProxy primitiveFail].
firstLarge := firstInteger].
(interpreterProxy isIntegerObject: secondInteger)
ifTrue:
[(interpreterProxy integerValueOf: secondInteger)
< 0 ifTrue: [^ interpreterProxy primitiveFail].
"convert it to a not normalized LargeInteger"
self remapOop: firstLarge in: [secondLarge := self createLargeFromSmallInteger: secondInteger]]
ifFalse:
+ [(interpreterProxy isLargePositiveIntegerObject: secondInteger) ifFalse: [^ interpreterProxy primitiveFail].
- [(interpreterProxy fetchClassOf: secondInteger)
- = interpreterProxy classLargeNegativeInteger ifTrue: [^ interpreterProxy primitiveFail].
secondLarge := secondInteger].
firstLen := self byteSizeOfLargeInt: firstLarge.
secondLen := self byteSizeOfLargeInt: secondLarge.
firstLen < secondLen
ifTrue:
[shortLen := firstLen.
shortLarge := firstLarge.
longLen := secondLen.
longLarge := secondLarge]
ifFalse:
[shortLen := secondLen.
shortLarge := secondLarge.
longLen := firstLen.
longLarge := firstLarge].
self remapOop: #(shortLarge longLarge ) in: [result := interpreterProxy instantiateClass: interpreterProxy classLargePositiveInteger indexableSize: longLen].
self
cDigitOp: opIx
short: (self pointerToFirstDigitOfLargeInt: shortLarge)
len: shortLen + 3 // 4
long: (self pointerToFirstDigitOfLargeInt: longLarge)
len: longLen + 3 // 4
into: (self pointerToFirstDigitOfLargeInt: result).
interpreterProxy failed ifTrue: [^ 0].
^ self normalizePositive: result!
Item was changed:
----- Method: LargeIntegersPlugin>>digitSubLarge:with: (in category 'oop functions') -----
digitSubLarge: firstInteger with: secondInteger
"Normalizes."
| firstDigitLen secondDigitLen larger largeDigitLen smaller smallerDigitLen neg resDigitLen res firstNeg |
+ firstNeg := interpreterProxy isLargeNegativeIntegerObject: firstInteger.
- firstNeg := (interpreterProxy fetchClassOf: firstInteger)
- = interpreterProxy classLargeNegativeInteger.
firstDigitLen := self digitSizeOfLargeInt: firstInteger.
secondDigitLen := self digitSizeOfLargeInt: secondInteger.
firstDigitLen = secondDigitLen ifTrue:
[[firstDigitLen > 1
and: [(self unsafeDigitOfLargeInt: firstInteger at: firstDigitLen) = (self unsafeDigitOfLargeInt: secondInteger at: firstDigitLen)]]
whileTrue: [firstDigitLen := firstDigitLen - 1].
secondDigitLen := firstDigitLen].
(firstDigitLen < secondDigitLen
or: [firstDigitLen = secondDigitLen
and: [(self unsafeDigitOfLargeInt: firstInteger at: firstDigitLen) < (self unsafeDigitOfLargeInt: secondInteger at: firstDigitLen)]])
ifTrue:
[larger := secondInteger.
largeDigitLen := secondDigitLen.
smaller := firstInteger.
smallerDigitLen := firstDigitLen.
neg := firstNeg == false]
ifFalse:
[larger := firstInteger.
largeDigitLen := firstDigitLen.
smaller := secondInteger.
smallerDigitLen := secondDigitLen.
neg := firstNeg].
resDigitLen := largeDigitLen.
self remapOop: #(smaller larger)
in: [res := self createLargeIntegerNeg: neg digitLength: resDigitLen].
self
cDigitSub: (self pointerToFirstDigitOfLargeInt: smaller)
len: smallerDigitLen
with: (self pointerToFirstDigitOfLargeInt: larger)
len: largeDigitLen
into: (self pointerToFirstDigitOfLargeInt: res).
^neg
ifTrue: [self normalizeNegative: res]
ifFalse: [self normalizePositive: res]!
Item was changed:
----- Method: LargeIntegersPlugin>>isNormalized: (in category 'oop functions') -----
+ isNormalized: aLargeInteger
+ | len |
- isNormalized: anInteger
- | len maxVal minVal sLen val class positive |
- <var: #val type: #'unsigned long'>
- <var: #minVal type: #'unsigned long'>
- (interpreterProxy isIntegerObject: anInteger)
- ifTrue: [^ true].
- class := interpreterProxy fetchClassOf: anInteger.
- (positive := class = interpreterProxy classLargePositiveInteger) ifFalse:
- [class = interpreterProxy classLargeNegativeInteger ifFalse:
- [interpreterProxy primitiveFailFor: PrimErrBadArgument.
- ^false]].
"Check for leading zero of LargeInteger"
+ len := self byteSizeOfLargeInt: aLargeInteger.
- len := self byteSizeOfLargeInt: anInteger.
len = 0 ifTrue:
[^ false].
+ (self unsafeByteOfLargeInt: aLargeInteger at: len) = 0 ifTrue:
- (self unsafeByteOfLargeInt: anInteger at: len) = 0 ifTrue:
[^ false].
+ ^true!
- "no leading zero, now check if anInteger is in SmallInteger range or not"
- sLen := interpreterProxy maxSmallInteger > 16r3FFFFFFF
- ifTrue: [8]
- ifFalse: [4].
- "maximal digitLength of aSmallInteger"
- len > sLen ifTrue:
- [^ true].
- len < sLen ifTrue:
- [^ false].
- "len = sLen"
- ^positive
- ifTrue: [maxVal := interpreterProxy maxSmallInteger. "SmallInteger maxVal"
- "all bytes of maxVal but the highest one are just FF's"
- (self digitOfCSI: anInteger at: sLen // 4)
- > (self digitOfCSI: maxVal at: sLen // 4)]
- ifFalse: [val := self unsafeDigitOfLargeInt: anInteger at: len // 4.
- sLen > 4 ifTrue: [val := val << 32 + (self unsafeDigitOfLargeInt: anInteger at: 1)].
- minVal := 0 - interpreterProxy minSmallInteger.
- val > minVal]!
Item was changed:
----- Method: LargeIntegersPlugin>>normalize: (in category 'oop functions') -----
normalize: aLargeInteger
"Check for leading zeroes and return shortened copy if so."
self debugCode: [self msg: 'normalize: aLargeInteger'].
+ (interpreterProxy isLargePositiveIntegerObject: aLargeInteger)
- (interpreterProxy fetchClassOf: aLargeInteger)
- = interpreterProxy classLargePositiveInteger
ifTrue: [^ self normalizePositive: aLargeInteger]
ifFalse: [^ self normalizeNegative: aLargeInteger]!
Item was changed:
----- Method: LargeIntegersPlugin>>primDigitDiv:negative: (in category 'Integer primitives') -----
primDigitDiv: secondInteger negative: neg
"Answer the result of dividing firstInteger by secondInteger.
Fail if parameters are not integers, not normalized or secondInteger is
zero. "
| firstAsLargeInteger secondAsLargeInteger firstInteger |
self debugCode: [self msg: 'primDigitDiv: secondInteger negative: neg'].
firstInteger := self
primitive: 'primDigitDivNegative'
parameters: #(#Integer #Boolean )
receiver: #Integer.
- "Avoid crashes in case of getting unnormalized args."
- (self isNormalized: firstInteger)
- ifFalse: [self
- debugCode: [self msg: 'ERROR in primDigitDiv: secondInteger negative: neg'.
- self msg: '------> receiver *not* normalized!!'].
- ^ interpreterProxy primitiveFail].
- (self isNormalized: secondInteger)
- ifFalse: [self
- debugCode: [self msg: 'ERROR in primDigitDiv: secondInteger negative: neg'.
- self msg: '------> argument *not* normalized!!'].
- ^ interpreterProxy primitiveFail].
"Coerce SmallIntegers to corresponding (not normalized) large integers
and check for zerodivide."
(interpreterProxy isIntegerObject: firstInteger)
ifTrue: ["convert to LargeInteger"
self
remapOop: secondInteger
in: [firstAsLargeInteger := self createLargeFromSmallInteger: firstInteger]]
+ ifFalse:
+ ["Avoid crashes in case of getting unnormalized args."
+ (self isNormalized: firstInteger)
+ ifFalse:
+ [self debugCode:
+ [self msg: 'ERROR in primDigitDiv: secondInteger negative: neg'.
+ self msg: '------> receiver *not* normalized!!'].
+ ^ interpreterProxy primitiveFail].
+ firstAsLargeInteger := firstInteger].
- ifFalse: [firstAsLargeInteger := firstInteger].
(interpreterProxy isIntegerObject: secondInteger)
ifTrue: ["check for zerodivide and convert to LargeInteger"
(interpreterProxy integerValueOf: secondInteger)
= 0
ifTrue: [^ interpreterProxy primitiveFail].
self
remapOop: firstAsLargeInteger
in: [secondAsLargeInteger := self createLargeFromSmallInteger: secondInteger]]
+ ifFalse:
+ ["Avoid crashes in case of getting unnormalized args."
+ (self isNormalized: secondInteger)
+ ifFalse:
+ [self debugCode:
+ [self msg: 'ERROR in primDigitDiv: secondInteger negative: neg'.
+ self msg: '------> argument *not* normalized!!'].
+ ^ interpreterProxy primitiveFail].
+ secondAsLargeInteger := secondInteger].
- ifFalse: [secondAsLargeInteger := secondInteger].
^ self
digitDivLarge: firstAsLargeInteger
with: secondAsLargeInteger
negative: neg!
Item was added:
+ ----- Method: LargeNegativeInteger class>>ccg:prolog:expr:index: (in category '*VMMaker-plugin generation') -----
+ ccg: cg prolog: aBlock expr: aString index: anInteger
+
+ ^cg ccgLoad: aBlock expr: aString asMemberOfLargeNegativeIntegerFrom: anInteger!
Item was added:
+ ----- Method: LargePositiveInteger class>>ccg:prolog:expr:index: (in category '*VMMaker-plugin generation') -----
+ ccg: cg prolog: aBlock expr: aString index: anInteger
+
+ ^cg ccgLoad: aBlock expr: aString asMemberOfLargePositiveIntegerFrom: anInteger!
Item was added:
+ ----- Method: NewCoObjectMemorySimulator>>isKindOfInteger: (in category 'simulation only') -----
+ isKindOfInteger: offset
+ ^coInterpreter isKindOfInteger: offset!
Item was added:
+ ----- Method: NewCoObjectMemorySimulator>>isLargeIntegerObject: (in category 'simulation only') -----
+ isLargeIntegerObject: offset
+ ^coInterpreter isLargeIntegerObject: offset!
Item was added:
+ ----- Method: NewCoObjectMemorySimulator>>isLargeNegativeIntegerObject: (in category 'simulation only') -----
+ isLargeNegativeIntegerObject: offset
+ ^coInterpreter isLargeNegativeIntegerObject: offset!
Item was added:
+ ----- Method: NewCoObjectMemorySimulator>>isLargePositiveIntegerObject: (in category 'simulation only') -----
+ isLargePositiveIntegerObject: offset
+ ^coInterpreter isLargePositiveIntegerObject: offset!
Item was added:
+ ----- Method: NewObjectMemorySimulator>>isKindOfInteger: (in category 'simulation only') -----
+ isKindOfInteger: offset
+ ^coInterpreter isKindOfInteger: offset!
Item was added:
+ ----- Method: NewObjectMemorySimulator>>isLargeIntegerObject: (in category 'simulation only') -----
+ isLargeIntegerObject: offset
+ ^coInterpreter isLargeIntegerObject: offset!
Item was added:
+ ----- Method: NewObjectMemorySimulator>>isLargeNegativeIntegerObject: (in category 'simulation only') -----
+ isLargeNegativeIntegerObject: offset
+ ^coInterpreter isLargeNegativeIntegerObject: offset!
Item was added:
+ ----- Method: NewObjectMemorySimulator>>isLargePositiveIntegerObject: (in category 'simulation only') -----
+ isLargePositiveIntegerObject: offset
+ ^coInterpreter isLargePositiveIntegerObject: offset!
Item was changed:
----- Method: ObjectMemory>>cCoerceSimple:to: (in category 'simulation support') -----
cCoerceSimple: value to: cTypeString
<doNotGenerate>
^cTypeString caseOf:
+ { [#'char *'] -> [value].
+ [#'unsigned int'] -> [value]. }!
- { [#'char *'] -> [value] }!
Item was added:
+ ----- Method: ObjectMemory>>isInstanceOfClassLargeNegativeInteger: (in category 'interpreter access') -----
+ isInstanceOfClassLargeNegativeInteger: oop
+ <inline: true>
+ "N.B. Because Slang always inlines is:instanceOf:compactClassIndex:
+ (because is:instanceOf:compactClassIndex: has an inline: pragma) the
+ phrase (objectMemory splObj: ClassLargeNegativeInteger) is expanded
+ in-place and is _not_ evaluated if oop has a non-zero CompactClassIndex."
+ ^self
+ is: oop
+ instanceOf: (self splObj: ClassLargeNegativeInteger)
+ compactClassIndex: ClassLargeNegativeIntegerCompactIndex!
Item was added:
+ ----- Method: ObjectMemory>>isInstanceOfClassLargePositiveInteger: (in category 'interpreter access') -----
+ isInstanceOfClassLargePositiveInteger: oop
+ <inline: true>
+ "N.B. Because Slang always inlines is:instanceOf:compactClassIndex:
+ (because is:instanceOf:compactClassIndex: has an inline: pragma) the
+ phrase (objectMemory splObj: ClassLargePositiveInteger) is expanded
+ in-place and is _not_ evaluated if oop has a non-zero CompactClassIndex."
+ ^self
+ is: oop
+ instanceOf: (self splObj: ClassLargePositiveInteger)
+ compactClassIndex: ClassLargePositiveIntegerCompactIndex!
Item was added:
+ ----- Method: ObjectMemory>>isLargeIntegerInstance: (in category 'interpreter access') -----
+ isLargeIntegerInstance: oop
+ <inline: true>
+ ^(self isInstanceOfClassLargePositiveInteger: oop)
+ or: [self isInstanceOfClassLargeNegativeInteger: oop]!
Item was added:
+ ----- Method: SmartSyntaxPluginCodeGenerator>>ccgLoad:expr:asKindOfIntegerFrom: (in category 'coercing') -----
+ ccgLoad: aBlock expr: aString asKindOfIntegerFrom: anInteger
+
+ ^String streamContents: [:aStream | aStream
+ nextPutAll: 'interpreterProxy success: (interpreterProxy isKindOfInteger: (interpreterProxy stackValue: ';
+ nextPutAll: anInteger asString;
+ nextPutAll: ')).';
+ crtab;
+ nextPutAll: (self
+ ccgLoad: aBlock
+ expr: aString
+ asRawOopFrom: anInteger)]!
Item was added:
+ ----- Method: SmartSyntaxPluginCodeGenerator>>ccgLoad:expr:asMemberOfLargeNegativeIntegerFrom: (in category 'coercing') -----
+ ccgLoad: aBlock expr: aString asMemberOfLargeNegativeIntegerFrom: anInteger
+
+ ^String streamContents: [:aStream | aStream
+ nextPutAll: 'interpreterProxy success: (interpreterProxy isLargeNegativeIntegerObject: (interpreterProxy stackValue: ';
+ nextPutAll: anInteger asString;
+ nextPutAll: ')).';
+ crtab;
+ nextPutAll: (self
+ ccgLoad: aBlock
+ expr: aString
+ asRawOopFrom: anInteger)]!
Item was added:
+ ----- Method: SmartSyntaxPluginCodeGenerator>>ccgLoad:expr:asMemberOfLargePositiveIntegerFrom: (in category 'coercing') -----
+ ccgLoad: aBlock expr: aString asMemberOfLargePositiveIntegerFrom: anInteger
+
+ ^String streamContents: [:aStream | aStream
+ nextPutAll: 'interpreterProxy success: (interpreterProxy isLargePositiveIntegerObject: (interpreterProxy stackValue: ';
+ nextPutAll: anInteger asString;
+ nextPutAll: ')).';
+ crtab;
+ nextPutAll: (self
+ ccgLoad: aBlock
+ expr: aString
+ asRawOopFrom: anInteger)]!
Item was added:
+ ----- Method: SmartSyntaxPluginSimulator>>ccgLoad:expr:asKindOfIntegerFrom: (in category 'simulation') -----
+ ccgLoad: forProlog expr: failBlock asKindOfIntegerFrom: argIndexOrNil
+ ^[:oop|
+ interpreterProxy success: (interpreterProxy isKindOfInteger: oop).
+ oop]!
Item was added:
+ ----- Method: SmartSyntaxPluginSimulator>>ccgLoad:expr:asMemberOfLargeNegativeIntegerFrom: (in category 'simulation') -----
+ ccgLoad: forProlog expr: failBlock asMemberOfLargeNegativeIntegerFrom: argIndexOrNil
+ ^[:oop|
+ interpreterProxy success: (interpreterProxy isLargeNegativeIntegerObject: oop).
+ oop]!
Item was added:
+ ----- Method: SmartSyntaxPluginSimulator>>ccgLoad:expr:asMemberOfLargePositiveIntegerFrom: (in category 'simulation') -----
+ ccgLoad: forProlog expr: failBlock asMemberOfLargePositiveIntegerFrom: argIndexOrNil
+ ^[:oop|
+ interpreterProxy success: (interpreterProxy isLargePositiveIntegerObject: oop).
+ oop]!
Item was added:
+ ----- Method: SpurMemoryManager>>isInstanceOfClassLargeNegativeInteger: (in category 'interpreter access') -----
+ isInstanceOfClassLargeNegativeInteger: oop
+ "Answer if the oop is a large negative integer instance."
+ ^(self isNonImmediate: oop) and: [(self classIndexOf: oop) = ClassLargeNegativeIntegerCompactIndex]!
Item was added:
+ ----- Method: SpurMemoryManager>>isInstanceOfClassLargePositiveInteger: (in category 'interpreter access') -----
+ isInstanceOfClassLargePositiveInteger: oop
+ "Answer if the oop is a large positive integer instance."
+ ^(self isNonImmediate: oop) and: [(self classIndexOf: oop) = ClassLargePositiveIntegerCompactIndex]!
Item was added:
+ ----- Method: SpurMemoryManager>>isKindOfInteger: (in category 'simulation only') -----
+ isKindOfInteger: oop
+ <doNotGenerate>
+ ^coInterpreter isKindOfInteger: oop!
Item was added:
+ ----- Method: SpurMemoryManager>>isLargeIntegerInstance: (in category 'interpreter access') -----
+ isLargeIntegerInstance: oop
+ "Answer if the oop is a large positive or negative integer instance."
+ ^(self isNonImmediate: oop) and: [((self classIndexOf: oop) - ClassLargeNegativeIntegerCompactIndex) asUnsignedInteger <= 1]!
Item was added:
+ ----- Method: SpurMemoryManager>>isLargeNegativeIntegerObject: (in category 'simulation only') -----
+ isLargeNegativeIntegerObject: oop
+ <doNotGenerate>
+ ^coInterpreter isLargeNegativeIntegerObject: oop!
Item was added:
+ ----- Method: SpurMemoryManager>>isLargePositiveIntegerObject: (in category 'simulation only') -----
+ isLargePositiveIntegerObject: oop
+ <doNotGenerate>
+ ^coInterpreter isLargePositiveIntegerObject: oop!
Item was added:
+ ----- Method: StackInterpreter>>isKindOfInteger: (in category 'internal interpreter access') -----
+ isKindOfInteger: oop
+ "Answer true if the oop is kind of Integer (Small or Large)."
+ <api>
+ <inline: true>
+ ^(objectMemory isIntegerObject: oop)
+ or: [objectMemory isLargeIntegerInstance: oop]!
Item was added:
+ ----- Method: StackInterpreter>>isLargeIntegerObject: (in category 'internal interpreter access') -----
+ isLargeIntegerObject: oop
+ <api>
+ <inline: true>
+ ^objectMemory isLargeIntegerInstance: oop!
Item was added:
+ ----- Method: StackInterpreter>>isLargeNegativeIntegerObject: (in category 'internal interpreter access') -----
+ isLargeNegativeIntegerObject: oop
+ <api>
+ <inline: true>
+ ^objectMemory isInstanceOfClassLargeNegativeInteger: oop!
Item was added:
+ ----- Method: StackInterpreter>>isLargePositiveIntegerObject: (in category 'internal interpreter access') -----
+ isLargePositiveIntegerObject: oop
+ <api>
+ <inline: true>
+ ^objectMemory isInstanceOfClassLargePositiveInteger: oop!
Item was changed:
----- Method: StackInterpreter>>printStringOf: (in category 'debug printing') -----
printStringOf: oop
| fmt len cnt max i |
<inline: false>
(objectMemory isImmediate: oop) ifTrue:
[^self].
(objectMemory addressCouldBeObj: oop) ifFalse:
[^self].
fmt := objectMemory formatOf: oop.
fmt < objectMemory firstByteFormat ifTrue: [^self].
cnt := (max := 128) min: (len := objectMemory lengthOf: oop).
i := 0.
((objectMemory is: oop
instanceOf: (objectMemory splObj: ClassByteArray)
compactClassIndex: classByteArrayCompactIndex)
+ or: [(objectMemory isLargeIntegerInstance: oop)])
- or: [(self isInstanceOfClassLargePositiveInteger: oop)
- or: [(self isInstanceOfClassLargeNegativeInteger: oop)]])
ifTrue:
[[i < cnt] whileTrue:
[self printHex: (objectMemory fetchByte: i ofObject: oop).
i := i + 1]]
ifFalse:
[[i < cnt] whileTrue:
[self cCode:
[(objectMemory fetchByte: i ofObject: oop) = 13 "Character cr asInteger" ifTrue:
[self print: '<CR>'.
i + 1 < len ifTrue:
[self print: '...'].
^self]].
self printChar: (objectMemory fetchByte: i ofObject: oop).
i := i + 1]].
len > max ifTrue:
[self print: '...'].
self flush!
Item was changed:
----- Method: ThreadedFFIPlugin>>ffiIntegerValueOf: (in category 'callout support') -----
ffiIntegerValueOf: oop
"Support for generic callout. Answer an integer value that is coerced as C would do."
<inline: true>
"Cheat with a tag test"
(oop anyMask: BytesPerWord - 1)
ifTrue:
[(interpreterProxy isIntegerObject: oop) ifTrue:
[^interpreterProxy integerValueOf: oop].
self cppIf: SPURVM
ifTrue:
[(interpreterProxy isCharacterObject: oop) ifTrue: "Immediate in Spur"
[^interpreterProxy characterValueOf: oop].
(interpreterProxy isFloatObject: oop) ifTrue: "Immediate in 64-bit Spur"
[^interpreterProxy floatValueOf: oop]]]
ifFalse:
[self cppIf: SPURVM
ifTrue: "No non-immediate characters in Spur"
[]
ifFalse:
[(interpreterProxy isCharacterObject: oop) ifTrue:
[^interpreterProxy characterValueOf: oop]].
(interpreterProxy isFloatObject: oop) ifTrue:
[^interpreterProxy floatValueOf: oop].
oop = interpreterProxy nilObject ifTrue: [^0]. "@@: should we really allow this????"
oop = interpreterProxy falseObject ifTrue: [^0].
oop = interpreterProxy trueObject ifTrue: [^1].
+ (interpreterProxy isLargePositiveIntegerObject: oop) ifTrue:
- (interpreterProxy fetchClassOf: oop) = interpreterProxy classLargePositiveInteger ifTrue:
[self cppIf: BytesPerWord = 8 "Use cppIf: to get the return type of the function right. Should be sqInt on 32-bits."
ifTrue: [^interpreterProxy positive64BitValueOf: oop]
ifFalse: [^interpreterProxy positive32BitValueOf: oop]]].
^interpreterProxy signedMachineIntegerValueOf: oop "<- will fail if not integer"!
1
0
Eliot Miranda uploaded a new version of VMMaker to project VM Maker:
http://source.squeak.org/VMMaker/VMMaker.oscog-eem.1823.mcz
==================== Summary ====================
Name: VMMaker.oscog-eem.1823
Author: eem
Time: 19 April 2016, 4:53:05.619923 pm
UUID: e74631f5-1c33-4aeb-b228-c4fe40959252
Ancestors: VMMaker.oscog-eem.1822
Cogit:
Add a primitive that answers pc map data for methods which can be used to better decorate methods in the VM Profiler. Refactor the opc map enumeration facilities so that the Sista pic data primitive can share the same enumerator. Do this by collapsing the isBackwardBranch and annotation parameters into a single parameter. Nuke the Sista enumerator. Rename SistaStackToRegisterMappingCogit to SistaCogit and correct its comment now it inherits from RegisterAllocatingCogit.
=============== Diff against VMMaker.oscog-eem.1822 ===============
Item was changed:
----- Method: CoInterpreter>>ceCounterTripped: (in category 'cog jit support') -----
ceCounterTripped: condition
"Two things are going on here. The main one is catching a counter trip and attempting
to send the SelectorCounterTripped selector. In this case we would like to back-up
the pc to the return address of the send that yields the boolean to be tested, so that
after potential optimization, computation proceeds by retrying the jump. But we cannot,
since there may be no send, just a pop (as in and: [] and or: [] chains). In this case we also
want to prevent further callbacks until optimization is complete. So we nil-out the
SelectorCounterTripped entry in the specialSelectorArray.
The minor case is that there is an unlikely possibility that the cointer tripped but condition
is not a boolean, in which case a mustBeBoolean response should occur."
<api>
+ <option: #SistaCogit>
- <option: #SistaStackToRegisterMappingCogit>
"Send e.g. thisContext conditionalBranchCounterTrippedOn: boolean."
| context counterTrippedSelector classTag classObj |
(condition = objectMemory falseObject
or: [condition = objectMemory trueObject]) ifFalse:
[^self ceSendMustBeBoolean: condition].
counterTrippedSelector := objectMemory maybeSplObj: SelectorCounterTripped.
(counterTrippedSelector isNil
or: [counterTrippedSelector = objectMemory nilObject]) ifTrue:
[cogit resetCountersIn: (self mframeHomeMethod: framePointer).
^condition].
classTag := objectMemory
classTagForSpecialObjectsIndex: ClassMethodContext
compactClassIndex: ClassMethodContextCompactIndex.
(self lookupInMethodCacheSel: counterTrippedSelector classTag: classTag) ifFalse:
[messageSelector := counterTrippedSelector.
classObj := objectMemory classForClassTag: classTag.
(self lookupOrdinaryNoMNUEtcInClass: classObj) ~= 0 ifTrue:
[cogit resetCountersIn: (self mframeHomeMethod: framePointer).
^condition].
self addNewMethodToCache: classObj].
(primitiveFunctionPointer ~= 0
or: [(self argumentCountOf: newMethod) ~= 1]) ifTrue:
[cogit resetCountersIn: (self mframeHomeMethod: framePointer).
^condition].
objectMemory splObj: SelectorCounterTripped put: objectMemory nilObject.
instructionPointer := self popStack.
context := self ensureFrameIsMarried: framePointer SP: stackPointer.
self push: context.
self push: condition.
self ifAppropriateCompileToNativeCode: newMethod selector: counterTrippedSelector.
self activateNewMethod.
"not reached"
^true!
Item was added:
+ ----- Method: CoInterpreterPrimitives>>pcDataFor: (in category 'method introspection support') -----
+ pcDataFor: cogMethod
+ <var: #cogMethod type: #'CogMethod *'>
+ | cm nSlots nEntries data |
+ cm := cogMethod methodObject.
+ nSlots := (objectMemory byteSizeOf: cm) - (self startPCOfMethod: cm) * 2 + objectMemory minSlotsForShortening.
+ data := objectMemory instantiateClass: (objectMemory splObj: ClassArray) indexableSize: nSlots.
+ data ifNil: [^-1].
+ nEntries := cogit mapPCDataFor: cogMethod into: data.
+ nEntries = 0 ifTrue:
+ [^0].
+ nEntries < nSlots ifTrue:
+ [objectMemory shorten: data toIndexableSize: nEntries].
+ ^data!
Item was changed:
----- Method: CoInterpreterPrimitives>>picDataFor: (in category 'method introspection support') -----
picDataFor: cogMethod
<var: #cogMethod type: #'CogMethod *'>
| cm nSlots nEntries data |
cm := cogMethod methodObject.
nSlots := (objectMemory byteSizeOf: cm) - (self startPCOfMethod: cm) + objectMemory minSlotsForShortening.
data := objectMemory instantiateClass: (objectMemory splObj: ClassArray) indexableSize: nSlots.
+ data ifNil: [^-1].
nEntries := cogit picDataFor: cogMethod into: data.
nEntries = 0 ifTrue:
[^0].
nEntries < nSlots ifTrue:
[objectMemory shorten: data toIndexableSize: nEntries].
^data!
Item was added:
+ ----- Method: CoInterpreterPrimitives>>primitiveMethodPCData (in category 'method introspection primitives') -----
+ primitiveMethodPCData
+ <export: true>
+ | methodReceiver data |
+ argumentCount ~= 0 ifTrue:
+ [^self primitiveFailFor: PrimErrBadNumArgs].
+ methodReceiver := self stackTop.
+ data := 0.
+ (self methodHasCogMethod: methodReceiver) ifTrue:
+ [data := self pcDataFor: (self cogMethodOf: methodReceiver).
+ data = -1 ifTrue:
+ [^self primitiveFailFor: PrimErrNoMemory]].
+ data = 0 ifTrue:
+ [data := objectMemory instantiateClass: (objectMemory splObj: ClassArray) indexableSize: 0].
+ self pop: 1 thenPush: data!
Item was changed:
----- Method: CoInterpreterPrimitives>>primitiveResetCountersInMethod (in category 'method introspection primitives') -----
primitiveResetCountersInMethod
<export: true>
+ <option: #SistaCogit>
- <option: #SistaStackToRegisterMappingCogit>
| methodReceiver |
argumentCount ~= 0 ifTrue:
[^self primitiveFailFor: PrimErrBadNumArgs].
methodReceiver := self stackTop.
(self methodHasCogMethod: methodReceiver) ifTrue:
[cogit resetCountersIn: (self cogMethodOf: methodReceiver)]!
Item was changed:
----- Method: CoInterpreterPrimitives>>primitiveSistaMethodPICAndCounterData (in category 'method introspection primitives') -----
primitiveSistaMethodPICAndCounterData
<export: true>
+ <option: #SistaCogit>
- <option: #SistaStackToRegisterMappingCogit>
| methodReceiver data |
argumentCount ~= 0 ifTrue:
[^self primitiveFailFor: PrimErrBadNumArgs].
methodReceiver := self stackTop.
data := 0.
(self methodHasCogMethod: methodReceiver) ifTrue:
[data := self picDataFor: (self cogMethodOf: methodReceiver).
data = -1 ifTrue:
[^self primitiveFailFor: PrimErrNoMemory]].
data = 0 ifTrue:
[data := objectMemory instantiateClass: (objectMemory splObj: ClassArray) indexableSize: 0].
self pop: 1 thenPush: data!
Item was changed:
----- Method: CogObjectRepresentationForSpur>>freeCounters: (in category 'sista support') -----
freeCounters: theCounters
<var: #theCounters type: #usqInt>
<inline: true>
+ <option: #SistaCogit>
- <option: #SistaStackToRegisterMappingCogit>
theCounters ~= 0 ifTrue:
[objectMemory freeObject: theCounters - objectMemory baseHeaderSize]!
Item was changed:
----- Method: CogObjectRepresentationForSpur>>maybeMarkCounters: (in category 'sista support') -----
maybeMarkCounters: theCounters
"In SIsta Spur counters are held on the heap in pinned objects which must be marked
to avoid them being garbage collected. This is the hook through which that happens."
<var: #theCounters type: #usqInt>
+ <option: #SistaCogit>
- <option: #SistaStackToRegisterMappingCogit>
<inline: true>
theCounters ~= 0 ifTrue:
[objectMemory markAndTrace: theCounters - objectMemory baseHeaderSize]!
Item was changed:
----- Method: CogObjectRepresentationForSpur>>resetCountersIn: (in category 'sista support') -----
resetCountersIn: cogMethod
<var: #cogMethod type: #'CogMethod *'>
<api>
+ <option: #SistaCogit>
- <option: #SistaStackToRegisterMappingCogit>
cogit fillInCounters: (self numCountersFor: cogMethod counters) atStartAddress: cogMethod counters!
Item was changed:
----- Method: CogObjectRepresentationForSqueakV3>>resetCountersIn: (in category 'sista support') -----
resetCountersIn: cogMethod
<var: #cogMethod type: #'CogMethod *'>
<api>
+ <option: #SistaCogit>
- <option: #SistaStackToRegisterMappingCogit>
cogit
fillInCounters: (self numCountersFor: cogMethod counters)
atStartAddress: cogMethod counters!
Item was changed:
----- Method: Cogit>>find:IsBackwardBranch:Mcpc:Bcpc:MatchingBcpc: (in category 'method map') -----
+ find: descriptor IsBackwardBranch: isBackwardBranchAndAnnotation Mcpc: mcpc Bcpc: bcpc MatchingBcpc: targetBcpc
- find: descriptor IsBackwardBranch: isBackwardBranch Mcpc: mcpc Bcpc: bcpc MatchingBcpc: targetBcpc
<var: #descriptor type: #'BytecodeDescriptor *'>
<var: #mcpc type: #'char *'>
<var: #targetBcpc type: #'void *'>
<inline: true>
+ ^targetBcpc asInteger = ((descriptor isNil or: [isBackwardBranchAndAnnotation anyMask: 1])
+ ifTrue: [bcpc]
+ ifFalse: [bcpc + descriptor numBytes])
- ^targetBcpc asInteger = ((descriptor isNil or: [isBackwardBranch]) ifTrue: [bcpc] ifFalse: [bcpc + descriptor numBytes])
ifTrue: [mcpc asInteger]
ifFalse: [0]!
Item was changed:
----- Method: Cogit>>find:IsBackwardBranch:Mcpc:Bcpc:MatchingMcpc: (in category 'method map') -----
+ find: descriptor IsBackwardBranch: isBackwardBranchAndAnnotation Mcpc: mcpc Bcpc: bcpc MatchingMcpc: targetMcpc
- find: descriptor IsBackwardBranch: isBackwardBranch Mcpc: mcpc Bcpc: bcpc MatchingMcpc: targetMcpc
<var: #descriptor type: #'BytecodeDescriptor *'>
<var: #mcpc type: #'char *'>
<var: #targetMcpc type: #'void *'>
"Machine code addresses map to the following bytecode for all bytecodes
except backward branches, where they map to the backward branch itself.
This is so that loops continue, rather than terminate prematurely."
^targetMcpc = mcpc
+ ifTrue: [(descriptor isNil or: [isBackwardBranchAndAnnotation anyMask: 1])
- ifTrue: [(descriptor isNil or: [isBackwardBranch])
ifTrue: [bcpc]
ifFalse: [bcpc + descriptor numBytes]]
ifFalse: [0]!
Item was changed:
----- Method: Cogit>>findBackwardBranch:IsBackwardBranch:Mcpc:Bcpc:MatchingBcpc: (in category 'method map') -----
+ findBackwardBranch: descriptor IsBackwardBranch: isBackwardBranchAndAnnotation Mcpc: mcpc Bcpc: bcpc MatchingBcpc: targetBcpc
- findBackwardBranch: descriptor IsBackwardBranch: isBackwardBranch Mcpc: mcpc Bcpc: bcpc MatchingBcpc: targetBcpc
<var: #descriptor type: #'BytecodeDescriptor *'>
<var: #mcpc type: #'char *'>
<var: #targetBcpc type: #'void *'>
<inline: true>
+ ^((isBackwardBranchAndAnnotation anyMask: 1) and: [targetBcpc asInteger = bcpc])
- ^(isBackwardBranch and: [targetBcpc asInteger = bcpc])
ifTrue: [mcpc asInteger]
ifFalse: [0]!
Item was changed:
----- Method: Cogit>>mapFor:bcpc:performUntil:arg: (in category 'method map') -----
mapFor: cogMethod bcpc: startbcpc performUntil: functionSymbol arg: arg
"Machine-code <-> bytecode pc mapping support. Evaluate functionSymbol
for each mcpc, bcpc pair in the map until the function returns non-zero,
+ answering that result, or 0 if it fails to. To cut down on number of arguments.
+ and to be usable for both pc-mapping and method introspection, we encode
+ the annotation and the isBackwardBranch flag in the same parameter.
+ Guilty as charged."
- answering that result, or 0 if it fails to. This works only for frameful methods."
<var: #cogMethod type: #'CogBlockMethod *'>
+ <var: #functionSymbol declareC: 'sqInt (*functionSymbol)(BytecodeDescriptor *desc, sqInt annotationAndIsBackwardBranch, char *mcpc, sqInt bcpc, void *arg)'>
- <var: #functionSymbol declareC: 'sqInt (*functionSymbol)(BytecodeDescriptor *desc, sqInt isBackwardBranch, char *mcpc, sqInt bcpc, void *arg)'>
<var: #arg type: #'void *'>
<inline: true>
| isInBlock mcpc bcpc endbcpc map mapByte homeMethod aMethodObj result
+ latestContinuation byte descriptor bsOffset nExts annotation |
- latestContinuation byte descriptor bsOffset nExts |
<var: #descriptor type: #'BytecodeDescriptor *'>
<var: #homeMethod type: #'CogMethod *'>
self assert: cogMethod stackCheckOffset > 0.
mcpc := cogMethod asUnsignedInteger + cogMethod stackCheckOffset.
"The stack check maps to the start of the first bytecode,
the first bytecode being effectively after frame build."
result := self perform: functionSymbol
with: nil
+ with: 0 + (HasBytecodePC << 1)
- with: false
with: (self cCoerceSimple: mcpc to: #'char *')
with: startbcpc
with: arg.
result ~= 0 ifTrue:
[^result].
bcpc := startbcpc.
"In both CMMethod and CMBlock cases find the start of the map and
skip forward to the bytecode pc map entry for the stack check."
cogMethod cmType = CMMethod
ifTrue:
[isInBlock := false.
homeMethod := self cCoerceSimple: cogMethod to: #'CogMethod *'.
self assert: startbcpc = (coInterpreter startPCOfMethodHeader: homeMethod methodHeader).
map := self mapStartFor: homeMethod.
+ annotation := (objectMemory byteAt: map) >> AnnotationShift.
+ self assert: (annotation = IsAbsPCReference
+ or: [annotation = IsObjectReference
+ or: [annotation = IsRelativeCall
+ or: [annotation = IsDisplacementX2N]]]).
- self assert: ((objectMemory byteAt: map) >> AnnotationShift = IsAbsPCReference
- or: [(objectMemory byteAt: map) >> AnnotationShift = IsObjectReference
- or: [(objectMemory byteAt: map) >> AnnotationShift = IsRelativeCall
- or: [(objectMemory byteAt: map) >> AnnotationShift = IsDisplacementX2N]]]).
latestContinuation := startbcpc.
aMethodObj := homeMethod methodObject.
endbcpc := (objectMemory numBytesOf: aMethodObj) - 1.
bsOffset := self bytecodeSetOffsetForHeader: homeMethod methodHeader.
"If the method has a primitive, skip it and the error code store, if any;
Logically. these come before the stack check and so must be ignored."
bcpc := bcpc + (self deltaToSkipPrimAndErrorStoreIn: aMethodObj
header: homeMethod methodHeader)]
ifFalse:
[isInBlock := true.
self assert: bcpc = cogMethod startpc.
homeMethod := cogMethod cmHomeMethod.
map := self findMapLocationForMcpc: cogMethod asUnsignedInteger + (self sizeof: CogBlockMethod)
inMethod: homeMethod.
self assert: map ~= 0.
+ annotation := (objectMemory byteAt: map) >> AnnotationShift.
+ self assert: (annotation >> AnnotationShift = HasBytecodePC "fiducial"
+ or: [annotation >> AnnotationShift = IsDisplacementX2N]).
+ [(annotation := (objectMemory byteAt: map) >> AnnotationShift) ~= HasBytecodePC] whileTrue:
- self assert: ((objectMemory byteAt: map) >> AnnotationShift = HasBytecodePC "fiducial"
- or: [(objectMemory byteAt: map) >> AnnotationShift = IsDisplacementX2N]).
- [(objectMemory byteAt: map) >> AnnotationShift ~= HasBytecodePC] whileTrue:
[map := map - 1].
map := map - 1. "skip fiducial; i.e. the map entry for the pc immediately following the method header."
aMethodObj := homeMethod methodObject.
bcpc := startbcpc - (self blockCreationBytecodeSizeForHeader: homeMethod methodHeader).
bsOffset := self bytecodeSetOffsetForHeader: homeMethod methodHeader.
byte := (objectMemory fetchByte: bcpc ofObject: aMethodObj) + bsOffset.
descriptor := self generatorAt: byte.
endbcpc := self nextBytecodePCFor: descriptor at: bcpc exts: -1 in: aMethodObj.
bcpc := startbcpc].
nExts := 0.
+ self inlineCacheTagsAreIndexes ifTrue:
+ [enumeratingCogMethod := homeMethod].
"Now skip up through the bytecode pc map entry for the stack check."
[(objectMemory byteAt: map) >> AnnotationShift ~= HasBytecodePC] whileTrue:
[map := map - 1].
map := map - 1.
[(mapByte := objectMemory byteAt: map) ~= MapEnd] whileTrue: "defensive; we exit on bcpc"
[mapByte >= FirstAnnotation
ifTrue:
+ [| nextBcpc isBackwardBranch |
- [| annotation nextBcpc isBackwardBranch |
annotation := mapByte >> AnnotationShift.
mcpc := mcpc + ((mapByte bitAnd: DisplacementMask) * backEnd codeGranularity).
(self isPCMappedAnnotation: annotation) ifTrue:
[[byte := (objectMemory fetchByte: bcpc ofObject: aMethodObj) + bsOffset.
descriptor := self generatorAt: byte.
isInBlock
ifTrue: [bcpc >= endbcpc ifTrue: [^0]]
ifFalse:
[(descriptor isReturn and: [bcpc >= latestContinuation]) ifTrue: [^0].
(descriptor isBranch or: [descriptor isBlockCreation]) ifTrue:
[| targetPC |
targetPC := self latestContinuationPCFor: descriptor at: bcpc exts: nExts in: aMethodObj.
latestContinuation := latestContinuation max: targetPC]].
nextBcpc := self nextBytecodePCFor: descriptor at: bcpc exts: nExts in: aMethodObj.
descriptor isMapped
or: [isInBlock and: [descriptor isMappedInBlock]]] whileFalse:
[bcpc := nextBcpc.
nExts := descriptor isExtension ifTrue: [nExts + 1] ifFalse: [0]].
isBackwardBranch := descriptor isBranch
and: [self isBackwardBranch: descriptor at: bcpc exts: nExts in: aMethodObj].
result := self perform: functionSymbol
with: descriptor
+ with: (isBackwardBranch ifTrue: [annotation << 1 + 1] ifFalse: [annotation << 1])
- with: isBackwardBranch
with: (self cCoerceSimple: mcpc to: #'char *')
with: bcpc
with: arg.
result ~= 0 ifTrue:
[^result].
bcpc := nextBcpc.
nExts := descriptor isExtension ifTrue: [nExts + 1] ifFalse: [0]]]
ifFalse:
[self assert: (mapByte >> AnnotationShift = IsDisplacementX2N
or: [mapByte >> AnnotationShift = IsAnnotationExtension]).
mapByte < (IsAnnotationExtension << AnnotationShift) ifTrue:
[mcpc := mcpc + ((mapByte - DisplacementX2N << AnnotationShift) * backEnd codeGranularity)]].
map := map - 1].
^0!
Item was changed:
Cogit subclass: #SimpleStackBasedCogit
+ instanceVariableNames: 'primitiveGeneratorTable primSetFunctionLabel primInvokeInstruction externalPrimCallOffsets externalPrimJumpOffsets externalSetPrimOffsets introspectionDataIndex introspectionData'
- instanceVariableNames: 'primitiveGeneratorTable primSetFunctionLabel primInvokeInstruction externalPrimCallOffsets externalPrimJumpOffsets externalSetPrimOffsets'
classVariableNames: ''
poolDictionaries: 'VMMethodCacheConstants VMObjectIndices'
category: 'VMMaker-JIT'!
!SimpleStackBasedCogit commentStamp: '<historical>' prior: 0!
I am the stage one JIT for Cog that does not attempt to eliminate the stack via deferred code generation.!
Item was added:
+ ----- Method: SimpleStackBasedCogit>>mapPCDataFor:into: (in category 'method introspection') -----
+ mapPCDataFor: cogMethod into: arrayObj
+ "Collect the branch and send data for cogMethod, storing it into arrayObj."
+ <api>
+ <var: #cogMethod type: #'CogMethod *'>
+ | errCode |
+ introspectionDataIndex := 0.
+ introspectionData := arrayObj.
+ cogMethod stackCheckOffset = 0 ifTrue:
+ [^0].
+ errCode := self
+ mapFor: (self cCoerceSimple: cogMethod to: #'CogBlockMethod *')
+ bcpc: (coInterpreter startPCOfMethod: cogMethod methodObject)
+ performUntil: #pcDataFor:Annotation:Mcpc:Bcpc:Method:
+ arg: cogMethod asVoidPointer.
+ errCode ~= 0 ifTrue:
+ [self assert: errCode = PrimErrNoMemory.
+ ^-1].
+ cogMethod blockEntryOffset ~= 0 ifTrue:
+ [errCode := self blockDispatchTargetsFor: cogMethod
+ perform: #pcDataForBlockEntry:Method:
+ arg: cogMethod asInteger.
+ errCode ~= 0 ifTrue:
+ [self assert: errCode = PrimErrNoMemory.
+ ^-1]].
+ ^introspectionDataIndex!
Item was added:
+ ----- Method: SimpleStackBasedCogit>>pcDataFor:Annotation:Mcpc:Bcpc:Method: (in category 'method introspection') -----
+ pcDataFor: descriptor Annotation: isBackwardBranchAndAnnotation Mcpc: mcpc Bcpc: bcpc Method: cogMethodArg
+ <var: #descriptor type: #'BytecodeDescriptor *'>
+ <var: #mcpc type: #'char *'>
+ <var: #cogMethodArg type: #'void *'>
+
+ descriptor ifNil: "this is the stackCheck offset"
+ [self assert: introspectionDataIndex = 0.
+ (self cCoerceSimple: cogMethodArg to: #'CogMethod *') cmIsFullBlock
+ ifTrue:
+ [objectMemory
+ storePointerUnchecked: introspectionDataIndex + 0 ofObject: introspectionData withValue: objectMemory nilObject;
+ storePointerUnchecked: introspectionDataIndex + 1 ofObject: introspectionData withValue: (objectMemory integerObjectOf: cbNoSwitchEntryOffset);
+ storePointerUnchecked: introspectionDataIndex + 2 ofObject: introspectionData withValue: objectMemory nilObject;
+ storePointerUnchecked: introspectionDataIndex + 3 ofObject: introspectionData withValue: (objectMemory integerObjectOf: cbEntryOffset)]
+ ifFalse:
+ [objectMemory
+ storePointerUnchecked: introspectionDataIndex + 0 ofObject: introspectionData withValue: objectMemory nilObject;
+ storePointerUnchecked: introspectionDataIndex + 1 ofObject: introspectionData withValue: (objectMemory integerObjectOf: cmEntryOffset);
+ storePointerUnchecked: introspectionDataIndex + 2 ofObject: introspectionData withValue: objectMemory nilObject;
+ storePointerUnchecked: introspectionDataIndex + 3 ofObject: introspectionData withValue: (objectMemory integerObjectOf: cmNoCheckEntryOffset)].
+ introspectionDataIndex := introspectionDataIndex + 4.
+ ^0].
+
+ (self isPCMappedAnnotation: isBackwardBranchAndAnnotation >> 1) ifTrue:
+ [| actualBcpc actualMcpc |
+ actualBcpc := (isBackwardBranchAndAnnotation anyMask: 1)
+ ifTrue: [bcpc + 1]
+ ifFalse: [bcpc + descriptor numBytes + 1].
+ actualMcpc := mcpc asUnsignedInteger - cogMethodArg asUnsignedInteger.
+ objectMemory
+ storePointerUnchecked: introspectionDataIndex + 0 ofObject: introspectionData withValue: (objectMemory integerObjectOf: actualBcpc);
+ storePointerUnchecked: introspectionDataIndex + 1 ofObject: introspectionData withValue: (objectMemory integerObjectOf: actualMcpc).
+ introspectionDataIndex := introspectionDataIndex + 2].
+
+ ^0!
Item was added:
+ ----- Method: SimpleStackBasedCogit>>pcDataForBlockEntry:Method: (in category 'method introspection') -----
+ pcDataForBlockEntry: blockEntryMcpc Method: cogMethod
+ "Collect the branch and send data for the block method starting at blockEntryMcpc, storing it into picData."
+ <returnTypeC: #usqInt>
+ objectMemory
+ storePointerUnchecked: introspectionDataIndex + 0 ofObject: introspectionData withValue: objectMemory nilObject;
+ storePointerUnchecked: introspectionDataIndex + 1 ofObject: introspectionData withValue: (objectMemory integerObjectOf: blockEntryMcpc - blockNoContextSwitchOffset);
+ storePointerUnchecked: introspectionDataIndex + 2 ofObject: introspectionData withValue: objectMemory nilObject;
+ storePointerUnchecked: introspectionDataIndex + 3 ofObject: introspectionData withValue: (objectMemory integerObjectOf: blockEntryMcpc).
+ introspectionDataIndex := introspectionDataIndex + 4.
+ ^0!
Item was added:
+ RegisterAllocatingCogit subclass: #SistaCogit
+ instanceVariableNames: 'numCounters counters counterIndex initialCounterValue ceTrapTrampoline branchReachedOnlyForCounterTrip'
+ classVariableNames: 'CounterBytes MaxCounterValue'
+ poolDictionaries: 'VMSqueakClassIndices'
+ category: 'VMMaker-JIT'!
+
+ !SistaCogit commentStamp: 'eem 4/19/2016 14:22' prior: 0!
+ A SistaCogit is a refinement of RegisterAllocatingCogit that generates code suitable for dynamic optimization by Sista, the Speculative Inlining Smalltalk Architecture, a project by Clément Bera and Eliot Miranda. Sista is an optimizer that exists in the Smalltalk image, /not/ in the VM, and optimizes by substituting normal bytecoded methods by optimized bytecoded methods that may use special bytecodes for which the Cogit can generate faster code. These bytecodes eliminate overheads such as bounds checks or polymorphic code (indexing Array, ByteArray, String etc). But the bulk of the optimization performed is in inlining blocks and sends for the common path.
+
+ The basic scheme is that SistaCogit generates code containing performance counters. When these counters trip, a callback into the image is performed, at which point Sista analyses some portion of the stack, looking at performance data for the methods on the stack, and optimises based on the stack and performance data. Execution then resumes in the optimized code.
+
+ SistaCogit adds counters to conditional branches. Each branch has an executed and a taken count, implemented at the two 16-bit halves of a single 32-bit word. Each counter pair is initialized with initialCounterValue. On entry to the branch the executed count is decremented and if the count goes below zero the ceMustBeBooleanAdd[True|False] trampoline called. The trampoline distinguishes between true mustBeBoolean and counter trips because in the former the register temporarily holding the counter value will contain zero. Then the condition is tested, and if the branch is taken the taken count is decremented. The two counter values allow an optimizer to collect basic block execution paths and to know what are the "hot" paths through execution that are worth agressively optimizing. Since conditional branches are about 1/6 as frequent as sends, and since they can be used to determine the hot path through code, they are a better choice to count than, for example, method or block entry.
+
+ SistaCogit implements picDataFor:into: that fills an Array with the state of the counters in a method and the state of each linked send in a method. This is used to implement a primitive used by the optimizer to answer the branch and send data for a method as an Array.
+
+ Instance Variables
+ counterIndex: <Integer>
+ counterMethodCache: <CogMethod>
+ counters: <Array of AbstractInstruction>
+ initialCounterValue: <Integer>
+ numCounters: <Integer>
+ picData: <Integer Oop>
+ picDataIndex: <Integer>
+ prevMapAbsPCMcpc: <Integer>
+
+ counterIndex
+ - xxxxx
+
+ counterMethodCache
+ - xxxxx
+
+ counters
+ - xxxxx
+
+ initialCounterValue
+ - xxxxx
+
+ numCounters
+ - xxxxx
+
+ picData
+ - xxxxx
+
+ picDataIndex
+ - xxxxx
+
+ prevMapAbsPCMcpc
+ - xxxxx
+ !
Item was added:
+ ----- Method: SistaCogit class>>additionalHeadersDo: (in category 'translation') -----
+ additionalHeadersDo: aBinaryBlock
+ "Evaluate aBinaryBlock with the names and contents of
+ any additional header files that need to be generated."
+ aBinaryBlock
+ value: 'cogmethod.h'
+ value: SistaCogMethod cogMethodHeader!
Item was added:
+ ----- Method: SistaCogit class>>ancilliaryClasses: (in category 'translation') -----
+ ancilliaryClasses: options
+ ^(super ancilliaryClasses: options) copyWith: SistaCogMethod!
Item was added:
+ ----- Method: SistaCogit class>>declareCVarsIn: (in category 'translation') -----
+ declareCVarsIn: aCodeGen
+ aCodeGen var: 'counters' type: #usqInt!
Item was added:
+ ----- Method: SistaCogit class>>initializeWithOptions: (in category 'class initialization') -----
+ initializeWithOptions: optionsDictionary
+
+ super initializeWithOptions: optionsDictionary.
+ CounterBytes := 4.
+ MaxCounterValue := (1 << 16) - 1!
Item was added:
+ ----- Method: SistaCogit class>>numTrampolines (in category 'accessing') -----
+ numTrampolines
+ ^super numTrampolines + 1
+
+ "Cogit withAllSubclasses collect: [:c| {c. (c instVarNames select: [:ea| ea beginsWith: 'ce']) size}]"
+ "self instVarNames select: [:ea| ea beginsWith: 'ce']"!
Item was added:
+ ----- Method: SistaCogit>>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 |
+ <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.
+ initialCounterIndex := counterIndex.
+ 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."
+ 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.
+ counterIndex := initialCounterIndex.
+ NewspeakVM ifTrue:
+ [indexOfIRC := initialIndexOfIRC]].
+ compiledBlocksCount := compiledBlocksCount + 1].
+ needsFrame := savedNeedsFrame.
+ methodOrBlockNumArgs := savedNumArgs.
+ methodOrBlockNumTemps := savedNumTemps.
+ ^0!
Item was added:
+ ----- Method: SistaCogit>>compileCogFullBlockMethod: (in category 'compile abstract instructions') -----
+ compileCogFullBlockMethod: numCopied
+ <option: #SistaV1BytecodeSet>
+ counters := 0.
+ ^super compileCogFullBlockMethod: numCopied!
Item was added:
+ ----- Method: SistaCogit>>compileCogMethod: (in category 'compile abstract instructions') -----
+ compileCogMethod: selector
+ counters := 0.
+ ^super compileCogMethod: selector!
Item was added:
+ ----- Method: SistaCogit>>compileFrameBuild (in category 'compile abstract instructions') -----
+ compileFrameBuild
+ "Override to prefetch counters, if any."
+ super compileFrameBuild.
+ counters ~= 0 ifTrue:
+ [self PrefetchAw: counters]!
Item was added:
+ ----- Method: SistaCogit>>compileFullBlockMethodFrameBuild: (in category 'compile abstract instructions') -----
+ compileFullBlockMethodFrameBuild: numCopied
+ "Override to prefetch counters if any"
+ super compileFullBlockMethodFrameBuild: numCopied.
+ counters ~= 0 ifTrue:
+ [self PrefetchAw: counters]!
Item was added:
+ ----- Method: SistaCogit>>disassembleMethod:on: (in category 'disassembly') -----
+ disassembleMethod: surrogateOrAddress on: aStream
+ <doNotGenerate>
+ | cogMethod |
+ cogMethod := super disassembleMethod: surrogateOrAddress on: aStream.
+ (cogMethod cmType = CMMethod
+ and: [cogMethod counters ~= 0]) ifTrue:
+ [aStream nextPutAll: 'counters:'; cr.
+ numCounters := objectRepresentation numCountersFor: counters.
+ 0 to: numCounters - 1 do:
+ [:i| | addr |
+ addr := i * CounterBytes + counters.
+ addr printOn: aStream base: 16.
+ aStream nextPut: $:; space.
+ (objectMemory longAt: addr) printOn: aStream base: 16.
+ aStream cr].
+ aStream flush]!
Item was added:
+ ----- Method: SistaCogit>>estimateOfAbstractOpcodesPerBytecodes (in category 'accessing') -----
+ estimateOfAbstractOpcodesPerBytecodes
+ "Due to the counter logic, the estimation is higher"
+ <inline: true>
+ ^ 11!
Item was added:
+ ----- Method: SistaCogit>>fillInCPICHeader:numArgs:numCases:hasMNUCase:selector: (in category 'generate machine code') -----
+ fillInCPICHeader: pic numArgs: numArgs numCases: numCases hasMNUCase: hasMNUCase selector: selector
+ pic counters: 0.
+ ^super fillInCPICHeader: pic numArgs: numArgs numCases: numCases hasMNUCase: hasMNUCase selector: selector!
Item was added:
+ ----- Method: SistaCogit>>fillInCounters:atEndAddress: (in category 'generate machine code') -----
+ fillInCounters: nCounters atEndAddress: endAddress
+ endAddress - (nCounters * CounterBytes)
+ to: endAddress - CounterBytes
+ by: CounterBytes
+ do: [:address|
+ objectMemory
+ long32At: address
+ put: (initialCounterValue << 16 + initialCounterValue)]!
Item was added:
+ ----- Method: SistaCogit>>fillInCounters:atStartAddress: (in category 'generate machine code') -----
+ fillInCounters: nCounters atStartAddress: startAddress
+ startAddress
+ to: startAddress + (nCounters - 1 * CounterBytes)
+ by: CounterBytes
+ do: [:address|
+ objectMemory
+ long32At: address
+ put: (initialCounterValue << 16 + initialCounterValue)]!
Item was added:
+ ----- Method: SistaCogit>>fillInMethodHeader:size:selector: (in category 'generate machine code') -----
+ fillInMethodHeader: method size: size selector: selector
+ super fillInMethodHeader: method size: size selector: selector.
+ self fillInCounters: numCounters atStartAddress: counters.
+ method counters: counters.
+ ^method!
Item was added:
+ ----- Method: SistaCogit>>fillInOPICHeader:numArgs:selector: (in category 'generate machine code') -----
+ fillInOPICHeader: pic numArgs: numArgs selector: selector
+ pic counters: 0.
+ ^super fillInOPICHeader: pic numArgs: numArgs selector: selector!
Item was added:
+ ----- Method: SistaCogit>>genCounterTripOnlyJumpIf:to: (in category 'bytecode generator support') -----
+ genCounterTripOnlyJumpIf: boolean to: targetBytecodePC
+ "Specific version if the branch is only reached while falling through if the counter trips after an inlined #== branch. We do not regenerate the counter logic in this case to avoid 24 bytes instructions."
+
+ <var: #ok type: #'AbstractInstruction *'>
+ <var: #mustBeBooleanTrampoline type: #'AbstractInstruction *'>
+
+ | ok mustBeBooleanTrampoline |
+
+ extA := 0.
+
+ self ssFlushTo: simStackPtr - 1.
+
+ self ssTop popToReg: TempReg.
+
+ self ssPop: 1.
+
+ counterIndex := counterIndex + 1. "counters are increased / decreased in the inlined branch"
+
+ "We need SendNumArgsReg because of the mustBeBooleanTrampoline"
+ self ssAllocateRequiredReg: SendNumArgsReg.
+ self MoveCq: 1 R: SendNumArgsReg.
+
+ "The first time this is reached, it calls necessarily the counter trip for the trampoline because SendNumArgsReg is non zero"
+ mustBeBooleanTrampoline := self CallRT: (boolean == objectMemory falseObject
+ ifTrue: [ceSendMustBeBooleanAddFalseTrampoline]
+ ifFalse: [ceSendMustBeBooleanAddTrueTrampoline]).
+
+ self annotateBytecode: self Label.
+
+ "Cunning trick by LPD. If true and false are contiguous subtract the smaller.
+ Correct result is either 0 or the distance between them. If result is not 0 or
+ their distance send mustBeBoolean."
+ self assert: (objectMemory objectAfter: objectMemory falseObject) = objectMemory trueObject.
+ self genSubConstant: boolean R: TempReg.
+ self JumpZero: (self ensureFixupAt: targetBytecodePC - initialPC).
+
+ self CmpCq: (boolean == objectMemory falseObject
+ ifTrue: [objectMemory trueObject - objectMemory falseObject]
+ ifFalse: [objectMemory falseObject - objectMemory trueObject])
+ R: TempReg.
+
+ ok := self JumpZero: 0.
+ self MoveCq: 0 R: SendNumArgsReg. "if counterReg is 0 this is a mustBeBoolean, not a counter trip."
+
+ self Jump: mustBeBooleanTrampoline.
+
+ ok jmpTarget: self Label.
+ ^0!
Item was added:
+ ----- Method: SistaCogit>>genExecutionCountLogicInto:counterReg: (in category 'bytecode generator support') -----
+ genExecutionCountLogicInto: binaryBlock counterReg: counterReg
+ <var: #countTripped type: #'AbstractInstruction *'>
+ <inline: true>
+ | counterAddress countTripped |
+ counterAddress := counters + ((self sizeof: #sqInt) * counterIndex).
+ self flag: 'will need to use MoveAw32:R: if 64 bits'.
+ self assert: objectMemory wordSize = CounterBytes.
+ self MoveAw: counterAddress R: counterReg.
+ self SubCq: 16r10000 R: counterReg. "Count executed"
+ "If counter trips simply abort the comparison continuing to the following
+ branch *without* writing back. A double decrement will not trip the second time."
+ countTripped := self JumpCarry: 0.
+ self MoveR: counterReg Aw: counterAddress. "write back"
+ binaryBlock value: counterAddress value: countTripped!
Item was added:
+ ----- Method: SistaCogit>>genExtJumpIfNotInstanceOfBehaviorsOrPopBytecode (in category 'bytecode generators') -----
+ genExtJumpIfNotInstanceOfBehaviorsOrPopBytecode
+ "SistaV1: * 254 11111110 kkkkkkkk jjjjjjjj branch If Not Instance Of Behavior/Array Of Behavior kkkkkkkk (+ Extend A * 256, where Extend A >= 0) distance jjjjjjjj (+ Extend B * 256, where Extend B >= 0)"
+
+ | reg literal distance targetFixUp |
+
+ "We loose the information of in which register is stack top
+ when jitting the branch target so we need to flush everything.
+ We could use a fixed register here...."
+ reg := self allocateRegForStackEntryAt: 0.
+ self ssTop popToReg: reg.
+ self ssFlushTo: simStackPtr. "flushed but the value is still in reg"
+
+ literal := self getLiteral: (extA * 256 + byte1).
+ extA := 0.
+ distance := extB * 256 + byte2.
+ extB := 0.
+
+ targetFixUp := self cCoerceSimple: (self ensureFixupAt: bytecodePC + 3 + distance - initialPC) to: #'AbstractInstruction *'.
+
+ (objectMemory isArrayNonImm: literal)
+ ifTrue: [objectRepresentation branchIf: reg notInstanceOfBehaviors: literal target: targetFixUp]
+ ifFalse: [objectRepresentation branchIf: reg notInstanceOfBehavior: literal target: targetFixUp].
+
+ self genPopStackBytecode.
+
+ ^0!
Item was added:
+ ----- Method: SistaCogit>>genFallsThroughCountLogicCounterReg:counterAddress: (in category 'bytecode generator support') -----
+ genFallsThroughCountLogicCounterReg: counterReg counterAddress: counterAddress
+ <inline: true>
+ "Gen this when the branch has not been taken and forwarders have been followed."
+ self SubCq: 1 R: counterReg. "Count untaken"
+ self MoveR: counterReg Aw: counterAddress. "write back"!
Item was added:
+ ----- Method: SistaCogit>>genJumpIf:to: (in category 'bytecode generator support') -----
+ genJumpIf: boolean to: targetBytecodePC
+ "The heart of performance counting in Sista. Conditional branches are 6 times less
+ frequent than sends and can provide basic block frequencies (send counters can't).
+ Each conditional has a 32-bit counter split into an upper 16 bits counting executions
+ and a lower half counting untaken executions of the branch. Executing the branch
+ decrements the upper half, tripping if the count goes negative. Not taking the branch
+ decrements the lower half. N.B. We *do not* eliminate dead branches (true ifTrue:/true ifFalse:)
+ so that scanning for send and branch data is simplified and that branch data is correct."
+ <inline: false>
+ | ok counterAddress countTripped retry nextPC nextDescriptor |
+ <var: #ok type: #'AbstractInstruction *'>
+ <var: #retry type: #'AbstractInstruction *'>
+ <var: #countTripped type: #'AbstractInstruction *'>
+ <var: #nextDescriptor type: #'AbstractInstruction *'>
+
+ (coInterpreter isOptimizedMethod: methodObj) ifTrue: [ ^ super genJumpIf: boolean to: targetBytecodePC ].
+
+ branchReachedOnlyForCounterTrip ifTrue:
+ [ branchReachedOnlyForCounterTrip := false.
+ ^ self genCounterTripOnlyJumpIf: boolean to: targetBytecodePC ].
+
+ boolean == objectMemory falseObject ifTrue:
+ [ "detection of and: / or:"
+ nextPC := bytecodePC + (self generatorAt: byte0) numBytes.
+ nextDescriptor := self generatorAt: (objectMemory fetchByte: nextPC ofObject: methodObj) + bytecodeSetOffset.
+ nextDescriptor generator == #genPushConstantTrueBytecode ifTrue: [ ^ super genJumpIf: boolean to: targetBytecodePC ].
+ nextDescriptor := self generatorAt: (objectMemory fetchByte: targetBytecodePC ofObject: methodObj) + bytecodeSetOffset.
+ nextDescriptor generator == #genPushConstantFalseBytecode ifTrue: [ ^ super genJumpIf: boolean to: targetBytecodePC ]. ].
+
+ extA := 0.
+
+ self ssFlushTo: simStackPtr - 1.
+ self ssTop popToReg: TempReg.
+ self ssPop: 1.
+
+ "We need SendNumArgsReg because of the mustBeBooleanTrampoline"
+ self ssAllocateRequiredReg: SendNumArgsReg.
+
+ retry := self Label.
+ self
+ genExecutionCountLogicInto: [ :cAddress :countTripBranch |
+ counterAddress := cAddress.
+ countTripped := countTripBranch ]
+ counterReg: SendNumArgsReg.
+ counterIndex := counterIndex + 1.
+
+ "Cunning trick by LPD. If true and false are contiguous subtract the smaller.
+ Correct result is either 0 or the distance between them. If result is not 0 or
+ their distance send mustBeBoolean."
+ self assert: (objectMemory objectAfter: objectMemory falseObject) = objectMemory trueObject.
+ self genSubConstant: boolean R: TempReg.
+ self JumpZero: (self ensureFixupAt: targetBytecodePC - initialPC).
+
+ self genFallsThroughCountLogicCounterReg: SendNumArgsReg counterAddress: counterAddress.
+
+ self CmpCq: (boolean == objectMemory falseObject
+ ifTrue: [objectMemory trueObject - objectMemory falseObject]
+ ifFalse: [objectMemory falseObject - objectMemory trueObject])
+ R: TempReg.
+ ok := self JumpZero: 0.
+ self MoveCq: 0 R: SendNumArgsReg. "if counterReg is 0 this is a mustBeBoolean, not a counter trip."
+
+ countTripped jmpTarget:
+ (self CallRT: (boolean == objectMemory falseObject
+ ifTrue: [ceSendMustBeBooleanAddFalseTrampoline]
+ ifFalse: [ceSendMustBeBooleanAddTrueTrampoline])).
+
+ "If we're in an image which hasn't got the Sista code loaded then the ceCounterTripped:
+ trampoline will return directly to machine code, returning the boolean. So the code should
+ jump back to the retry point. The trampoline makes sure that TempReg has been reloaded."
+ self annotateBytecode: self Label.
+
+ self Jump: retry.
+
+ ok jmpTarget: self Label.
+ ^0!
Item was added:
+ ----- Method: SistaCogit>>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.
+ 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 "(*)"
+ regsToSave: self emptyRegisterMask.
+ "(*) 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 thought 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. Note we can't use putSelfInReceiverResultReg
+ when generating trampolines because simSelf has not yet been initialized."
+ 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
+ regsToSave: self emptyRegisterMask
+ pushLinkReg: true
+ resultReg: NoReg
+ appendOpcodes: true!
Item was added:
+ ----- Method: SistaCogit>>genSpecialSelectorComparison (in category 'bytecode generators') -----
+ genSpecialSelectorComparison
+ "Override to count inlined branches if followed by a conditional branch.
+ We borrow the following conditional branch's counter and when about to
+ inline the comparison we decrement the counter (without writing it back)
+ and if it trips simply abort the inlining, falling back to the normal send which
+ will then continue to the conditional branch which will trip and enter the abort."
+ | nextPC postBranchPC targetBytecodePC primDescriptor branchDescriptor
+ rcvrIsInt argIsInt argInt jumpNotSmallInts inlineCAB
+ counterAddress countTripped counterReg index |
+ <var: #countTripped type: #'AbstractInstruction *'>
+ <var: #primDescriptor type: #'BytecodeDescriptor *'>
+ <var: #jumpNotSmallInts type: #'AbstractInstruction *'>
+ <var: #branchDescriptor type: #'BytecodeDescriptor *'>
+
+ (coInterpreter isOptimizedMethod: methodObj) ifTrue: [ ^ self genSpecialSelectorComparisonWithoutCounters ].
+
+ self ssFlushTo: simStackPtr - 2.
+ primDescriptor := self generatorAt: byte0.
+ argIsInt := self ssTop type = SSConstant
+ and: [objectMemory isIntegerObject: (argInt := self ssTop constant)].
+ rcvrIsInt := (self ssValue: 1) type = SSConstant
+ and: [objectMemory isIntegerObject: (self ssValue: 1) constant].
+
+ "short-cut the jump if operands are SmallInteger constants."
+ (argIsInt and: [rcvrIsInt]) ifTrue:
+ [^ self genStaticallyResolvedSpecialSelectorComparison].
+
+ self extractMaybeBranchDescriptorInto: [ :descr :next :postBranch :target |
+ branchDescriptor := descr. nextPC := next. postBranchPC := postBranch. targetBytecodePC := target ].
+
+ "Only interested in inlining if followed by a conditional branch."
+ inlineCAB := branchDescriptor isBranchTrue or: [branchDescriptor isBranchFalse].
+ "Further, only interested in inlining = and ~= if there's a SmallInteger constant involved.
+ The relational operators successfully statically predict SmallIntegers; the equality operators do not."
+ (inlineCAB and: [primDescriptor opcode = JumpZero or: [primDescriptor opcode = JumpNonZero]]) ifTrue:
+ [inlineCAB := argIsInt or: [rcvrIsInt]].
+ inlineCAB ifFalse:
+ [^self genSpecialSelectorSend].
+
+ argIsInt
+ ifTrue:
+ [(self ssValue: 1) popToReg: ReceiverResultReg.
+ self ssPop: 2.
+ self MoveR: ReceiverResultReg R: TempReg]
+ ifFalse:
+ [self marshallSendArguments: 1.
+ self MoveR: Arg0Reg R: TempReg].
+ jumpNotSmallInts := (argIsInt or: [rcvrIsInt])
+ ifTrue: [objectRepresentation genJumpNotSmallIntegerInScratchReg: TempReg]
+ ifFalse: [objectRepresentation genJumpNotSmallIntegersIn: ReceiverResultReg andScratch: TempReg scratch: ClassReg].
+
+ counterReg := self allocateRegNotConflictingWith: (self registerMaskFor: ReceiverResultReg and: Arg0Reg).
+ self
+ genExecutionCountLogicInto: [ :cAddress :countTripBranch |
+ counterAddress := cAddress.
+ countTripped := countTripBranch ]
+ counterReg: counterReg.
+
+ argIsInt
+ ifTrue: [self CmpCq: argInt R: ReceiverResultReg]
+ ifFalse: [self CmpR: Arg0Reg R: ReceiverResultReg].
+ "Cmp is weird/backwards so invert the comparison. Further since there is a following conditional
+ jump bytecode define non-merge fixups and leave the cond bytecode to set the mergeness."
+ self genConditionalBranch: (branchDescriptor isBranchTrue
+ ifTrue: [primDescriptor opcode]
+ ifFalse: [self inverseBranchFor: primDescriptor opcode])
+ operand: (self ensureNonMergeFixupAt: targetBytecodePC - initialPC) asUnsignedInteger.
+
+ self genFallsThroughCountLogicCounterReg: counterReg counterAddress: counterAddress.
+
+ self Jump: (self ensureNonMergeFixupAt: postBranchPC - initialPC).
+ countTripped jmpTarget: (jumpNotSmallInts jmpTarget: self Label).
+
+ argIsInt ifTrue:
+ [self MoveCq: argInt R: Arg0Reg].
+ index := byte0 - self firstSpecialSelectorBytecodeOffset.
+ ^self genMarshalledSend: index negated - 1 numArgs: 1 sendTable: ordinarySendTrampolines!
Item was added:
+ ----- Method: SistaCogit>>genSpecialSelectorComparisonWithoutCounters (in category 'bytecode generators') -----
+ genSpecialSelectorComparisonWithoutCounters
+ "This method is there because if I put directly the super send in genSpecialSelectorComparison Slang does not correctly translte the code to C, it does not correctly type one of the branchDescriptor to BytecodeDescriptor"
+ ^ super genSpecialSelectorComparison!
Item was added:
+ ----- Method: SistaCogit>>genSpecialSelectorEqualsEqualsWithForwarders (in category 'bytecode generators') -----
+ genSpecialSelectorEqualsEqualsWithForwarders
+ "Override to count inlined branches if followed by a conditional branch.
+ We borrow the following conditional branch's counter and when about to
+ inline the comparison we decrement the counter (without writing it back)
+ and if it trips simply abort the inlining, falling back to the normal send which
+ will then continue to the conditional branch which will trip and enter the abort."
+ | nextPC postBranchPC targetBytecodePC branchDescriptor counterReg fixup jumpEqual jumpNotEqual
+ counterAddress countTripped unforwardArg unforwardRcvr argReg rcvrReg regMask |
+ <var: #fixup type: #'BytecodeFixup *'>
+ <var: #countTripped type: #'AbstractInstruction *'>
+ <var: #label type: #'AbstractInstruction *'>
+ <var: #branchDescriptor type: #'BytecodeDescriptor *'>
+ <var: #jumpEqual type: #'AbstractInstruction *'>
+ <var: #jumpNotEqual type: #'AbstractInstruction *'>
+
+ ((coInterpreter isOptimizedMethod: methodObj) or: [needsFrame not]) ifTrue:
+ [^super genSpecialSelectorEqualsEqualsWithForwarders].
+
+ regMask := 0.
+
+ self extractMaybeBranchDescriptorInto: [ :descr :next :postBranch :target |
+ branchDescriptor := descr. nextPC := next. postBranchPC := postBranch. targetBytecodePC := target ].
+
+ unforwardRcvr := (objectRepresentation isUnannotatableConstant: (self ssValue: 1)) not.
+ unforwardArg := (objectRepresentation isUnannotatableConstant: self ssTop) not.
+
+ "If an operand is an annotable constant, it may be forwarded, so we need to store it into a
+ register so the forwarder check can jump back to the comparison after unforwarding the constant.
+ However, if one of the operand is an unnanotable constant, does not allocate a register for it
+ (machine code will use operations on constants)."
+ rcvrReg:= argReg := NoReg.
+ self
+ allocateEqualsEqualsRegistersArgNeedsReg: unforwardArg
+ rcvrNeedsReg: unforwardRcvr
+ into: [ :rcvr :arg | rcvrReg:= rcvr. argReg := arg ].
+
+ argReg ~= NoReg ifTrue: [ regMask := self registerMaskFor: argReg ].
+ rcvrReg ~= NoReg ifTrue: [ regMask := regMask bitOr: (self registerMaskFor: rcvrReg) ].
+
+ "Only interested in inlining if followed by a conditional branch."
+ (branchDescriptor isBranchTrue or: [branchDescriptor isBranchFalse]) ifFalse:
+ [^ self genEqualsEqualsNoBranchArgIsConstant: unforwardArg not rcvrIsConstant: unforwardRcvr not argReg: argReg rcvrReg: rcvrReg].
+
+ "If branching the stack must be flushed for the merge"
+ self ssFlushTo: simStackPtr - 2.
+
+ unforwardArg ifTrue: [ objectRepresentation genEnsureOopInRegNotForwarded: argReg scratchReg: TempReg ].
+ unforwardRcvr ifTrue: [ objectRepresentation genEnsureOopInRegNotForwarded: rcvrReg scratchReg: TempReg ].
+
+ counterReg := self allocateRegNotConflictingWith: regMask.
+ self
+ genExecutionCountLogicInto: [ :cAddress :countTripBranch |
+ counterAddress := cAddress.
+ countTripped := countTripBranch ]
+ counterReg: counterReg.
+
+ self assert: (unforwardArg or: [ unforwardRcvr ]).
+
+ self genEqualsEqualsComparisonArgIsConstant: unforwardArg not rcvrIsConstant: unforwardRcvr not argReg: argReg rcvrReg: rcvrReg.
+
+ self ssPop: 2.
+
+ branchDescriptor isBranchTrue
+ ifTrue:
+ [ fixup := self ensureNonMergeFixupAt: postBranchPC - initialPC.
+ self JumpZero: (self ensureNonMergeFixupAt: targetBytecodePC - initialPC) asUnsignedInteger. ]
+ ifFalse:
+ [ fixup := self ensureNonMergeFixupAt: targetBytecodePC - initialPC.
+ self JumpZero: (self ensureNonMergeFixupAt: postBranchPC - initialPC) asUnsignedInteger. ].
+
+ self genFallsThroughCountLogicCounterReg: counterReg counterAddress: counterAddress.
+ self Jump: fixup.
+
+ countTripped jmpTarget: self Label.
+
+ "inlined version of #== ignoring the branchDescriptor if the counter trips to have normal state for the optimizer"
+ self ssPop: -2.
+ self genEqualsEqualsComparisonArgIsConstant: unforwardArg not rcvrIsConstant: unforwardRcvr not argReg: argReg rcvrReg: rcvrReg.
+ self ssPop: 2.
+
+ "This code necessarily directly falls through the jumpIf: code which pops the top of the stack into TempReg.
+ We therefore directly assign the result to TempReg to save one move instruction"
+ jumpEqual := self JumpZero: 0.
+ self genMoveFalseR: TempReg.
+ jumpNotEqual := self Jump: 0.
+ jumpEqual jmpTarget: (self genMoveTrueR: TempReg).
+ jumpNotEqual jmpTarget: self Label.
+ self ssPushRegister: TempReg.
+
+ (self fixupAt: nextPC - initialPC) notAFixup ifTrue: [ branchReachedOnlyForCounterTrip := true ].
+
+ ^ 0!
Item was added:
+ ----- Method: SistaCogit>>genUnconditionalTrapBytecode (in category 'bytecode generators') -----
+ genUnconditionalTrapBytecode
+ "SistaV1: * 217 Trap"
+ self ssFlushTo: simStackPtr.
+ self CallRT: ceTrapTrampoline.
+ self annotateBytecode: self Label.
+ ^0!
Item was added:
+ ----- Method: SistaCogit>>genUnoptimizedSpecialSelectorComparison (in category 'bytecode generators') -----
+ genUnoptimizedSpecialSelectorComparison
+ "This method is there because if I put directly the super send in genSpecialSelectorComparison Slang does not correctly translte the code to C, it does not correctly type one of the branchDescriptor to BytecodeDescriptor"
+ ^ super genSpecialSelectorComparison!
Item was added:
+ ----- Method: SistaCogit>>generateSistaRuntime (in category 'initialization') -----
+ generateSistaRuntime
+ "Trap sends Sista trap message to context with top of stack, so we don't need any arguments..."
+ ceTrapTrampoline := self genTrampolineFor: #ceSistaTrap called: 'ceSistaTrapTrampoline'!
Item was added:
+ ----- Method: SistaCogit>>getJumpTargetPCAt: (in category 'method introspection') -----
+ getJumpTargetPCAt: pc
+ <api>
+ ^backEnd jumpTargetPCAt: pc!
Item was added:
+ ----- Method: SistaCogit>>initialize (in category 'initialization') -----
+ initialize
+ super initialize.
+ branchReachedOnlyForCounterTrip := false.
+ cogMethodSurrogateClass := (objectMemory ifNil: [self class objectMemoryClass]) wordSize = 4
+ ifTrue: [CogSistaMethodSurrogate32]
+ ifFalse: [CogSistaMethodSurrogate64]!
Item was added:
+ ----- Method: SistaCogit>>initializeCodeZoneFrom:upTo: (in category 'initialization') -----
+ initializeCodeZoneFrom: startAddress upTo: endAddress
+ initialCounterValue := MaxCounterValue.
+ super initializeCodeZoneFrom: startAddress upTo: endAddress!
Item was added:
+ ----- Method: SistaCogit>>maybeAllocAndInitCounters (in category 'compile abstract instructions') -----
+ maybeAllocAndInitCounters
+ <inline: true>
+ self assert: counters = 0.
+ counterIndex := 0.
+ numCounters = 0 ifTrue:
+ [^true].
+ counters := objectRepresentation allocateCounters: numCounters.
+ ^counters ~= 0!
Item was added:
+ ----- Method: SistaCogit>>maybeFreeCounters (in category 'compile abstract instructions') -----
+ maybeFreeCounters
+ <inline: true>
+ counters ~= 0 ifTrue:
+ [objectRepresentation freeCounters: counters]!
Item was added:
+ ----- Method: SistaCogit>>maybeFreeCountersOf: (in category 'compaction') -----
+ maybeFreeCountersOf: aCogMethod
+ "Free any counters in the method."
+ <inline: true>
+ objectRepresentation freeCounters: aCogMethod counters!
Item was added:
+ ----- Method: SistaCogit>>maybeMarkCountersIn: (in category 'garbage collection') -----
+ maybeMarkCountersIn: cogMethod
+ "In SIsta Spur counters are held on the heap in pinned objects which must be marked
+ to avoid them being garbage collected. This is the hook through which that happens."
+ <var: #cogMethod type: #'CogMethod *'>
+ <inline: true>
+ objectRepresentation maybeMarkCounters: cogMethod counters!
Item was added:
+ ----- Method: SistaCogit>>picDataFor:Annotation:Mcpc:Bcpc:Method: (in category 'method introspection') -----
+ picDataFor: descriptor Annotation: isBackwardBranchAndAnnotation Mcpc: mcpc Bcpc: bcpc Method: cogMethodArg
+ <var: #descriptor type: #'BytecodeDescriptor *'>
+ <var: #mcpc type: #'char *'>
+ <var: #cogMethodArg type: #'void *'>
+ | annotation entryPoint tuple counter |
+ <var: #counter type: #'unsigned long'>
+
+ descriptor ifNil:
+ [^0].
+ descriptor isBranch ifTrue:
+ ["it's a branch; conditional?"
+ (descriptor isBranchTrue or: [descriptor isBranchFalse]) ifTrue:
+ [counter := (self
+ cCoerce: ((self
+ cCoerceSimple: cogMethodArg
+ to: #'CogMethod *') counters)
+ to: #'unsigned long *')
+ at: counterIndex.
+ tuple := self picDataForCounter: counter at: bcpc + 1.
+ tuple = 0 ifTrue: [^PrimErrNoMemory].
+ objectMemory storePointer: introspectionDataIndex ofObject: introspectionData withValue: tuple.
+ introspectionDataIndex := introspectionDataIndex + 1.
+ counterIndex := counterIndex + 1].
+ ^0].
+ annotation := isBackwardBranchAndAnnotation >> 1.
+ ((self isPureSendAnnotation: annotation)
+ and: [entryPoint := backEnd callTargetFromReturnAddress: mcpc asUnsignedInteger.
+ entryPoint > methodZoneBase]) ifFalse: "send is not linked, or is not a send"
+ [^0].
+ self targetMethodAndSendTableFor: entryPoint "It's a linked send; find which kind."
+ annotation: annotation
+ into: [:targetMethod :sendTable| | methodClassIfSuper association |
+ methodClassIfSuper := nil.
+ sendTable = superSendTrampolines ifTrue:
+ [methodClassIfSuper := coInterpreter methodClassOf: (self cCoerceSimple: cogMethodArg to: #'CogMethod *') methodObject].
+ sendTable = directedSuperSendTrampolines ifTrue:
+ [association := backEnd literalBeforeInlineCacheTagAt: mcpc asUnsignedInteger.
+ methodClassIfSuper := objectRepresentation valueOfAssociation: association].
+ tuple := self picDataForSendTo: targetMethod
+ methodClassIfSuper: methodClassIfSuper
+ at: mcpc
+ bcpc: bcpc + 1].
+ tuple = 0 ifTrue: [^PrimErrNoMemory].
+ objectMemory storePointer: introspectionDataIndex ofObject: introspectionData withValue: tuple.
+ introspectionDataIndex := introspectionDataIndex + 1.
+ ^0!
Item was added:
+ ----- Method: SistaCogit>>picDataFor:into: (in category 'method introspection') -----
+ picDataFor: cogMethod into: arrayObj
+ "Collect the branch and send data for cogMethod, storing it into arrayObj."
+ <api>
+ <var: #cogMethod type: #'CogMethod *'>
+ | errCode |
+ cogMethod stackCheckOffset = 0 ifTrue:
+ [^0].
+ introspectionDataIndex := counterIndex := 0.
+ introspectionData := arrayObj.
+ errCode := self
+ mapFor: (self cCoerceSimple: cogMethod to: #'CogBlockMethod *')
+ bcpc: (coInterpreter startPCOfMethod: cogMethod methodObject)
+ performUntil: #picDataFor:Annotation:Mcpc:Bcpc:Method:
+ arg: cogMethod asVoidPointer.
+ errCode ~= 0 ifTrue:
+ [self assert: errCode = PrimErrNoMemory.
+ ^-1].
+ cogMethod blockEntryOffset ~= 0 ifTrue:
+ [errCode := self blockDispatchTargetsFor: cogMethod
+ perform: #picDataForBlockEntry:Method:
+ arg: cogMethod asInteger.
+ errCode ~= 0 ifTrue:
+ [self assert: errCode = PrimErrNoMemory.
+ ^-1]].
+ ^introspectionDataIndex!
Item was added:
+ ----- Method: SistaCogit>>picDataForBlockEntry:Method: (in category 'method introspection') -----
+ picDataForBlockEntry: blockEntryMcpc Method: cogMethod
+ "Collect the branch and send data for the block method starting at blockEntryMcpc, storing it into picData."
+ <returnTypeC: #usqInt>
+ | cogBlockMethod |
+ <var: #cogBlockMethod type: #'CogBlockMethod *'>
+ cogBlockMethod := self cCoerceSimple: blockEntryMcpc - (self sizeof: CogBlockMethod)
+ to: #'CogBlockMethod *'.
+ cogBlockMethod stackCheckOffset = 0 ifTrue:
+ [^0].
+ ^self
+ mapFor: cogBlockMethod
+ bcpc: cogBlockMethod startpc
+ performUntil: #picDataFor:Annotation:Mcpc:Bcpc:Method:
+ arg: cogMethod asVoidPointer!
Item was added:
+ ----- Method: SistaCogit>>picDataForCounter:at: (in category 'method introspection') -----
+ picDataForCounter: counter at: bcpc
+ | executedCount tuple untakenCount |
+ <var: #counter type: #'unsigned long'>
+ tuple := objectMemory
+ eeInstantiateClassIndex: ClassArrayCompactIndex
+ format: objectMemory arrayFormat
+ numSlots: 3.
+ tuple = 0 ifTrue:
+ [^0].
+ self assert: CounterBytes = 4.
+ executedCount := initialCounterValue - (counter >> 16).
+ untakenCount := initialCounterValue - (counter bitAnd: 16rFFFF).
+ objectMemory
+ storePointerUnchecked: 0 ofObject: tuple withValue: (objectMemory integerObjectOf: bcpc);
+ storePointerUnchecked: 1 ofObject: tuple withValue: (objectMemory integerObjectOf: executedCount);
+ storePointerUnchecked: 2 ofObject: tuple withValue: (objectMemory integerObjectOf: untakenCount).
+ ^tuple!
Item was added:
+ ----- Method: SistaCogit>>picDataForSendTo:methodClassIfSuper:at:bcpc: (in category 'method introspection') -----
+ picDataForSendTo: cogMethod methodClassIfSuper: methodClassOrNil at: sendMcpc bcpc: sendBcpc
+ "Answer a tuple with the send data for a linked send to cogMethod.
+ If the target is a CogMethod (monomorphic send) answer
+ { bytecode pc, inline cache class, target method }
+ If the target is an open PIC (megamorphic send) answer
+ { bytecode pc, nil, send selector }
+ If the target is a closed PIC (polymorphic send) answer
+ { bytecode pc, first class, target method, second class, second target method, ... }"
+ <var: #cogMethod type: #'CogMethod *'>
+ <var: #sendMcpc type: #'char *'>
+ | tuple class |
+ tuple := objectMemory
+ eeInstantiateClassIndex: ClassArrayCompactIndex
+ format: objectMemory arrayFormat
+ numSlots: (cogMethod cmType = CMClosedPIC
+ ifTrue: [2 * cogMethod cPICNumCases + 1]
+ ifFalse: [3]).
+ tuple = 0 ifTrue:
+ [^0].
+ objectMemory storePointerUnchecked: 0 ofObject: tuple withValue: (objectMemory integerObjectOf: sendBcpc).
+ cogMethod cmType = CMMethod ifTrue:
+ [class := methodClassOrNil ifNil:
+ [objectRepresentation classForInlineCacheTag: (backEnd inlineCacheTagAt: sendMcpc asUnsignedInteger)].
+ objectMemory
+ storePointer: 1 ofObject: tuple withValue: class;
+ storePointer: 2 ofObject: tuple withValue: cogMethod methodObject.
+ ^tuple].
+ cogMethod cmType = CMClosedPIC ifTrue:
+ [self populate: tuple withPICInfoFor: cogMethod firstCacheTag: (backEnd inlineCacheTagAt: sendMcpc asUnsignedInteger).
+ ^tuple].
+ cogMethod cmType = CMOpenPIC ifTrue:
+ [objectMemory
+ storePointerUnchecked: 1 ofObject: tuple withValue: objectMemory nilObject;
+ storePointer: 2 ofObject: tuple withValue: cogMethod selector.
+ ^tuple].
+ self error: 'invalid method type'.
+ ^0 "to get Slang to type this method as answering sqInt"!
Item was added:
+ ----- Method: SistaCogit>>populate:withPICInfoFor:firstCacheTag: (in category 'method introspection') -----
+ populate: tuple withPICInfoFor: cPIC firstCacheTag: firstCacheTag
+ "Populate tuple (which must be large enough) with the ClosedPIC's target method class pairs.
+ The first entry in tuple contains the bytecode pc for the send, so skip the tuple's first field."
+ <var: #cPIC type: #'CogMethod *'>
+ | pc cacheTag classOop entryPoint targetMethod value |
+ <var: #targetMethod type: #'CogMethod *'>
+
+ 1 to: cPIC cPICNumCases do:
+ [:i|
+ pc := self addressOfEndOfCase: i inCPIC: cPIC.
+ cacheTag := i = 1
+ ifTrue: [firstCacheTag]
+ ifFalse: [backEnd literalBeforeFollowingAddress: pc - backEnd jumpLongConditionalByteSize].
+ classOop := objectRepresentation classForInlineCacheTag: cacheTag.
+ objectMemory storePointer: i * 2 - 1 ofObject: tuple withValue: classOop.
+ entryPoint := i = 1
+ ifTrue: [backEnd jumpLongTargetBeforeFollowingAddress: pc]
+ ifFalse: [backEnd jumpLongConditionalTargetBeforeFollowingAddress: pc].
+ "Find target from jump. A jump to the MNU entry-point should collect #doesNotUnderstand:"
+ (cPIC containsAddress: entryPoint)
+ ifTrue:
+ [value := objectMemory splObj: SelectorDoesNotUnderstand]
+ ifFalse:
+ [targetMethod := self cCoerceSimple: entryPoint - cmNoCheckEntryOffset to: #'CogMethod *'.
+ self assert: targetMethod cmType = CMMethod.
+ value := targetMethod methodObject].
+ objectMemory storePointer: i * 2 ofObject: tuple withValue: value]!
Item was added:
+ ----- Method: SistaCogit>>printPICDataForMethods (in category 'tests') -----
+ printPICDataForMethods
+ <doNotGenerate>
+ methodZone methodsDo:
+ [:cogMethod|
+ cogMethod cmType = CMMethod ifTrue:
+ [(coInterpreter picDataFor: cogMethod) ifNotNil:
+ [:thePicData|
+ coInterpreter printOop: thePicData]]]!
Item was added:
+ ----- Method: SistaCogit>>resetCountersIn: (in category 'sista callbacks') -----
+ resetCountersIn: cogMethod
+ <doNotGenerate>
+ objectRepresentation resetCountersIn: cogMethod!
Item was added:
+ ----- Method: SistaCogit>>scanMethod (in category 'compile abstract instructions') -----
+ scanMethod
+ "Scan the method (and all embedded blocks) to determine
+ - what the last bytecode is; extra bytes at the end of a method are used to encode things like source pointers or temp names
+ - if the method needs a frame or not
+ - what are the targets of any backward branches.
+ - how many blocks it creates
+ - how many counters it needs/conditional branches it contains
+ Answer the block count or on error a negative error code"
+ | latestContinuation nExts descriptor pc numBlocks distance targetPC framelessStackDelta |
+ <var: #descriptor type: #'BytecodeDescriptor *'>
+ needsFrame := false.
+ numFixups := 0.
+ prevBCDescriptor := nil.
+ numCounters := 0.
+ NewspeakVM ifTrue:
+ [numIRCs := 0].
+ (primitiveIndex > 0
+ and: [coInterpreter isQuickPrimitiveIndex: primitiveIndex]) ifTrue:
+ [^0].
+ pc := latestContinuation := initialPC.
+ numBlocks := framelessStackDelta := nExts := extA := extB := 0.
+ [pc <= endPC] whileTrue:
+ [byte0 := (objectMemory fetchByte: pc ofObject: methodObj) + bytecodeSetOffset.
+ descriptor := self generatorAt: byte0.
+ descriptor isExtension ifTrue:
+ [descriptor opcode = Nop ifTrue: "unknown bytecode tag; see Cogit class>>#generatorTableFrom:"
+ [^EncounteredUnknownBytecode].
+ self loadSubsequentBytesForDescriptor: descriptor at: pc.
+ self perform: descriptor generator].
+ (descriptor isReturn
+ and: [pc >= latestContinuation]) ifTrue:
+ [endPC := pc].
+ needsFrame ifFalse:
+ [(descriptor needsFrameFunction isNil
+ or: [self perform: descriptor needsFrameFunction with: framelessStackDelta])
+ ifTrue: [needsFrame := true]
+ ifFalse: [framelessStackDelta := framelessStackDelta + descriptor stackDelta]].
+ descriptor isBranch ifTrue:
+ [distance := self spanFor: descriptor at: pc exts: nExts in: methodObj.
+ targetPC := pc + descriptor numBytes + distance.
+ (self isBackwardBranch: descriptor at: pc exts: nExts in: methodObj)
+ ifTrue: [self initializeFixupAt: targetPC - initialPC]
+ ifFalse:
+ [latestContinuation := latestContinuation max: targetPC.
+ numFixups := numFixups + 1.
+ (descriptor isBranchTrue or: [descriptor isBranchFalse]) ifTrue:
+ [numCounters := numCounters + 1]]].
+ descriptor isBlockCreation ifTrue:
+ [numBlocks := numBlocks + 1.
+ distance := self spanFor: descriptor at: pc exts: nExts in: methodObj.
+ targetPC := pc + descriptor numBytes + distance.
+ latestContinuation := latestContinuation max: targetPC.
+ numFixups := numFixups + 1].
+ NewspeakVM ifTrue:
+ [descriptor hasIRC ifTrue:
+ [numIRCs := numIRCs + 1]].
+ pc := pc + descriptor numBytes.
+ descriptor isExtension
+ ifTrue: [nExts := nExts + 1]
+ ifFalse: [nExts := extA := extB := 0].
+ prevBCDescriptor := descriptor].
+ ^numBlocks!
Item was removed:
- RegisterAllocatingCogit subclass: #SistaStackToRegisterMappingCogit
- instanceVariableNames: 'picDataIndex picData numCounters counters counterIndex initialCounterValue ceTrapTrampoline branchReachedOnlyForCounterTrip'
- classVariableNames: 'CounterBytes MaxCounterValue'
- poolDictionaries: 'VMSqueakClassIndices'
- category: 'VMMaker-JIT'!
-
- !SistaStackToRegisterMappingCogit commentStamp: 'eem 4/7/2014 12:23' prior: 0!
- A SistaStackToRegisterMappingCogit is a refinement of StackToRegisterMappingCogit that generates code suitable for dynamic optimization by Sista, the Speculative Inlining Smalltalk Architecture, a project by Clément Bera and Eliot Miranda. Sista is an optimizer that exists in the Smalltalk image, /not/ in the VM, and optimizes by substituting normal bytecoded methods by optimized bytecoded methods that may use special bytecodes for which the Cogit can generate faster code. These bytecodes eliminate overheads such as bounds checks or polymorphic code (indexing Array, ByteArray, String etc). But the bulk of the optimization performed is in inlining blocks and sends for the common path.
-
- The basic scheme is that SistaStackToRegisterMappingCogit generates code containing performance counters. When these counters trip, a callback into the image is performed, at which point Sista analyses some portion of the stack, looking at performance data for the methods on the stack, and optimises based on the stack and performance data. Execution then resumes in the optimized code.
-
- SistaStackToRegisterMappingCogit adds counters to conditional branches. Each branch has an executed and a taken count, implemented at the two 16-bit halves of a single 32-bit word. Each counter pair is initialized with initialCounterValue. On entry to the branch the executed count is decremented and if the count goes below zero the ceMustBeBooleanAdd[True|False] trampoline called. The trampoline distinguishes between true mustBeBoolean and counter trips because in the former the register temporarily holding the counter value will contain zero. Then the condition is tested, and if the branch is taken the taken count is decremented. The two counter values allow an optimizer to collect basic block execution paths and to know what are the "hot" paths through execution that are worth agressively optimizing. Since conditional branches are about 1/6 as frequent as sends, and since they can be used to determine the hot path through code, they are a better choice to count than, for example, method or block entry.
-
- SistaStackToRegisterMappingCogit implements picDataFor:into: that fills an Array with the state of the counters in a method and the state of each linked send in a method. This is used to implement a primitive used by the optimizer to answer the branch and send data for a method as an Array.
-
- Instance Variables
- counterIndex: <Integer>
- counterMethodCache: <CogMethod>
- counters: <Array of AbstractInstruction>
- initialCounterValue: <Integer>
- numCounters: <Integer>
- picData: <Integer Oop>
- picDataIndex: <Integer>
- prevMapAbsPCMcpc: <Integer>
-
- counterIndex
- - xxxxx
-
- counterMethodCache
- - xxxxx
-
- counters
- - xxxxx
-
- initialCounterValue
- - xxxxx
-
- numCounters
- - xxxxx
-
- picData
- - xxxxx
-
- picDataIndex
- - xxxxx
-
- prevMapAbsPCMcpc
- - xxxxx
- !
Item was removed:
- ----- Method: SistaStackToRegisterMappingCogit class>>additionalHeadersDo: (in category 'translation') -----
- additionalHeadersDo: aBinaryBlock
- "Evaluate aBinaryBlock with the names and contents of
- any additional header files that need to be generated."
- aBinaryBlock
- value: 'cogmethod.h'
- value: SistaCogMethod cogMethodHeader!
Item was removed:
- ----- Method: SistaStackToRegisterMappingCogit class>>ancilliaryClasses: (in category 'translation') -----
- ancilliaryClasses: options
- ^(super ancilliaryClasses: options) copyWith: SistaCogMethod!
Item was removed:
- ----- Method: SistaStackToRegisterMappingCogit class>>declareCVarsIn: (in category 'translation') -----
- declareCVarsIn: aCodeGen
- aCodeGen var: 'counters' type: #usqInt!
Item was removed:
- ----- Method: SistaStackToRegisterMappingCogit class>>initializeWithOptions: (in category 'class initialization') -----
- initializeWithOptions: optionsDictionary
-
- super initializeWithOptions: optionsDictionary.
- CounterBytes := 4.
- MaxCounterValue := (1 << 16) - 1!
Item was removed:
- ----- Method: SistaStackToRegisterMappingCogit class>>numTrampolines (in category 'accessing') -----
- numTrampolines
- ^super numTrampolines + 1
-
- "Cogit withAllSubclasses collect: [:c| {c. (c instVarNames select: [:ea| ea beginsWith: 'ce']) size}]"
- "self instVarNames select: [:ea| ea beginsWith: 'ce']"!
Item was removed:
- ----- 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 |
- <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.
- initialCounterIndex := counterIndex.
- 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."
- 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.
- counterIndex := initialCounterIndex.
- NewspeakVM ifTrue:
- [indexOfIRC := initialIndexOfIRC]].
- compiledBlocksCount := compiledBlocksCount + 1].
- needsFrame := savedNeedsFrame.
- methodOrBlockNumArgs := savedNumArgs.
- methodOrBlockNumTemps := savedNumTemps.
- ^0!
Item was removed:
- ----- Method: SistaStackToRegisterMappingCogit>>compileCogFullBlockMethod: (in category 'compile abstract instructions') -----
- compileCogFullBlockMethod: numCopied
- <option: #SistaV1BytecodeSet>
- counters := 0.
- ^super compileCogFullBlockMethod: numCopied!
Item was removed:
- ----- Method: SistaStackToRegisterMappingCogit>>compileCogMethod: (in category 'compile abstract instructions') -----
- compileCogMethod: selector
- counters := 0.
- ^super compileCogMethod: selector!
Item was removed:
- ----- Method: SistaStackToRegisterMappingCogit>>compileFrameBuild (in category 'compile abstract instructions') -----
- compileFrameBuild
- "Override to prefetch counters, if any."
- super compileFrameBuild.
- counters ~= 0 ifTrue:
- [self PrefetchAw: counters]!
Item was removed:
- ----- Method: SistaStackToRegisterMappingCogit>>compileFullBlockMethodFrameBuild: (in category 'compile abstract instructions') -----
- compileFullBlockMethodFrameBuild: numCopied
- "Override to prefetch counters if any"
- super compileFullBlockMethodFrameBuild: numCopied.
- counters ~= 0 ifTrue:
- [self PrefetchAw: counters]!
Item was removed:
- ----- Method: SistaStackToRegisterMappingCogit>>disassembleMethod:on: (in category 'disassembly') -----
- disassembleMethod: surrogateOrAddress on: aStream
- <doNotGenerate>
- | cogMethod |
- cogMethod := super disassembleMethod: surrogateOrAddress on: aStream.
- (cogMethod cmType = CMMethod
- and: [cogMethod counters ~= 0]) ifTrue:
- [aStream nextPutAll: 'counters:'; cr.
- numCounters := objectRepresentation numCountersFor: counters.
- 0 to: numCounters - 1 do:
- [:i| | addr |
- addr := i * CounterBytes + counters.
- addr printOn: aStream base: 16.
- aStream nextPut: $:; space.
- (objectMemory longAt: addr) printOn: aStream base: 16.
- aStream cr].
- aStream flush]!
Item was removed:
- ----- Method: SistaStackToRegisterMappingCogit>>estimateOfAbstractOpcodesPerBytecodes (in category 'accessing') -----
- estimateOfAbstractOpcodesPerBytecodes
- "Due to the counter logic, the estimation is higher"
- <inline: true>
- ^ 11!
Item was removed:
- ----- Method: SistaStackToRegisterMappingCogit>>fillInCPICHeader:numArgs:numCases:hasMNUCase:selector: (in category 'generate machine code') -----
- fillInCPICHeader: pic numArgs: numArgs numCases: numCases hasMNUCase: hasMNUCase selector: selector
- pic counters: 0.
- ^super fillInCPICHeader: pic numArgs: numArgs numCases: numCases hasMNUCase: hasMNUCase selector: selector!
Item was removed:
- ----- Method: SistaStackToRegisterMappingCogit>>fillInCounters:atEndAddress: (in category 'generate machine code') -----
- fillInCounters: nCounters atEndAddress: endAddress
- endAddress - (nCounters * CounterBytes)
- to: endAddress - CounterBytes
- by: CounterBytes
- do: [:address|
- objectMemory
- long32At: address
- put: (initialCounterValue << 16 + initialCounterValue)]!
Item was removed:
- ----- Method: SistaStackToRegisterMappingCogit>>fillInCounters:atStartAddress: (in category 'generate machine code') -----
- fillInCounters: nCounters atStartAddress: startAddress
- startAddress
- to: startAddress + (nCounters - 1 * CounterBytes)
- by: CounterBytes
- do: [:address|
- objectMemory
- long32At: address
- put: (initialCounterValue << 16 + initialCounterValue)]!
Item was removed:
- ----- Method: SistaStackToRegisterMappingCogit>>fillInMethodHeader:size:selector: (in category 'generate machine code') -----
- fillInMethodHeader: method size: size selector: selector
- super fillInMethodHeader: method size: size selector: selector.
- self fillInCounters: numCounters atStartAddress: counters.
- method counters: counters.
- ^method!
Item was removed:
- ----- Method: SistaStackToRegisterMappingCogit>>fillInOPICHeader:numArgs:selector: (in category 'generate machine code') -----
- fillInOPICHeader: pic numArgs: numArgs selector: selector
- pic counters: 0.
- ^super fillInOPICHeader: pic numArgs: numArgs selector: selector!
Item was removed:
- ----- Method: SistaStackToRegisterMappingCogit>>genCounterTripOnlyJumpIf:to: (in category 'bytecode generator support') -----
- genCounterTripOnlyJumpIf: boolean to: targetBytecodePC
- "Specific version if the branch is only reached while falling through if the counter trips after an inlined #== branch. We do not regenerate the counter logic in this case to avoid 24 bytes instructions."
-
- <var: #ok type: #'AbstractInstruction *'>
- <var: #mustBeBooleanTrampoline type: #'AbstractInstruction *'>
-
- | ok mustBeBooleanTrampoline |
-
- extA := 0.
-
- self ssFlushTo: simStackPtr - 1.
-
- self ssTop popToReg: TempReg.
-
- self ssPop: 1.
-
- counterIndex := counterIndex + 1. "counters are increased / decreased in the inlined branch"
-
- "We need SendNumArgsReg because of the mustBeBooleanTrampoline"
- self ssAllocateRequiredReg: SendNumArgsReg.
- self MoveCq: 1 R: SendNumArgsReg.
-
- "The first time this is reached, it calls necessarily the counter trip for the trampoline because SendNumArgsReg is non zero"
- mustBeBooleanTrampoline := self CallRT: (boolean == objectMemory falseObject
- ifTrue: [ceSendMustBeBooleanAddFalseTrampoline]
- ifFalse: [ceSendMustBeBooleanAddTrueTrampoline]).
-
- self annotateBytecode: self Label.
-
- "Cunning trick by LPD. If true and false are contiguous subtract the smaller.
- Correct result is either 0 or the distance between them. If result is not 0 or
- their distance send mustBeBoolean."
- self assert: (objectMemory objectAfter: objectMemory falseObject) = objectMemory trueObject.
- self genSubConstant: boolean R: TempReg.
- self JumpZero: (self ensureFixupAt: targetBytecodePC - initialPC).
-
- self CmpCq: (boolean == objectMemory falseObject
- ifTrue: [objectMemory trueObject - objectMemory falseObject]
- ifFalse: [objectMemory falseObject - objectMemory trueObject])
- R: TempReg.
-
- ok := self JumpZero: 0.
- self MoveCq: 0 R: SendNumArgsReg. "if counterReg is 0 this is a mustBeBoolean, not a counter trip."
-
- self Jump: mustBeBooleanTrampoline.
-
- ok jmpTarget: self Label.
- ^0!
Item was removed:
- ----- Method: SistaStackToRegisterMappingCogit>>genExecutionCountLogicInto:counterReg: (in category 'bytecode generator support') -----
- genExecutionCountLogicInto: binaryBlock counterReg: counterReg
- <var: #countTripped type: #'AbstractInstruction *'>
- <inline: true>
- | counterAddress countTripped |
- counterAddress := counters + ((self sizeof: #sqInt) * counterIndex).
- self flag: 'will need to use MoveAw32:R: if 64 bits'.
- self assert: objectMemory wordSize = CounterBytes.
- self MoveAw: counterAddress R: counterReg.
- self SubCq: 16r10000 R: counterReg. "Count executed"
- "If counter trips simply abort the comparison continuing to the following
- branch *without* writing back. A double decrement will not trip the second time."
- countTripped := self JumpCarry: 0.
- self MoveR: counterReg Aw: counterAddress. "write back"
- binaryBlock value: counterAddress value: countTripped!
Item was removed:
- ----- Method: SistaStackToRegisterMappingCogit>>genExtJumpIfNotInstanceOfBehaviorsOrPopBytecode (in category 'bytecode generators') -----
- genExtJumpIfNotInstanceOfBehaviorsOrPopBytecode
- "SistaV1: * 254 11111110 kkkkkkkk jjjjjjjj branch If Not Instance Of Behavior/Array Of Behavior kkkkkkkk (+ Extend A * 256, where Extend A >= 0) distance jjjjjjjj (+ Extend B * 256, where Extend B >= 0)"
-
- | reg literal distance targetFixUp |
-
- "We loose the information of in which register is stack top
- when jitting the branch target so we need to flush everything.
- We could use a fixed register here...."
- reg := self allocateRegForStackEntryAt: 0.
- self ssTop popToReg: reg.
- self ssFlushTo: simStackPtr. "flushed but the value is still in reg"
-
- literal := self getLiteral: (extA * 256 + byte1).
- extA := 0.
- distance := extB * 256 + byte2.
- extB := 0.
-
- targetFixUp := self cCoerceSimple: (self ensureFixupAt: bytecodePC + 3 + distance - initialPC) to: #'AbstractInstruction *'.
-
- (objectMemory isArrayNonImm: literal)
- ifTrue: [objectRepresentation branchIf: reg notInstanceOfBehaviors: literal target: targetFixUp]
- ifFalse: [objectRepresentation branchIf: reg notInstanceOfBehavior: literal target: targetFixUp].
-
- self genPopStackBytecode.
-
- ^0!
Item was removed:
- ----- Method: SistaStackToRegisterMappingCogit>>genFallsThroughCountLogicCounterReg:counterAddress: (in category 'bytecode generator support') -----
- genFallsThroughCountLogicCounterReg: counterReg counterAddress: counterAddress
- <inline: true>
- "Gen this when the branch has not been taken and forwarders have been followed."
- self SubCq: 1 R: counterReg. "Count untaken"
- self MoveR: counterReg Aw: counterAddress. "write back"!
Item was removed:
- ----- Method: SistaStackToRegisterMappingCogit>>genJumpIf:to: (in category 'bytecode generator support') -----
- genJumpIf: boolean to: targetBytecodePC
- "The heart of performance counting in Sista. Conditional branches are 6 times less
- frequent than sends and can provide basic block frequencies (send counters can't).
- Each conditional has a 32-bit counter split into an upper 16 bits counting executions
- and a lower half counting untaken executions of the branch. Executing the branch
- decrements the upper half, tripping if the count goes negative. Not taking the branch
- decrements the lower half. N.B. We *do not* eliminate dead branches (true ifTrue:/true ifFalse:)
- so that scanning for send and branch data is simplified and that branch data is correct."
- <inline: false>
- | ok counterAddress countTripped retry nextPC nextDescriptor |
- <var: #ok type: #'AbstractInstruction *'>
- <var: #retry type: #'AbstractInstruction *'>
- <var: #countTripped type: #'AbstractInstruction *'>
- <var: #nextDescriptor type: #'AbstractInstruction *'>
-
- (coInterpreter isOptimizedMethod: methodObj) ifTrue: [ ^ super genJumpIf: boolean to: targetBytecodePC ].
-
- branchReachedOnlyForCounterTrip ifTrue:
- [ branchReachedOnlyForCounterTrip := false.
- ^ self genCounterTripOnlyJumpIf: boolean to: targetBytecodePC ].
-
- boolean == objectMemory falseObject ifTrue:
- [ "detection of and: / or:"
- nextPC := bytecodePC + (self generatorAt: byte0) numBytes.
- nextDescriptor := self generatorAt: (objectMemory fetchByte: nextPC ofObject: methodObj) + bytecodeSetOffset.
- nextDescriptor generator == #genPushConstantTrueBytecode ifTrue: [ ^ super genJumpIf: boolean to: targetBytecodePC ].
- nextDescriptor := self generatorAt: (objectMemory fetchByte: targetBytecodePC ofObject: methodObj) + bytecodeSetOffset.
- nextDescriptor generator == #genPushConstantFalseBytecode ifTrue: [ ^ super genJumpIf: boolean to: targetBytecodePC ]. ].
-
- extA := 0.
-
- self ssFlushTo: simStackPtr - 1.
- self ssTop popToReg: TempReg.
- self ssPop: 1.
-
- "We need SendNumArgsReg because of the mustBeBooleanTrampoline"
- self ssAllocateRequiredReg: SendNumArgsReg.
-
- retry := self Label.
- self
- genExecutionCountLogicInto: [ :cAddress :countTripBranch |
- counterAddress := cAddress.
- countTripped := countTripBranch ]
- counterReg: SendNumArgsReg.
- counterIndex := counterIndex + 1.
-
- "Cunning trick by LPD. If true and false are contiguous subtract the smaller.
- Correct result is either 0 or the distance between them. If result is not 0 or
- their distance send mustBeBoolean."
- self assert: (objectMemory objectAfter: objectMemory falseObject) = objectMemory trueObject.
- self genSubConstant: boolean R: TempReg.
- self JumpZero: (self ensureFixupAt: targetBytecodePC - initialPC).
-
- self genFallsThroughCountLogicCounterReg: SendNumArgsReg counterAddress: counterAddress.
-
- self CmpCq: (boolean == objectMemory falseObject
- ifTrue: [objectMemory trueObject - objectMemory falseObject]
- ifFalse: [objectMemory falseObject - objectMemory trueObject])
- R: TempReg.
- ok := self JumpZero: 0.
- self MoveCq: 0 R: SendNumArgsReg. "if counterReg is 0 this is a mustBeBoolean, not a counter trip."
-
- countTripped jmpTarget:
- (self CallRT: (boolean == objectMemory falseObject
- ifTrue: [ceSendMustBeBooleanAddFalseTrampoline]
- ifFalse: [ceSendMustBeBooleanAddTrueTrampoline])).
-
- "If we're in an image which hasn't got the Sista code loaded then the ceCounterTripped:
- trampoline will return directly to machine code, returning the boolean. So the code should
- jump back to the retry point. The trampoline makes sure that TempReg has been reloaded."
- self annotateBytecode: self Label.
-
- self Jump: retry.
-
- ok jmpTarget: self Label.
- ^0!
Item was removed:
- ----- 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.
- 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 "(*)"
- regsToSave: self emptyRegisterMask.
- "(*) 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 thought 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. Note we can't use putSelfInReceiverResultReg
- when generating trampolines because simSelf has not yet been initialized."
- 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
- regsToSave: self emptyRegisterMask
- pushLinkReg: true
- resultReg: NoReg
- appendOpcodes: true!
Item was removed:
- ----- Method: SistaStackToRegisterMappingCogit>>genSpecialSelectorComparison (in category 'bytecode generators') -----
- genSpecialSelectorComparison
- "Override to count inlined branches if followed by a conditional branch.
- We borrow the following conditional branch's counter and when about to
- inline the comparison we decrement the counter (without writing it back)
- and if it trips simply abort the inlining, falling back to the normal send which
- will then continue to the conditional branch which will trip and enter the abort."
- | nextPC postBranchPC targetBytecodePC primDescriptor branchDescriptor
- rcvrIsInt argIsInt argInt jumpNotSmallInts inlineCAB
- counterAddress countTripped counterReg index |
- <var: #countTripped type: #'AbstractInstruction *'>
- <var: #primDescriptor type: #'BytecodeDescriptor *'>
- <var: #jumpNotSmallInts type: #'AbstractInstruction *'>
- <var: #branchDescriptor type: #'BytecodeDescriptor *'>
-
- (coInterpreter isOptimizedMethod: methodObj) ifTrue: [ ^ self genSpecialSelectorComparisonWithoutCounters ].
-
- self ssFlushTo: simStackPtr - 2.
- primDescriptor := self generatorAt: byte0.
- argIsInt := self ssTop type = SSConstant
- and: [objectMemory isIntegerObject: (argInt := self ssTop constant)].
- rcvrIsInt := (self ssValue: 1) type = SSConstant
- and: [objectMemory isIntegerObject: (self ssValue: 1) constant].
-
- "short-cut the jump if operands are SmallInteger constants."
- (argIsInt and: [rcvrIsInt]) ifTrue:
- [^ self genStaticallyResolvedSpecialSelectorComparison].
-
- self extractMaybeBranchDescriptorInto: [ :descr :next :postBranch :target |
- branchDescriptor := descr. nextPC := next. postBranchPC := postBranch. targetBytecodePC := target ].
-
- "Only interested in inlining if followed by a conditional branch."
- inlineCAB := branchDescriptor isBranchTrue or: [branchDescriptor isBranchFalse].
- "Further, only interested in inlining = and ~= if there's a SmallInteger constant involved.
- The relational operators successfully statically predict SmallIntegers; the equality operators do not."
- (inlineCAB and: [primDescriptor opcode = JumpZero or: [primDescriptor opcode = JumpNonZero]]) ifTrue:
- [inlineCAB := argIsInt or: [rcvrIsInt]].
- inlineCAB ifFalse:
- [^self genSpecialSelectorSend].
-
- argIsInt
- ifTrue:
- [(self ssValue: 1) popToReg: ReceiverResultReg.
- self ssPop: 2.
- self MoveR: ReceiverResultReg R: TempReg]
- ifFalse:
- [self marshallSendArguments: 1.
- self MoveR: Arg0Reg R: TempReg].
- jumpNotSmallInts := (argIsInt or: [rcvrIsInt])
- ifTrue: [objectRepresentation genJumpNotSmallIntegerInScratchReg: TempReg]
- ifFalse: [objectRepresentation genJumpNotSmallIntegersIn: ReceiverResultReg andScratch: TempReg scratch: ClassReg].
-
- counterReg := self allocateRegNotConflictingWith: (self registerMaskFor: ReceiverResultReg and: Arg0Reg).
- self
- genExecutionCountLogicInto: [ :cAddress :countTripBranch |
- counterAddress := cAddress.
- countTripped := countTripBranch ]
- counterReg: counterReg.
-
- argIsInt
- ifTrue: [self CmpCq: argInt R: ReceiverResultReg]
- ifFalse: [self CmpR: Arg0Reg R: ReceiverResultReg].
- "Cmp is weird/backwards so invert the comparison. Further since there is a following conditional
- jump bytecode define non-merge fixups and leave the cond bytecode to set the mergeness."
- self genConditionalBranch: (branchDescriptor isBranchTrue
- ifTrue: [primDescriptor opcode]
- ifFalse: [self inverseBranchFor: primDescriptor opcode])
- operand: (self ensureNonMergeFixupAt: targetBytecodePC - initialPC) asUnsignedInteger.
-
- self genFallsThroughCountLogicCounterReg: counterReg counterAddress: counterAddress.
-
- self Jump: (self ensureNonMergeFixupAt: postBranchPC - initialPC).
- countTripped jmpTarget: (jumpNotSmallInts jmpTarget: self Label).
-
- argIsInt ifTrue:
- [self MoveCq: argInt R: Arg0Reg].
- index := byte0 - self firstSpecialSelectorBytecodeOffset.
- ^self genMarshalledSend: index negated - 1 numArgs: 1 sendTable: ordinarySendTrampolines!
Item was removed:
- ----- Method: SistaStackToRegisterMappingCogit>>genSpecialSelectorComparisonWithoutCounters (in category 'bytecode generators') -----
- genSpecialSelectorComparisonWithoutCounters
- "This method is there because if I put directly the super send in genSpecialSelectorComparison Slang does not correctly translte the code to C, it does not correctly type one of the branchDescriptor to BytecodeDescriptor"
- ^ super genSpecialSelectorComparison!
Item was removed:
- ----- Method: SistaStackToRegisterMappingCogit>>genSpecialSelectorEqualsEqualsWithForwarders (in category 'bytecode generators') -----
- genSpecialSelectorEqualsEqualsWithForwarders
- "Override to count inlined branches if followed by a conditional branch.
- We borrow the following conditional branch's counter and when about to
- inline the comparison we decrement the counter (without writing it back)
- and if it trips simply abort the inlining, falling back to the normal send which
- will then continue to the conditional branch which will trip and enter the abort."
- | nextPC postBranchPC targetBytecodePC branchDescriptor counterReg fixup jumpEqual jumpNotEqual
- counterAddress countTripped unforwardArg unforwardRcvr argReg rcvrReg regMask |
- <var: #fixup type: #'BytecodeFixup *'>
- <var: #countTripped type: #'AbstractInstruction *'>
- <var: #label type: #'AbstractInstruction *'>
- <var: #branchDescriptor type: #'BytecodeDescriptor *'>
- <var: #jumpEqual type: #'AbstractInstruction *'>
- <var: #jumpNotEqual type: #'AbstractInstruction *'>
-
- ((coInterpreter isOptimizedMethod: methodObj) or: [needsFrame not]) ifTrue:
- [^super genSpecialSelectorEqualsEqualsWithForwarders].
-
- regMask := 0.
-
- self extractMaybeBranchDescriptorInto: [ :descr :next :postBranch :target |
- branchDescriptor := descr. nextPC := next. postBranchPC := postBranch. targetBytecodePC := target ].
-
- unforwardRcvr := (objectRepresentation isUnannotatableConstant: (self ssValue: 1)) not.
- unforwardArg := (objectRepresentation isUnannotatableConstant: self ssTop) not.
-
- "If an operand is an annotable constant, it may be forwarded, so we need to store it into a
- register so the forwarder check can jump back to the comparison after unforwarding the constant.
- However, if one of the operand is an unnanotable constant, does not allocate a register for it
- (machine code will use operations on constants)."
- rcvrReg:= argReg := NoReg.
- self
- allocateEqualsEqualsRegistersArgNeedsReg: unforwardArg
- rcvrNeedsReg: unforwardRcvr
- into: [ :rcvr :arg | rcvrReg:= rcvr. argReg := arg ].
-
- argReg ~= NoReg ifTrue: [ regMask := self registerMaskFor: argReg ].
- rcvrReg ~= NoReg ifTrue: [ regMask := regMask bitOr: (self registerMaskFor: rcvrReg) ].
-
- "Only interested in inlining if followed by a conditional branch."
- (branchDescriptor isBranchTrue or: [branchDescriptor isBranchFalse]) ifFalse:
- [^ self genEqualsEqualsNoBranchArgIsConstant: unforwardArg not rcvrIsConstant: unforwardRcvr not argReg: argReg rcvrReg: rcvrReg].
-
- "If branching the stack must be flushed for the merge"
- self ssFlushTo: simStackPtr - 2.
-
- unforwardArg ifTrue: [ objectRepresentation genEnsureOopInRegNotForwarded: argReg scratchReg: TempReg ].
- unforwardRcvr ifTrue: [ objectRepresentation genEnsureOopInRegNotForwarded: rcvrReg scratchReg: TempReg ].
-
- counterReg := self allocateRegNotConflictingWith: regMask.
- self
- genExecutionCountLogicInto: [ :cAddress :countTripBranch |
- counterAddress := cAddress.
- countTripped := countTripBranch ]
- counterReg: counterReg.
-
- self assert: (unforwardArg or: [ unforwardRcvr ]).
-
- self genEqualsEqualsComparisonArgIsConstant: unforwardArg not rcvrIsConstant: unforwardRcvr not argReg: argReg rcvrReg: rcvrReg.
-
- self ssPop: 2.
-
- branchDescriptor isBranchTrue
- ifTrue:
- [ fixup := self ensureNonMergeFixupAt: postBranchPC - initialPC.
- self JumpZero: (self ensureNonMergeFixupAt: targetBytecodePC - initialPC) asUnsignedInteger. ]
- ifFalse:
- [ fixup := self ensureNonMergeFixupAt: targetBytecodePC - initialPC.
- self JumpZero: (self ensureNonMergeFixupAt: postBranchPC - initialPC) asUnsignedInteger. ].
-
- self genFallsThroughCountLogicCounterReg: counterReg counterAddress: counterAddress.
- self Jump: fixup.
-
- countTripped jmpTarget: self Label.
-
- "inlined version of #== ignoring the branchDescriptor if the counter trips to have normal state for the optimizer"
- self ssPop: -2.
- self genEqualsEqualsComparisonArgIsConstant: unforwardArg not rcvrIsConstant: unforwardRcvr not argReg: argReg rcvrReg: rcvrReg.
- self ssPop: 2.
-
- "This code necessarily directly falls through the jumpIf: code which pops the top of the stack into TempReg.
- We therefore directly assign the result to TempReg to save one move instruction"
- jumpEqual := self JumpZero: 0.
- self genMoveFalseR: TempReg.
- jumpNotEqual := self Jump: 0.
- jumpEqual jmpTarget: (self genMoveTrueR: TempReg).
- jumpNotEqual jmpTarget: self Label.
- self ssPushRegister: TempReg.
-
- (self fixupAt: nextPC - initialPC) notAFixup ifTrue: [ branchReachedOnlyForCounterTrip := true ].
-
- ^ 0!
Item was removed:
- ----- Method: SistaStackToRegisterMappingCogit>>genUnconditionalTrapBytecode (in category 'bytecode generators') -----
- genUnconditionalTrapBytecode
- "SistaV1: * 217 Trap"
- self ssFlushTo: simStackPtr.
- self CallRT: ceTrapTrampoline.
- self annotateBytecode: self Label.
- ^0!
Item was removed:
- ----- Method: SistaStackToRegisterMappingCogit>>genUnoptimizedSpecialSelectorComparison (in category 'bytecode generators') -----
- genUnoptimizedSpecialSelectorComparison
- "This method is there because if I put directly the super send in genSpecialSelectorComparison Slang does not correctly translte the code to C, it does not correctly type one of the branchDescriptor to BytecodeDescriptor"
- ^ super genSpecialSelectorComparison!
Item was removed:
- ----- Method: SistaStackToRegisterMappingCogit>>generateSistaRuntime (in category 'initialization') -----
- generateSistaRuntime
- "Trap sends Sista trap message to context with top of stack, so we don't need any arguments..."
- ceTrapTrampoline := self genTrampolineFor: #ceSistaTrap called: 'ceSistaTrapTrampoline'!
Item was removed:
- ----- Method: SistaStackToRegisterMappingCogit>>getJumpTargetPCAt: (in category 'method introspection') -----
- getJumpTargetPCAt: pc
- <api>
- ^backEnd jumpTargetPCAt: pc!
Item was removed:
- ----- Method: SistaStackToRegisterMappingCogit>>initialize (in category 'initialization') -----
- initialize
- super initialize.
- branchReachedOnlyForCounterTrip := false.
- cogMethodSurrogateClass := (objectMemory ifNil: [self class objectMemoryClass]) wordSize = 4
- ifTrue: [CogSistaMethodSurrogate32]
- ifFalse: [CogSistaMethodSurrogate64]!
Item was removed:
- ----- Method: SistaStackToRegisterMappingCogit>>initializeCodeZoneFrom:upTo: (in category 'initialization') -----
- initializeCodeZoneFrom: startAddress upTo: endAddress
- initialCounterValue := MaxCounterValue.
- super initializeCodeZoneFrom: startAddress upTo: endAddress!
Item was removed:
- ----- Method: SistaStackToRegisterMappingCogit>>mapFor:bcpc:withAnnotationPerformUntil:arg: (in category 'method map') -----
- mapFor: cogMethod bcpc: startbcpc withAnnotationPerformUntil: functionSymbol arg: arg
- "A version of mapFor:bcpc:performUntil:arg: that passes the annotation instead of the isBackwardBranch
- flag. Evaluate functionSymbol for each mcpc, bcpc pair in the map until the function returns non-zero,
- answering that result, or 0 if it fails to. This works only for frameful methods"
- <var: #cogMethod type: #'CogBlockMethod *'>
- <var: #functionSymbol declareC: 'sqInt (*functionSymbol)(BytecodeDescriptor *desc, sqInt annotation, char *mcpc, sqInt bcpc, void *arg)'>
- <var: #arg type: #'void *'>
- <inline: true>
- | isInBlock mcpc bcpc endbcpc map mapByte homeMethod aMethodObj result
- latestContinuation byte descriptor bsOffset nExts annotation |
- <var: #descriptor type: #'BytecodeDescriptor *'>
- <var: #homeMethod type: #'CogMethod *'>
- self assert: cogMethod stackCheckOffset > 0.
- "In both CMMethod and CMBlock cases find the start of the map and
- skip forward to the bytecode pc map entry for the stack check."
- cogMethod cmType = CMMethod
- ifTrue:
- [isInBlock := false.
- homeMethod := self cCoerceSimple: cogMethod to: #'CogMethod *'.
- self assert: startbcpc = (coInterpreter startPCOfMethodHeader: homeMethod methodHeader).
- map := self mapStartFor: homeMethod.
- annotation := (objectMemory byteAt: map) >> AnnotationShift.
- self assert: (annotation = IsAbsPCReference
- or: [annotation = IsObjectReference
- or: [annotation = IsRelativeCall
- or: [annotation = IsDisplacementX2N]]]).
- latestContinuation := startbcpc.
- aMethodObj := homeMethod methodObject.
- endbcpc := (objectMemory numBytesOf: aMethodObj) - 1.
- bsOffset := self bytecodeSetOffsetForHeader: homeMethod methodHeader]
- ifFalse:
- [isInBlock := true.
- homeMethod := cogMethod cmHomeMethod.
- map := self findMapLocationForMcpc: cogMethod asUnsignedInteger + (self sizeof: CogBlockMethod)
- inMethod: homeMethod.
- self assert: map ~= 0.
- annotation := (objectMemory byteAt: map) >> AnnotationShift.
- self assert: (annotation >> AnnotationShift = HasBytecodePC "fiducial"
- or: [annotation >> AnnotationShift = IsDisplacementX2N]).
- [(annotation := (objectMemory byteAt: map) >> AnnotationShift) ~= HasBytecodePC] whileTrue:
- [map := map - 1].
- map := map - 1. "skip fiducial; i.e. the map entry for the pc immediately following the method header."
- aMethodObj := homeMethod methodObject.
- bcpc := startbcpc - (self blockCreationBytecodeSizeForHeader: homeMethod methodHeader).
- bsOffset := self bytecodeSetOffsetForHeader: homeMethod methodHeader.
- byte := (objectMemory fetchByte: bcpc ofObject: aMethodObj) + bsOffset.
- descriptor := self generatorAt: byte.
- endbcpc := self nextBytecodePCFor: descriptor at: bcpc exts: -1 in: aMethodObj].
- bcpc := startbcpc.
- mcpc := cogMethod asUnsignedInteger + cogMethod stackCheckOffset.
- nExts := 0.
- self inlineCacheTagsAreIndexes ifTrue:
- [enumeratingCogMethod := homeMethod].
- "The stack check maps to the start of the first bytecode,
- the first bytecode being effectively after frame build."
- result := self perform: functionSymbol
- with: nil
- with: annotation
- with: (self cCoerceSimple: mcpc to: #'char *')
- with: startbcpc
- with: arg.
- result ~= 0 ifTrue:
- [^result].
- "Now skip up through the bytecode pc map entry for the stack check."
- [(objectMemory byteAt: map) >> AnnotationShift ~= HasBytecodePC] whileTrue:
- [map := map - 1].
- map := map - 1.
- [(mapByte := objectMemory byteAt: map) ~= MapEnd] whileTrue: "defensive; we exit on bcpc"
- [mapByte >= FirstAnnotation
- ifTrue:
- [| nextBcpc |
- annotation := mapByte >> AnnotationShift.
- mcpc := mcpc + ((mapByte bitAnd: DisplacementMask) * backEnd codeGranularity).
- (self isPCMappedAnnotation: annotation) ifTrue:
- [(annotation = IsSendCall
- and: [(mapByte := objectMemory byteAt: map - 1) >> AnnotationShift = IsAnnotationExtension]) ifTrue:
- [annotation := annotation + (mapByte bitAnd: DisplacementMask).
- map := map - 1].
- [byte := (objectMemory fetchByte: bcpc ofObject: aMethodObj) + bsOffset.
- descriptor := self generatorAt: byte.
- isInBlock
- ifTrue: [bcpc >= endbcpc ifTrue: [^0]]
- ifFalse:
- [(descriptor isReturn and: [bcpc >= latestContinuation]) ifTrue: [^0].
- (descriptor isBranch or: [descriptor isBlockCreation]) ifTrue:
- [| targetPC |
- targetPC := self latestContinuationPCFor: descriptor at: bcpc exts: nExts in: aMethodObj.
- latestContinuation := latestContinuation max: targetPC]].
- nextBcpc := self nextBytecodePCFor: descriptor at: bcpc exts: nExts in: aMethodObj.
- descriptor isMapped
- or: [isInBlock and: [descriptor isMappedInBlock]]] whileFalse:
- [bcpc := nextBcpc.
- nExts := descriptor isExtension ifTrue: [nExts + 1] ifFalse: [0]].
- result := self perform: functionSymbol
- with: descriptor
- with: annotation
- with: (self cCoerceSimple: mcpc to: #'char *')
- with: bcpc
- with: arg.
- result ~= 0 ifTrue:
- [^result].
- bcpc := nextBcpc.
- nExts := descriptor isExtension ifTrue: [nExts + 1] ifFalse: [0]]]
- ifFalse:
- [self assert: (mapByte >> AnnotationShift = IsDisplacementX2N
- or: [mapByte >> AnnotationShift = IsAnnotationExtension]).
- mapByte < (IsAnnotationExtension << AnnotationShift) ifTrue:
- [mcpc := mcpc + ((mapByte - DisplacementX2N << AnnotationShift) * backEnd codeGranularity)]].
- map := map - 1].
- ^0!
Item was removed:
- ----- Method: SistaStackToRegisterMappingCogit>>maybeAllocAndInitCounters (in category 'compile abstract instructions') -----
- maybeAllocAndInitCounters
- <inline: true>
- self assert: counters = 0.
- counterIndex := 0.
- numCounters = 0 ifTrue:
- [^true].
- counters := objectRepresentation allocateCounters: numCounters.
- ^counters ~= 0!
Item was removed:
- ----- Method: SistaStackToRegisterMappingCogit>>maybeFreeCounters (in category 'compile abstract instructions') -----
- maybeFreeCounters
- <inline: true>
- counters ~= 0 ifTrue:
- [objectRepresentation freeCounters: counters]!
Item was removed:
- ----- Method: SistaStackToRegisterMappingCogit>>maybeFreeCountersOf: (in category 'compaction') -----
- maybeFreeCountersOf: aCogMethod
- "Free any counters in the method."
- <inline: true>
- objectRepresentation freeCounters: aCogMethod counters!
Item was removed:
- ----- Method: SistaStackToRegisterMappingCogit>>maybeMarkCountersIn: (in category 'garbage collection') -----
- maybeMarkCountersIn: cogMethod
- "In SIsta Spur counters are held on the heap in pinned objects which must be marked
- to avoid them being garbage collected. This is the hook through which that happens."
- <var: #cogMethod type: #'CogMethod *'>
- <inline: true>
- objectRepresentation maybeMarkCounters: cogMethod counters!
Item was removed:
- ----- Method: SistaStackToRegisterMappingCogit>>picDataFor:Annotation:Mcpc:Bcpc:Method: (in category 'method introspection') -----
- picDataFor: descriptor Annotation: annotation Mcpc: mcpc Bcpc: bcpc Method: cogMethodArg
- <var: #descriptor type: #'BytecodeDescriptor *'>
- <var: #mcpc type: #'char *'>
- <var: #cogMethodArg type: #'void *'>
- | entryPoint tuple counter |
- <var: #counter type: #'unsigned long'>
-
- descriptor ifNil:
- [^0].
- descriptor isBranch ifTrue:
- ["it's a branch; conditional?"
- (descriptor isBranchTrue or: [descriptor isBranchFalse]) ifTrue:
- [counter := (self
- cCoerce: ((self
- cCoerceSimple: cogMethodArg
- to: #'CogMethod *') counters)
- to: #'unsigned long *')
- at: counterIndex.
- tuple := self picDataForCounter: counter at: bcpc + 1.
- tuple = 0 ifTrue: [^PrimErrNoMemory].
- objectMemory storePointer: picDataIndex ofObject: picData withValue: tuple.
- picDataIndex := picDataIndex + 1.
- counterIndex := counterIndex + 1].
- ^0].
- ((self isPureSendAnnotation: annotation)
- and: [entryPoint := backEnd callTargetFromReturnAddress: mcpc asUnsignedInteger.
- entryPoint > methodZoneBase]) ifFalse: "send is not linked, or is not a send"
- [^0].
- self targetMethodAndSendTableFor: entryPoint "It's a linked send; find which kind."
- annotation: annotation
- into: [:targetMethod :sendTable| | methodClassIfSuper association |
- methodClassIfSuper := nil.
- sendTable = superSendTrampolines ifTrue:
- [methodClassIfSuper := coInterpreter methodClassOf: (self cCoerceSimple: cogMethodArg to: #'CogMethod *') methodObject].
- sendTable = directedSuperSendTrampolines ifTrue:
- [association := backEnd literalBeforeInlineCacheTagAt: mcpc asUnsignedInteger.
- methodClassIfSuper := objectRepresentation valueOfAssociation: association].
- tuple := self picDataForSendTo: targetMethod
- methodClassIfSuper: methodClassIfSuper
- at: mcpc
- bcpc: bcpc + 1].
- tuple = 0 ifTrue: [^PrimErrNoMemory].
- objectMemory storePointer: picDataIndex ofObject: picData withValue: tuple.
- picDataIndex := picDataIndex + 1.
- ^0!
Item was removed:
- ----- Method: SistaStackToRegisterMappingCogit>>picDataFor:into: (in category 'method introspection') -----
- picDataFor: cogMethod into: arrayObj
- "Collect the branch and send data for cogMethod, storing it into arrayObj."
- <api>
- <var: #cogMethod type: #'CogMethod *'>
- | errCode |
- cogMethod stackCheckOffset = 0 ifTrue:
- [^0].
- picDataIndex := counterIndex := 0.
- picData := arrayObj.
- errCode := self
- mapFor: (self cCoerceSimple: cogMethod to: #'CogBlockMethod *')
- bcpc: (coInterpreter startPCOfMethod: cogMethod methodObject)
- withAnnotationPerformUntil: #picDataFor:Annotation:Mcpc:Bcpc:Method:
- arg: cogMethod asVoidPointer.
- errCode ~= 0 ifTrue:
- [self assert: errCode = PrimErrNoMemory.
- ^-1].
- cogMethod blockEntryOffset ~= 0 ifTrue:
- [errCode := self blockDispatchTargetsFor: cogMethod
- perform: #picDataForBlockEntry:Method:
- arg: cogMethod asInteger.
- errCode ~= 0 ifTrue:
- [self assert: errCode = PrimErrNoMemory.
- ^-1]].
- ^picDataIndex!
Item was removed:
- ----- Method: SistaStackToRegisterMappingCogit>>picDataForBlockEntry:Method: (in category 'method introspection') -----
- picDataForBlockEntry: blockEntryMcpc Method: cogMethod
- "Collect the branch and send data for the block method starting at blockEntryMcpc, storing it into picData."
- <returnTypeC: #usqInt>
- | cogBlockMethod |
- <var: #cogBlockMethod type: #'CogBlockMethod *'>
- cogBlockMethod := self cCoerceSimple: blockEntryMcpc - (self sizeof: CogBlockMethod)
- to: #'CogBlockMethod *'.
- cogBlockMethod stackCheckOffset = 0 ifTrue:
- [^0].
- ^self
- mapFor: cogBlockMethod
- bcpc: cogBlockMethod startpc
- withAnnotationPerformUntil: #picDataFor:Annotation:Mcpc:Bcpc:Method:
- arg: cogMethod asVoidPointer!
Item was removed:
- ----- Method: SistaStackToRegisterMappingCogit>>picDataForCounter:at: (in category 'method introspection') -----
- picDataForCounter: counter at: bcpc
- | executedCount tuple untakenCount |
- <var: #counter type: #'unsigned long'>
- tuple := objectMemory
- eeInstantiateClassIndex: ClassArrayCompactIndex
- format: objectMemory arrayFormat
- numSlots: 3.
- tuple = 0 ifTrue:
- [^0].
- self assert: CounterBytes = 4.
- executedCount := initialCounterValue - (counter >> 16).
- untakenCount := initialCounterValue - (counter bitAnd: 16rFFFF).
- objectMemory
- storePointerUnchecked: 0 ofObject: tuple withValue: (objectMemory integerObjectOf: bcpc);
- storePointerUnchecked: 1 ofObject: tuple withValue: (objectMemory integerObjectOf: executedCount);
- storePointerUnchecked: 2 ofObject: tuple withValue: (objectMemory integerObjectOf: untakenCount).
- ^tuple!
Item was removed:
- ----- Method: SistaStackToRegisterMappingCogit>>picDataForSendTo:methodClassIfSuper:at:bcpc: (in category 'method introspection') -----
- picDataForSendTo: cogMethod methodClassIfSuper: methodClassOrNil at: sendMcpc bcpc: sendBcpc
- "Answer a tuple with the send data for a linked send to cogMethod.
- If the target is a CogMethod (monomorphic send) answer
- { bytecode pc, inline cache class, target method }
- If the target is an open PIC (megamorphic send) answer
- { bytecode pc, nil, send selector }
- If the target is a closed PIC (polymorphic send) answer
- { bytecode pc, first class, target method, second class, second target method, ... }"
- <var: #cogMethod type: #'CogMethod *'>
- <var: #sendMcpc type: #'char *'>
- | tuple class |
- tuple := objectMemory
- eeInstantiateClassIndex: ClassArrayCompactIndex
- format: objectMemory arrayFormat
- numSlots: (cogMethod cmType = CMClosedPIC
- ifTrue: [2 * cogMethod cPICNumCases + 1]
- ifFalse: [3]).
- tuple = 0 ifTrue:
- [^0].
- objectMemory storePointerUnchecked: 0 ofObject: tuple withValue: (objectMemory integerObjectOf: sendBcpc).
- cogMethod cmType = CMMethod ifTrue:
- [class := methodClassOrNil ifNil:
- [objectRepresentation classForInlineCacheTag: (backEnd inlineCacheTagAt: sendMcpc asUnsignedInteger)].
- objectMemory
- storePointer: 1 ofObject: tuple withValue: class;
- storePointer: 2 ofObject: tuple withValue: cogMethod methodObject.
- ^tuple].
- cogMethod cmType = CMClosedPIC ifTrue:
- [self populate: tuple withPICInfoFor: cogMethod firstCacheTag: (backEnd inlineCacheTagAt: sendMcpc asUnsignedInteger).
- ^tuple].
- cogMethod cmType = CMOpenPIC ifTrue:
- [objectMemory
- storePointerUnchecked: 1 ofObject: tuple withValue: objectMemory nilObject;
- storePointer: 2 ofObject: tuple withValue: cogMethod selector.
- ^tuple].
- self error: 'invalid method type'.
- ^0 "to get Slang to type this method as answering sqInt"!
Item was removed:
- ----- Method: SistaStackToRegisterMappingCogit>>populate:withPICInfoFor:firstCacheTag: (in category 'method introspection') -----
- populate: tuple withPICInfoFor: cPIC firstCacheTag: firstCacheTag
- "Populate tuple (which must be large enough) with the ClosedPIC's target method class pairs.
- The first entry in tuple contains the bytecode pc for the send, so skip the tuple's first field."
- <var: #cPIC type: #'CogMethod *'>
- | pc cacheTag classOop entryPoint targetMethod value |
- <var: #targetMethod type: #'CogMethod *'>
-
- 1 to: cPIC cPICNumCases do:
- [:i|
- pc := self addressOfEndOfCase: i inCPIC: cPIC.
- cacheTag := i = 1
- ifTrue: [firstCacheTag]
- ifFalse: [backEnd literalBeforeFollowingAddress: pc - backEnd jumpLongConditionalByteSize].
- classOop := objectRepresentation classForInlineCacheTag: cacheTag.
- objectMemory storePointer: i * 2 - 1 ofObject: tuple withValue: classOop.
- entryPoint := i = 1
- ifTrue: [backEnd jumpLongTargetBeforeFollowingAddress: pc]
- ifFalse: [backEnd jumpLongConditionalTargetBeforeFollowingAddress: pc].
- "Find target from jump. A jump to the MNU entry-point should collect #doesNotUnderstand:"
- (cPIC containsAddress: entryPoint)
- ifTrue:
- [value := objectMemory splObj: SelectorDoesNotUnderstand]
- ifFalse:
- [targetMethod := self cCoerceSimple: entryPoint - cmNoCheckEntryOffset to: #'CogMethod *'.
- self assert: targetMethod cmType = CMMethod.
- value := targetMethod methodObject].
- objectMemory storePointer: i * 2 ofObject: tuple withValue: value]!
Item was removed:
- ----- Method: SistaStackToRegisterMappingCogit>>printPICDataForMethods (in category 'tests') -----
- printPICDataForMethods
- <doNotGenerate>
- methodZone methodsDo:
- [:cogMethod|
- cogMethod cmType = CMMethod ifTrue:
- [(coInterpreter picDataFor: cogMethod) ifNotNil:
- [:thePicData|
- coInterpreter printOop: thePicData]]]!
Item was removed:
- ----- Method: SistaStackToRegisterMappingCogit>>resetCountersIn: (in category 'sista callbacks') -----
- resetCountersIn: cogMethod
- <doNotGenerate>
- objectRepresentation resetCountersIn: cogMethod!
Item was removed:
- ----- Method: SistaStackToRegisterMappingCogit>>scanMethod (in category 'compile abstract instructions') -----
- scanMethod
- "Scan the method (and all embedded blocks) to determine
- - what the last bytecode is; extra bytes at the end of a method are used to encode things like source pointers or temp names
- - if the method needs a frame or not
- - what are the targets of any backward branches.
- - how many blocks it creates
- - how many counters it needs/conditional branches it contains
- Answer the block count or on error a negative error code"
- | latestContinuation nExts descriptor pc numBlocks distance targetPC framelessStackDelta |
- <var: #descriptor type: #'BytecodeDescriptor *'>
- needsFrame := false.
- numFixups := 0.
- prevBCDescriptor := nil.
- numCounters := 0.
- NewspeakVM ifTrue:
- [numIRCs := 0].
- (primitiveIndex > 0
- and: [coInterpreter isQuickPrimitiveIndex: primitiveIndex]) ifTrue:
- [^0].
- pc := latestContinuation := initialPC.
- numBlocks := framelessStackDelta := nExts := extA := extB := 0.
- [pc <= endPC] whileTrue:
- [byte0 := (objectMemory fetchByte: pc ofObject: methodObj) + bytecodeSetOffset.
- descriptor := self generatorAt: byte0.
- descriptor isExtension ifTrue:
- [descriptor opcode = Nop ifTrue: "unknown bytecode tag; see Cogit class>>#generatorTableFrom:"
- [^EncounteredUnknownBytecode].
- self loadSubsequentBytesForDescriptor: descriptor at: pc.
- self perform: descriptor generator].
- (descriptor isReturn
- and: [pc >= latestContinuation]) ifTrue:
- [endPC := pc].
- needsFrame ifFalse:
- [(descriptor needsFrameFunction isNil
- or: [self perform: descriptor needsFrameFunction with: framelessStackDelta])
- ifTrue: [needsFrame := true]
- ifFalse: [framelessStackDelta := framelessStackDelta + descriptor stackDelta]].
- descriptor isBranch ifTrue:
- [distance := self spanFor: descriptor at: pc exts: nExts in: methodObj.
- targetPC := pc + descriptor numBytes + distance.
- (self isBackwardBranch: descriptor at: pc exts: nExts in: methodObj)
- ifTrue: [self initializeFixupAt: targetPC - initialPC]
- ifFalse:
- [latestContinuation := latestContinuation max: targetPC.
- numFixups := numFixups + 1.
- (descriptor isBranchTrue or: [descriptor isBranchFalse]) ifTrue:
- [numCounters := numCounters + 1]]].
- descriptor isBlockCreation ifTrue:
- [numBlocks := numBlocks + 1.
- distance := self spanFor: descriptor at: pc exts: nExts in: methodObj.
- targetPC := pc + descriptor numBytes + distance.
- latestContinuation := latestContinuation max: targetPC.
- numFixups := numFixups + 1].
- NewspeakVM ifTrue:
- [descriptor hasIRC ifTrue:
- [numIRCs := numIRCs + 1]].
- pc := pc + descriptor numBytes.
- descriptor isExtension
- ifTrue: [nExts := nExts + 1]
- ifFalse: [nExts := extA := extB := 0].
- prevBCDescriptor := descriptor].
- ^numBlocks!
Item was changed:
----- Method: StackToRegisterMappingCogit>>genSpecialSelectorArithmetic (in category 'bytecode generators') -----
genSpecialSelectorArithmetic
| primDescriptor rcvrIsConst argIsConst rcvrIsInt argIsInt rcvrInt argInt result
jumpNotSmallInts jumpContinue index |
+ <var: #jumpContinue type: #'AbstractInstruction *'>
<var: #primDescriptor type: #'BytecodeDescriptor *'>
<var: #jumpNotSmallInts type: #'AbstractInstruction *'>
- <var: #jumpContinue type: #'AbstractInstruction *'>
- <var: #instToAnnotate type: #'AbstractInstruction *'>
primDescriptor := self generatorAt: byte0.
argIsInt := (argIsConst := self ssTop type = SSConstant)
and: [objectMemory isIntegerObject: (argInt := self ssTop constant)].
rcvrIsInt := (rcvrIsConst := (self ssValue: 1) type = SSConstant)
and: [objectMemory isIntegerObject: (rcvrInt := (self ssValue: 1) constant)].
(argIsInt and: [rcvrIsInt]) ifTrue:
[rcvrInt := objectMemory integerValueOf: rcvrInt.
argInt := objectMemory integerValueOf: argInt.
primDescriptor opcode caseOf: {
[AddRR] -> [result := rcvrInt + argInt].
[SubRR] -> [result := rcvrInt - argInt].
[AndRR] -> [result := rcvrInt bitAnd: argInt].
[OrRR] -> [result := rcvrInt bitOr: argInt] }.
(objectMemory isIntegerValue: result) ifTrue:
["Must annotate the bytecode for correct pc mapping."
^self ssPop: 2; ssPushAnnotatedConstant: (objectMemory integerObjectOf: result)].
^self genSpecialSelectorSend].
"If there's any constant involved other than a SmallInteger don't attempt to inline."
((rcvrIsConst and: [rcvrIsInt not])
or: [argIsConst and: [argIsInt not]]) ifTrue:
[^self genSpecialSelectorSend].
"If we know nothing about the types then better not to inline as the inline cache and
primitive code is not terribly slow so wasting time on duplicating tag tests is pointless."
(argIsInt or: [rcvrIsInt]) ifFalse:
[^self genSpecialSelectorSend].
argIsInt
ifTrue:
[self ssFlushTo: simStackPtr - 2.
(self ssValue: 1) popToReg: ReceiverResultReg.
self ssPop: 2.
self MoveR: ReceiverResultReg R: TempReg]
ifFalse:
[self marshallSendArguments: 1.
self MoveR: Arg0Reg R: TempReg].
jumpNotSmallInts := (argIsInt or: [rcvrIsInt])
ifTrue: [objectRepresentation genJumpNotSmallIntegerInScratchReg: TempReg]
ifFalse: [objectRepresentation genJumpNotSmallIntegersIn: ReceiverResultReg andScratch: TempReg scratch: ClassReg].
primDescriptor opcode caseOf: {
[AddRR] -> [argIsInt
ifTrue:
[self AddCq: argInt - ConstZero R: ReceiverResultReg.
jumpContinue := self JumpNoOverflow: 0.
"overflow; must undo the damage before continuing"
self SubCq: argInt - ConstZero R: ReceiverResultReg]
ifFalse:
[objectRepresentation genRemoveSmallIntegerTagsInScratchReg: ReceiverResultReg.
self AddR: Arg0Reg R: ReceiverResultReg.
jumpContinue := self JumpNoOverflow: 0.
"overflow; must undo the damage before continuing"
rcvrIsInt
ifTrue: [self MoveCq: rcvrInt R: ReceiverResultReg]
ifFalse:
[self SubR: Arg0Reg R: ReceiverResultReg.
objectRepresentation genSetSmallIntegerTagsIn: ReceiverResultReg]]].
[SubRR] -> [argIsInt
ifTrue:
[self SubCq: argInt - ConstZero R: ReceiverResultReg.
jumpContinue := self JumpNoOverflow: 0.
"overflow; must undo the damage before continuing"
self AddCq: argInt - ConstZero R: ReceiverResultReg]
ifFalse:
[objectRepresentation genRemoveSmallIntegerTagsInScratchReg: Arg0Reg.
self SubR: Arg0Reg R: ReceiverResultReg.
jumpContinue := self JumpNoOverflow: 0.
"overflow; must undo the damage before continuing"
self AddR: Arg0Reg R: ReceiverResultReg.
objectRepresentation genSetSmallIntegerTagsIn: Arg0Reg]].
[AndRR] -> [argIsInt
ifTrue: [self AndCq: argInt R: ReceiverResultReg]
ifFalse: [self AndR: Arg0Reg R: ReceiverResultReg].
jumpContinue := self Jump: 0].
[OrRR] -> [argIsInt
ifTrue: [self OrCq: argInt R: ReceiverResultReg]
ifFalse: [self OrR: Arg0Reg R: ReceiverResultReg].
jumpContinue := self Jump: 0] }.
jumpNotSmallInts jmpTarget: self Label.
argIsInt ifTrue:
[self MoveCq: argInt R: Arg0Reg].
index := byte0 - self firstSpecialSelectorBytecodeOffset.
self genMarshalledSend: index negated - 1 numArgs: 1 sendTable: ordinarySendTrampolines.
jumpContinue jmpTarget: self Label.
^0!
Item was changed:
----- Method: VMMaker class>>generateSqueakSpurCogSista64VM (in category 'configurations') -----
generateSqueakSpurCogSista64VM
^VMMaker
generate: CoInterpreter
+ and: SistaCogit
- and: SistaStackToRegisterMappingCogit
with: #( SistaVM true
ObjectMemory Spur64BitCoMemoryManager
MULTIPLEBYTECODESETS true
bytecodeTableInitializer initializeBytecodeTableForSqueakV3PlusClosuresSistaV1Hybrid)
to: (FileDirectory default pathFromURI: self sourceTree, '/spursista64src')
platformDir: (FileDirectory default pathFromURI: self sourceTree, '/platforms')
including:#()!
Item was changed:
----- Method: VMMaker class>>generateSqueakSpurCogSistaVM (in category 'configurations') -----
generateSqueakSpurCogSistaVM
"No primitives since we can use those for the Cog VM"
^VMMaker
generate: CoInterpreter
+ and: SistaCogit
- and: SistaStackToRegisterMappingCogit
with: #( SistaVM true
ObjectMemory Spur32BitCoMemoryManager
MULTIPLEBYTECODESETS true
bytecodeTableInitializer initializeBytecodeTableForSqueakV3PlusClosuresSistaV1Hybrid)
to: (FileDirectory default pathFromURI: self sourceTree, '/spursistasrc')
platformDir: (FileDirectory default pathFromURI: self sourceTree, '/platforms')
including:#()!
1
0
Nicolas Cellier uploaded a new version of VMMaker to project VM Maker:
http://source.squeak.org/VMMaker/VMMaker.oscog-nice.1813.mcz
==================== Summary ====================
Name: VMMaker.oscog-nice.1813
Author: nice
Time: 20 April 2016, 1:02:48.617 am
UUID: 9ce7e2b2-2956-4228-9744-345c61a693ed
Ancestors: VMMaker.oscog-nice.1812
Revert elimination of type specifications for LargeIntegersPlugin.
Instead, provide a bunch of Integer type checking.
- isIntegerObject: <=> isMemberOf: SmallInteger (already existing)
- isKindOfInteger: <=> isKindOf: Integer
- isLargeIntegerObject= <=> isKindOf: LargePositiveInteger (Squeak) or LargeInteger (Pharo)
- isLargePositiveIntegerObject: <=> isMemberOf: LargePositiveInteger
- isLargeNegativeIntegerObject: <=> isMemberOf: LargeNegativeInteger
Note that this will require a change of svn source for platforms/Cross/vm/sqVirtalMachine.[ch]
=============== Diff against VMMaker.oscog-nice.1812 ===============
Item was changed:
----- Method: FFIPlugin>>ffiPushUnsignedLongLongOop: (in category 'callout support') -----
ffiPushUnsignedLongLongOop: oop
"Push a longlong type (e.g., a 64bit integer).
Note: Coercions from float are *not* supported."
| lowWord highWord length ptr |
<var: #ptr type:'unsigned char *'>
oop == interpreterProxy nilObject
ifTrue:[^self ffiPushUnsignedLong: 0 Long: 0.]. "@@: check this"
oop == interpreterProxy falseObject
ifTrue:[^self ffiPushUnsignedLong: 0 Long: 0].
oop == interpreterProxy trueObject
ifTrue:[^self ffiPushUnsignedLong: 0 Long: 1].
(interpreterProxy isIntegerObject: oop) ifTrue:[
lowWord := interpreterProxy integerValueOf: oop.
lowWord < 0 ifTrue:[^self ffiFail: FFIErrorCoercionFailed].
highWord := 0.
] ifFalse:[
+ (interpreterProxy isLargePositiveIntegerObject: oop)
- (interpreterProxy fetchClassOf: oop) = interpreterProxy classLargePositiveInteger
ifFalse:[^interpreterProxy primitiveFail].
(interpreterProxy isBytes: oop) ifFalse:[^self ffiFail: FFIErrorCoercionFailed].
length := interpreterProxy byteSizeOf: oop.
length > 8 ifTrue:[^self ffiFail: FFIErrorCoercionFailed].
lowWord := highWord := 0.
ptr := interpreterProxy firstIndexableField: oop.
0 to: (length min: 4)-1 do:[:i|
lowWord := lowWord + ((ptr at: i) << (i*8))].
0 to: (length-5) do:[:i|
highWord := highWord + ((ptr at: i+4) << (i*8))].
].
^self ffiPushUnsignedLong: lowWord Long: highWord.!
Item was changed:
----- Method: IA32ABIPlugin>>primAlienReplace (in category 'primitives-accessing') -----
primAlienReplace
"Copy some number of bytes from some source object starting at the index
into the receiver destination object from startIndex to stopIndex . The source
and destination may be Aliens or byte-indexable objects. The primitive wll have either
of the following signatures:
<Alien | indexableByteSubclass | indexableWordSubclass>
primReplaceFrom: start <Integer>
to: stop <Integer>
with: replacement <Alien | indexableByteSubclass | indexableWordSubclass | Integer>
startingAt: repStart <Integer> ^<self>
<primitive: 'primitiveAlienReplace' error: errorCode module: 'IA32ABI'>
<Anywhere>
primReplaceIn: dest <Alien | indexableByteSubclass | indexableWordSubclass>
from: start <Integer>
to: stop <Integer>
with: replacement <Alien | indexableByteSubclass | indexableWordSubclass | Integer>
startingAt: repStart <Integer> ^<self>
<primitive: 'primitiveAlienReplace' error: errorCode module: 'IA32ABI'>
"
| array start stop repl replStart dest src totalLength count |
<export: true>
array := interpreterProxy stackValue: 4.
start := interpreterProxy stackIntegerValue: 3.
stop := interpreterProxy stackIntegerValue: 2.
repl := interpreterProxy stackValue: 1.
replStart := interpreterProxy stackIntegerValue: 0.
(interpreterProxy failed
or: [(interpreterProxy isWordsOrBytes: array) not]) ifTrue:
[^interpreterProxy primitiveFailFor: PrimErrBadArgument].
(self isAlien: array)
ifTrue:
[totalLength := self sizeField: array.
dest := (self startOfData: array withSize: totalLength) + start - 1.
totalLength = 0 "no bounds checks for zero-sized (pointer) Aliens"
ifTrue: [totalLength := stop]
ifFalse: [totalLength := totalLength abs]]
ifFalse:
[totalLength := interpreterProxy byteSizeOf: array.
dest := (self startOfByteData: array) + start - 1].
(start >= 1 and: [start - 1 <= stop and: [stop <= totalLength]])
ifFalse: [^interpreterProxy primitiveFailFor: PrimErrBadIndex].
(interpreterProxy isIntegerObject: repl)
ifTrue:
[(interpreterProxy integerValueOf: repl) <= 0 ifTrue:
[^interpreterProxy primitiveFailFor: PrimErrBadArgument].
src := (interpreterProxy integerValueOf: repl) + replStart - 1]
ifFalse:
+ [(interpreterProxy isLargePositiveIntegerObject: repl)
- [(interpreterProxy fetchClassOf: repl) == interpreterProxy classLargePositiveInteger
ifTrue:
[src := (interpreterProxy positive32BitValueOf: repl) + replStart - 1.
interpreterProxy failed ifTrue:
[^interpreterProxy primitiveFailFor: PrimErrBadArgument]]
ifFalse:
[(self isAlien: repl)
ifTrue:
[totalLength := self sizeField: repl.
src := (self startOfData: repl withSize: totalLength) + replStart - 1.
totalLength = 0 "no bounds checks for zero-sized (pointer) Aliens"
ifTrue: [totalLength := stop - start + replStart]
ifFalse: [totalLength := totalLength abs]]
ifFalse:
[(interpreterProxy isWordsOrBytes: repl) ifFalse:
[^interpreterProxy primitiveFailFor: PrimErrBadArgument].
totalLength := interpreterProxy byteSizeOf: repl.
src := (self startOfByteData: repl) + replStart - 1].
(replStart >= 1 and: [stop - start + replStart <= totalLength]) ifFalse:
[^interpreterProxy primitiveFailFor: PrimErrBadIndex]]].
(interpreterProxy isOopImmutable: array) ifTrue:
[^interpreterProxy primitiveFailFor: PrimErrNoModification].
count := stop - start + 1.
self cCode: 'memmove((void *)dest,(void *)src,count)'
inSmalltalk:
[count := count + src + dest. "squash unused var compiler warnings"
self error: 'not implemented'].
interpreterProxy pop: interpreterProxy methodArgumentCount!
Item was added:
+ ----- Method: Integer class>>ccg:prolog:expr:index: (in category '*VMMaker-plugin generation') -----
+ ccg: cg prolog: aBlock expr: aString index: anInteger
+
+ ^cg ccgLoad: aBlock expr: aString asKindOfIntegerFrom: anInteger!
Item was added:
+ ----- Method: Interpreter>>isKindOfInteger: (in category 'plugin primitive support') -----
+ isKindOfInteger: oop
+ "Answer true if the oop is kind of Integer (Small or Large)."
+ <api>
+ <inline: true>
+ ^(self isIntegerObject: oop)
+ or: [self isLargeIntegerInstance: oop]!
Item was added:
+ ----- Method: Interpreter>>isLargeIntegerObject: (in category 'plugin primitive support') -----
+ isLargeIntegerObject: oop
+ ^(self isLargeIntegerInstance: oop)!
Item was added:
+ ----- Method: Interpreter>>isLargeNegativeIntegerObject: (in category 'plugin primitive support') -----
+ isLargeNegativeIntegerObject: oop
+ ^(self isInstanceOfClassLargeNegativeInteger: oop)!
Item was added:
+ ----- Method: Interpreter>>isLargePositiveIntegerObject: (in category 'plugin primitive support') -----
+ isLargePositiveIntegerObject: oop
+ ^(self isInstanceOfClassLargePositiveInteger: oop)!
Item was removed:
- ----- Method: InterpreterPrimitives>>isInstanceOfClassLargeNegativeInteger: (in category 'primitive support') -----
- isInstanceOfClassLargeNegativeInteger: oop
- <inline: true>
- "N.B. Because Slang always inlines is:instanceOf:compactClassIndex:
- (because is:instanceOf:compactClassIndex: has an inline: pragma) the
- phrase (objectMemory splObj: ClassLargeNegativeInteger) is expanded
- in-place and is _not_ evaluated if oop has a non-zero CompactClassIndex."
- ^objectMemory
- is: oop
- instanceOf: (objectMemory splObj: ClassLargeNegativeInteger)
- compactClassIndex: ClassLargeNegativeIntegerCompactIndex!
Item was removed:
- ----- Method: InterpreterPrimitives>>isInstanceOfClassLargePositiveInteger: (in category 'primitive support') -----
- isInstanceOfClassLargePositiveInteger: oop
- <inline: true>
- "N.B. Because Slang always inlines is:instanceOf:compactClassIndex:
- (because is:instanceOf:compactClassIndex: has an inline: pragma) the
- phrase (objectMemory splObj: ClassLargePositiveInteger) is expanded
- in-place and is _not_ evaluated if oop has a non-zero CompactClassIndex."
- ^objectMemory
- is: oop
- instanceOf: (objectMemory splObj: ClassLargePositiveInteger)
- compactClassIndex: ClassLargePositiveIntegerCompactIndex!
Item was added:
+ ----- Method: InterpreterProxy>>isKindOfInteger: (in category 'testing') -----
+ isKindOfInteger: objectOrientedPointer
+ ^objectOrientedPointer isInteger!
Item was added:
+ ----- Method: InterpreterProxy>>isLargeIntegerObject: (in category 'testing') -----
+ isLargeIntegerObject: objectOrientedPointer
+ ^objectOrientedPointer isKindOf: LargePositiveInteger!
Item was added:
+ ----- Method: InterpreterProxy>>isLargeNegativeIntegerObject: (in category 'testing') -----
+ isLargeNegativeIntegerObject: objectOrientedPointer
+ ^objectOrientedPointer isMemberOf: LargeNegativeInteger!
Item was added:
+ ----- Method: InterpreterProxy>>isLargePositiveIntegerObject: (in category 'testing') -----
+ isLargePositiveIntegerObject: objectOrientedPointer
+ ^objectOrientedPointer isMemberOf: LargePositiveInteger!
Item was changed:
----- Method: LargeIntegersPlugin>>digitAddLarge:with: (in category 'oop functions') -----
digitAddLarge: firstInteger with: secondInteger
"Does not need to normalize!!"
| over firstDigitLen secondDigitLen shortInt shortDigitLen longInt longDigitLen sum newSum neg |
<var: #over type: #'unsigned int'>
firstDigitLen := self digitSizeOfLargeInt: firstInteger.
secondDigitLen := self digitSizeOfLargeInt: secondInteger.
+ neg := interpreterProxy isLargeNegativeIntegerObject: firstInteger.
- neg := (interpreterProxy fetchClassOf: firstInteger)
- = interpreterProxy classLargeNegativeInteger.
firstDigitLen <= secondDigitLen
ifTrue:
[shortInt := firstInteger.
shortDigitLen := firstDigitLen.
longInt := secondInteger.
longDigitLen := secondDigitLen]
ifFalse:
[shortInt := secondInteger.
shortDigitLen := secondDigitLen.
longInt := firstInteger.
longDigitLen := firstDigitLen].
" sum := Integer new: len neg: firstInteger negative."
self remapOop: #(shortInt longInt ) in: [sum := self createLargeIntegerNeg: neg digitLength: longDigitLen].
over := self
cDigitAdd: (self pointerToFirstDigitOfLargeInt: shortInt)
len: shortDigitLen
with: (self pointerToFirstDigitOfLargeInt: longInt)
len: longDigitLen
into: (self pointerToFirstDigitOfLargeInt: sum).
over > 0
ifTrue:
["sum := sum growby: 1."
self remapOop: sum in: [newSum := self createLargeIntegerNeg: neg byteLength: longDigitLen * 4 + 1].
self
cDigitCopyFrom: (self pointerToFirstDigitOfLargeInt: sum)
to: (self pointerToFirstDigitOfLargeInt: newSum)
len: longDigitLen.
sum := newSum.
"C index!!"
self cDigitOf: (self pointerToFirstDigitOfLargeInt: sum)
at: longDigitLen put: over]
ifFalse:
[sum := neg
ifTrue: [self normalizeNegative: sum]
ifFalse: [self normalizePositive: sum]].
^ sum!
Item was changed:
----- Method: LargeIntegersPlugin>>digitBitLogic:with:opIndex: (in category 'oop functions') -----
digitBitLogic: firstInteger with: secondInteger opIndex: opIx
"Bit logic here is only implemented for positive integers or Zero;
if rec or arg is negative, it fails."
| firstLarge secondLarge firstLen secondLen shortLen shortLarge longLen longLarge result |
(interpreterProxy isIntegerObject: firstInteger)
ifTrue:
[(interpreterProxy integerValueOf: firstInteger)
< 0 ifTrue: [^ interpreterProxy primitiveFail].
"convert it to a not normalized LargeInteger"
self remapOop: secondInteger in: [firstLarge := self createLargeFromSmallInteger: firstInteger]]
ifFalse:
+ [(interpreterProxy isLargePositiveIntegerObject: firstInteger) ifFalse: [^ interpreterProxy primitiveFail].
- [(interpreterProxy fetchClassOf: firstInteger)
- = interpreterProxy classLargePositiveInteger ifFalse: [^ interpreterProxy primitiveFail].
firstLarge := firstInteger].
(interpreterProxy isIntegerObject: secondInteger)
ifTrue:
[(interpreterProxy integerValueOf: secondInteger)
< 0 ifTrue: [^ interpreterProxy primitiveFail].
"convert it to a not normalized LargeInteger"
self remapOop: firstLarge in: [secondLarge := self createLargeFromSmallInteger: secondInteger]]
ifFalse:
+ [(interpreterProxy isLargePositiveIntegerObject: secondInteger) ifFalse: [^ interpreterProxy primitiveFail].
- [(interpreterProxy fetchClassOf: secondInteger)
- = interpreterProxy classLargePositiveInteger ifFalse: [^ interpreterProxy primitiveFail].
secondLarge := secondInteger].
firstLen := self byteSizeOfLargeInt: firstLarge.
secondLen := self byteSizeOfLargeInt: secondLarge.
firstLen < secondLen
ifTrue:
[shortLen := firstLen.
shortLarge := firstLarge.
longLen := secondLen.
longLarge := secondLarge]
ifFalse:
[shortLen := secondLen.
shortLarge := secondLarge.
longLen := firstLen.
longLarge := firstLarge].
self remapOop: #(shortLarge longLarge ) in: [result := interpreterProxy instantiateClass: interpreterProxy classLargePositiveInteger indexableSize: longLen].
self
cDigitOp: opIx
short: (self pointerToFirstDigitOfLargeInt: shortLarge)
len: shortLen + 3 // 4
long: (self pointerToFirstDigitOfLargeInt: longLarge)
len: longLen + 3 // 4
into: (self pointerToFirstDigitOfLargeInt: result).
interpreterProxy failed ifTrue: [^ 0].
^ self normalizePositive: result!
Item was changed:
----- Method: LargeIntegersPlugin>>digitSubLarge:with: (in category 'oop functions') -----
digitSubLarge: firstInteger with: secondInteger
"Normalizes."
| firstDigitLen secondDigitLen larger largeDigitLen smaller smallerDigitLen neg resDigitLen res firstNeg |
+ firstNeg := interpreterProxy isLargeNegativeIntegerObject: firstInteger.
- firstNeg := (interpreterProxy fetchClassOf: firstInteger)
- = interpreterProxy classLargeNegativeInteger.
firstDigitLen := self digitSizeOfLargeInt: firstInteger.
secondDigitLen := self digitSizeOfLargeInt: secondInteger.
firstDigitLen = secondDigitLen ifTrue:
[[firstDigitLen > 1
and: [(self unsafeDigitOfLargeInt: firstInteger at: firstDigitLen) = (self unsafeDigitOfLargeInt: secondInteger at: firstDigitLen)]]
whileTrue: [firstDigitLen := firstDigitLen - 1].
secondDigitLen := firstDigitLen].
(firstDigitLen < secondDigitLen
or: [firstDigitLen = secondDigitLen
and: [(self unsafeDigitOfLargeInt: firstInteger at: firstDigitLen) < (self unsafeDigitOfLargeInt: secondInteger at: firstDigitLen)]])
ifTrue:
[larger := secondInteger.
largeDigitLen := secondDigitLen.
smaller := firstInteger.
smallerDigitLen := firstDigitLen.
neg := firstNeg == false]
ifFalse:
[larger := firstInteger.
largeDigitLen := firstDigitLen.
smaller := secondInteger.
smallerDigitLen := secondDigitLen.
neg := firstNeg].
resDigitLen := largeDigitLen.
self remapOop: #(smaller larger)
in: [res := self createLargeIntegerNeg: neg digitLength: resDigitLen].
self
cDigitSub: (self pointerToFirstDigitOfLargeInt: smaller)
len: smallerDigitLen
with: (self pointerToFirstDigitOfLargeInt: larger)
len: largeDigitLen
into: (self pointerToFirstDigitOfLargeInt: res).
^neg
ifTrue: [self normalizeNegative: res]
ifFalse: [self normalizePositive: res]!
Item was removed:
- ----- Method: LargeIntegersPlugin>>isLargeIntegerOop: (in category 'util') -----
- isLargeIntegerOop: oop
- | oopClass |
- oopClass := interpreterProxy fetchClassOf: oop.
- ^oopClass == interpreterProxy classLargeNegativeInteger or: [oopClass == interpreterProxy classLargePositiveInteger]!
Item was changed:
----- Method: LargeIntegersPlugin>>normalize: (in category 'oop functions') -----
normalize: aLargeInteger
"Check for leading zeroes and return shortened copy if so."
self debugCode: [self msg: 'normalize: aLargeInteger'].
+ (interpreterProxy isLargePositiveIntegerObject: aLargeInteger)
- (interpreterProxy fetchClassOf: aLargeInteger)
- = interpreterProxy classLargePositiveInteger
ifTrue: [^ self normalizePositive: aLargeInteger]
ifFalse: [^ self normalizeNegative: aLargeInteger]!
Item was changed:
----- Method: LargeIntegersPlugin>>primAnyBitFrom:to: (in category 'Integer primitives') -----
primAnyBitFrom: from to: to
| integer large |
self debugCode: [self msg: 'primAnyBitFrom: from to: to'].
integer := self
primitive: 'primAnyBitFromTo'
+ parameters: #(#SmallInteger #SmallInteger )
+ receiver: #Integer.
- parameters: #(#SmallInteger #SmallInteger ).
(interpreterProxy isIntegerObject: integer)
ifTrue: ["convert it to a not normalized LargeInteger"
large := self createLargeFromSmallInteger: integer]
+ ifFalse: [large := integer].
- ifFalse:
- [(self isLargeIntegerOop: integer) ifFalse: [^interpreterProxy primitiveFail].
- large := integer].
^ (self
anyBitOfLargeInt: large
from: from
to: to)
asOop: Boolean!
Item was changed:
----- Method: LargeIntegersPlugin>>primDigitAdd: (in category 'Integer primitives') -----
primDigitAdd: secondInteger
| firstLarge secondLarge firstInteger |
self debugCode: [self msg: 'primDigitAdd: secondInteger'].
+ firstInteger := self
+ primitive: 'primDigitAdd'
+ parameters: #(Integer )
+ receiver: #Integer.
- firstInteger := self primitive: 'primDigitAdd'.
(interpreterProxy isIntegerObject: firstInteger)
+ ifTrue: ["convert it to a not normalized LargeInteger"
- ifTrue:
- ["convert it to a not normalized LargeInteger"
self remapOop: secondInteger in: [firstLarge := self createLargeFromSmallInteger: firstInteger]]
+ ifFalse: [firstLarge := firstInteger].
- ifFalse:
- [(self isLargeIntegerOop: firstInteger) ifFalse: [^interpreterProxy primitiveFail].
- firstLarge := firstInteger].
(interpreterProxy isIntegerObject: secondInteger)
+ ifTrue: ["convert it to a not normalized LargeInteger"
- ifTrue:
- ["convert it to a not normalized LargeInteger"
self remapOop: firstLarge in: [secondLarge := self createLargeFromSmallInteger: secondInteger]]
+ ifFalse: [secondLarge := secondInteger].
- ifFalse:
- [(self isLargeIntegerOop: secondInteger) ifFalse: [^interpreterProxy primitiveFail].
- secondLarge := secondInteger].
^ self digitAddLarge: firstLarge with: secondLarge!
Item was changed:
----- Method: LargeIntegersPlugin>>primDigitBitAnd: (in category 'Integer primitives') -----
primDigitBitAnd: secondInteger
"Bit logic here is only implemented for positive integers or Zero; if rec
or arg is negative, it fails."
| firstInteger |
self debugCode: [self msg: 'primDigitBitAnd: secondInteger'].
+ firstInteger := self
+ primitive: 'primDigitBitAnd'
+ parameters: #(Integer )
+ receiver: #Integer.
- firstInteger := self primitive: 'primDigitBitAnd'.
^ self
digitBitLogic: firstInteger
with: secondInteger
opIndex: andOpIndex!
Item was changed:
----- Method: LargeIntegersPlugin>>primDigitBitOr: (in category 'Integer primitives') -----
primDigitBitOr: secondInteger
"Bit logic here is only implemented for positive integers or Zero; if rec
or arg is negative, it fails."
| firstInteger |
self debugCode: [self msg: 'primDigitBitOr: secondInteger'].
+ firstInteger := self
+ primitive: 'primDigitBitOr'
+ parameters: #(Integer )
+ receiver: #Integer.
- firstInteger := self primitive: 'primDigitBitOr'.
^ self
digitBitLogic: firstInteger
with: secondInteger
opIndex: orOpIndex!
Item was changed:
----- Method: LargeIntegersPlugin>>primDigitBitShiftMagnitude: (in category 'Integer primitives') -----
primDigitBitShiftMagnitude: shiftCount
| rShift aLarge anInteger |
self debugCode: [self msg: 'primDigitBitShiftMagnitude: shiftCount'].
anInteger := self
primitive: 'primDigitBitShiftMagnitude'
+ parameters: #(#SmallInteger )
+ receiver: #Integer.
- parameters: #(#SmallInteger ).
(interpreterProxy isIntegerObject: anInteger)
+ ifTrue: ["convert it to a not normalized LargeInteger"
- ifTrue:
- ["convert it to a not normalized LargeInteger"
aLarge := self createLargeFromSmallInteger: anInteger]
+ ifFalse: [aLarge := anInteger].
- ifFalse:
- [(self isLargeIntegerOop: anInteger) ifFalse: [^interpreterProxy primitiveFail].
- aLarge := anInteger].
shiftCount >= 0
ifTrue: [^ self digit: aLarge Lshift: shiftCount]
ifFalse:
[rShift := 0 - shiftCount.
^ self normalize: (self
digit: aLarge
Rshift: rShift
lookfirst: (self digitSizeOfLargeInt: aLarge))]!
Item was changed:
----- Method: LargeIntegersPlugin>>primDigitBitXor: (in category 'Integer primitives') -----
primDigitBitXor: secondInteger
"Bit logic here is only implemented for positive integers or Zero; if rec
or arg is negative, it fails."
| firstInteger |
self debugCode: [self msg: 'primDigitBitXor: secondInteger'].
+ firstInteger := self
+ primitive: 'primDigitBitXor'
+ parameters: #(Integer )
+ receiver: #Integer.
- firstInteger := self primitive: 'primDigitBitXor'.
^ self
digitBitLogic: firstInteger
with: secondInteger
opIndex: xorOpIndex!
Item was changed:
----- Method: LargeIntegersPlugin>>primDigitCompare: (in category 'Integer primitives') -----
primDigitCompare: secondInteger
+ | firstVal secondVal firstInteger |
- | firstVal secondVal firstInteger firstIsSmall secondIsSmall |
self debugCode: [self msg: 'primDigitCompare: secondInteger'].
+ firstInteger := self
+ primitive: 'primDigitCompare'
+ parameters: #(#Integer )
+ receiver: #Integer.
- firstInteger := self primitive: 'primDigitCompare'.
"shortcut: aSmallInteger has to be smaller in Magnitude as aLargeInteger"
+ (interpreterProxy isIntegerObject: firstInteger)
+ ifTrue: ["first"
+ (interpreterProxy isIntegerObject: secondInteger)
+ ifTrue: ["second"
+ (firstVal := interpreterProxy integerValueOf: firstInteger) > (secondVal := interpreterProxy integerValueOf: secondInteger)
- firstIsSmall := interpreterProxy isIntegerObject: firstInteger.
- secondIsSmall := interpreterProxy isIntegerObject: secondInteger.
- firstIsSmall ifFalse: [(self isLargeIntegerOop: firstInteger) ifFalse: [^interpreterProxy primitiveFail]].
- secondIsSmall ifFalse: [(self isLargeIntegerOop: secondInteger) ifFalse: [^interpreterProxy primitiveFail]].
- firstIsSmall
- ifTrue:
- [secondIsSmall
- ifTrue:
- [(firstVal := interpreterProxy integerValueOf: firstInteger) > (secondVal := interpreterProxy integerValueOf: secondInteger)
ifTrue: [^ 1 asOop: SmallInteger"first > second"]
ifFalse: [firstVal < secondVal
ifTrue: [^ -1 asOop: SmallInteger"first < second"]
ifFalse: [^ 0 asOop: SmallInteger"first = second"]]]
+ ifFalse: ["SECOND"
+ ^ -1 asOop: SmallInteger"first < SECOND"]]
+ ifFalse: ["FIRST"
+ (interpreterProxy isIntegerObject: secondInteger)
+ ifTrue: ["second"
+ ^ 1 asOop: SmallInteger"FIRST > second"]
+ ifFalse: ["SECOND"
+ ^ self digitCompareLarge: firstInteger with: secondInteger]]!
- ifFalse:
- [^ -1 asOop: SmallInteger"first < SECOND"]]
- ifFalse:
- [secondIsSmall
- ifTrue:
- [^ 1 asOop: SmallInteger"FIRST > second"]
- ifFalse:
- [^ self digitCompareLarge: firstInteger with: secondInteger]]!
Item was changed:
----- Method: LargeIntegersPlugin>>primDigitDiv:negative: (in category 'Integer primitives') -----
primDigitDiv: secondInteger negative: neg
"Answer the result of dividing firstInteger by secondInteger.
Fail if parameters are not integers, not normalized or secondInteger is
zero. "
| firstAsLargeInteger secondAsLargeInteger firstInteger |
self debugCode: [self msg: 'primDigitDiv: secondInteger negative: neg'].
firstInteger := self
primitive: 'primDigitDivNegative'
+ parameters: #(#Integer #Boolean )
+ receiver: #Integer.
- parameters: #(#Oop #Boolean ).
"Coerce SmallIntegers to corresponding (not normalized) large integers
and check for zerodivide."
(interpreterProxy isIntegerObject: firstInteger)
+ ifTrue: ["convert to LargeInteger"
- ifTrue:
- ["convert to LargeInteger"
self
remapOop: secondInteger
in: [firstAsLargeInteger := self createLargeFromSmallInteger: firstInteger]]
ifFalse:
+ ["Avoid crashes in case of getting unnormalized args."
+ (self isNormalized: firstInteger)
+ ifFalse:
+ [self debugCode:
+ [self msg: 'ERROR in primDigitDiv: secondInteger negative: neg'.
+ self msg: '------> receiver *not* normalized!!'].
+ ^ interpreterProxy primitiveFail].
+ firstAsLargeInteger := firstInteger].
- [(self isLargeIntegerOop: firstInteger) ifFalse: [^interpreterProxy primitiveFail].
- "Avoid crashes in case of getting unnormalized args."
- (self isNormalized: firstInteger) ifFalse: [self
- debugCode: [self msg: 'ERROR in primDigitDiv: secondInteger negative: neg'.
- self msg: '------> receiver *not* normalized!!'].
- ^ interpreterProxy primitiveFail].firstAsLargeInteger := firstInteger].
(interpreterProxy isIntegerObject: secondInteger)
+ ifTrue: ["check for zerodivide and convert to LargeInteger"
+ (interpreterProxy integerValueOf: secondInteger)
+ = 0
- ifTrue:
- ["check for zerodivide and convert to LargeInteger"
- (interpreterProxy integerValueOf: secondInteger) = 0
ifTrue: [^ interpreterProxy primitiveFail].
self
remapOop: firstAsLargeInteger
in: [secondAsLargeInteger := self createLargeFromSmallInteger: secondInteger]]
ifFalse:
+ ["Avoid crashes in case of getting unnormalized args."
+ (self isNormalized: secondInteger)
+ ifFalse:
+ [self debugCode:
+ [self msg: 'ERROR in primDigitDiv: secondInteger negative: neg'.
+ self msg: '------> argument *not* normalized!!'].
+ ^ interpreterProxy primitiveFail].
- [(self isLargeIntegerOop: secondInteger) ifFalse: [^interpreterProxy primitiveFail].
- (self isNormalized: secondInteger) ifFalse: [self
- debugCode: [self msg: 'ERROR in primDigitDiv: secondInteger negative: neg'.
- self msg: '------> argument *not* normalized!!'].
- ^ interpreterProxy primitiveFail].
secondAsLargeInteger := secondInteger].
^ self
digitDivLarge: firstAsLargeInteger
with: secondAsLargeInteger
negative: neg!
Item was changed:
----- Method: LargeIntegersPlugin>>primDigitMultiply:negative: (in category 'Integer primitives') -----
primDigitMultiply: secondInteger negative: neg
| firstLarge secondLarge firstInteger |
self debugCode: [self msg: 'primDigitMultiply: secondInteger negative: neg'].
firstInteger := self
primitive: 'primDigitMultiplyNegative'
+ parameters: #(#Integer #Boolean )
+ receiver: #Integer.
- parameters: #(#Oop #Boolean ).
(interpreterProxy isIntegerObject: firstInteger)
+ ifTrue: ["convert it to a not normalized LargeInteger"
- ifTrue:
- ["convert it to a not normalized LargeInteger"
self
remapOop: secondInteger
in: [firstLarge := self createLargeFromSmallInteger: firstInteger]]
+ ifFalse: [firstLarge := firstInteger].
- ifFalse:
- [(self isLargeIntegerOop: firstInteger) ifFalse: [^interpreterProxy primitiveFail].
- firstLarge := firstInteger].
(interpreterProxy isIntegerObject: secondInteger)
+ ifTrue: ["convert it to a not normalized LargeInteger"
- ifTrue:
- ["convert it to a not normalized LargeInteger"
self
remapOop: firstLarge
in: [secondLarge := self createLargeFromSmallInteger: secondInteger]]
+ ifFalse: [secondLarge := secondInteger].
- ifFalse:
- [(self isLargeIntegerOop: secondInteger) ifFalse: [^interpreterProxy primitiveFail].
- secondLarge := secondInteger].
^ self
digitMultiplyLarge: firstLarge
with: secondLarge
negative: neg!
Item was changed:
----- Method: LargeIntegersPlugin>>primDigitSubtract: (in category 'Integer primitives') -----
primDigitSubtract: secondInteger
| firstLarge secondLarge firstInteger |
self debugCode: [self msg: 'primDigitSubtract: secondInteger'].
+ firstInteger := self
+ primitive: 'primDigitSubtract'
+ parameters: #(#Integer )
+ receiver: #Integer.
- firstInteger := self primitive: 'primDigitSubtract'.
(interpreterProxy isIntegerObject: firstInteger)
+ ifTrue: ["convert it to a not normalized LargeInteger"
- ifTrue:
- ["convert it to a not normalized LargeInteger"
self
remapOop: secondInteger
in: [firstLarge := self createLargeFromSmallInteger: firstInteger]]
+ ifFalse: [firstLarge := firstInteger].
- ifFalse:
- [(self isLargeIntegerOop: firstInteger) ifFalse: [^interpreterProxy primitiveFail].
- firstLarge := firstInteger].
(interpreterProxy isIntegerObject: secondInteger)
+ ifTrue: ["convert it to a not normalized LargeInteger"
- ifTrue:
- ["convert it to a not normalized LargeInteger"
self
remapOop: firstLarge
in: [secondLarge := self createLargeFromSmallInteger: secondInteger]]
+ ifFalse: [secondLarge := secondInteger].
- ifFalse:
- [(self isLargeIntegerOop: firstInteger) ifFalse: [^interpreterProxy primitiveFail].
- secondLarge := secondInteger].
^ self digitSubLarge: firstLarge with: secondLarge!
Item was changed:
----- Method: LargeIntegersPlugin>>primMontgomeryDigitLength (in category 'Integer primitives') -----
primMontgomeryDigitLength
self debugCode: [self msg: 'primMontgomeryDigitLength'].
+ self
+ primitive: 'primMontgomeryDigitLength'
+ parameters: #()
+ receiver: #Integer.
- self primitive: 'primMontgomeryDigitLength'.
^interpreterProxy integerObjectOf: 32!
Item was changed:
----- Method: LargeIntegersPlugin>>primMontgomeryTimes:modulo:mInvModB: (in category 'Integer primitives') -----
primMontgomeryTimes: secondOperandInteger modulo: thirdModuloInteger mInvModB: mInverseInteger
| firstLarge secondLarge firstInteger thirdLarge mInv |
<var: #mInv type: #'unsigned int'>
self debugCode: [self msg: 'montgomeryTimes: secondOperandInteger modulo: thirdModuloInteger mInvModB: smallInverseInteger'].
+ firstInteger := self
+ primitive: 'primMontgomeryTimesModulo'
+ parameters: #(Integer Integer Integer )
+ receiver: #Integer.
+ mInv := interpreterProxy positive32BitValueOf: mInverseInteger.
- firstInteger := self primitive: 'primMontgomeryTimesModulo'.
- mInv := interpreterProxy positive32BitValueOf: mInverseInteger.
(interpreterProxy isIntegerObject: firstInteger)
+ ifTrue: ["convert it to a not normalized LargeInteger"
- ifTrue:
- ["convert it to a not normalized LargeInteger"
self remapOop: #(secondOperandInteger thirdModuloInteger) in: [firstLarge := self createLargeFromSmallInteger: firstInteger]]
+ ifFalse: [firstLarge := firstInteger].
- ifFalse:
- [(self isLargeIntegerOop: firstInteger) ifFalse: [^interpreterProxy primitiveFail].
- firstLarge := firstInteger].
(interpreterProxy isIntegerObject: secondOperandInteger)
+ ifTrue: ["convert it to a not normalized LargeInteger"
- ifTrue:
- ["convert it to a not normalized LargeInteger"
self remapOop: #(firstLarge thirdModuloInteger) in: [secondLarge := self createLargeFromSmallInteger: secondOperandInteger]]
+ ifFalse: [secondLarge := secondOperandInteger].
- ifFalse:
- [(self isLargeIntegerOop: secondOperandInteger) ifFalse: [^interpreterProxy primitiveFail].
- secondLarge := secondOperandInteger].
(interpreterProxy isIntegerObject: thirdModuloInteger)
+ ifTrue: ["convert it to a not normalized LargeInteger"
- ifTrue:
- ["convert it to a not normalized LargeInteger"
self remapOop: #(firstLarge secondLarge) in: [thirdLarge := self createLargeFromSmallInteger: thirdModuloInteger]]
+ ifFalse: [thirdLarge := thirdModuloInteger].
- ifFalse:
- [(self isLargeIntegerOop: thirdModuloInteger) ifFalse: [^interpreterProxy primitiveFail].
- thirdLarge := thirdModuloInteger].
^ self digitMontgomery: firstLarge times: secondLarge modulo: thirdLarge mInvModB: mInv!
Item was changed:
----- Method: LargeIntegersPlugin>>primNormalizeNegative (in category 'Integer primitives') -----
primNormalizeNegative
| rcvr |
self debugCode: [self msg: 'primNormalizeNegative'].
+ rcvr := self
+ primitive: 'primNormalizeNegative'
+ parameters: #()
+ receiver: #LargeNegativeInteger.
- rcvr := self primitive: 'primNormalizeNegative'.
- (interpreterProxy fetchClassOf: rcvr) == interpreterProxy classLargeNegativeInteger ifFalse: [^interpreterProxy primitiveFail].
^ self normalizeNegative: rcvr!
Item was changed:
----- Method: LargeIntegersPlugin>>primNormalizePositive (in category 'Integer primitives') -----
primNormalizePositive
| rcvr |
self debugCode: [self msg: 'primNormalizePositive'].
+ rcvr := self
+ primitive: 'primNormalizePositive'
+ parameters: #()
+ receiver: #LargePositiveInteger.
- rcvr := self primitive: 'primNormalizePositive'.
- (interpreterProxy fetchClassOf: rcvr) == interpreterProxy classLargePositiveInteger ifFalse: [^interpreterProxy primitiveFail].
^ self normalizePositive: rcvr!
Item was added:
+ ----- Method: LargeNegativeInteger class>>ccg:prolog:expr:index: (in category '*VMMaker-plugin generation') -----
+ ccg: cg prolog: aBlock expr: aString index: anInteger
+
+ ^cg ccgLoad: aBlock expr: aString asMemberOfLargeNegativeIntegerFrom: anInteger!
Item was added:
+ ----- Method: LargePositiveInteger class>>ccg:prolog:expr:index: (in category '*VMMaker-plugin generation') -----
+ ccg: cg prolog: aBlock expr: aString index: anInteger
+
+ ^cg ccgLoad: aBlock expr: aString asMemberOfLargePositiveIntegerFrom: anInteger!
Item was added:
+ ----- Method: NewCoObjectMemorySimulator>>isKindOfInteger: (in category 'simulation only') -----
+ isKindOfInteger: offset
+ ^coInterpreter isKindOfInteger: offset!
Item was added:
+ ----- Method: NewCoObjectMemorySimulator>>isLargeIntegerObject: (in category 'simulation only') -----
+ isLargeIntegerObject: offset
+ ^coInterpreter isLargeIntegerObject: offset!
Item was added:
+ ----- Method: NewCoObjectMemorySimulator>>isLargeNegativeIntegerObject: (in category 'simulation only') -----
+ isLargeNegativeIntegerObject: offset
+ ^coInterpreter isLargeNegativeIntegerObject: offset!
Item was added:
+ ----- Method: NewCoObjectMemorySimulator>>isLargePositiveIntegerObject: (in category 'simulation only') -----
+ isLargePositiveIntegerObject: offset
+ ^coInterpreter isLargePositiveIntegerObject: offset!
Item was added:
+ ----- Method: NewObjectMemorySimulator>>isKindOfInteger: (in category 'simulation only') -----
+ isKindOfInteger: offset
+ ^coInterpreter isKindOfInteger: offset!
Item was added:
+ ----- Method: NewObjectMemorySimulator>>isLargeIntegerObject: (in category 'simulation only') -----
+ isLargeIntegerObject: offset
+ ^coInterpreter isLargeIntegerObject: offset!
Item was added:
+ ----- Method: NewObjectMemorySimulator>>isLargeNegativeIntegerObject: (in category 'simulation only') -----
+ isLargeNegativeIntegerObject: offset
+ ^coInterpreter isLargeNegativeIntegerObject: offset!
Item was added:
+ ----- Method: NewObjectMemorySimulator>>isLargePositiveIntegerObject: (in category 'simulation only') -----
+ isLargePositiveIntegerObject: offset
+ ^coInterpreter isLargePositiveIntegerObject: offset!
Item was changed:
----- Method: ObjectMemory>>cCoerceSimple:to: (in category 'simulation support') -----
cCoerceSimple: value to: cTypeString
<doNotGenerate>
^cTypeString caseOf:
+ { [#'char *'] -> [value].
+ [#'unsigned int'] -> [value]. }!
- { [#'char *'] -> [value] }!
Item was added:
+ ----- Method: ObjectMemory>>isInstanceOfClassLargeNegativeInteger: (in category 'interpreter access') -----
+ isInstanceOfClassLargeNegativeInteger: oop
+ <inline: true>
+ "N.B. Because Slang always inlines is:instanceOf:compactClassIndex:
+ (because is:instanceOf:compactClassIndex: has an inline: pragma) the
+ phrase (objectMemory splObj: ClassLargeNegativeInteger) is expanded
+ in-place and is _not_ evaluated if oop has a non-zero CompactClassIndex."
+ ^self
+ is: oop
+ instanceOf: (self splObj: ClassLargeNegativeInteger)
+ compactClassIndex: ClassLargeNegativeIntegerCompactIndex!
Item was added:
+ ----- Method: ObjectMemory>>isInstanceOfClassLargePositiveInteger: (in category 'interpreter access') -----
+ isInstanceOfClassLargePositiveInteger: oop
+ <inline: true>
+ "N.B. Because Slang always inlines is:instanceOf:compactClassIndex:
+ (because is:instanceOf:compactClassIndex: has an inline: pragma) the
+ phrase (objectMemory splObj: ClassLargePositiveInteger) is expanded
+ in-place and is _not_ evaluated if oop has a non-zero CompactClassIndex."
+ ^self
+ is: oop
+ instanceOf: (self splObj: ClassLargePositiveInteger)
+ compactClassIndex: ClassLargePositiveIntegerCompactIndex!
Item was added:
+ ----- Method: ObjectMemory>>isLargeIntegerInstance: (in category 'interpreter access') -----
+ isLargeIntegerInstance: oop
+ <inline: true>
+ ^(self isInstanceOfClassLargePositiveInteger: oop)
+ or: [self isInstanceOfClassLargeNegativeInteger: oop]!
Item was added:
+ ----- Method: SmartSyntaxPluginCodeGenerator>>ccgLoad:expr:asKindOfIntegerFrom: (in category 'coercing') -----
+ ccgLoad: aBlock expr: aString asKindOfIntegerFrom: anInteger
+
+ ^String streamContents: [:aStream | aStream
+ nextPutAll: 'interpreterProxy success: (interpreterProxy isKindOfInteger: (interpreterProxy stackValue: ';
+ nextPutAll: anInteger asString;
+ nextPutAll: ')).';
+ crtab;
+ nextPutAll: (self
+ ccgLoad: aBlock
+ expr: aString
+ asRawOopFrom: anInteger)]!
Item was added:
+ ----- Method: SmartSyntaxPluginCodeGenerator>>ccgLoad:expr:asMemberOfLargeNegativeIntegerFrom: (in category 'coercing') -----
+ ccgLoad: aBlock expr: aString asMemberOfLargeNegativeIntegerFrom: anInteger
+
+ ^String streamContents: [:aStream | aStream
+ nextPutAll: 'interpreterProxy success: (interpreterProxy isLargeNegativeIntegerObject: (interpreterProxy stackValue: ';
+ nextPutAll: anInteger asString;
+ nextPutAll: ')).';
+ crtab;
+ nextPutAll: (self
+ ccgLoad: aBlock
+ expr: aString
+ asRawOopFrom: anInteger)]!
Item was added:
+ ----- Method: SmartSyntaxPluginCodeGenerator>>ccgLoad:expr:asMemberOfLargePositiveIntegerFrom: (in category 'coercing') -----
+ ccgLoad: aBlock expr: aString asMemberOfLargePositiveIntegerFrom: anInteger
+
+ ^String streamContents: [:aStream | aStream
+ nextPutAll: 'interpreterProxy success: (interpreterProxy isLargePositiveIntegerObject: (interpreterProxy stackValue: ';
+ nextPutAll: anInteger asString;
+ nextPutAll: ')).';
+ crtab;
+ nextPutAll: (self
+ ccgLoad: aBlock
+ expr: aString
+ asRawOopFrom: anInteger)]!
Item was added:
+ ----- Method: SmartSyntaxPluginSimulator>>ccgLoad:expr:asKindOfIntegerFrom: (in category 'simulation') -----
+ ccgLoad: forProlog expr: failBlock asKindOfIntegerFrom: argIndexOrNil
+ ^[:oop|
+ interpreterProxy success: (interpreterProxy isKindOfInteger: oop).
+ oop]!
Item was added:
+ ----- Method: SmartSyntaxPluginSimulator>>ccgLoad:expr:asMemberOfLargeNegativeIntegerFrom: (in category 'simulation') -----
+ ccgLoad: forProlog expr: failBlock asMemberOfLargeNegativeIntegerFrom: argIndexOrNil
+ ^[:oop|
+ interpreterProxy success: (interpreterProxy isLargeNegativeIntegerObject: oop).
+ oop]!
Item was added:
+ ----- Method: SmartSyntaxPluginSimulator>>ccgLoad:expr:asMemberOfLargePositiveIntegerFrom: (in category 'simulation') -----
+ ccgLoad: forProlog expr: failBlock asMemberOfLargePositiveIntegerFrom: argIndexOrNil
+ ^[:oop|
+ interpreterProxy success: (interpreterProxy isLargePositiveIntegerObject: oop).
+ oop]!
Item was added:
+ ----- Method: SpurMemoryManager>>isInstanceOfClassLargeNegativeInteger: (in category 'interpreter access') -----
+ isInstanceOfClassLargeNegativeInteger: oop
+ "Answer if the oop is a large negative integer instance."
+ ^(self isNonImmediate: oop) and: [(self classIndexOf: oop) = ClassLargeNegativeIntegerCompactIndex]!
Item was added:
+ ----- Method: SpurMemoryManager>>isInstanceOfClassLargePositiveInteger: (in category 'interpreter access') -----
+ isInstanceOfClassLargePositiveInteger: oop
+ "Answer if the oop is a large positive integer instance."
+ ^(self isNonImmediate: oop) and: [(self classIndexOf: oop) = ClassLargePositiveIntegerCompactIndex]!
Item was added:
+ ----- Method: SpurMemoryManager>>isLargeIntegerInstance: (in category 'interpreter access') -----
+ isLargeIntegerInstance: oop
+ "Answer if the oop is a large positive or negative integer instance."
+ ^(self isNonImmediate: oop) and: [((self classIndexOf: oop) - ClassLargeNegativeIntegerCompactIndex) asUnsignedInteger <= 1]!
Item was added:
+ ----- Method: StackInterpreter>>isKindOfInteger: (in category 'internal interpreter access') -----
+ isKindOfInteger: oop
+ "Answer true if the oop is kind of Integer (Small or Large)."
+ <api>
+ <inline: true>
+ ^(objectMemory isIntegerObject: oop)
+ or: [objectMemory isLargeIntegerInstance: oop]!
Item was added:
+ ----- Method: StackInterpreter>>isLargeIntegerObject: (in category 'internal interpreter access') -----
+ isLargeIntegerObject: oop
+ <api>
+ <inline: true>
+ ^objectMemory isLargeIntegerInstance: oop!
Item was added:
+ ----- Method: StackInterpreter>>isLargeNegativeIntegerObject: (in category 'internal interpreter access') -----
+ isLargeNegativeIntegerObject: oop
+ <api>
+ <inline: true>
+ ^objectMemory isInstanceOfClassLargeNegativeInteger: oop!
Item was added:
+ ----- Method: StackInterpreter>>isLargePositiveIntegerObject: (in category 'internal interpreter access') -----
+ isLargePositiveIntegerObject: oop
+ <api>
+ <inline: true>
+ ^objectMemory isInstanceOfClassLargePositiveInteger: oop!
Item was changed:
----- Method: StackInterpreter>>printStringOf: (in category 'debug printing') -----
printStringOf: oop
| fmt len cnt max i |
<inline: false>
(objectMemory isImmediate: oop) ifTrue:
[^self].
(objectMemory addressCouldBeObj: oop) ifFalse:
[^self].
fmt := objectMemory formatOf: oop.
fmt < objectMemory firstByteFormat ifTrue: [^self].
cnt := (max := 128) min: (len := objectMemory lengthOf: oop).
i := 0.
((objectMemory is: oop
instanceOf: (objectMemory splObj: ClassByteArray)
compactClassIndex: classByteArrayCompactIndex)
+ or: [(objectMemory isLargeIntegerInstance: oop)])
- or: [(self isInstanceOfClassLargePositiveInteger: oop)
- or: [(self isInstanceOfClassLargeNegativeInteger: oop)]])
ifTrue:
[[i < cnt] whileTrue:
[self printHex: (objectMemory fetchByte: i ofObject: oop).
i := i + 1]]
ifFalse:
[[i < cnt] whileTrue:
[self cCode:
[(objectMemory fetchByte: i ofObject: oop) = 13 "Character cr asInteger" ifTrue:
[self print: '<CR>'.
i + 1 < len ifTrue:
[self print: '...'].
^self]].
self printChar: (objectMemory fetchByte: i ofObject: oop).
i := i + 1]].
len > max ifTrue:
[self print: '...'].
self flush!
Item was changed:
----- Method: ThreadedFFIPlugin>>ffiIntegerValueOf: (in category 'callout support') -----
ffiIntegerValueOf: oop
"Support for generic callout. Answer an integer value that is coerced as C would do."
<inline: true>
"Cheat with a tag test"
(oop anyMask: BytesPerWord - 1)
ifTrue:
[(interpreterProxy isIntegerObject: oop) ifTrue:
[^interpreterProxy integerValueOf: oop].
self cppIf: SPURVM
ifTrue:
[(interpreterProxy isCharacterObject: oop) ifTrue: "Immediate in Spur"
[^interpreterProxy characterValueOf: oop].
(interpreterProxy isFloatObject: oop) ifTrue: "Immediate in 64-bit Spur"
[^interpreterProxy floatValueOf: oop]]]
ifFalse:
[self cppIf: SPURVM
ifTrue: "No non-immediate characters in Spur"
[]
ifFalse:
[(interpreterProxy isCharacterObject: oop) ifTrue:
[^interpreterProxy characterValueOf: oop]].
(interpreterProxy isFloatObject: oop) ifTrue:
[^interpreterProxy floatValueOf: oop].
oop = interpreterProxy nilObject ifTrue: [^0]. "@@: should we really allow this????"
oop = interpreterProxy falseObject ifTrue: [^0].
oop = interpreterProxy trueObject ifTrue: [^1].
+ (interpreterProxy isLargePositiveIntegerObject: oop) ifTrue:
- (interpreterProxy fetchClassOf: oop) = interpreterProxy classLargePositiveInteger ifTrue:
[self cppIf: BytesPerWord = 8 "Use cppIf: to get the return type of the function right. Should be sqInt on 32-bits."
ifTrue: [^interpreterProxy positive64BitValueOf: oop]
ifFalse: [^interpreterProxy positive32BitValueOf: oop]]].
^interpreterProxy signedMachineIntegerValueOf: oop "<- will fail if not integer"!
1
0
19 Apr '16
Revision: 3672
Author: eliot
Date: 2016-04-19 11:21:14 -0700 (Tue, 19 Apr 2016)
Log Message:
-----------
CogVM source as per VMMaker.oscog-eem.1822
General:
Add support for full block closures (visible in the Ssta VMs). Full
block closures have their own method, and receiver, independent of
their outerContext's.
Spur:
Fix bug in following state on primitive failure. The old code would
always follow to depth 1, even if the accessor depth was 0.
Hard-code primitiveSize's depth to 0 (accessing length in at:[put:]
and size causes the stack depth computation to answer 1 instead of
0 for these primitives.
Fix assert and dequeueMourner for case where mournQueue is nil.
- use option:IMMUTABILITY instead of cppIf: to make the immutability
primitive code look better.
- fixed a bug in receiver accessing in immutability primitive for
mirror primitive.
- change primitiveSetOrHasIdentityHash to patch the class table if
the new hash is set to a behavior (the primitive knows it's a
behavior if the second (optional) argument is true)
For example:
FullBlockClosure tryPrimitive: 161 withArgs: {38.true}
No longer follow the method and context fields in a closure in
activateNewClosureMethod:numArgs:mayContextSwitch:; the caller will
have failed if these are forwarders, so no need to check again.
Cogit:
Follow selectors in the openPICList post Spur become.
Removed all the annoteUse (from the struct, its usage, etc...)
Abstract out the asnnotate Label or Nop routine and use it to fix
doubleExtendedDoAnythingBytecode
- improved support for register allocation: branch merge
successfully compiled with register moved instead of spilling.
- refactored annotateUse in CogSimStackEntry to share code between methods
- tried to make some sense out of the fixup merge logic. Now all
return and unconditionnal jumps marked explicitly the execution
flow as being deadCode. At each merge point, depending if the
execution can fall through or not, handle the merge differently.
Rename ScratchNReg to ExtraNReg. Provide availableRegisterOrNoneFor:
in ARM & X64 to allocate ExtraNRegs when available.
Provide isCallerSavedReg: as a convenience and use it where
(self register: ReceiverResultReg isInMask: callerSavedRegMask) was.
- Made explicit messages related to bytecode fixup (abstract away
from integer flags)
JIT and execution-time support for full block closures. Use the old
cpicHasMNUFlag in CMMethod to mark full block code, hence renaming
the flag to cpicHasMNUCaseOrCMIsFullBlock. Provide
isVanillaBlockClosure: to disinguish between standard and full block
closures. Use it in makeBaseFrameFor:.
Sista Bytecodes:
Added the ExtB flags extension to tip the JIT how what machine code
checks can be ignored on specific operations.
Sista Cogit:
Don't bother to add counters to conditional jumps implementing and:
and or:. Added the remote inst var access bytecode in sista V1
bytecode set without interfering with existing code.
Plugins:
Upgrade LargeIntegersPlugin to v2.0
LargeInteger primitives now deal with 32-bits digits.
At image side, LargeInteger digits are still 8-bit wide.
This enables fallback code to work in absence of the plugin.
Subtle code:
1) Large integers still have byteLength calculated as short as possible
this is to avoid having null highest 8-bit digit at image side
2) For this reason largeInt:growTo: takes a byte-length parameter
and we need to restore byteSizeOfCSI: and byteSizeOfLargeInt:
3) For multiply, the result is allocated with just enough bytes
for example 13 bytes*11 bytes->24 bytes->6 digits
If we would round to digits, that would be: 4 digits*3 digits->7 digits
for this reason, an additional parameter (resLen) has been added to cDigitMultiply
and care is taken to not write a (null) carry past this result length
4) For hypothetical big-endian machines, bytes are swapped on the fly at each fetch/store from/to memory (see cDigitOf:at: / cDigitOf:at:put:)
This is achieved thru byteSwapped32IfBigEndian: which translates to a C macro SQ_SWAP_4_BYTES_IF_BIGENDIAN (defined in SVN platforms/Cross/vm/sqMemoryAccess.h)
But this is necessary only for arithmetic ops (+ - * / < > ...)
For bit ops or copy, there is no need to swap bytes, so direct access to pointer is used.
Other than that I renamed a few messages
cDigitOfCSI:at: -> digitOfCSI:at:
cDigitLengthOfCSI: -> digitSizeOfCSI:
This was to have a better symetry with digitOfLargeInt:at: digitSizeOfLargeInt:
Slang:
Use the new macro SQ_SWAP_4/8_BYTES_IF_BIGENDIAN to factor out
proliferation of cppIf: VMBIGENDIAN.
Memory is 8 bytes aligned on Spur. When storing 32/64 bits large
integers values, allways fill the eight bytes whatever the
effectivily used size, rather than bother with dissertion of size.
Prepare the same change for fetching 32/64 LargeIntegers values on
SpurVM, but comment it out for now as it's unclear whether those
oversize bytes are effectivly zero for extant LargeIntegers.
Fix generation of byteSwapped in v3.
Go the extra quarter-mile and define an optional primitive as the
fast primitive fail code (null pointer) so that unselected optional
primitives are in the prmitiveTable as fast primitive fails.
Changes to get the RegisterAllocatingCogit to compile. The struct
classes must be generated in the order specified in the Cogit's
ancilliaryClasses since the structs referent each other and the
first must precede the referers. CogSimStackEntry and subclasses
get SimStackEntry as their struct name. The ancilliary classes must
include the most specific fixup and simstackentry classes only.
Factor out the duplicated code generating C integer literals.
Generate sqInt literals as 0x123ULL so that they're valid in
64-bit compiles as well as 32-bit.
Mac OS Builds:
Don't link with -fvisibility=hidden; it breaks external plugins. Use
-fvisibility=default instead.
Modified Paths:
--------------
branches/Cog/build.macos32x86/common/Makefile.flags
branches/Cog/build.macos64x64/common/Makefile.flags
branches/Cog/build.macos64x64/common/Makefile.rules
branches/Cog/image/LoadSistaSupport.st
branches/Cog/image/buildsistareaderimage.sh
branches/Cog/nsspur64src/vm/cogit.h
branches/Cog/nsspur64src/vm/cogitX64.c
branches/Cog/nsspur64src/vm/cogmethod.h
branches/Cog/nsspur64src/vm/cointerp.c
branches/Cog/nsspur64src/vm/cointerp.h
branches/Cog/nsspur64src/vm/gcc3x-cointerp.c
branches/Cog/nsspursrc/vm/cogit.h
branches/Cog/nsspursrc/vm/cogitARMv5.c
branches/Cog/nsspursrc/vm/cogitIA32.c
branches/Cog/nsspursrc/vm/cogitMIPSEL.c
branches/Cog/nsspursrc/vm/cogmethod.h
branches/Cog/nsspursrc/vm/cointerp.c
branches/Cog/nsspursrc/vm/cointerp.h
branches/Cog/nsspursrc/vm/gcc3x-cointerp.c
branches/Cog/nsspurstack64src/vm/gcc3x-interp.c
branches/Cog/nsspurstack64src/vm/interp.c
branches/Cog/nsspurstacksrc/vm/gcc3x-interp.c
branches/Cog/nsspurstacksrc/vm/interp.c
branches/Cog/scripts/lastCheckin
branches/Cog/spur64src/vm/cogit.h
branches/Cog/spur64src/vm/cogitX64.c
branches/Cog/spur64src/vm/cogmethod.h
branches/Cog/spur64src/vm/cointerp.c
branches/Cog/spur64src/vm/cointerp.h
branches/Cog/spur64src/vm/gcc3x-cointerp.c
branches/Cog/spursistasrc/vm/cogit.h
branches/Cog/spursistasrc/vm/cogitARMv5.c
branches/Cog/spursistasrc/vm/cogitIA32.c
branches/Cog/spursistasrc/vm/cogitMIPSEL.c
branches/Cog/spursistasrc/vm/cogmethod.h
branches/Cog/spursistasrc/vm/cointerp.c
branches/Cog/spursistasrc/vm/cointerp.h
branches/Cog/spursistasrc/vm/gcc3x-cointerp.c
branches/Cog/spursrc/vm/cogit.h
branches/Cog/spursrc/vm/cogitARMv5.c
branches/Cog/spursrc/vm/cogitIA32.c
branches/Cog/spursrc/vm/cogitMIPSEL.c
branches/Cog/spursrc/vm/cogmethod.h
branches/Cog/spursrc/vm/cointerp.c
branches/Cog/spursrc/vm/cointerp.h
branches/Cog/spursrc/vm/gcc3x-cointerp.c
branches/Cog/spurstack64src/vm/gcc3x-interp.c
branches/Cog/spurstack64src/vm/interp.c
branches/Cog/spurstacksrc/vm/gcc3x-interp.c
branches/Cog/spurstacksrc/vm/interp.c
branches/Cog/src/plugins/ADPCMCodecPlugin/ADPCMCodecPlugin.c
branches/Cog/src/plugins/AsynchFilePlugin/AsynchFilePlugin.c
branches/Cog/src/plugins/B2DPlugin/B2DPlugin.c
branches/Cog/src/plugins/B3DAcceleratorPlugin/B3DAcceleratorPlugin.c
branches/Cog/src/plugins/BitBltPlugin/BitBltPlugin.c
branches/Cog/src/plugins/BochsIA32Plugin/BochsIA32Plugin.c
branches/Cog/src/plugins/BochsX64Plugin/BochsX64Plugin.c
branches/Cog/src/plugins/CameraPlugin/CameraPlugin.c
branches/Cog/src/plugins/CroquetPlugin/CroquetPlugin.c
branches/Cog/src/plugins/DSAPrims/DSAPrims.c
branches/Cog/src/plugins/FFTPlugin/FFTPlugin.c
branches/Cog/src/plugins/FilePlugin/FilePlugin.c
branches/Cog/src/plugins/FloatArrayPlugin/FloatArrayPlugin.c
branches/Cog/src/plugins/GdbARMPlugin/GdbARMPlugin.c
branches/Cog/src/plugins/GeniePlugin/GeniePlugin.c
branches/Cog/src/plugins/IA32ABI/IA32ABI.c
branches/Cog/src/plugins/JPEGReaderPlugin/JPEGReaderPlugin.c
branches/Cog/src/plugins/JoystickTabletPlugin/JoystickTabletPlugin.c
branches/Cog/src/plugins/Klatt/Klatt.c
branches/Cog/src/plugins/LargeIntegers/LargeIntegers.c
branches/Cog/src/plugins/MacMenubarPlugin/MacMenubarPlugin.c
branches/Cog/src/plugins/Matrix2x3Plugin/Matrix2x3Plugin.c
branches/Cog/src/plugins/MiscPrimitivePlugin/MiscPrimitivePlugin.c
branches/Cog/src/plugins/RePlugin/RePlugin.c
branches/Cog/src/plugins/ScratchPlugin/ScratchPlugin.c
branches/Cog/src/plugins/SocketPlugin/SocketPlugin.c
branches/Cog/src/plugins/SoundGenerationPlugin/SoundGenerationPlugin.c
branches/Cog/src/plugins/SoundPlugin/SoundPlugin.c
branches/Cog/src/plugins/SqueakFFIPrims/ARM32FFIPlugin.c
branches/Cog/src/plugins/SqueakFFIPrims/IA32FFIPlugin.c
branches/Cog/src/plugins/SqueakFFIPrims/X64SysVFFIPlugin.c
branches/Cog/src/plugins/SqueakFFIPrims/X64Win64FFIPlugin.c
branches/Cog/src/plugins/StarSqueakPlugin/StarSqueakPlugin.c
branches/Cog/src/plugins/UnicodePlugin/UnicodePlugin.c
branches/Cog/src/plugins/VMProfileLinuxSupportPlugin/VMProfileLinuxSupportPlugin.c
branches/Cog/src/plugins/VMProfileMacSupportPlugin/VMProfileMacSupportPlugin.c
branches/Cog/src/plugins/WeDoPlugin/WeDoPlugin.c
branches/Cog/src/plugins/Win32OSProcessPlugin/Win32OSProcessPlugin.c
branches/Cog/src/plugins/ZipPlugin/ZipPlugin.c
branches/Cog/src/vm/cogit.h
branches/Cog/src/vm/cogitARMv5.c
branches/Cog/src/vm/cogitIA32.c
branches/Cog/src/vm/cogitMIPSEL.c
branches/Cog/src/vm/cogmethod.h
branches/Cog/src/vm/cointerp.c
branches/Cog/src/vm/cointerp.h
branches/Cog/src/vm/cointerpmt.c
branches/Cog/src/vm/cointerpmt.h
branches/Cog/src/vm/gcc3x-cointerp.c
branches/Cog/src/vm/gcc3x-cointerpmt.c
branches/Cog/stacksrc/vm/gcc3x-interp.c
branches/Cog/stacksrc/vm/interp.c
Added Paths:
-----------
branches/Cog/scripts/indentit
Property Changed:
----------------
branches/Cog/platforms/Cross/vm/sqSCCSVersion.h
Modified: branches/Cog/build.macos32x86/common/Makefile.flags
===================================================================
--- branches/Cog/build.macos32x86/common/Makefile.flags 2016-04-09 00:17:14 UTC (rev 3671)
+++ branches/Cog/build.macos32x86/common/Makefile.flags 2016-04-19 18:21:14 UTC (rev 3672)
@@ -14,7 +14,7 @@
CFLAGS:=$(CFLAGS) -DBUILD_FOR_OSX=1 \
-arch $(TARGET_ARCH) \
-mmacosx-version-min=$(TARGET_VERSION_MIN) -msse4.2 \
- -fvisibility=hidden -fwrapv \
+ -fvisibility=default -fwrapv \
-fmacro-backtrace-limit=0 -fdiagnostics-show-note-include-stack \
-fmessage-length=0 -fpascal-strings -fasm-blocks -fstrict-aliasing \
-isysroot $(SDK) \
Modified: branches/Cog/build.macos64x64/common/Makefile.flags
===================================================================
--- branches/Cog/build.macos64x64/common/Makefile.flags 2016-04-09 00:17:14 UTC (rev 3671)
+++ branches/Cog/build.macos64x64/common/Makefile.flags 2016-04-19 18:21:14 UTC (rev 3672)
@@ -14,7 +14,7 @@
CFLAGS:=$(CFLAGS) -DBUILD_FOR_OSX=1 \
-arch $(TARGET_ARCH) \
-mmacosx-version-min=$(TARGET_VERSION_MIN) -msse4.2 \
- -fvisibility=hidden -fwrapv \
+ -fvisibility=default -fwrapv \
-fmacro-backtrace-limit=0 -fdiagnostics-show-note-include-stack \
-fmessage-length=0 -fpascal-strings -fasm-blocks -fstrict-aliasing \
-isysroot $(SDK) \
Modified: branches/Cog/build.macos64x64/common/Makefile.rules
===================================================================
--- branches/Cog/build.macos64x64/common/Makefile.rules 2016-04-09 00:17:14 UTC (rev 3671)
+++ branches/Cog/build.macos64x64/common/Makefile.rules 2016-04-19 18:21:14 UTC (rev 3672)
@@ -13,7 +13,6 @@
DEPFLAGS = -MT $@ -MMD -MP -MF deps/$(*F).Td
ALLFLAGS = $(DEPFLAGS) $(WARNINGS) $(CFLAGS)
-#POSTCOMPILE = mv -f deps/$(*F).Td deps/$(*F).d
POSTCOMPILE = sed '/^$$/d' <deps/$(*F).Td | sed '/^.*:$$/d' | sed 's/^build[^/]*/$$(BUILD)/' > deps/$(*F).d; rm deps/$(*F).Td; touch -r $< deps/$(*F).d
$(OBJDIR)/%.o: %.c deps/%.d
Modified: branches/Cog/image/LoadSistaSupport.st
===================================================================
--- branches/Cog/image/LoadSistaSupport.st 2016-04-09 00:17:14 UTC (rev 3671)
+++ branches/Cog/image/LoadSistaSupport.st 2016-04-19 18:21:14 UTC (rev 3672)
@@ -35,4 +35,8 @@
ex resume]]]
valueWithArguments: tuple].
+CompiledMethod installSecondaryBytecodeSet: (Smalltalk classNamed: #EncoderForSistaV1).
+
+FullBlockClosure tryPrimitive: 161 withArgs: #(38 true).
+
Smalltalk snapshot: true andQuit: true
Modified: branches/Cog/image/buildsistareaderimage.sh
===================================================================
--- branches/Cog/image/buildsistareaderimage.sh 2016-04-09 00:17:14 UTC (rev 3671)
+++ branches/Cog/image/buildsistareaderimage.sh 2016-04-19 18:21:14 UTC (rev 3672)
@@ -10,7 +10,11 @@
cp -p trunk50.image sistareader.image
cp -p trunk50.changes sistareader.changes
+if test -n "$1"; then
+ VM="$1"
+else
. ./getGoodSpurVM.sh
+fi
echo $VM sistareader.image LoadSistaSupport.st
$VM sistareader.image LoadSistaSupport.st
Modified: branches/Cog/nsspur64src/vm/cogit.h
===================================================================
--- branches/Cog/nsspur64src/vm/cogit.h 2016-04-09 00:17:14 UTC (rev 3671)
+++ branches/Cog/nsspur64src/vm/cogit.h 2016-04-19 18:21:14 UTC (rev 3672)
@@ -1,5 +1,5 @@
/* Automatically generated by
- CCodeGenerator VMMaker.oscog-eem.1756 uuid: 141cf0f3-955a-486f-8082-decbc14645d7
+ CCodeGenerator VMMaker.oscog-eem.1822 uuid: f18408b3-d8bb-4ac7-9d7d-b37ace026619
*/
@@ -152,4 +152,6 @@
#define setCStackPointer(theSP) (CStackPointer = (void *)(theSP))
#define tryLockVMOwner() (ceTryLockVMOwner() != 0)
#define unlockVMOwner() ceUnlockVMOwner()
+#define fullBlockEntryOffset() "cbEntryOffset"
+#define fullBlockNoContextSwitchEntryOffset() "cbNoSwitchEntryOffset"
Modified: branches/Cog/nsspur64src/vm/cogitX64.c
===================================================================
--- branches/Cog/nsspur64src/vm/cogitX64.c 2016-04-09 00:17:14 UTC (rev 3671)
+++ branches/Cog/nsspur64src/vm/cogitX64.c 2016-04-19 18:21:14 UTC (rev 3672)
@@ -1,9 +1,9 @@
/* Automatically generated by
- CCodeGenerator VMMaker.oscog-eem.1756 uuid: 141cf0f3-955a-486f-8082-decbc14645d7
+ CCodeGenerator VMMaker.oscog-eem.1822 uuid: f18408b3-d8bb-4ac7-9d7d-b37ace026619
from
- StackToRegisterMappingCogit VMMaker.oscog-eem.1756 uuid: 141cf0f3-955a-486f-8082-decbc14645d7
+ StackToRegisterMappingCogit VMMaker.oscog-eem.1822 uuid: f18408b3-d8bb-4ac7-9d7d-b37ace026619
*/
-static char __buildInfo[] = "StackToRegisterMappingCogit VMMaker.oscog-eem.1756 uuid: 141cf0f3-955a-486f-8082-decbc14645d7 " __DATE__ ;
+static char __buildInfo[] = "StackToRegisterMappingCogit VMMaker.oscog-eem.1822 uuid: f18408b3-d8bb-4ac7-9d7d-b37ace026619 " __DATE__ ;
char *__cogitBuildInfo = __buildInfo;
@@ -82,6 +82,12 @@
#define DPFPReg1 1
#define DPFPReg2 2
#define EncounteredUnknownBytecode -6
+#define Extra0Reg 10
+#define Extra1Reg 11
+#define Extra2Reg 12
+#define Extra3Reg 13
+#define Extra4Reg 14
+#define Extra5Reg 15
#define Fill32 4
#define FirstAnnotation 64
#define FirstJump 11
@@ -209,6 +215,8 @@
#define MoveXwrRR 47
#define MULTIPLEBYTECODESETS 1
#define MulRdRd 112
+#define NeedsMergeFixupFlag 2
+#define NeedsNonMergeFixupFlag 1
#define NegateR 79
#define NewspeakVM 1
#define Nop 5
@@ -260,8 +268,6 @@
#define RotateRightCqR 87
#define RSI 6
#define RSP 4
-#define Scratch0Reg 10
-#define Scratch1Reg 11
#define SelectorCannotInterpret 34
#define SelectorDoesNotUnderstand 20
#define SenderIndex 0
@@ -270,9 +276,13 @@
#define SIB1 0
#define SIB4 2
#define SIB8 3
+#define SistaV1BytecodeSet 0
#define SistaVM 0
#define SmallContextSlots 22
#define SPReg 4
+#if !defined(SPURVM) /* Allow this to be overridden on the compiler command line */
+# define SPURVM 1
+#endif
#define SpecialSelectors 23
#define SqrtRd 114
#define SSBaseOffset 1
@@ -289,6 +299,7 @@
#define TstCqR 99
#define UnfailingPrimitive 3
#define UnimplementedPrimitive -7
+#define UnknownSimStackPtrFlag -2
#define ValueIndex 1
#define VarBaseReg 3
#define XCHGRR 128
@@ -358,6 +369,19 @@
typedef struct {
+ char type;
+ char spilled;
+ sqInt annotateUse;
+ sqInt registerr;
+ sqInt offset;
+ sqInt constant;
+ sqInt bcptr;
+ } SimStackEntry;
+
+#define CogSimStackEntry SimStackEntry
+
+
+typedef struct {
AbstractInstruction *targetInstruction;
sqInt instructionIndex;
sqInt simStackPtr;
@@ -368,17 +392,6 @@
typedef struct {
- char type;
- char spilled;
- char annotateUse;
- sqInt registerr;
- sqInt offset;
- sqInt constant;
- sqInt bcptr;
- } CogSimStackEntry;
-
-
-typedef struct {
sqInt isReceiverResultRegLive;
CogSimStackEntry *ssEntry;
} CogSSOptStatus;
@@ -403,7 +416,6 @@
#endif
static AbstractInstruction * NoDbgRegParms addDependent(AbstractInstruction * self_in_addDependent, AbstractInstruction *anInstruction);
-static sqInt NoDbgRegParms availableRegisterOrNoneFor(AbstractInstruction * self_in_availableRegisterOrNoneFor, sqInt liveRegsMask);
static AbstractInstruction * NoDbgRegParms cloneLiteralFrom(AbstractInstruction * self_in_cloneLiteralFrom, AbstractInstruction *existingLiteral);
static sqInt NoDbgRegParms concretizeAt(AbstractInstruction * self_in_concretizeAt, sqInt actualAddress);
static AbstractInstruction * NoDbgRegParms genWriteCResultIntoReg(AbstractInstruction * self_in_genWriteCResultIntoReg, sqInt abstractRegister);
@@ -420,6 +432,7 @@
static sqInt NoDbgRegParms rewriteConditionalJumpLongAttarget(AbstractInstruction * self_in_rewriteConditionalJumpLongAttarget, sqInt callSiteReturnAddress, sqInt callTargetAddress);
static sqInt NoDbgRegParms setLabelOffset(AbstractInstruction * self_in_setLabelOffset, sqInt aValue);
static AbstractInstruction * NoDbgRegParms updateLabel(AbstractInstruction * self_in_updateLabel, AbstractInstruction *labelInstruction);
+static sqInt NoDbgRegParms wantsNearAddressFor(AbstractInstruction * self_in_wantsNearAddressFor, sqInt anObject);
static CogMethod * NoDbgRegParms cmHomeMethod(CogBlockMethod * self_in_cmHomeMethod);
static sqInt NoDbgRegParms isBranch(BytecodeDescriptor * self_in_isBranch);
static sqInt NoDbgRegParms isUnconditionalBranch(BytecodeDescriptor * self_in_isUnconditionalBranch);
@@ -495,6 +508,7 @@
static sqInt NoDbgRegParms compilePICAbort(sqInt numArgs);
static void NoDbgRegParms compileTrampolineFornumArgsargargargargregsToSavepushLinkRegresultReg(void *aRoutine, sqInt numArgs, sqInt regOrConst0, sqInt regOrConst1, sqInt regOrConst2, sqInt regOrConst3, sqInt regMask, sqInt pushLinkReg, sqInt resultRegOrNone);
static void computeEntryOffsets(void);
+static void computeFullBlockEntryOffsets(void);
static void computeMaximumSizes(void);
static sqInt NoDbgRegParms configureCPICCase0Case1MethodtagisMNUCasenumArgsdelta(CogMethod *cPIC, CogMethod *case0CogMethod, sqInt case1Method, sqInt case1Tag, sqInt isMNUCase, sqInt numArgs, sqInt addrDelta);
static sqInt NoDbgRegParms configureMNUCPICmethodOperandnumArgsdelta(CogMethod *cPIC, sqInt methodOperand, sqInt numArgs, sqInt addrDelta);
@@ -516,6 +530,7 @@
static sqInt NoDbgRegParms findMapLocationForMcpcinMethod(sqInt targetMcpc, CogMethod *cogMethod);
extern CogBlockMethod * findMethodForStartBcpcinHomeMethod(sqInt startbcpc, CogMethod *cogMethod);
static sqInt NoDbgRegParms findIsBackwardBranchMcpcBcpcMatchingMcpc(BytecodeDescriptor *descriptor, sqInt isBackwardBranch, char *mcpc, sqInt bcpc, void *targetMcpc);
+static sqInt NoDbgRegParms firstMappedPCFor(CogMethod *cogMethod);
extern void followForwardedLiteralsIn(CogMethod *cogMethod);
extern void followForwardedMethods(void);
static sqInt NoDbgRegParms followMaybeObjRefInClosedPICAt(sqInt mcpc);
@@ -624,6 +639,7 @@
extern sqInt patchToOpenPICFornumArgsreceiver(sqInt selector, sqInt numArgs, sqInt receiver);
static sqInt picAbortDiscriminatorValue(void);
static sqInt picInterpretAbortOffset(void);
+static void preenMethodLabel(void);
static AbstractInstruction * previousInstruction(void);
extern void printCogMethodFor(void *address);
extern void printPCMapPairsFor(CogMethod *cogMethod);
@@ -677,6 +693,7 @@
static void compactCompiledCode(void);
static void NoDbgRegParms ensureInYoungReferrers(CogMethod *cogMethod);
static CogMethod * NoDbgRegParms findPreviouslyCompiledVersionOfwith(sqInt aMethodObj, sqInt aSelectorOop);
+static void followForwardedLiteralsInOpenPICList(void);
extern void freeMethod(CogMethod *cogMethod);
static void freeOlderMethodsForCompaction(void);
static sqInt kosherYoungReferrers(void);
@@ -867,12 +884,15 @@
static sqInt NoDbgRegParms remapOop(sqInt objOop);
static sqInt NoDbgRegParms shouldAnnotateObjectReference(sqInt anOop);
static sqInt NoDbgRegParms slotOffsetOfInstVarIndex(sqInt index);
-static CogSimStackEntry * NoDbgRegParms ensureSpilledAtfrom(CogSimStackEntry * self_in_ensureSpilledAtfrom, sqInt baseOffset, sqInt baseRegister);
-static CogSimStackEntry * NoDbgRegParms mergeAtfrom(CogSimStackEntry * self_in_mergeAtfrom, sqInt baseOffset, sqInt baseRegister);
-static CogSimStackEntry * NoDbgRegParms popToReg(CogSimStackEntry * self_in_popToReg, sqInt reg);
-static sqInt NoDbgRegParms registerMask(CogSimStackEntry * self_in_registerMask);
-static sqInt NoDbgRegParms registerOrNone(CogSimStackEntry * self_in_registerOrNone);
-static CogSimStackEntry * NoDbgRegParms storeToReg(CogSimStackEntry * self_in_storeToReg, sqInt reg);
+static SimStackEntry * NoDbgRegParms ensureSpilledAtfrom(SimStackEntry * self_in_ensureSpilledAtfrom, sqInt baseOffset, sqInt baseRegister);
+static SimStackEntry * NoDbgRegParms popToReg(SimStackEntry * self_in_popToReg, sqInt reg);
+static sqInt NoDbgRegParms registerMask(SimStackEntry * self_in_registerMask);
+static sqInt NoDbgRegParms registerOrNone(SimStackEntry * self_in_registerOrNone);
+static SimStackEntry * NoDbgRegParms storeToReg(SimStackEntry * self_in_storeToReg, sqInt reg);
+static sqInt NoDbgRegParms isBackwardBranchFixup(BytecodeFixup * self_in_isBackwardBranchFixup);
+static sqInt NoDbgRegParms isMergeFixup(BytecodeFixup * self_in_isMergeFixup);
+static sqInt NoDbgRegParms isMergeFixupOrIsFixedUp(BytecodeFixup * self_in_isMergeFixupOrIsFixedUp);
+static sqInt NoDbgRegParms availableRegisterOrNoneFor(AbstractInstruction * self_in_availableRegisterOrNoneFor, sqInt liveRegsMask);
static sqInt NoDbgRegParms callerSavedRegisterMask(AbstractInstruction * self_in_callerSavedRegisterMask);
static sqInt NoDbgRegParms callFullTargetFromReturnAddress(AbstractInstruction * self_in_callFullTargetFromReturnAddress, sqInt callSiteReturnAddress);
static sqInt NoDbgRegParms callInstructionByteSize(AbstractInstruction * self_in_callInstructionByteSize);
@@ -953,7 +973,6 @@
static sqInt extendedStoreAndPopBytecode(void);
static sqInt extendedStoreBytecode(void);
static sqInt NoDbgRegParms frameOffsetOfTemporary(sqInt index);
-static sqInt genBlockReturn(void);
static AbstractInstruction * NoDbgRegParms genDoubleFailIfZeroArgRcvrarg(sqInt rcvrReg, sqInt argReg);
static sqInt genExtendedSendBytecode(void);
static sqInt genExtendedSuperBytecode(void);
@@ -1031,7 +1050,6 @@
static PrimitiveDescriptor * primitiveGeneratorOrNil(void);
extern void recordCallOffsetIn(CogMethod *cogMethod);
static sqInt NoDbgRegParms registerisInMask(sqInt reg, sqInt mask);
-static sqInt returnRegForStoreCheck(void);
extern void rewritePrimInvocationInto(CogMethod *cogMethod, void (*primFunctionPointer)(void));
static sqInt NoDbgRegParms v3BlockCodeSize(BytecodeDescriptor *descriptor, sqInt pc, sqInt nExts, sqInt aMethodObj);
static sqInt NoDbgRegParms v3LongForwardBranchDistance(BytecodeDescriptor *descriptor, sqInt pc, sqInt nExts, sqInt aMethodObj);
@@ -1045,7 +1063,6 @@
static void NoDbgRegParms adjustArgumentsForPerform(sqInt numArgs);
static sqInt NoDbgRegParms allocateRegForStackEntryAtnotConflictingWith(sqInt index, sqInt regMask);
static sqInt NoDbgRegParms allocateRegNotConflictingWith(sqInt regMask);
-static void NoDbgRegParms annotateBytecodeIfAnnotated(CogSimStackEntry *aSimStackEntry);
static sqInt NoDbgRegParms anyReferencesToRegisterinTopNItems(sqInt reg, sqInt n);
extern void callCogCodePopReceiverArg0Regs(void);
extern void callCogCodePopReceiverArg1Arg0Regs(void);
@@ -1064,6 +1081,7 @@
static void ensureReceiverResultRegContainsSelf(void);
static void NoDbgRegParms evaluateat(BytecodeDescriptor *descriptor, sqInt pc);
static sqInt NoDbgRegParms freeAnyRegNotConflictingWith(sqInt regMask);
+static sqInt genBlockReturn(void);
static void (*genCallPICEnilopmartNumArgs(sqInt numArgs))(void) ;
static sqInt genCallPrimitiveBytecode(void);
static sqInt NoDbgRegParms genEqualsEqualsNoBranchArgIsConstantrcvrIsConstantargRegrcvrReg(sqInt argIsConstant, sqInt rcvrIsConstant, sqInt argReg, sqInt rcvrRegOrNone);
@@ -1110,9 +1128,13 @@
static sqInt genSpecialSelectorEqualsEqualsWithForwarders(void);
static sqInt genStaticallyResolvedSpecialSelectorComparison(void);
static sqInt NoDbgRegParms genStorePopLiteralVariable(sqInt popBoolean, sqInt litVarIndex);
+static sqInt NoDbgRegParms genStorePopLiteralVariableneedsStoreCheck(sqInt popBoolean, sqInt litVarIndex, sqInt needsStoreCheck);
static sqInt NoDbgRegParms genStorePopMaybeContextReceiverVariable(sqInt popBoolean, sqInt slotIndex);
+static sqInt NoDbgRegParms genStorePopMaybeContextReceiverVariableneedsStoreCheck(sqInt popBoolean, sqInt slotIndex, sqInt needsStoreCheck);
static sqInt NoDbgRegParms genStorePopReceiverVariable(sqInt popBoolean, sqInt slotIndex);
+static sqInt NoDbgRegParms genStorePopReceiverVariableneedsStoreCheck(sqInt popBoolean, sqInt slotIndex, sqInt needsStoreCheck);
static sqInt NoDbgRegParms genStorePopRemoteTempAt(sqInt popBoolean, sqInt slotIndex, sqInt remoteTempIndex);
+static sqInt NoDbgRegParms genStorePopRemoteTempAtneedsStoreCheck(sqInt popBoolean, sqInt slotIndex, sqInt remoteTempIndex, sqInt needsStoreCheck);
static sqInt NoDbgRegParms genStorePopTemporaryVariable(sqInt popBoolean, sqInt tempIndex);
static sqInt genUpArrowReturn(void);
static BytecodeFixup * NoDbgRegParms initializeFixupAt(sqInt targetIndex);
@@ -1122,7 +1144,7 @@
static sqInt liveRegisters(void);
static void NoDbgRegParms marshallAbsentReceiverSendArguments(sqInt numArgs);
static void NoDbgRegParms marshallSendArguments(sqInt numArgs);
-static void NoDbgRegParms mergeafterContinuation(BytecodeFixup *fixup, sqInt mergeWithContinuation);
+static sqInt NoDbgRegParms mergeWithFixupIfRequired(BytecodeFixup *fixup);
static sqInt NoDbgRegParms methodAbortTrampolineFor(sqInt numArgs);
static sqInt NoDbgRegParms needsFrameIfExtBGT2(sqInt stackDelta);
static sqInt NoDbgRegParms needsFrameIfMod16GENumArgs(sqInt stackDelta);
@@ -1148,14 +1170,14 @@
static sqInt NoDbgRegParms ssPushAnnotatedConstant(sqInt literal);
static sqInt NoDbgRegParms ssPushBaseoffset(sqInt reg, sqInt offset);
static sqInt NoDbgRegParms ssPushConstant(sqInt literal);
-static sqInt NoDbgRegParms ssPushDesc(CogSimStackEntry simStackEntry);
+static sqInt NoDbgRegParms ssPushDesc(SimStackEntry simStackEntry);
static sqInt NoDbgRegParms ssPushRegister(sqInt reg);
static void NoDbgRegParms ssPush(sqInt n);
static void NoDbgRegParms ssStoreAndReplacePoptoReg(sqInt popBoolean, sqInt reg);
static sqInt NoDbgRegParms ssStorePoptoPreferredReg(sqInt popBoolean, sqInt preferredReg);
static void NoDbgRegParms ssStorePoptoReg(sqInt popBoolean, sqInt reg);
static CogSimStackEntry * ssTop(void);
-static CogSimStackEntry ssTopDescriptor(void);
+static SimStackEntry ssTopDescriptor(void);
static CogSimStackEntry * NoDbgRegParms ssValue(sqInt n);
static sqInt NoDbgRegParms tryCollapseTempVectorInitializationOfSize(sqInt slots);
static void updateSimSpillBase(void);
@@ -1185,6 +1207,8 @@
void * CFramePointer;
void * CStackPointer;
static sqInt callerSavedRegMask;
+static sqInt cbEntryOffset;
+static sqInt cbNoSwitchEntryOffset;
sqInt ceBaseFrameReturnTrampoline;
void (*ceCall0ArgsPIC)(void);
void (*ceCall1ArgsPIC)(void);
@@ -1260,6 +1284,8 @@
static sqInt firstCPICCaseOffset;
static sqInt firstSend;
static BytecodeFixup * fixups;
+static AbstractInstruction * fullBlockEntry;
+static AbstractInstruction * fullBlockNoContextSwitchEntry;
static BytecodeDescriptor generatorTable[512] = {
{ genPushReceiverVariableBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0 },
{ genPushReceiverVariableBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0 },
@@ -1827,7 +1853,7 @@
static AbstractInstruction * sendMiss;
static CogSimStackEntry simSelf;
static sqInt simSpillBase;
-static CogSimStackEntry simStack[77];
+static SimStackEntry simStack[70];
static sqInt simStackPtr;
static AbstractInstruction * stackCheckLabel;
static AbstractInstruction * stackOverflowCall;
@@ -1902,6 +1928,8 @@
#define unalignedLong32Atput(inst,byteAddress,aWord) long32Atput(byteAddress,aWord)
#define unalignedLongAt(byteAddress) longAt(byteAddress)
#define unalignedLongAtput(byteAddress,aWord) longAtput(byteAddress,aWord)
+#define fullBlockEntryOffset() "cbEntryOffset"
+#define fullBlockNoContextSwitchEntryOffset() "cbNoSwitchEntryOffset"
#define fixupAt(index) (&fixups[index])
#define simStackAt(index) (simStack + (index))
#define traceDescriptor(ign) 0
@@ -1931,33 +1959,6 @@
}
-/* Answer an unused abstract register in the liveRegMask.
- Subclasses with more registers can override to answer them. */
-
- /* CogAbstractInstruction>>#availableRegisterOrNoneFor: */
-static sqInt NoDbgRegParms
-availableRegisterOrNoneFor(AbstractInstruction * self_in_availableRegisterOrNoneFor, sqInt liveRegsMask)
-{
- flag("searching physical registers that are not assigned to abstract registers first will do a better job and allocate with fewer conflicts. But this will be much easier if we use the same range for concrete and abstract registers (0-N) and simply number abstract registers the same as their corresponding concrete registers.");
- if (!(liveRegsMask & (1LL << Arg1Reg))) {
- return Arg1Reg;
- }
- if (!(liveRegsMask & (1LL << Arg0Reg))) {
- return Arg0Reg;
- }
- if (!(liveRegsMask & (1LL << SendNumArgsReg))) {
- return SendNumArgsReg;
- }
- if (!(liveRegsMask & (1LL << ClassReg))) {
- return ClassReg;
- }
- if (!(liveRegsMask & (1LL << ReceiverResultReg))) {
- return ReceiverResultReg;
- }
- return NoReg;
-}
-
-
/* For out-of-line literal support, clone a literal from a literal. */
/* CogAbstractInstruction>>#cloneLiteralFrom: */
@@ -2177,6 +2178,20 @@
return self_in_updateLabel;
}
+
+/* A hack hook to allow ARM to override the simulated address for the
+ short-cut trampolines,
+ and to allow x64 to address CStackPointer and CFramePointer relative to
+ VarBaseReg.
+ */
+
+ /* CogAbstractInstruction>>#wantsNearAddressFor: */
+static sqInt NoDbgRegParms
+wantsNearAddressFor(AbstractInstruction * self_in_wantsNearAddressFor, sqInt anObject)
+{
+ return 0;
+}
+
/* CogBlockMethod>>#cmHomeMethod */
static CogMethod * NoDbgRegParms
cmHomeMethod(CogBlockMethod * self_in_cmHomeMethod)
@@ -3651,7 +3666,7 @@
closedPICRefersToUnmarkedObject(CogMethod *cPIC)
{
sqInt i;
- usqInt object;
+ sqInt object;
sqInt pc;
if (!((isImmediate((cPIC->selector)))
@@ -3831,7 +3846,7 @@
if (isMNUCase) {
/* this is an MNU so tag the CPIC header and setup a jump to the MNUAbort */
- (cPIC->cpicHasMNUCase = 1);
+ (cPIC->cpicHasMNUCaseOrCMIsFullBlock) = 1;
target = (((sqInt)cPIC)) + (sizeof(CogMethod));
}
else {
@@ -3853,6 +3868,14 @@
void
cogitPostGCAction(sqInt gcMode)
{
+
+# if SPURVM
+ if (gcMode == GCModeBecome) {
+ followForwardedLiteralsInOpenPICList();
+ }
+
+# endif /* SPURVM */
+
assert(allMethodsHaveCorrectHeader());
assert(((gcMode & (GCModeFull + GCModeNewSpace)) == 0)
|| (kosherYoungReferrers()));
@@ -3964,7 +3987,7 @@
(pic->cmNumArgs = numArgs);
(pic->cmRefersToYoung = 0);
(pic->cmUsageCount = initialClosedPICUsageCount());
- (pic->cpicHasMNUCase = 1);
+ (pic->cpicHasMNUCaseOrCMIsFullBlock) = 1;
(pic->cPICNumCases = 1);
(pic->blockEntryOffset = 0);
assert(((pic->cmType)) == CMClosedPIC);
@@ -4033,7 +4056,7 @@
addToYoungReferrers(pic);
}
(pic->cmUsageCount = initialOpenPICUsageCount());
- (pic->cpicHasMNUCase = 0);
+ (pic->cpicHasMNUCaseOrCMIsFullBlock) = 0;
(pic->cPICNumCases = 0);
(pic->blockEntryOffset = 0);
assert(((pic->cmType)) == CMOpenPIC);
@@ -4084,7 +4107,7 @@
(pic->cmNumArgs = numArgs);
(pic->cmRefersToYoung = 0);
(pic->cmUsageCount = initialClosedPICUsageCount());
- (pic->cpicHasMNUCase = isMNUCase);
+ (pic->cpicHasMNUCaseOrCMIsFullBlock) = isMNUCase;
(pic->cPICNumCases = 2);
(pic->blockEntryOffset = 0);
assert(((pic->cmType)) == CMClosedPIC);
@@ -4642,6 +4665,20 @@
}
+/* Generate the entry code for a method to determine cmEntryOffset and
+ cmNoCheckEntryOffset. We
+ need cmNoCheckEntryOffset up front to be able to generate the map starting
+ from cmNoCheckEntryOffset */
+/* stack allocate the various collections so that they
+ are effectively garbage collected on return. */
+
+ /* Cogit>>#computeFullBlockEntryOffsets */
+static void
+computeFullBlockEntryOffsets(void)
+{
+ }
+
+
/* 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
@@ -5146,7 +5183,7 @@
addToYoungReferrers(method);
}
(method->cmUsageCount = initialMethodUsageCount());
- (method->cpicHasMNUCase = 0);
+ (method->cpicHasMNUCaseOrCMIsFullBlock) = 0;
(method->cmUsesPenultimateLit = maxLitIndex >= ((literalCountOfMethodHeader(methodHeader)) - 2));
(method->blockEntryOffset = (blockEntryLabel != null
? ((blockEntryLabel->address)) - (((sqInt)method))
@@ -5188,7 +5225,9 @@
sqInt mapByte;
sqInt mcpc;
- mcpc = (((sqInt)cogMethod)) + cmNoCheckEntryOffset;
+ mcpc = (0
+ ? (((usqInt)cogMethod)) + cbNoSwitchEntryOffset
+ : (((usqInt)cogMethod)) + cmNoCheckEntryOffset);
map = ((((usqInt)cogMethod)) + ((cogMethod->blockSize))) - 1;
if (mcpc == targetMcpc) {
return map;
@@ -5252,6 +5291,15 @@
: 0);
}
+ /* Cogit>>#firstMappedPCFor: */
+static sqInt NoDbgRegParms
+firstMappedPCFor(CogMethod *cogMethod)
+{
+ return (0
+ ? (((usqInt)cogMethod)) + cbNoSwitchEntryOffset
+ : (((usqInt)cogMethod)) + cmNoCheckEntryOffset);
+}
+
/* Cogit>>#followForwardedLiteralsIn: */
void
followForwardedLiteralsIn(CogMethod *cogMethod)
@@ -5262,7 +5310,8 @@
sqInt mcpc;
sqInt result;
- assert(!(isForwarded((cogMethod->methodObject))));
+ assert((((cogMethod->cmType)) != CMMethod)
+ || (!(isForwarded((cogMethod->methodObject)))));
if (shouldRemapOop((cogMethod->selector))) {
(cogMethod->selector = remapObj((cogMethod->selector)));
if (isYoung((cogMethod->selector))) {
@@ -5270,7 +5319,9 @@
}
}
/* begin mapFor:performUntil:arg: */
- mcpc = (((sqInt)cogMethod)) + cmNoCheckEntryOffset;
+ mcpc = (0
+ ? (((usqInt)cogMethod)) + cbNoSwitchEntryOffset
+ : (((usqInt)cogMethod)) + cmNoCheckEntryOffset);
map = ((((usqInt)cogMethod)) + ((cogMethod->blockSize))) - 1;
enumeratingCogMethod = cogMethod;
@@ -5848,12 +5899,12 @@
generateMapAtstart(sqInt addressOrNull, sqInt startAddress)
{
unsigned char annotation;
- sqInt delta;
+ usqInt delta;
sqInt i;
AbstractInstruction *instruction;
sqInt length;
- sqInt location;
- sqInt mapEntry;
+ usqInt location;
+ usqInt mapEntry;
sqInt maxDelta;
usqInt mcpc;
@@ -6711,6 +6762,7 @@
generateStackPointerCapture();
generateTrampolines();
computeEntryOffsets();
+ computeFullBlockEntryOffsets();
generateClosedPICPrototype();
manageFromto(methodZoneBase, endAddress);
generateOpenPICPrototype();
@@ -7064,7 +7116,7 @@
end = ((((usqInt)cogMethod)) + ((cogMethod->blockSize))) - 1;
while ((byteAt(end)) != MapEnd) {
end -= 1;
- assert(end > ((((sqInt)cogMethod)) + cmNoCheckEntryOffset));
+ assert(end > (firstMappedPCFor(cogMethod)));
}
return end;
}
@@ -7082,7 +7134,9 @@
sqInt mcpc;
sqInt result;
- mcpc = (((sqInt)cogMethod)) + cmNoCheckEntryOffset;
+ mcpc = (0
+ ? (((usqInt)cogMethod)) + cbNoSwitchEntryOffset
+ : (((usqInt)cogMethod)) + cmNoCheckEntryOffset);
map = ((((usqInt)cogMethod)) + ((cogMethod->blockSize))) - 1;
enumeratingCogMethod = cogMethod;
@@ -7238,7 +7292,9 @@
}
}
/* begin mapFor:performUntil:arg: */
- mcpc = (((sqInt)cogMethod)) + cmNoCheckEntryOffset;
+ mcpc = (0
+ ? (((usqInt)cogMethod)) + cbNoSwitchEntryOffset
+ : (((usqInt)cogMethod)) + cmNoCheckEntryOffset);
map = ((((usqInt)cogMethod)) + ((cogMethod->blockSize))) - 1;
enumeratingCogMethod = cogMethod;
@@ -7320,7 +7376,9 @@
(cogMethod->methodObject = remapOop((cogMethod->methodObject)));
}
/* begin mapFor:performUntil:arg: */
- mcpc = (((sqInt)cogMethod)) + cmNoCheckEntryOffset;
+ mcpc = (0
+ ? (((usqInt)cogMethod)) + cbNoSwitchEntryOffset
+ : (((usqInt)cogMethod)) + cmNoCheckEntryOffset);
map = ((((usqInt)cogMethod)) + ((cogMethod->blockSize))) - 1;
enumeratingCogMethod = cogMethod;
@@ -7411,7 +7469,9 @@
}
}
/* begin mapFor:performUntil:arg: */
- mcpc = (((sqInt)cogMethod)) + cmNoCheckEntryOffset;
+ mcpc = (0
+ ? (((usqInt)cogMethod)) + cbNoSwitchEntryOffset
+ : (((usqInt)cogMethod)) + cmNoCheckEntryOffset);
map = ((((usqInt)cogMethod)) + ((cogMethod->blockSize))) - 1;
enumeratingCogMethod = cogMethod;
@@ -7529,7 +7589,9 @@
/* begin mapFor:performUntil:arg: */
- mcpc = (((sqInt)cogMethod)) + cmNoCheckEntryOffset;
+ mcpc = (0
+ ? (((usqInt)cogMethod)) + cbNoSwitchEntryOffset
+ : (((usqInt)cogMethod)) + cmNoCheckEntryOffset);
map = ((((usqInt)cogMethod)) + ((cogMethod->blockSize))) - 1;
enumeratingCogMethod = cogMethod;
@@ -7573,7 +7635,9 @@
/* begin mapFor:performUntil:arg: */
- mcpc1 = (((sqInt)cogMethod)) + cmNoCheckEntryOffset;
+ mcpc1 = (0
+ ? (((usqInt)cogMethod)) + cbNoSwitchEntryOffset
+ : (((usqInt)cogMethod)) + cmNoCheckEntryOffset);
map1 = ((((usqInt)cogMethod)) + ((cogMethod->blockSize))) - 1;
enumeratingCogMethod = cogMethod;
@@ -7677,7 +7741,9 @@
/* begin mapFor:performUntil:arg: */
- mcpc = (((sqInt)cogMethod)) + cmNoCheckEntryOffset;
+ mcpc = (0
+ ? (((usqInt)cogMethod)) + cbNoSwitchEntryOffset
+ : (((usqInt)cogMethod)) + cmNoCheckEntryOffset);
map = ((((usqInt)cogMethod)) + ((cogMethod->blockSize))) - 1;
enumeratingCogMethod = cogMethod;
@@ -7988,7 +8054,9 @@
: cmHomeMethod(aCogMethod));
(cogMethod->cmUsageCount = CMMaxUsageCount);
/* begin mapFor:performUntil:arg: */
- mcpc = (((sqInt)cogMethod)) + cmNoCheckEntryOffset;
+ mcpc = (0
+ ? (((usqInt)cogMethod)) + cbNoSwitchEntryOffset
+ : (((usqInt)cogMethod)) + cmNoCheckEntryOffset);
map = ((((usqInt)cogMethod)) + ((cogMethod->blockSize))) - 1;
enumeratingCogMethod = cogMethod;
@@ -8509,6 +8577,22 @@
return (interpretOffset()) - (callInstructionByteSize(backEnd));
}
+
+/* The methodLabel serves as the reference to the start of the current code
+ object being produced (CMMethod, CMClosedPIC etc), but it also carries
+ type flags for
+ the frame method field, set via the labelOffset. So we must clean the
+ flags on each
+ compilation to avoid stale lags being left behind from previous
+ compilations. */
+
+ /* Cogit>>#preenMethodLabel */
+static void
+preenMethodLabel(void)
+{
+ setLabelOffset(methodLabel, 0);
+}
+
/* Cogit>>#previousInstruction */
static AbstractInstruction *
previousInstruction(void)
@@ -8543,7 +8627,9 @@
sqInt mcpc;
sqInt value;
- mcpc = (((sqInt)cogMethod)) + cmNoCheckEntryOffset;
+ mcpc = (0
+ ? (((usqInt)cogMethod)) + cbNoSwitchEntryOffset
+ : (((usqInt)cogMethod)) + cmNoCheckEntryOffset);
map = ((((usqInt)cogMethod)) + ((cogMethod->blockSize))) - 1;
while (((mapByte = byteAt(map))) != MapEnd) {
annotation = ((usqInt) mapByte) >> AnnotationShift;
@@ -8730,7 +8816,9 @@
: picAbortTrampolineFor((cogMethod->cmNumArgs)))));
relocateCallBeforeReturnPCby(backEnd, (((sqInt)cogMethod)) + missOffset, -callDelta);
/* begin mapFor:performUntil:arg: */
- mcpc = (((sqInt)cogMethod)) + cmNoCheckEntryOffset;
+ mcpc = (0
+ ? (((usqInt)cogMethod)) + cbNoSwitchEntryOffset
+ : (((usqInt)cogMethod)) + cmNoCheckEntryOffset);
map = ((((usqInt)cogMethod)) + ((cogMethod->blockSize))) - 1;
enumeratingCogMethod = cogMethod;
@@ -9299,7 +9387,9 @@
while (cogMethod < (limitZony())) {
if (((cogMethod->cmType)) == CMMethod) {
/* begin mapFor:performUntil:arg: */
- mcpc = (((sqInt)cogMethod)) + cmNoCheckEntryOffset;
+ mcpc = (0
+ ? (((usqInt)cogMethod)) + cbNoSwitchEntryOffset
+ : (((usqInt)cogMethod)) + cmNoCheckEntryOffset);
map = ((((usqInt)cogMethod)) + ((cogMethod->blockSize))) - 1;
enumeratingCogMethod = cogMethod;
@@ -9741,7 +9831,9 @@
while (cogMethod < (limitZony())) {
if (((cogMethod->cmType)) == CMMethod) {
/* begin mapFor:performUntil:arg: */
- mcpc = (((sqInt)cogMethod)) + cmNoCheckEntryOffset;
+ mcpc = (0
+ ? (((usqInt)cogMethod)) + cbNoSwitchEntryOffset
+ : (((usqInt)cogMethod)) + cmNoCheckEntryOffset);
map = ((((usqInt)cogMethod)) + ((cogMethod->blockSize))) - 1;
enumeratingCogMethod = cogMethod;
@@ -9817,7 +9909,7 @@
if (isMNUSelector) {
while (cogMethod < (limitZony())) {
if (((cogMethod->cmType)) != CMFree) {
- if ((cogMethod->cpicHasMNUCase)) {
+ if ((cogMethod->cpicHasMNUCaseOrCMIsFullBlock)) {
assert(((cogMethod->cmType)) == CMClosedPIC);
freeMethod(cogMethod);
mustScanAndUnlink = 1;
@@ -9854,7 +9946,9 @@
while (cogMethod < (limitZony())) {
if (((cogMethod->cmType)) == CMMethod) {
/* begin mapFor:performUntil:arg: */
- mcpc = (((sqInt)cogMethod)) + cmNoCheckEntryOffset;
+ mcpc = (0
+ ? (((usqInt)cogMethod)) + cbNoSwitchEntryOffset
+ : (((usqInt)cogMethod)) + cmNoCheckEntryOffset);
map = ((((usqInt)cogMethod)) + ((cogMethod->blockSize))) - 1;
enumeratingCogMethod = cogMethod;
@@ -9913,7 +10007,9 @@
while (cogMethod < (limitZony())) {
if (((cogMethod->cmType)) == CMMethod) {
/* begin mapFor:performUntil:arg: */
- mcpc = (((sqInt)cogMethod)) + cmNoCheckEntryOffset;
+ mcpc = (0
+ ? (((usqInt)cogMethod)) + cbNoSwitchEntryOffset
+ : (((usqInt)cogMethod)) + cmNoCheckEntryOffset);
map = ((((usqInt)cogMethod)) + ((cogMethod->blockSize))) - 1;
enumeratingCogMethod = cogMethod;
@@ -9986,7 +10082,9 @@
while (cogMethod < (limitZony())) {
if (((cogMethod->cmType)) == CMMethod) {
/* begin mapFor:performUntil:arg: */
- mcpc = (((sqInt)cogMethod)) + cmNoCheckEntryOffset;
+ mcpc = (0
+ ? (((usqInt)cogMethod)) + cbNoSwitchEntryOffset
+ : (((usqInt)cogMethod)) + cmNoCheckEntryOffset);
map = ((((usqInt)cogMethod)) + ((cogMethod->blockSize))) - 1;
enumeratingCogMethod = cogMethod;
@@ -10291,6 +10389,19 @@
return null;
}
+ /* CogMethodZone>>#followForwardedLiteralsInOpenPICList */
+static void
+followForwardedLiteralsInOpenPICList(void)
+{
+ CogMethod *openPIC;
+
+ openPIC = openPICList;
+ while (openPIC != null) {
+ followForwardedLiteralsIn(openPIC);
+ openPIC = ((CogMethod *) ((openPIC->nextOpenPIC)));
+ }
+}
+
/* CogMethodZone>>#freeMethod: */
void
freeMethod(CogMethod *cogMethod)
@@ -12724,8 +12835,8 @@
anInstruction12 = genoperandoperand(CmpCqR, ClassMethodContextCompactIndex, TempReg);
/* begin JumpZero: */
jumpIsContext = genConditionalBranchoperand(JumpZero, ((sqInt)0));
- genGetClassObjectOfClassIndexintoscratchReg(formatReg, Scratch0Reg, TempReg);
- genLoadSlotsourceRegdestReg(InstanceSpecificationIndex, Scratch0Reg, formatReg);
+ genGetClassObjectOfClassIndexintoscratchReg(formatReg, Extra0Reg, TempReg);
+ genLoadSlotsourceRegdestReg(InstanceSpecificationIndex, Extra0Reg, formatReg);
genConvertSmallIntegerToIntegerInReg(formatReg);
/* begin AndCq:R: */
quickConstant8 = fixedFieldsOfClassFormatMask();
@@ -12879,8 +12990,8 @@
anInstruction3 = genoperandoperand(CmpCqR, ClassMethodContextCompactIndex, formatReg);
/* begin JumpZero: */
jumpIsContext = genConditionalBranchoperand(JumpZero, ((sqInt)0));
- genGetClassObjectOfClassIndexintoscratchReg(formatReg, Scratch0Reg, TempReg);
- genLoadSlotsourceRegdestReg(InstanceSpecificationIndex, Scratch0Reg, formatReg);
+ genGetClassObjectOfClassIndexintoscratchReg(formatReg, Extra0Reg, TempReg);
+ genLoadSlotsourceRegdestReg(InstanceSpecificationIndex, Extra0Reg, formatReg);
genConvertSmallIntegerToIntegerInReg(formatReg);
/* begin AndCq:R: */
quickConstant2 = fixedFieldsOfClassFormatMask();
@@ -13376,7 +13487,7 @@
/* Assume there's an available scratch register on 64-bit machines. This holds the saved numFixedFields and then the value to fill with */
headerReg = SendNumArgsReg;
- fillReg = Scratch0Reg;
+ fillReg = Extra0Reg;
assert(fillReg > 0);
/* The max slots we'll allocate here are those for a single header */
@@ -13807,7 +13918,7 @@
/* Assume there's an available scratch register on 64-bit machines. This holds the saved numFixedFields and then the value to fill with */
headerReg = SendNumArgsReg;
- fillReg = Scratch0Reg;
+ fillReg = Extra0Reg;
assert(fillReg > 0);
/* The max slots we'll allocate here are those for a single header */
@@ -14397,7 +14508,8 @@
It is called from the send trampolines.
If the selector index is negative, convert it into a positive index into
the special selectors array and index that. Otherwise, index the current
- method. */
+ method. The routine uses Extra0Reg & Extra1Reg, which are available, since
+ they are not live at point of send. */
/* CogObjectRepresentationFor64BitSpur>>#maybeGenerateSelectorIndexDereferenceRoutine */
static void
@@ -14407,10 +14519,10 @@
AbstractInstruction *anInstruction;
AbstractInstruction *anInstruction1;
AbstractInstruction *anInstruction10;
+ AbstractInstruction *anInstruction11;
+ AbstractInstruction *anInstruction12;
AbstractInstruction *anInstruction2;
AbstractInstruction *anInstruction3;
- AbstractInstruction *anInstruction4;
- AbstractInstruction *anInstruction5;
AbstractInstruction *anInstruction6;
AbstractInstruction *anInstruction7;
AbstractInstruction *anInstruction8;
@@ -14427,32 +14539,32 @@
/* begin JumpLess: */
jumpNegative = genConditionalBranchoperand(JumpLess, ((sqInt)0));
/* begin MoveMw:r:R: */
- anInstruction4 = genoperandoperandoperand(MoveMwrR, FoxMethod, FPReg, Scratch0Reg);
+ anInstruction6 = genoperandoperandoperand(MoveMwrR, FoxMethod, FPReg, Extra0Reg);
/* begin AddCq:R: */
anInstruction1 = genoperandoperand(AddCqR, 2, ClassReg);
/* begin TstCq:R: */
- anInstruction5 = genoperandoperand(TstCqR, MFMethodFlagIsBlockFlag, Scratch0Reg);
+ anInstruction7 = genoperandoperand(TstCqR, MFMethodFlagIsBlockFlag, Extra0Reg);
/* begin JumpZero: */
jumpNotBlock = genConditionalBranchoperand(JumpZero, ((sqInt)0));
/* begin AndCq:R: */
quickConstant = -(alignment());
/* begin gen:quickConstant:operand: */
- anInstruction2 = genoperandoperand(AndCqR, quickConstant, Scratch0Reg);
+ anInstruction2 = genoperandoperand(AndCqR, quickConstant, Extra0Reg);
/* begin MoveM16:r:R: */
- anInstruction6 = genoperandoperandoperand(MoveM16rR, 0, Scratch0Reg, Scratch1Reg);
+ anInstruction8 = genoperandoperandoperand(MoveM16rR, 0, Extra0Reg, Extra1Reg);
/* begin SubR:R: */
- genoperandoperand(SubRR, Scratch1Reg, Scratch0Reg);
+ genoperandoperand(SubRR, Extra1Reg, Extra0Reg);
jmpTarget(jumpNotBlock, gLabel());
/* begin AndCq:R: */
quickConstant1 = -(alignment());
/* begin gen:quickConstant:operand: */
- anInstruction3 = genoperandoperand(AndCqR, quickConstant1, Scratch0Reg);
+ anInstruction3 = genoperandoperand(AndCqR, quickConstant1, Extra0Reg);
/* begin MoveMw:r:R: */
offset = offsetof(CogMethod, methodObject);
/* begin gen:quickConstant:operand:operand: */
- anInstruction7 = genoperandoperandoperand(MoveMwrR, offset, Scratch0Reg, Scratch1Reg);
+ anInstruction9 = genoperandoperandoperand(MoveMwrR, offset, Extra0Reg, Extra1Reg);
/* begin MoveXwr:R:R: */
- genoperandoperandoperand(MoveXwrRR, ClassReg, Scratch1Reg, ClassReg);
+ genoperandoperandoperand(MoveXwrRR, ClassReg, Extra1Reg, ClassReg);
/* begin RetN: */
genoperand(RetN, 0);
jmpTarget(jumpNegative, gLabel());
@@ -14463,13 +14575,13 @@
/* begin MoveAw:R: */
address = specialObjectsArrayAddress();
/* begin gen:literal:operand: */
- anInstruction8 = genoperandoperand(MoveAwR, address, Scratch0Reg);
+ anInstruction10 = genoperandoperand(MoveAwR, address, Extra0Reg);
/* begin SubCq:R: */
- anInstruction9 = genoperandoperand(SubCqR, 1, ClassReg);
+ anInstruction11 = genoperandoperand(SubCqR, 1, ClassReg);
/* begin MoveMw:r:R: */
- anInstruction10 = genoperandoperandoperand(MoveMwrR, (SpecialSelectors + 1) * BytesPerWord, Scratch0Reg, Scratch1Reg);
+ anInstruction12 = genoperandoperandoperand(MoveMwrR, (SpecialSelectors + 1) * BytesPerWord, Extra0Reg, Extra1Reg);
/* begin MoveXwr:R:R: */
- genoperandoperandoperand(MoveXwrRR, ClassReg, Scratch1Reg, ClassReg);
+ genoperandoperandoperand(MoveXwrRR, ClassReg, Extra1Reg, ClassReg);
/* begin RetN: */
genoperand(RetN, 0);
ceDereferenceSelectorIndex = methodZoneBase();
@@ -14850,7 +14962,9 @@
genoperand(RetN, 0);
jmpTarget(jumpSC, gLabel());
}
- ceStoreCheckTrampoline = genTrampolineForcallednumArgsargargargargregsToSavepushLinkRegresultRegappendOpcodes(remember, "ceStoreCheckTrampoline", 1, ReceiverResultReg, null, null, null, (((callerSavedRegMask()) | (1LL << ReceiverResultReg)) - (1LL << ReceiverResultReg)), 1, returnRegForStoreCheck(), CheckRememberedInTrampoline);
+ ceStoreCheckTrampoline = genTrampolineForcallednumArgsargargargargregsToSavepushLinkRegresultRegappendOpcodes(remember, "ceStoreCheckTrampoline", 1, ReceiverResultReg, null, null, null, (((callerSavedRegMask()) | (1LL << ReceiverResultReg)) - (1LL << ReceiverResultReg)), 1, (callerSavedRegMask & (1LL << ReceiverResultReg)
+ ? ReceiverResultReg
+ : RAX), CheckRememberedInTrampoline);
ceStoreCheckContextReceiverTrampoline = genStoreCheckContextReceiverTrampoline();
ceScheduleScavengeTrampoline = genTrampolineForcalledregsToSave(ceScheduleScavenge, "ceScheduleScavengeTrampoline", callerSavedRegMask());
ceSmallActiveContextInMethodTrampoline = genActiveContextTrampolineLargeinBlockcalled(0, 0, "ceSmallMethodContext");
@@ -15021,7 +15135,7 @@
genoperandoperandoperand(MoveXwrRR, TempReg, FPReg, TempReg);
}
else {
- /* begin genMoveConstant:R: */
+ /* begin genMoveNilR: */
constant = nilObject();
if (shouldAnnotateObjectReference(constant)) {
annotateobjRef(gMoveCwR(constant, TempReg), constant);
@@ -15870,8 +15984,8 @@
anInstruction9 = genoperandoperand(CmpCqR, ClassMethodContextCompactIndex, TempReg);
/* begin JumpZero: */
jumpIsContext1 = genConditionalBranchoperand(JumpZero, ((sqInt)0));
- genGetClassObjectOfClassIndexintoscratchReg(SendNumArgsReg, Scratch0Reg, TempReg);
- genLoadSlotsourceRegdestReg(InstanceSpecificationIndex, Scratch0Reg, SendNumArgsReg);
+ genGetClassObjectOfClassIndexintoscratchReg(SendNumArgsReg, Extra0Reg, TempReg);
+ genLoadSlotsourceRegdestReg(InstanceSpecificationIndex, Extra0Reg, SendNumArgsReg);
genConvertSmallIntegerToIntegerInReg(SendNumArgsReg);
/* begin AndCq:R: */
quickConstant6 = fixedFieldsOfClassFormatMask();
@@ -16451,11 +16565,13 @@
}
/* CogSimStackEntry>>#ensureSpilledAt:from: */
-static CogSimStackEntry * NoDbgRegParms
-ensureSpilledAtfrom(CogSimStackEntry * self_in_ensureSpilledAtfrom, sqInt baseOffset, sqInt baseRegister)
+static SimStackEntry * NoDbgRegParms
+ensureSpilledAtfrom(SimStackEntry * self_in_ensureSpilledAtfrom, sqInt baseOffset, sqInt baseRegister)
{
AbstractInstruction *anInstruction;
+ AbstractInstruction *anInstruction1;
sqInt baseReg;
+ sqInt constant;
AbstractInstruction *inst;
sqInt offset;
sqInt reg;
@@ -16470,7 +16586,16 @@
assert(((self_in_ensureSpilledAtfrom->type)) != SSSpill);
traceSpill(self_in_ensureSpilledAtfrom);
if (((self_in_ensureSpilledAtfrom->type)) == SSConstant) {
- inst = annotateobjRef(gPushCw((self_in_ensureSpilledAtfrom->constant)), (self_in_ensureSpilledAtfrom->constant));
+ /* begin genPushConstant: */
+ constant = (self_in_ensureSpilledAtfrom->constant);
+ if (shouldAnnotateObjectReference(constant)) {
+ inst = annotateobjRef(gPushCw(constant), constant);
+ }
+ else {
+ /* begin PushCq: */
+ anInstruction = genoperand(PushCq, constant);
+ inst = anInstruction;
+ }
}
else {
if (((self_in_ensureSpilledAtfrom->type)) == SSBaseOffset) {
@@ -16478,7 +16603,7 @@
offset = (self_in_ensureSpilledAtfrom->offset);
baseReg = (self_in_ensureSpilledAtfrom->registerr);
/* begin gen:quickConstant:operand:operand: */
- anInstruction = genoperandoperandoperand(MoveMwrR, offset, baseReg, TempReg);
+ anInstruction1 = genoperandoperandoperand(MoveMwrR, offset, baseReg, TempReg);
/* begin PushR: */
inst = genoperand(PushR, TempReg);
}
@@ -16493,37 +16618,12 @@
(self_in_ensureSpilledAtfrom->registerr) = baseRegister;
}
(self_in_ensureSpilledAtfrom->spilled) = 1;
- if ((self_in_ensureSpilledAtfrom->annotateUse)) {
- /* begin annotateBytecode: */
- (inst->annotation = HasBytecodePC);
- (self_in_ensureSpilledAtfrom->annotateUse) = 0;
- }
return self_in_ensureSpilledAtfrom;
}
-
-/* Discard type information because of a control-flow merge. */
-
- /* CogSimStackEntry>>#mergeAt:from: */
-static CogSimStackEntry * NoDbgRegParms
-mergeAtfrom(CogSimStackEntry * self_in_mergeAtfrom, sqInt baseOffset, sqInt baseRegister)
-{
- assert((self_in_mergeAtfrom->spilled));
- if (((self_in_mergeAtfrom->type)) == SSSpill) {
- assert((((self_in_mergeAtfrom->offset)) == baseOffset)
- && (((self_in_mergeAtfrom->registerr)) == baseRegister));
- }
- else {
- (self_in_mergeAtfrom->type) = SSSpill;
- (self_in_mergeAtfrom->offset) = baseOffset;
- (self_in_mergeAtfrom->registerr) = baseRegister;
- }
- return self_in_mergeAtfrom;
-}
-
/* CogSimStackEntry>>#popToReg: */
-static CogSimStackEntry * NoDbgRegParms
-popToReg(CogSimStackEntry * self_in_popToReg, sqInt reg)
+static SimStackEntry * NoDbgRegParms
+popToReg(SimStackEntry * self_in_popToReg, sqInt reg)
{
AbstractInstruction *anInstruction;
AbstractInstruction *anInstruction1;
@@ -16575,11 +16675,6 @@
error("Case not found and no otherwise clause");
}
}
- if ((self_in_popToReg->annotateUse)) {
- /* begin annotateBytecode: */
- (inst->annotation = HasBytecodePC);
- (self_in_popToReg->annotateUse) = 0;
- }
return self_in_popToReg;
}
@@ -16588,7 +16683,7 @@
/* CogSimStackEntry>>#registerMask */
static sqInt NoDbgRegParms
-registerMask(CogSimStackEntry * self_in_registerMask)
+registerMask(SimStackEntry * self_in_registerMask)
{
sqInt reg;
@@ -16602,7 +16697,7 @@
/* CogSimStackEntry>>#registerOrNone */
static sqInt NoDbgRegParms
-registerOrNone(CogSimStackEntry * self_in_registerOrNone)
+registerOrNone(SimStackEntry * self_in_registerOrNone)
{
return (((self_in_registerOrNone->type)) == SSRegister
? (self_in_registerOrNone->registerr)
@@ -16610,8 +16705,8 @@
}
/* CogSimStackEntry>>#storeToReg: */
-static CogSimStackEntry * NoDbgRegParms
-storeToReg(CogSimStackEntry * self_in_storeToReg, sqInt reg)
+static SimStackEntry * NoDbgRegParms
+storeToReg(SimStackEntry * self_in_storeToReg, sqInt reg)
{
AbstractInstruction *anInstruction;
AbstractInstruction *anInstruction1;
@@ -16658,15 +16753,79 @@
default:
error("Case not found and no otherwise clause");
}
- if ((self_in_storeToReg->annotateUse)) {
- /* begin annotateBytecode: */
- (inst->annotation = HasBytecodePC);
- (self_in_storeToReg->annotateUse) = 0;
- }
return self_in_storeToReg;
}
+ /* CogSSBytecodeFixup>>#isBackwardBranchFixup */
+static sqInt NoDbgRegParms
+isBackwardBranchFixup(BytecodeFixup * self_in_isBackwardBranchFixup)
+{
+ return ((self_in_isBackwardBranchFixup->simStackPtr)) == UnknownSimStackPtrFlag;
+}
+ /* CogSSBytecodeFixup>>#isMergeFixup */
+static sqInt NoDbgRegParms
+isMergeFixup(BytecodeFixup * self_in_isMergeFixup)
+{
+ return (((usqInt)((self_in_isMergeFixup->targetInstruction)))) == NeedsMergeFixupFlag;
+}
+
+ /* CogSSBytecodeFixup>>#isMergeFixupOrIsFixedUp */
+static sqInt NoDbgRegParms
+isMergeFixupOrIsFixedUp(BytecodeFixup * self_in_isMergeFixupOrIsFixedUp)
+{
+ return (((usqInt)((self_in_isMergeFixupOrIsFixedUp->targetInstruction)))) >= NeedsMergeFixupFlag;
+}
+
+
+/* Answer an unused abstract register in the liveRegMask.
+ Subclasses with more registers can override to answer them.
+ N.B. Do /not/ allocate TempReg. */
+/* Answer an unused abstract register in the liveRegMask.
+ Subclasses with more registers can override to answer them.
+ N.B. Do /not/ allocate TempReg. */
+
+ /* CogX64Compiler>>#availableRegisterOrNoneFor: */
+static sqInt NoDbgRegParms
+availableRegisterOrNoneFor(AbstractInstruction * self_in_availableRegisterOrNoneFor, sqInt liveRegsMask)
+{
+ if (!(liveRegsMask & (1LL << Extra5Reg))) {
+ return Extra5Reg;
+ }
+ if (!(liveRegsMask & (1LL << Extra4Reg))) {
+ return Extra4Reg;
+ }
+ if (!(liveRegsMask & (1LL << Extra3Reg))) {
+ return Extra3Reg;
+ }
+ if (!(liveRegsMask & (1LL << Extra2Reg))) {
+ return Extra2Reg;
+ }
+ if (!(liveRegsMask & (1LL << Extra1Reg))) {
+ return Extra1Reg;
+ }
+ if (!(liveRegsMask & (1LL << Extra0Reg))) {
+ return Extra0Reg;
+ }
+ if (!(liveRegsMask & (1LL << Arg1Reg))) {
+ return Arg1Reg;
+ }
+ if (!(liveRegsMask & (1LL << Arg0Reg))) {
+ return Arg0Reg;
+ }
+ if (!(liveRegsMask & (1LL << SendNumArgsReg))) {
+ return SendNumArgsReg;
+ }
+ if (!(liveRegsMask & (1LL << ClassReg))) {
+ return ClassReg;
+ }
+ if (!(liveRegsMask & (1LL << ReceiverResultReg))) {
+ return ReceiverResultReg;
+ }
+ return NoReg;
+}
+
+
/* See e.g. Figure 3.4 Register Usage in
System V Application Binary Interface
AMD64 Architecture Processor Supplement
@@ -21478,6 +21637,7 @@
sqInt quickConstant;
sqInt reg;
+ preenMethodLabel();
compilePICAbort(numArgs);
entry = genGetClassTagOfintoscratchReg(ReceiverResultReg, ClassReg, TempReg);
/* begin MoveR:R: */
@@ -21487,7 +21647,7 @@
if (!(isWithinMwOffsetRange(backEnd, methodCacheAddress()))) {
/* begin MoveCq:R: */
quickConstant = ((sqInt) (methodCacheAddress()));
- reg = (cacheBaseReg = Scratch0Reg);
+ reg = (cacheBaseReg = Extra0Reg);
/* begin gen:quickConstant:operand: */
anInstruction = genoperandoperand(MoveCqR, quickConstant, reg);
}
@@ -21734,24 +21894,6 @@
: (FoxMFReceiver - BytesPerWord) + ((methodOrBlockNumArgs - index) * BytesPerWord));
}
-
-/* Return from block, assuming result already loaded into ReceiverResultReg. */
-
- /* SimpleStackBasedCogit>>#genBlockReturn */
-static sqInt
-genBlockReturn(void)
-{
- if (needsFrame) {
- /* begin MoveR:R: */
- genoperandoperand(MoveRR, FPReg, SPReg);
- /* begin PopR: */
- genoperand(PopR, FPReg);
- }
- /* begin RetN: */
- genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
- return 0;
-}
-
/* SimpleStackBasedCogit>>#genDoubleFailIfZeroArgRcvr:arg: */
static AbstractInstruction * NoDbgRegParms
genDoubleFailIfZeroArgRcvrarg(sqInt rcvrReg, sqInt argReg)
@@ -22357,7 +22499,7 @@
if (!(isWithinMwOffsetRange(backEnd, methodCacheAddress()))) {
/* begin MoveCq:R: */
quickConstant = ((sqInt) (methodCacheAddress()));
- reg = (cacheBaseReg = Scratch0Reg);
+ reg = (cacheBaseReg = Extra0Reg);
/* begin gen:quickConstant:operand: */
anInstruction1 = genoperandoperand(MoveCqR, quickConstant, reg);
}
@@ -22655,17 +22797,17 @@
genQuickReturnConst(void)
{
AbstractInstruction *anInstruction;
- AbstractInstruction *anInstruction1;
sqInt constant;
constant = quickPrimitiveConstantFor(primitiveIndex);
- annotateobjRef((isImmediate(constant)
- ? (/* begin MoveCq:R: */
- (anInstruction = genoperandoperand(MoveCqR, constant, ReceiverResultReg)),
- anInstruction)
- : (/* begin MoveCw:R: */
- (anInstruction1 = genoperandoperand(MoveCwR, constant, ReceiverResultReg)),
- anInstruction1)), constant);
+ /* begin genMoveConstant:R: */
+ if (shouldAnnotateObjectReference(constant)) {
+ annotateobjRef(gMoveCwR(constant, ReceiverResultReg), constant);
+ }
+ else {
+ /* begin MoveCq:R: */
+ anInstruction = genoperandoperand(MoveCqR, constant, ReceiverResultReg);
+ }
genUpArrowReturn();
return UnfailingPrimitive;
}
@@ -22722,7 +22864,7 @@
AbstractInstruction *anInstruction;
sqInt constant;
- /* begin genMoveConstant:R: */
+ /* begin genMoveNilR: */
constant = nilObject();
if (shouldAnnotateObjectReference(constant)) {
annotateobjRef(gMoveCwR(constant, ReceiverResultReg), constant);
@@ -23568,25 +23710,6 @@
return mask & (1LL << reg);
}
-
-/* We must ensure the ReceiverResultReg is live across the store check so
- that we can store into receiver inst vars in a frameless method since self
- exists only in ReceiverResultReg in a frameless method. So if
@@ Diff output truncated at 50000 characters. @@
1
0
Eliot Miranda uploaded a new version of VMMaker to project VM Maker:
http://source.squeak.org/VMMaker/VMMaker.oscog-eem.1822.mcz
==================== Summary ====================
Name: VMMaker.oscog-eem.1822
Author: eem
Time: 19 April 2016, 10:24:04.070999 am
UUID: f18408b3-d8bb-4ac7-9d7d-b37ace026619
Ancestors: VMMaker.oscog-cb.1821
Slang, go the extra quarter-mile and define an optional primitive as the fast primitive fail code (null pointer) so that unselected optional primitives are in the prmitiveTable as fast primitive fails.
=============== Diff against VMMaker.oscog-cb.1821 ===============
Item was added:
+ ----- Method: CCodeGenerator>>maybeEmitPrimitiveFailureDefineFor:on: (in category 'C translation support') -----
+ maybeEmitPrimitiveFailureDefineFor: selector on: aStream
+ (vmClass notNil
+ and: [(vmClass inheritsFrom: InterpreterPrimitives)
+ and: [(vmClass primitiveTable includes: selector)]]) ifTrue:
+ [aStream nextPutAll: '#else\# define ' withCRs; nextPutAll: selector; nextPutAll: ' (void (*)(void))0\' withCRs]!
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.
Answer if the method has any compileTimeOptionPragmas"
| compileTimeOptionPragmas returnTypeIsFunctionPointer |
(compileTimeOptionPragmas := self compileTimeOptionPragmas) notEmpty ifTrue:
[self outputConditionalDefineFor: compileTimeOptionPragmas on: aStream].
returnTypeIsFunctionPointer := returnType last = $)
and: [returnType includesSubString: (aCodeGen cFunctionNameFor: selector)].
export
ifTrue:
[aStream nextPutAll: 'EXPORT('; nextPutAll: returnType; nextPut: $)]
ifFalse:
[self isStatic
ifTrue: [aStream nextPutAll: 'static ']
ifFalse:
[isPrototype ifTrue:
[aStream nextPutAll: 'extern ']].
(isPrototype or: [inline ~~ #always]) ifFalse: [aStream nextPutAll: 'inline '].
aStream nextPutAll: returnType].
(functionAttributes isNil or: [returnTypeIsFunctionPointer]) ifFalse:
[aStream space; nextPutAll: functionAttributes].
isPrototype ifTrue: [aStream space] ifFalse: [aStream cr].
returnTypeIsFunctionPointer ifFalse:
[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: $)].
isPrototype ifTrue:
[aStream nextPut: $;; cr.
+ compileTimeOptionPragmas isEmpty ifFalse:
+ [aCodeGen maybeEmitPrimitiveFailureDefineFor: selector on: aStream.
+ self terminateConditionalDefineFor: compileTimeOptionPragmas on: aStream]].
- self terminateConditionalDefineFor: compileTimeOptionPragmas on: aStream].
^compileTimeOptionPragmas notEmpty!
1
0
ClementBera uploaded a new version of VMMaker to project VM Maker:
http://source.squeak.org/VMMaker/VMMaker.oscog-cb.1821.mcz
==================== Summary ====================
Name: VMMaker.oscog-cb.1821
Author: cb
Time: 19 April 2016, 9:36:36.685084 am
UUID: b05e8610-8a40-46c9-992a-99b19ce720ed
Ancestors: VMMaker.oscog-cb.1820
Got confused with the indexes. Sorry for the extra commit.
=============== Diff against VMMaker.oscog-cb.1820 ===============
Item was changed:
----- Method: InterpreterPrimitives>>primitiveGetImmutability (in category 'object access primitives') -----
primitiveGetImmutability
<option: #IMMUTABILITY>
| rcvr |
+ rcvr := self stackValue: 0.
- rcvr := self stackValue: argumentCount.
self pop: argumentCount + 1 thenPushBool: (objectMemory isOopImmutable: rcvr)!
Item was changed:
----- Method: InterpreterPrimitives>>primitiveSetImmutability (in category 'object access primitives') -----
primitiveSetImmutability
<option: #IMMUTABILITY>
| rcvr wasImmutable |
+ rcvr := self stackValue: 1.
- rcvr := self stackValue: argumentCount.
(objectMemory isImmediate: rcvr) ifTrue:
[^self primitiveFailFor: PrimErrBadReceiver].
wasImmutable := objectMemory isObjImmutable: rcvr.
self stackTop = objectMemory trueObject
ifTrue:
[(self canBeImmutable: rcvr) ifFalse:
[^self primitiveFailFor: PrimErrInappropriate].
objectMemory setIsImmutableOf: rcvr to: true]
ifFalse: [
self stackTop = objectMemory falseObject
ifTrue: [objectMemory setIsImmutableOf: rcvr to: false]
ifFalse:
[^self primitiveFailFor: PrimErrBadArgument]].
self pop: argumentCount + 1 thenPushBool: wasImmutable!
1
0
ClementBera uploaded a new version of VMMaker to project VM Maker:
http://source.squeak.org/VMMaker/VMMaker.oscog-cb.1820.mcz
==================== Summary ====================
Name: VMMaker.oscog-cb.1820
Author: cb
Time: 19 April 2016, 9:32:35.692708 am
UUID: ce04560e-30f7-4eb5-ab6b-4863985954bb
Ancestors: VMMaker.oscog-eem.1819
- use option:IMMUTABILITY instead of ccpIf: to make it look better.
- fixed a bug in receiver accessing in immutability primitive for mirror primitive.
=============== Diff against VMMaker.oscog-eem.1819 ===============
Item was changed:
----- Method: InterpreterPrimitives>>primitiveGetImmutability (in category 'object access primitives') -----
primitiveGetImmutability
+ <option: #IMMUTABILITY>
+ | rcvr |
+ rcvr := self stackValue: argumentCount.
+ self pop: argumentCount + 1 thenPushBool: (objectMemory isOopImmutable: rcvr)!
- self cppIf: #IMMUTABILITY
- ifTrue:
- [| rcvr |
- rcvr := self stackValue: 0.
- self pop: argumentCount + 1 thenPushBool: (objectMemory isOopImmutable: rcvr)]
- ifFalse:
- [self primitiveFailFor: PrimErrUnsupported]!
Item was changed:
----- Method: InterpreterPrimitives>>primitiveSetImmutability (in category 'object access primitives') -----
primitiveSetImmutability
+ <option: #IMMUTABILITY>
+ | rcvr wasImmutable |
+ rcvr := self stackValue: argumentCount.
+ (objectMemory isImmediate: rcvr) ifTrue:
+ [^self primitiveFailFor: PrimErrBadReceiver].
+ wasImmutable := objectMemory isObjImmutable: rcvr.
+ self stackTop = objectMemory trueObject
- self cppIf: #IMMUTABILITY
ifTrue:
+ [(self canBeImmutable: rcvr) ifFalse:
+ [^self primitiveFailFor: PrimErrInappropriate].
+ objectMemory setIsImmutableOf: rcvr to: true]
+ ifFalse: [
+ self stackTop = objectMemory falseObject
+ ifTrue: [objectMemory setIsImmutableOf: rcvr to: false]
+ ifFalse:
+ [^self primitiveFailFor: PrimErrBadArgument]].
+ self pop: argumentCount + 1 thenPushBool: wasImmutable!
- [| rcvr wasImmutable |
- rcvr := self stackValue: 1.
- (objectMemory isImmediate: rcvr) ifTrue:
- [^self primitiveFailFor: PrimErrBadReceiver].
- wasImmutable := objectMemory isObjImmutable: rcvr.
- self stackTop = objectMemory trueObject
- ifTrue:
- [(self canBeImmutable: rcvr) ifFalse:
- [^self primitiveFailFor: PrimErrInappropriate].
- objectMemory setIsImmutableOf: rcvr to: true]
- ifFalse: [
- self stackTop = objectMemory falseObject
- ifTrue: [objectMemory setIsImmutableOf: rcvr to: false]
- ifFalse:
- [^self primitiveFailFor: PrimErrBadArgument]].
- self pop: argumentCount + 1 thenPushBool: wasImmutable]
- ifFalse:
- [self primitiveFailFor: PrimErrUnsupported]!
1
0
Eliot Miranda uploaded a new version of VMMaker to project VM Maker:
http://source.squeak.org/VMMaker/VMMaker.oscog-eem.1819.mcz
==================== Summary ====================
Name: VMMaker.oscog-eem.1819
Author: eem
Time: 19 April 2016, 9:29:34.944574 am
UUID: ad6ff521-03fe-4a02-a5e1-37394ef3b399
Ancestors: VMMaker.oscog-eem.1818
Spur: Fix bug in following state on primitive failure. The old code would always follow to depth 1, even if the accessor depth was 0. Hard-code primitiveSize's depth to 0 (accessing length in at:[put:] and size causes the stack depth computation to answer 1 instead of 0 for these primitives.
=============== Diff against VMMaker.oscog-eem.1818 ===============
Item was changed:
----- Method: InterpreterPrimitives>>primitiveSize (in category 'indexing primitives') -----
primitiveSize
+ <accessorDepth: 0>
| rcvr hdr fmt fixedFields totalLength |
rcvr := self stackTop.
((objectMemory isImmediate: rcvr) "Integers are not indexable"
or: [hdr := objectMemory baseHeader: rcvr.
(fmt := objectMemory formatOfHeader: hdr) < 2]) "This is not an indexable object"
ifTrue:
[^self primitiveFailFor: PrimErrBadReceiver].
(fmt = objectMemory indexablePointersFormat
and: [objectMemory isContextHeader: hdr]) ifTrue:
[^self primitiveContextSize].
totalLength := objectMemory lengthOf: rcvr baseHeader: hdr format: fmt.
fixedFields := objectMemory fixedFieldsOf: rcvr format: fmt length: totalLength.
self pop: argumentCount + 1 thenPush: (objectMemory integerObjectOf: totalLength - fixedFields)!
Item was changed:
----- Method: StackInterpreter>>checkForAndFollowForwardedPrimitiveState (in category 'primitive support') -----
checkForAndFollowForwardedPrimitiveState
"In Spur a primitive may fail due to encountering a forwarder. On failure,
check the accessorDepth for the primitive and if non-negative scan the
args to the depth, following any forwarders. Answer if any are found so
the prim can be retried. The primitive index is derived from newMethod.
If the primitive is 118, then primitiveDoPrimitiveWithArgs sets newMethod
to a SmallInteger whose value is the primitive it is evaluating."
<option: #SpurObjectMemory>
| primIndex accessorDepth found scannedStackFrame |
self assert: self failed.
found := scannedStackFrame := false.
primIndex := (objectMemory isIntegerObject: newMethod)
ifTrue: [objectMemory integerValueOf: newMethod]
ifFalse:
[self assert: argumentCount = (self argumentCountOf: newMethod).
self primitiveIndexOf: newMethod].
accessorDepth := primitiveAccessorDepthTable at: primIndex.
"For the method-executing primitives, failure could have been in those primitives or the
primitives of the methods they execute. Find out which failed by seeing what is in effect."
((primIndex = 117 and: [primitiveFunctionPointer ~~ #primitiveExternalCall])
or: [primIndex = 218 and: [primitiveFunctionPointer ~~ #primitiveDoNamedPrimitiveWithArgs]])
ifTrue:
[accessorDepth := self primitiveAccessorDepthForExternalPrimitiveMethod: newMethod]
ifFalse:
[self assert: (self saneFunctionPointerForFailureOfPrimIndex: primIndex)].
self assert: (accessorDepth between: -127 and: 127).
accessorDepth >= 0 ifTrue:
[0 to: argumentCount do:
[:index| | oop |
oop := self stackValue: index.
(objectMemory isNonImmediate: oop) ifTrue:
[(objectMemory isForwarded: oop) ifTrue:
[self assert: index < argumentCount. "receiver should have been caught at send time."
found := true.
oop := objectMemory followForwarded: oop.
self stackValue: index put: oop.
scannedStackFrame ifFalse:
[scannedStackFrame := true.
self
followForwardedFrameContents: framePointer
stackPointer: stackPointer + (argumentCount + 1 * objectMemory wordSize) "don't repeat effort"]].
+ (accessorDepth > 0
+ and: [(objectMemory hasPointerFields: oop)
+ and: [objectMemory followForwardedObjectFields: oop toDepth: accessorDepth]]) ifTrue:
- ((objectMemory hasPointerFields: oop)
- and: [objectMemory followForwardedObjectFields: oop toDepth: accessorDepth]) ifTrue:
[found := true]]]].
^found!
1
0
Eliot Miranda uploaded a new version of VMMaker to project VM Maker:
http://source.squeak.org/VMMaker/VMMaker.oscog-eem.1818.mcz
==================== Summary ====================
Name: VMMaker.oscog-eem.1818
Author: eem
Time: 18 April 2016, 11:00:43.154499 pm
UUID: 247e87e6-3e55-41b3-9801-7366a5913066
Ancestors: VMMaker.oscog-cb.1817
Abstract out the asnnotate Label or Nop riutine and use it to fix doubleExtendedDoAnythingBytecode
=============== Diff against VMMaker.oscog-cb.1817 ===============
Item was added:
+ ----- Method: StackToRegisterMappingCogit>>annotateInstructionForBytecode (in category 'bytecode generator support') -----
+ annotateInstructionForBytecode
+ "Annotate the current instruction as having a bytecode pc. If the current instruction
+ is already annotated, insert a nop and annotate that. We cannot have the same instruction
+ address carry multiple annotations."
+ <inline: true>
+ self annotateBytecode: (self prevInstIsPCAnnotated
+ ifTrue: [self Nop]
+ ifFalse: [self Label]).!
Item was changed:
----- Method: StackToRegisterMappingCogit>>doubleExtendedDoAnythingBytecode (in category 'bytecode generators') -----
doubleExtendedDoAnythingBytecode
"Replaces the Blue Book double-extended send [132], in which the first byte was wasted on 8 bits of argument count.
Here we use 3 bits for the operation sub-type (opType), and the remaining 5 bits for argument count where needed.
The last byte give access to 256 instVars or literals.
See also secondExtendedSendBytecode"
| opType |
opType := byte1 >> 5.
opType = 0 ifTrue:
[^self genSend: byte2 numArgs: (byte1 bitAnd: 31)].
opType = 1 ifTrue:
[^self genSendSuper: byte2 numArgs: (byte1 bitAnd: 31)].
"We need a map entry for this bytecode for correct parsing.
The sends will get an IsSend entry anyway. The other cases need a fake one."
opType caseOf: {
[2] -> [(coInterpreter isReadMediatedContextInstVarIndex: byte2)
ifTrue: [self genPushMaybeContextReceiverVariable: byte2]
ifFalse: [self genPushReceiverVariable: byte2.
+ self annotateInstructionForBytecode.
- self annotateBytecode: self Label.
^0]].
[3] -> [self genPushLiteralIndex: byte2.
+ self annotateInstructionForBytecode.
- self annotateBytecode: self Label.
^0].
[4] -> [self genPushLiteralVariable: byte2.].
[7] -> [self genStorePop: false LiteralVariable: byte2.
self cppIf: IMMUTABILITY ifTrue: [ "genStorePop:LiteralVariable: annotates; don't annotate twice" ^0 ] ] }
otherwise: "5 & 6"
[(coInterpreter isWriteMediatedContextInstVarIndex: byte2)
ifTrue: [self genStorePop: opType = 6 MaybeContextReceiverVariable: byte2]
ifFalse: [self genStorePop: opType = 6 ReceiverVariable: byte2].
self cppIf: IMMUTABILITY ifTrue: [ "genStorePop:LiteralVariable: annotates; don't annotate twice" ^0 ]].
"We need a map entry for this bytecode for correct parsing (if the method builds a frame)."
self assert: needsFrame.
"genPushMaybeContextInstVar, pushListVar, store & storePop all generate code"
self assert: self prevInstIsPCAnnotated not.
self annotateBytecode: self Label.
^0!
Item was changed:
----- Method: StackToRegisterMappingCogit>>ssPushAnnotatedConstant: (in category 'simulation stack') -----
ssPushAnnotatedConstant: literal
self ssPush: 1.
self updateSimSpillBase.
self ssTop
type: SSConstant;
spilled: false;
constant: literal;
bcptr: bytecodePC.
+ self annotateInstructionForBytecode.
- self annotateBytecode: self Label.
^0!
1
0
ClementBera uploaded a new version of VMMaker to project VM Maker:
http://source.squeak.org/VMMaker/VMMaker.oscog-cb.1817.mcz
==================== Summary ====================
Name: VMMaker.oscog-cb.1817
Author: cb
Time: 18 April 2016, 6:26:01.068449 pm
UUID: 3306d184-513f-4ee4-a56e-dfad6680f5ac
Ancestors: VMMaker.oscog-eem.1816
Removed all the annoteUse (from the struct, its usage, etc...)
=============== Diff against VMMaker.oscog-eem.1816 ===============
Item was changed:
----- Method: CogRegisterAllocatingSimStackEntry>>ensureSpilledAt:from: (in category 'compile abstract instructions') -----
ensureSpilledAt: baseOffset from: baseRegister
| inst |
<var: #inst type: #'AbstractInstruction *'>
spilled ifTrue:
[type = SSSpill ifTrue:
[self assert: (offset = baseOffset and: [register = baseRegister]).
^self]].
self assert: type ~= SSSpill.
cogit traceSpill: self.
type = SSConstant
ifTrue:
[inst := cogit genPushConstant: constant]
ifFalse:
[type = SSBaseOffset
ifTrue:
[ liveRegister = NoReg
ifTrue:
[cogit MoveMw: offset r: register R: TempReg.
inst := cogit PushR: TempReg ]
ifFalse: [ inst := cogit PushR: liveRegister]]
ifFalse:
[self assert: type = SSRegister.
inst := cogit PushR: register].
type := SSSpill.
offset := baseOffset.
register := baseRegister].
+ spilled := true.!
- spilled := true.
- self maybeAnnotateUse: inst!
Item was changed:
----- Method: CogRegisterAllocatingSimStackEntry>>popToReg: (in category 'compile abstract instructions') -----
popToReg: reg
| inst |
<var: #inst type: #'AbstractInstruction *'>
liveRegister ~= NoReg
ifTrue:
[inst := reg ~= liveRegister
ifTrue: [cogit MoveR: liveRegister R: reg]
ifFalse: [cogit Label] ]
ifFalse:
[spilled
ifTrue:
[inst := cogit PopR: reg]
ifFalse:
[type caseOf: {
[SSBaseOffset] -> [inst := cogit MoveMw: offset r: register R: reg].
[SSConstant] -> [inst := cogit genMoveConstant: constant R: reg].
[SSRegister] -> [inst := reg ~= register
ifTrue: [cogit MoveR: register R: reg]
ifFalse: [cogit Label]] }]].
- self maybeAnnotateUse: inst.
reg ~= TempReg ifTrue: [ liveRegister := reg ]!
Item was changed:
----- Method: CogRegisterAllocatingSimStackEntry>>printStateOn: (in category 'printing') -----
printStateOn: aStream
<doNotGenerate> "Smalltalk-side only"
type isInteger ifFalse: [^self].
aStream nextPut: $(.
type caseOf: {
[SSBaseOffset] -> [aStream
nextPutAll: 'bo ';
nextPutAll: (cogit backEnd nameForRegister: register).
offset negative ifFalse: [aStream nextPut: $+].
aStream print: offset].
[SSConstant] -> [aStream
nextPutAll: 'const ';
print: constant].
[SSRegister] -> [aStream
nextPutAll: 'reg ';
nextPutAll: (cogit backEnd nameForRegister: register)].
[SSSpill] -> [aStream
nextPutAll: 'spill @ ';
nextPutAll: (cogit backEnd nameForRegister: register).
offset negative ifFalse: [aStream nextPut: $+].
aStream print: offset] }.
(spilled and: [type ~= SSSpill]) ifTrue:
[aStream nextPutAll: ' (spilled)'].
liveRegister ~= NoReg ifTrue:
[aStream nextPutAll: ' (live: '; nextPutAll: (cogit backEnd nameForRegister: liveRegister); nextPut: $)].
- annotateUse ifTrue:
- [aStream nextPutAll: ' (ANNOTATED)'].
bcptr ifNotNil:
[aStream space; nextPut: ${; print: bcptr; nextPut: $}].
aStream nextPut: $)!
Item was changed:
----- Method: CogRegisterAllocatingSimStackEntry>>storeToReg: (in category 'compile abstract instructions') -----
storeToReg: reg
| inst |
<var: #inst type: #'AbstractInstruction *'>
liveRegister ~= NoReg
ifTrue:
[inst := reg ~= liveRegister
ifTrue: [cogit MoveR: liveRegister R: reg]
ifFalse: [cogit Label]]
ifFalse:
[type caseOf: {
[SSBaseOffset] -> [inst := cogit MoveMw: offset r: register R: reg].
[SSSpill] -> [inst := cogit MoveMw: offset r: register R: reg].
[SSConstant] -> [inst := cogit genMoveConstant: constant R: reg].
[SSRegister] -> [inst := reg ~= register
ifTrue: [cogit MoveR: register R: reg]
ifFalse: [cogit Label]] }].
- self maybeAnnotateUse: inst.
reg ~= TempReg ifTrue: [ liveRegister := reg ]!
Item was changed:
----- Method: CogSimStackEntry class>>instVarNamesAndTypesForTranslationDo: (in category 'translation') -----
instVarNamesAndTypesForTranslationDo: aBinaryBlock
"enumerate aBinaryBlock with the names and C type strings for the inst vars to include in a CogSimStackEntry struct."
"self printTypedefOn: Transcript"
self filteredInstVarNames do:
[:ivn|
aBinaryBlock
value: (ivn = 'register' ifTrue: ['registerr'] ifFalse: [ivn]) "avoid reservedWord conflict"
value: (ivn caseOf: {
['type'] -> [#char].
+ ['spilled'] -> [#char].}
- ['spilled'] -> [#char].
- ['annotateUse'] -> [#char]}
otherwise:
[#sqInt])]!
Item was removed:
- ----- Method: CogSimStackEntry>>annotateUse (in category 'accessing') -----
- annotateUse
- "Answer the value of annotateUse"
-
- ^ annotateUse!
Item was removed:
- ----- Method: CogSimStackEntry>>annotateUse: (in category 'accessing') -----
- annotateUse: anObject
- "Set the value of annotateUse"
-
- ^annotateUse := anObject!
Item was changed:
----- Method: CogSimStackEntry>>ensureSpilledAt:from: (in category 'compile abstract instructions') -----
ensureSpilledAt: baseOffset from: baseRegister
| inst |
<var: #inst type: #'AbstractInstruction *'>
spilled ifTrue:
[type = SSSpill ifTrue:
[self assert: (offset = baseOffset and: [register = baseRegister]).
^self]].
self assert: type ~= SSSpill.
cogit traceSpill: self.
type = SSConstant
ifTrue:
[inst := cogit genPushConstant: constant]
ifFalse:
[type = SSBaseOffset
ifTrue:
[cogit MoveMw: offset r: register R: TempReg.
inst := cogit PushR: TempReg]
ifFalse:
[self assert: type = SSRegister.
inst := cogit PushR: register].
type := SSSpill.
offset := baseOffset.
register := baseRegister].
+ spilled := true.!
- spilled := true.
- self maybeAnnotateUse: inst!
Item was removed:
- ----- Method: CogSimStackEntry>>maybeAnnotateUse: (in category 'compile abstract instructions') -----
- maybeAnnotateUse: inst
- <inline: true>
- annotateUse ifTrue:
- [inst annotation = 0
- ifTrue: [cogit annotateBytecode: inst]
- ifFalse: [cogit annotateBytecode: cogit Label].
- annotateUse := false]!
Item was changed:
----- Method: CogSimStackEntry>>popToReg: (in category 'compile abstract instructions') -----
popToReg: reg
| inst |
<var: #inst type: #'AbstractInstruction *'>
spilled
ifTrue:
[inst := cogit PopR: reg]
ifFalse:
[type caseOf: {
[SSBaseOffset] -> [inst := cogit MoveMw: offset r: register R: reg].
[SSConstant] -> [inst := cogit genMoveConstant: constant R: reg].
[SSRegister] -> [inst := reg ~= register
ifTrue: [cogit MoveR: register R: reg]
+ ifFalse: [cogit Label]] }].!
- ifFalse: [cogit Label]] }].
- self maybeAnnotateUse: inst!
Item was changed:
----- Method: CogSimStackEntry>>printStateOn: (in category 'printing') -----
printStateOn: aStream
<doNotGenerate> "Smalltalk-side only"
type isInteger ifFalse: [^self].
aStream nextPut: $(.
type caseOf: {
[SSBaseOffset] -> [aStream
nextPutAll: 'bo ';
nextPutAll: (cogit backEnd nameForRegister: register).
offset negative ifFalse: [aStream nextPut: $+].
aStream print: offset].
[SSConstant] -> [aStream
nextPutAll: 'const ';
print: constant].
[SSRegister] -> [aStream
nextPutAll: 'reg ';
nextPutAll: (cogit backEnd nameForRegister: register)].
[SSSpill] -> [aStream
nextPutAll: 'spill @ ';
nextPutAll: (cogit backEnd nameForRegister: register).
offset negative ifFalse: [aStream nextPut: $+].
aStream print: offset] }.
(spilled and: [type ~= SSSpill]) ifTrue:
[aStream nextPutAll: ' (spilled)'].
- annotateUse ifTrue:
- [aStream nextPutAll: ' (ANNOTATED)'].
bcptr ifNotNil:
[aStream space; nextPut: ${; print: bcptr; nextPut: $}].
aStream nextPut: $)!
Item was changed:
----- Method: CogSimStackEntry>>storeToReg: (in category 'compile abstract instructions') -----
storeToReg: reg
| inst |
<var: #inst type: #'AbstractInstruction *'>
type caseOf: {
[SSBaseOffset] -> [inst := cogit MoveMw: offset r: register R: reg].
[SSSpill] -> [inst := cogit MoveMw: offset r: register R: reg].
[SSConstant] -> [inst := cogit genMoveConstant: constant R: reg].
[SSRegister] -> [inst := reg ~= register
ifTrue: [cogit MoveR: register R: reg]
+ ifFalse: [cogit Label]] }!
- ifFalse: [cogit Label]] }.
- self maybeAnnotateUse: inst!
Item was changed:
----- Method: RegisterAllocatingCogit>>ssStorePop:toPreferredReg: (in category 'simulation stack') -----
ssStorePop: popBoolean toPreferredReg: preferredReg
"Store or pop the top simulated stack entry to a register.
Use preferredReg if the entry is not itself a register.
Answer the actual register the result ends up in."
| actualReg |
actualReg := preferredReg.
self ssTop type = SSRegister ifTrue:
[self assert: self ssTop liveRegister = self ssTop register.
- self assert: self ssTop annotateUse not.
self assert: self ssTop spilled not].
self ssTop liveRegister ~= NoReg ifTrue:
[actualReg := self ssTop liveRegister].
self ssStorePop: popBoolean toReg: actualReg. "generates nothing if ssTop is already in actualReg"
^ actualReg!
Item was changed:
----- Method: SistaStackToRegisterMappingCogit>>genSpecialSelectorComparison (in category 'bytecode generators') -----
genSpecialSelectorComparison
"Override to count inlined branches if followed by a conditional branch.
We borrow the following conditional branch's counter and when about to
inline the comparison we decrement the counter (without writing it back)
and if it trips simply abort the inlining, falling back to the normal send which
will then continue to the conditional branch which will trip and enter the abort."
| nextPC postBranchPC targetBytecodePC primDescriptor branchDescriptor
+ rcvrIsInt argIsInt argInt jumpNotSmallInts inlineCAB
- rcvrIsInt argIsInt argInt jumpNotSmallInts inlineCAB annotateInst
counterAddress countTripped counterReg index |
<var: #countTripped type: #'AbstractInstruction *'>
<var: #primDescriptor type: #'BytecodeDescriptor *'>
<var: #jumpNotSmallInts type: #'AbstractInstruction *'>
<var: #branchDescriptor type: #'BytecodeDescriptor *'>
(coInterpreter isOptimizedMethod: methodObj) ifTrue: [ ^ self genSpecialSelectorComparisonWithoutCounters ].
self ssFlushTo: simStackPtr - 2.
primDescriptor := self generatorAt: byte0.
argIsInt := self ssTop type = SSConstant
and: [objectMemory isIntegerObject: (argInt := self ssTop constant)].
rcvrIsInt := (self ssValue: 1) type = SSConstant
and: [objectMemory isIntegerObject: (self ssValue: 1) constant].
"short-cut the jump if operands are SmallInteger constants."
(argIsInt and: [rcvrIsInt]) ifTrue:
[^ self genStaticallyResolvedSpecialSelectorComparison].
self extractMaybeBranchDescriptorInto: [ :descr :next :postBranch :target |
branchDescriptor := descr. nextPC := next. postBranchPC := postBranch. targetBytecodePC := target ].
"Only interested in inlining if followed by a conditional branch."
inlineCAB := branchDescriptor isBranchTrue or: [branchDescriptor isBranchFalse].
"Further, only interested in inlining = and ~= if there's a SmallInteger constant involved.
The relational operators successfully statically predict SmallIntegers; the equality operators do not."
(inlineCAB and: [primDescriptor opcode = JumpZero or: [primDescriptor opcode = JumpNonZero]]) ifTrue:
[inlineCAB := argIsInt or: [rcvrIsInt]].
inlineCAB ifFalse:
[^self genSpecialSelectorSend].
argIsInt
ifTrue:
[(self ssValue: 1) popToReg: ReceiverResultReg.
- annotateInst := self ssTop annotateUse.
self ssPop: 2.
self MoveR: ReceiverResultReg R: TempReg]
ifFalse:
[self marshallSendArguments: 1.
self MoveR: Arg0Reg R: TempReg].
jumpNotSmallInts := (argIsInt or: [rcvrIsInt])
ifTrue: [objectRepresentation genJumpNotSmallIntegerInScratchReg: TempReg]
ifFalse: [objectRepresentation genJumpNotSmallIntegersIn: ReceiverResultReg andScratch: TempReg scratch: ClassReg].
counterReg := self allocateRegNotConflictingWith: (self registerMaskFor: ReceiverResultReg and: Arg0Reg).
self
genExecutionCountLogicInto: [ :cAddress :countTripBranch |
counterAddress := cAddress.
countTripped := countTripBranch ]
counterReg: counterReg.
argIsInt
+ ifTrue: [self CmpCq: argInt R: ReceiverResultReg]
- ifTrue: [annotateInst
- ifTrue: [self annotateBytecode: (self CmpCq: argInt R: ReceiverResultReg)]
- ifFalse: [self CmpCq: argInt R: ReceiverResultReg]]
ifFalse: [self CmpR: Arg0Reg R: ReceiverResultReg].
"Cmp is weird/backwards so invert the comparison. Further since there is a following conditional
jump bytecode define non-merge fixups and leave the cond bytecode to set the mergeness."
self genConditionalBranch: (branchDescriptor isBranchTrue
ifTrue: [primDescriptor opcode]
ifFalse: [self inverseBranchFor: primDescriptor opcode])
operand: (self ensureNonMergeFixupAt: targetBytecodePC - initialPC) asUnsignedInteger.
self genFallsThroughCountLogicCounterReg: counterReg counterAddress: counterAddress.
self Jump: (self ensureNonMergeFixupAt: postBranchPC - initialPC).
countTripped jmpTarget: (jumpNotSmallInts jmpTarget: self Label).
argIsInt ifTrue:
[self MoveCq: argInt R: Arg0Reg].
index := byte0 - self firstSpecialSelectorBytecodeOffset.
^self genMarshalledSend: index negated - 1 numArgs: 1 sendTable: ordinarySendTrampolines!
Item was removed:
- ----- Method: StackToRegisterMappingCogit>>annotateBytecodeIfAnnotated: (in category 'bytecode generator support') -----
- annotateBytecodeIfAnnotated: aSimStackEntry
- <var: #aSimStackEntry type: #'CogSimStackEntry *'>
- <inline: false>
- aSimStackEntry annotateUse ifTrue:
- [self annotateBytecode: (self prevInstIsPCAnnotated
- ifTrue: [self Nop]
- ifFalse: [self Label]).
- aSimStackEntry annotateUse: false]!
Item was changed:
----- Method: StackToRegisterMappingCogit>>doubleExtendedDoAnythingBytecode (in category 'bytecode generators') -----
doubleExtendedDoAnythingBytecode
"Replaces the Blue Book double-extended send [132], in which the first byte was wasted on 8 bits of argument count.
Here we use 3 bits for the operation sub-type (opType), and the remaining 5 bits for argument count where needed.
The last byte give access to 256 instVars or literals.
See also secondExtendedSendBytecode"
| opType |
opType := byte1 >> 5.
opType = 0 ifTrue:
[^self genSend: byte2 numArgs: (byte1 bitAnd: 31)].
opType = 1 ifTrue:
[^self genSendSuper: byte2 numArgs: (byte1 bitAnd: 31)].
"We need a map entry for this bytecode for correct parsing.
The sends will get an IsSend entry anyway. The other cases need a fake one."
opType caseOf: {
[2] -> [(coInterpreter isReadMediatedContextInstVarIndex: byte2)
ifTrue: [self genPushMaybeContextReceiverVariable: byte2]
ifFalse: [self genPushReceiverVariable: byte2.
+ self annotateBytecode: self Label.
- self ssTop annotateUse: true.
^0]].
[3] -> [self genPushLiteralIndex: byte2.
+ self annotateBytecode: self Label.
- self ssTop annotateUse: true.
^0].
[4] -> [self genPushLiteralVariable: byte2.].
[7] -> [self genStorePop: false LiteralVariable: byte2.
self cppIf: IMMUTABILITY ifTrue: [ "genStorePop:LiteralVariable: annotates; don't annotate twice" ^0 ] ] }
otherwise: "5 & 6"
[(coInterpreter isWriteMediatedContextInstVarIndex: byte2)
ifTrue: [self genStorePop: opType = 6 MaybeContextReceiverVariable: byte2]
ifFalse: [self genStorePop: opType = 6 ReceiverVariable: byte2].
self cppIf: IMMUTABILITY ifTrue: [ "genStorePop:LiteralVariable: annotates; don't annotate twice" ^0 ]].
"We need a map entry for this bytecode for correct parsing (if the method builds a frame)."
self assert: needsFrame.
"genPushMaybeContextInstVar, pushListVar, store & storePop all generate code"
self assert: self prevInstIsPCAnnotated not.
self annotateBytecode: self Label.
^0!
Item was changed:
----- Method: StackToRegisterMappingCogit>>genJumpIf:to: (in category 'bytecode generator support') -----
genJumpIf: boolean to: targetBytecodePC
<inline: false>
| desc fixup ok |
<var: #desc type: #'CogSimStackEntry *'>
<var: #fixup type: #'BytecodeFixup *'>
<var: #ok type: #'AbstractInstruction *'>
self ssFlushTo: simStackPtr - 1.
desc := self ssTop.
self ssPop: 1.
(desc type == SSConstant
and: [desc constant = objectMemory trueObject or: [desc constant = objectMemory falseObject]]) ifTrue:
["Must arrange there's a fixup at the target whether it is jumped to or
not so that the simStackPtr can be kept correct."
fixup := self ensureFixupAt: targetBytecodePC - initialPC.
- "Must enter any annotatedConstants into the map"
- desc annotateUse ifTrue:
- [self annotateBytecode: (self prevInstIsPCAnnotated
- ifTrue: [self Nop]
- ifFalse: [self Label])].
"Must annotate the bytecode for correct pc mapping."
self annotateBytecode: (desc constant = boolean
ifTrue: [self Jump: fixup]
ifFalse: [self prevInstIsPCAnnotated
ifTrue: [self Nop]
ifFalse: [self Label]]).
^0].
desc popToReg: TempReg.
"Cunning trick by LPD. If true and false are contiguous subtract the smaller.
Correct result is either 0 or the distance between them. If result is not 0 or
their distance send mustBeBoolean."
self assert: (objectMemory objectAfter: objectMemory falseObject) = objectMemory trueObject.
self genSubConstant: boolean R: TempReg.
self JumpZero: (self ensureFixupAt: targetBytecodePC - initialPC).
self extASpecifiesNoMustBeBoolean ifTrue:
[ extA := 0.
self annotateBytecode: self lastOpcode.
^ 0].
extA := 0.
. self CmpCq: (boolean == objectMemory falseObject
ifTrue: [objectMemory trueObject - objectMemory falseObject]
ifFalse: [objectMemory falseObject - objectMemory trueObject])
R: TempReg.
ok := self JumpZero: 0.
self CallRT: (boolean == objectMemory falseObject
ifTrue: [ceSendMustBeBooleanAddFalseTrampoline]
ifFalse: [ceSendMustBeBooleanAddTrueTrampoline]).
ok jmpTarget: (self annotateBytecode: self Label).
^0!
Item was changed:
----- Method: StackToRegisterMappingCogit>>genPopStackBytecode (in category 'bytecode generators') -----
genPopStackBytecode
- self annotateBytecodeIfAnnotated: self ssTop.
self ssTop spilled ifTrue:
[self AddCq: objectMemory wordSize R: SPReg].
self ssPop: 1.
^0!
Item was changed:
----- Method: StackToRegisterMappingCogit>>genSpecialSelectorArithmetic (in category 'bytecode generators') -----
genSpecialSelectorArithmetic
| primDescriptor rcvrIsConst argIsConst rcvrIsInt argIsInt rcvrInt argInt result
+ jumpNotSmallInts jumpContinue index |
- jumpNotSmallInts jumpContinue annotateInst instToAnnotate index |
<var: #primDescriptor type: #'BytecodeDescriptor *'>
<var: #jumpNotSmallInts type: #'AbstractInstruction *'>
<var: #jumpContinue type: #'AbstractInstruction *'>
<var: #instToAnnotate type: #'AbstractInstruction *'>
primDescriptor := self generatorAt: byte0.
argIsInt := (argIsConst := self ssTop type = SSConstant)
and: [objectMemory isIntegerObject: (argInt := self ssTop constant)].
rcvrIsInt := (rcvrIsConst := (self ssValue: 1) type = SSConstant)
and: [objectMemory isIntegerObject: (rcvrInt := (self ssValue: 1) constant)].
(argIsInt and: [rcvrIsInt]) ifTrue:
[rcvrInt := objectMemory integerValueOf: rcvrInt.
argInt := objectMemory integerValueOf: argInt.
primDescriptor opcode caseOf: {
[AddRR] -> [result := rcvrInt + argInt].
[SubRR] -> [result := rcvrInt - argInt].
[AndRR] -> [result := rcvrInt bitAnd: argInt].
[OrRR] -> [result := rcvrInt bitOr: argInt] }.
(objectMemory isIntegerValue: result) ifTrue:
+ ["Must annotate the bytecode for correct pc mapping."
- ["Must enter any annotatedConstants into the map"
- self annotateBytecodeIfAnnotated: (self ssValue: 1).
- self annotateBytecodeIfAnnotated: self ssTop.
- "Must annotate the bytecode for correct pc mapping."
^self ssPop: 2; ssPushAnnotatedConstant: (objectMemory integerObjectOf: result)].
^self genSpecialSelectorSend].
"If there's any constant involved other than a SmallInteger don't attempt to inline."
((rcvrIsConst and: [rcvrIsInt not])
or: [argIsConst and: [argIsInt not]]) ifTrue:
[^self genSpecialSelectorSend].
"If we know nothing about the types then better not to inline as the inline cache and
primitive code is not terribly slow so wasting time on duplicating tag tests is pointless."
(argIsInt or: [rcvrIsInt]) ifFalse:
[^self genSpecialSelectorSend].
argIsInt
ifTrue:
[self ssFlushTo: simStackPtr - 2.
(self ssValue: 1) popToReg: ReceiverResultReg.
- annotateInst := self ssTop annotateUse.
self ssPop: 2.
self MoveR: ReceiverResultReg R: TempReg]
ifFalse:
[self marshallSendArguments: 1.
self MoveR: Arg0Reg R: TempReg].
jumpNotSmallInts := (argIsInt or: [rcvrIsInt])
ifTrue: [objectRepresentation genJumpNotSmallIntegerInScratchReg: TempReg]
ifFalse: [objectRepresentation genJumpNotSmallIntegersIn: ReceiverResultReg andScratch: TempReg scratch: ClassReg].
primDescriptor opcode caseOf: {
[AddRR] -> [argIsInt
ifTrue:
+ [self AddCq: argInt - ConstZero R: ReceiverResultReg.
- [instToAnnotate := self AddCq: argInt - ConstZero R: ReceiverResultReg.
jumpContinue := self JumpNoOverflow: 0.
"overflow; must undo the damage before continuing"
self SubCq: argInt - ConstZero R: ReceiverResultReg]
ifFalse:
[objectRepresentation genRemoveSmallIntegerTagsInScratchReg: ReceiverResultReg.
self AddR: Arg0Reg R: ReceiverResultReg.
jumpContinue := self JumpNoOverflow: 0.
"overflow; must undo the damage before continuing"
rcvrIsInt
ifTrue: [self MoveCq: rcvrInt R: ReceiverResultReg]
ifFalse:
[self SubR: Arg0Reg R: ReceiverResultReg.
objectRepresentation genSetSmallIntegerTagsIn: ReceiverResultReg]]].
[SubRR] -> [argIsInt
ifTrue:
+ [self SubCq: argInt - ConstZero R: ReceiverResultReg.
- [instToAnnotate := self SubCq: argInt - ConstZero R: ReceiverResultReg.
jumpContinue := self JumpNoOverflow: 0.
"overflow; must undo the damage before continuing"
self AddCq: argInt - ConstZero R: ReceiverResultReg]
ifFalse:
[objectRepresentation genRemoveSmallIntegerTagsInScratchReg: Arg0Reg.
self SubR: Arg0Reg R: ReceiverResultReg.
jumpContinue := self JumpNoOverflow: 0.
"overflow; must undo the damage before continuing"
self AddR: Arg0Reg R: ReceiverResultReg.
objectRepresentation genSetSmallIntegerTagsIn: Arg0Reg]].
[AndRR] -> [argIsInt
+ ifTrue: [self AndCq: argInt R: ReceiverResultReg]
- ifTrue: [instToAnnotate := self AndCq: argInt R: ReceiverResultReg]
ifFalse: [self AndR: Arg0Reg R: ReceiverResultReg].
jumpContinue := self Jump: 0].
[OrRR] -> [argIsInt
+ ifTrue: [self OrCq: argInt R: ReceiverResultReg]
- ifTrue: [instToAnnotate := self OrCq: argInt R: ReceiverResultReg]
ifFalse: [self OrR: Arg0Reg R: ReceiverResultReg].
jumpContinue := self Jump: 0] }.
jumpNotSmallInts jmpTarget: self Label.
argIsInt ifTrue:
+ [self MoveCq: argInt R: Arg0Reg].
- [annotateInst ifTrue: [self annotateBytecode: instToAnnotate].
- self MoveCq: argInt R: Arg0Reg].
index := byte0 - self firstSpecialSelectorBytecodeOffset.
self genMarshalledSend: index negated - 1 numArgs: 1 sendTable: ordinarySendTrampolines.
jumpContinue jmpTarget: self Label.
^0!
Item was changed:
----- Method: StackToRegisterMappingCogit>>genSpecialSelectorComparison (in category 'bytecode generators') -----
genSpecialSelectorComparison
| nextPC postBranchPC targetBytecodePC primDescriptor branchDescriptor
+ rcvrIsInt argIsInt argInt jumpNotSmallInts inlineCAB index |
- rcvrIsInt argIsInt argInt jumpNotSmallInts inlineCAB annotateInst index |
<var: #primDescriptor type: #'BytecodeDescriptor *'>
<var: #branchDescriptor type: #'BytecodeDescriptor *'>
<var: #jumpNotSmallInts type: #'AbstractInstruction *'>
self ssFlushTo: simStackPtr - 2.
primDescriptor := self generatorAt: byte0.
argIsInt := self ssTop type = SSConstant
and: [objectMemory isIntegerObject: (argInt := self ssTop constant)].
rcvrIsInt := (self ssValue: 1) type = SSConstant
and: [objectMemory isIntegerObject: (self ssValue: 1) constant].
(argIsInt and: [rcvrIsInt]) ifTrue:
[^ self genStaticallyResolvedSpecialSelectorComparison].
self extractMaybeBranchDescriptorInto: [ :descr :next :postBranch :target |
branchDescriptor := descr. nextPC := next. postBranchPC := postBranch. targetBytecodePC := target ].
"Only interested in inlining if followed by a conditional branch."
inlineCAB := branchDescriptor isBranchTrue or: [branchDescriptor isBranchFalse].
"Further, only interested in inlining = and ~= if there's a SmallInteger constant involved.
The relational operators successfully statically predict SmallIntegers; the equality operators do not."
(inlineCAB and: [primDescriptor opcode = JumpZero or: [primDescriptor opcode = JumpNonZero]]) ifTrue:
[inlineCAB := argIsInt or: [rcvrIsInt]].
inlineCAB ifFalse:
[^self genSpecialSelectorSend].
argIsInt
ifTrue:
[(self ssValue: 1) popToReg: ReceiverResultReg.
- annotateInst := self ssTop annotateUse.
self ssPop: 2.
self MoveR: ReceiverResultReg R: TempReg]
ifFalse:
[self marshallSendArguments: 1.
self MoveR: Arg0Reg R: TempReg].
jumpNotSmallInts := (argIsInt or: [rcvrIsInt])
ifTrue: [objectRepresentation genJumpNotSmallIntegerInScratchReg: TempReg]
ifFalse: [objectRepresentation genJumpNotSmallIntegersIn: ReceiverResultReg andScratch: TempReg scratch: ClassReg].
argIsInt
+ ifTrue: [self CmpCq: argInt R: ReceiverResultReg]
- ifTrue: [annotateInst
- ifTrue: [self annotateBytecode: (self CmpCq: argInt R: ReceiverResultReg)]
- ifFalse: [self CmpCq: argInt R: ReceiverResultReg]]
ifFalse: [self CmpR: Arg0Reg R: ReceiverResultReg].
"Cmp is weird/backwards so invert the comparison. Further since there is a following conditional
jump bytecode define non-merge fixups and leave the cond bytecode to set the mergeness."
self genConditionalBranch: (branchDescriptor isBranchTrue
ifTrue: [primDescriptor opcode]
ifFalse: [self inverseBranchFor: primDescriptor opcode])
operand: (self ensureNonMergeFixupAt: targetBytecodePC - initialPC) asUnsignedInteger.
self Jump: (self ensureNonMergeFixupAt: postBranchPC - initialPC).
jumpNotSmallInts jmpTarget: self Label.
argIsInt ifTrue:
[self MoveCq: argInt R: Arg0Reg].
index := byte0 - self firstSpecialSelectorBytecodeOffset.
^self genMarshalledSend: index negated - 1 numArgs: 1 sendTable: ordinarySendTrampolines!
Item was changed:
----- Method: StackToRegisterMappingCogit>>genStaticallyResolvedSpecialSelectorComparison (in category 'bytecode generator support') -----
genStaticallyResolvedSpecialSelectorComparison
"Assumes both operands are ints"
<var: #primDescriptor type: #'BytecodeDescriptor *'>
| rcvrInt argInt primDescriptor result |
primDescriptor := self generatorAt: byte0.
argInt := self ssTop constant.
rcvrInt := (self ssValue: 1) constant.
self cCode: '' inSmalltalk: "In Simulator ints are unsigned..."
[rcvrInt := objectMemory integerValueOf: rcvrInt.
argInt := objectMemory integerValueOf: argInt].
primDescriptor opcode caseOf: {
[JumpLess] -> [result := rcvrInt < argInt].
[JumpLessOrEqual] -> [result := rcvrInt <= argInt].
[JumpGreater] -> [result := rcvrInt > argInt].
[JumpGreaterOrEqual] -> [result := rcvrInt >= argInt].
[JumpZero] -> [result := rcvrInt = argInt].
[JumpNonZero] -> [result := rcvrInt ~= argInt] }.
- "Must enter any annotatedConstants into the map"
- self annotateBytecodeIfAnnotated: (self ssValue: 1).
- self annotateBytecodeIfAnnotated: self ssTop.
"Must annotate the bytecode for correct pc mapping."
self ssPop: 2.
^self ssPushAnnotatedConstant: (result
ifTrue: [objectMemory trueObject]
ifFalse: [objectMemory falseObject])!
Item was changed:
----- Method: StackToRegisterMappingCogit>>initSimStackForFramefulMethod: (in category 'simulation stack') -----
initSimStackForFramefulMethod: startpc
<var: #desc type: #'CogSimStackEntry *'>
simSelf
type: SSBaseOffset;
spilled: true;
- annotateUse: false;
register: FPReg;
offset: FoxMFReceiver.
optStatus
isReceiverResultRegLive: false;
ssEntry: (self addressOf: simSelf).
simSpillBase := methodOrBlockNumTemps. "N.B. Includes num args"
simStackPtr := simSpillBase - 1.
"args"
0 to: methodOrBlockNumArgs - 1 do:
[:i| | desc |
desc := self simStackAt: i.
desc
type: SSBaseOffset;
spilled: true;
- annotateUse: false;
register: FPReg;
offset: FoxCallerSavedIP + ((methodOrBlockNumArgs - i) * objectMemory wordSize);
bcptr: startpc].
"temps"
methodOrBlockNumArgs to: simStackPtr do:
[:i| | desc |
desc := self simStackAt: i.
desc
type: SSBaseOffset;
spilled: true;
- annotateUse: false;
register: FPReg;
offset: FoxMFReceiver - (i - methodOrBlockNumArgs + 1 * objectMemory wordSize);
bcptr: startpc]!
Item was changed:
----- Method: StackToRegisterMappingCogit>>initSimStackForFramelessBlock: (in category 'simulation stack') -----
initSimStackForFramelessBlock: startpc
"The register receiver (the closure itself) and args are pushed by the closure value primitive(s)
and hence a frameless block has all arguments and copied values pushed to the stack. However,
the method receiver (self) is put in the ReceiverResultRegister by the block entry."
| desc |
<var: #desc type: #'CogSimStackEntry *'>
simSelf
type: SSRegister;
spilled: false;
- annotateUse: false;
register: ReceiverResultReg.
optStatus
isReceiverResultRegLive: true;
ssEntry: (self addressOf: simSelf).
self assert: methodOrBlockNumTemps >= methodOrBlockNumArgs.
0 to: methodOrBlockNumTemps - 1 do:
[:i|
desc := self simStackAt: i.
desc
type: SSBaseOffset;
spilled: true;
- annotateUse: false;
register: SPReg;
offset: ((backEnd hasLinkRegister
ifTrue: [methodOrBlockNumArgs - 1- i]
ifFalse: [methodOrBlockNumArgs - i]) * objectMemory wordSize);
bcptr: startpc].
simSpillBase := simStackPtr := methodOrBlockNumTemps - 1!
Item was changed:
----- Method: StackToRegisterMappingCogit>>initSimStackForFramelessMethod: (in category 'simulation stack') -----
initSimStackForFramelessMethod: startpc
| desc |
<var: #desc type: #'CogSimStackEntry *'>
simSelf
type: SSRegister;
spilled: false;
- annotateUse: false;
register: ReceiverResultReg.
optStatus
isReceiverResultRegLive: true;
ssEntry: (self addressOf: simSelf).
self assert: methodOrBlockNumTemps >= methodOrBlockNumArgs.
self assert: self numRegArgs <= 2.
(methodOrBlockNumArgs between: 1 and: self numRegArgs)
ifTrue:
[desc := self simStackAt: 0.
desc
type: SSRegister;
spilled: false;
- annotateUse: false;
register: Arg0Reg;
bcptr: startpc.
methodOrBlockNumArgs > 1 ifTrue:
[desc := self simStackAt: 1.
desc
type: SSRegister;
spilled: false;
- annotateUse: false;
register: Arg1Reg;
bcptr: startpc]]
ifFalse:
[0 to: methodOrBlockNumArgs - 1 do:
[:i|
desc := self simStackAt: i.
desc
type: SSBaseOffset;
register: SPReg;
spilled: true;
- annotateUse: false;
offset: ((backEnd hasLinkRegister
ifTrue: [methodOrBlockNumArgs - 1- i]
ifFalse: [methodOrBlockNumArgs - i]) * objectMemory wordSize);
bcptr: startpc]].
simSpillBase := simStackPtr := methodOrBlockNumArgs - 1!
Item was changed:
----- Method: StackToRegisterMappingCogit>>ssPushAnnotatedConstant: (in category 'simulation stack') -----
ssPushAnnotatedConstant: literal
self ssPush: 1.
self updateSimSpillBase.
self ssTop
type: SSConstant;
- annotateUse: true;
spilled: false;
constant: literal;
bcptr: bytecodePC.
+ self annotateBytecode: self Label.
^0!
Item was changed:
----- Method: StackToRegisterMappingCogit>>ssPushBase:offset: (in category 'simulation stack') -----
ssPushBase: reg offset: offset
self ssPush: 1.
self updateSimSpillBase.
self ssTop
type: SSBaseOffset;
spilled: false;
- annotateUse: false;
register: reg;
offset: offset;
bcptr: bytecodePC.
^0!
Item was changed:
----- Method: StackToRegisterMappingCogit>>ssPushConstant: (in category 'simulation stack') -----
ssPushConstant: literal
self ssPush: 1.
self updateSimSpillBase.
self ssTop
type: SSConstant;
spilled: false;
- annotateUse: false;
constant: literal;
bcptr: bytecodePC.
^0!
Item was changed:
----- Method: StackToRegisterMappingCogit>>ssPushDesc: (in category 'simulation stack') -----
ssPushDesc: simStackEntry
<var: #simStackEntry type: #SimStackEntry>
self cCode:
[simStackEntry type = SSSpill ifTrue:
[simStackEntry type: SSBaseOffset].
simStackEntry
spilled: false;
- annotateUse: false;
bcptr: bytecodePC.
simStack
at: (simStackPtr := simStackPtr + 1)
put: simStackEntry]
inSmalltalk:
[(simStack at: (simStackPtr := simStackPtr + 1))
copyFrom: simStackEntry;
type: (simStackEntry type = SSSpill
ifTrue: [SSBaseOffset]
ifFalse: [simStackEntry type]);
spilled: false;
- annotateUse: false;
bcptr: bytecodePC].
self updateSimSpillBase.
^0!
Item was changed:
----- Method: StackToRegisterMappingCogit>>ssPushRegister: (in category 'simulation stack') -----
ssPushRegister: reg
self ssPush: 1.
self updateSimSpillBase.
self ssTop
type: SSRegister;
spilled: false;
- annotateUse: false;
register: reg;
bcptr: bytecodePC.
^0!
Item was changed:
----- Method: StackToRegisterMappingCogit>>ssStorePop:toPreferredReg: (in category 'simulation stack') -----
ssStorePop: popBoolean toPreferredReg: preferredReg
"Store or pop the top simulated stack entry to a register.
Use preferredReg if the entry is not itself a register.
Answer the actual register the result ends up in."
| actualReg |
actualReg := preferredReg.
self ssTop type = SSRegister ifTrue:
+ [self assert: self ssTop spilled not.
+ actualReg := self ssTop register].
- [ self assert: self ssTop annotateUse not.
- self assert: self ssTop spilled not.
- actualReg := self ssTop register].
self ssStorePop: popBoolean toReg: actualReg. "generates nothing if ssTop is already in actualReg"
^ actualReg!
1
0