[Vm-dev] VM Maker: VMMaker.oscog-nice.1812.mcz

commits at source.squeak.org commits at source.squeak.org
Sat Apr 16 22:38:28 UTC 2016 

Nicolas Cellier uploaded a new version of VMMaker to project VM Maker:
http://source.squeak.org/VMMaker/VMMaker.oscog-nice.1812.mcz

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

Name: VMMaker.oscog-nice.1812
Author: nice
Time: 17 April 2016, 12:34:58.361 am
UUID: 7e94561e-6dca-48d9-99e6-206c528b632c
Ancestors: VMMaker.oscog-nice.1811

Revisit LargeIntegersPlugin and suppress the is:KindOf: way of testing if oops are kind of Integer.

The is for the benefit of primitive speed.

=============== Diff against VMMaker.oscog-nice.1811 ===============

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 fetchClassOf: firstInteger)
+ 				= interpreterProxy classLargePositiveInteger ifFalse: [^ interpreterProxy primitiveFail].
- 				= 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 fetchClassOf: secondInteger)
+ 				= interpreterProxy classLargePositiveInteger ifFalse: [^ interpreterProxy primitiveFail].
- 				= 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>>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>>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 ).
- 				parameters: #(#SmallInteger #SmallInteger )
- 				receiver: #Integer.
  	(interpreterProxy isIntegerObject: integer)
  		ifTrue: ["convert it to a not normalized LargeInteger"
  			large := self createLargeFromSmallInteger: integer]
+ 		ifFalse:
+ 			[(self isLargeIntegerOop: integer) ifFalse: [^interpreterProxy primitiveFail].
+ 			large := integer].
- 		ifFalse: [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'.
- 	firstInteger := self
- 				primitive: 'primDigitAdd'
- 				parameters: #(Integer )
- 				receiver: #Integer.
  	(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:
+ 			[(self isLargeIntegerOop: firstInteger) ifFalse: [^interpreterProxy primitiveFail].
+ 			firstLarge := firstInteger].
- 		ifFalse: [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:
+ 			[(self isLargeIntegerOop: secondInteger) ifFalse: [^interpreterProxy primitiveFail].
+ 			secondLarge := secondInteger].
- 		ifFalse: [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'.
- 	firstInteger := self
- 				primitive: 'primDigitBitAnd'
- 				parameters: #(Integer )
- 				receiver: #Integer.
  	^ 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'.
- 	firstInteger := self
- 				primitive: 'primDigitBitOr'
- 				parameters: #(Integer )
- 				receiver: #Integer.
  	^ 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 ).
- 				parameters: #(#SmallInteger )
- 				receiver: #Integer.
  	(interpreterProxy isIntegerObject: anInteger)
+ 		ifTrue:
+ 			["convert it to a not normalized LargeInteger"
- 		ifTrue: ["convert it to a not normalized LargeInteger"
  			aLarge := self createLargeFromSmallInteger: anInteger]
+ 		ifFalse:
+ 			[(self isLargeIntegerOop: anInteger) ifFalse: [^interpreterProxy primitiveFail].
+ 			aLarge := anInteger].
- 		ifFalse: [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'.
- 	firstInteger := self
- 				primitive: 'primDigitBitXor'
- 				parameters: #(Integer )
- 				receiver: #Integer.
  	^ self
  		digitBitLogic: firstInteger
  		with: secondInteger
  		opIndex: xorOpIndex!

Item was changed:
  ----- Method: LargeIntegersPlugin>>primDigitCompare: (in category 'Integer primitives') -----
  primDigitCompare: secondInteger 
  	| firstVal secondVal firstInteger firstIsSmall secondIsSmall |
  	self debugCode: [self msg: 'primDigitCompare: secondInteger'].
  	firstInteger := self primitive: 'primDigitCompare'.
  	"shortcut: aSmallInteger has to be smaller in Magnitude as aLargeInteger"
  	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 ifFalse: [(self isLargeIntegerOop: firstInteger) ifFalse: [^self primitiveFail]].
- 	secondIsSmall ifFalse: [(self isLargeIntegerOop: secondInteger) ifFalse: [^self 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: 
  					[^ -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: #(#Oop #Boolean ).
- 				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"
- 		ifTrue: ["convert to LargeInteger"
  			self
  				remapOop: secondInteger
  				in: [firstAsLargeInteger := self createLargeFromSmallInteger: firstInteger]]
+ 		ifFalse:
+ 			[(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].
- 		ifFalse: [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:
+ 			[(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].
- 		ifFalse: [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: #(#Oop #Boolean ).
- 				parameters: #(#Integer #Boolean )
- 				receiver: #Integer.
  	(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:
+ 			[(self isLargeIntegerOop: firstInteger) ifFalse: [^interpreterProxy primitiveFail].
+ 			firstLarge := firstInteger].
- 		ifFalse: [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:
+ 			[(self isLargeIntegerOop: secondInteger) ifFalse: [^interpreterProxy primitiveFail].
+ 			secondLarge := secondInteger].
- 		ifFalse: [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'.
- 	firstInteger := self
- 				primitive: 'primDigitSubtract'
- 				parameters: #(#Integer )
- 				receiver: #Integer.
  	(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:
+ 			[(self isLargeIntegerOop: firstInteger) ifFalse: [^interpreterProxy primitiveFail].
+ 			firstLarge := firstInteger].
- 		ifFalse: [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:
+ 			[(self isLargeIntegerOop: firstInteger) ifFalse: [^interpreterProxy primitiveFail].
+ 			secondLarge := secondInteger].
- 		ifFalse: [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'.
- 	self
- 				primitive: 'primMontgomeryDigitLength'
- 				parameters: #()
- 				receiver: #Integer.
  	^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'.
+ 	mInv := interpreterProxy positive32BitValueOf: mInverseInteger.
- 	firstInteger := self
- 				primitive: 'primMontgomeryTimesModulo'
- 				parameters: #(Integer Integer Integer )
- 				receiver: #Integer.
- 	 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:
+ 			[(self isLargeIntegerOop: firstInteger) ifFalse: [^interpreterProxy primitiveFail].
+ 			firstLarge := firstInteger].
- 		ifFalse: [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:
+ 			[(self isLargeIntegerOop: secondOperandInteger) ifFalse: [^interpreterProxy primitiveFail].
+ 			secondLarge := secondOperandInteger].
- 		ifFalse: [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:
+ 			[(self isLargeIntegerOop: thirdModuloInteger) ifFalse: [^interpreterProxy primitiveFail].
+ 			thirdLarge := thirdModuloInteger].
- 		ifFalse: [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'.
+ 	(interpreterProxy fetchClassOf: rcvr) == interpreterProxy classLargeNegativeInteger ifFalse: [^interpreterProxy primitiveFail].
- 	rcvr := self
- 				primitive: 'primNormalizeNegative'
- 				parameters: #()
- 				receiver: #LargeNegativeInteger.
  	^ self normalizeNegative: rcvr!

Item was changed:
  ----- Method: LargeIntegersPlugin>>primNormalizePositive (in category 'Integer primitives') -----
  primNormalizePositive
  	| rcvr |
  	self debugCode: [self msg: 'primNormalizePositive'].
+ 	rcvr := self primitive: 'primNormalizePositive'.
+ 	(interpreterProxy fetchClassOf: rcvr) == interpreterProxy classLargePositiveInteger ifFalse: [^interpreterProxy primitiveFail].
- 	rcvr := self
- 				primitive: 'primNormalizePositive'
- 				parameters: #()
- 				receiver: #LargePositiveInteger.
  	^ self normalizePositive: rcvr!

More information about the Vm-dev mailing list