From: simonmar Date: Wed, 8 Dec 1999 14:22:00 +0000 (+0000) Subject: [project @ 1999-12-08 14:21:52 by simonmar] X-Git-Tag: Approximately_9120_patches~5398 X-Git-Url: http://git.megacz.com/?a=commitdiff_plain;h=9c370d695ac7b7b7108440b028b017459ae5ef02;p=ghc-hetmet.git [project @ 1999-12-08 14:21:52 by simonmar] Add Marc Van Dongen's Integer improvements. Specifically: - new primops: gcdInt#, gcdIntegerInt#, divExact#, quotInteger#, remInteger#. - new definitions of quot and rem for Integer in PrelNum (using the new quotInteger# and remInteger# primops instead of quotRemInteger#). Should be slightly faster than before. div & mod aren't likewise optimised (yet). - specialisations of gcd for Int and Integer, and lcm for Integer in PrelNum. --- diff --git a/ghc/compiler/prelude/PrimOp.lhs b/ghc/compiler/prelude/PrimOp.lhs index ad858b2..54f4b01 100644 --- a/ghc/compiler/prelude/PrimOp.lhs +++ b/ghc/compiler/prelude/PrimOp.lhs @@ -78,6 +78,7 @@ data PrimOp | IntAddCOp | IntSubCOp | IntMulCOp + | IntGcdOp -- Word#-related ops: | WordQuotOp | WordRemOp @@ -117,6 +118,8 @@ data PrimOp -- slightly weird -- to match GMP package. | IntegerAddOp | IntegerSubOp | IntegerMulOp | IntegerGcdOp | IntegerQuotRemOp | IntegerDivModOp | IntegerNegOp + | IntegerIntGcdOp | IntegerDivExactOp + | IntegerQuotOp | IntegerRemOp | IntegerCmpOp | IntegerCmpIntOp @@ -351,221 +354,213 @@ tagOf_PrimOp IntAddOp = ILIT( 39) tagOf_PrimOp IntSubOp = ILIT( 40) tagOf_PrimOp IntMulOp = ILIT( 41) tagOf_PrimOp IntQuotOp = ILIT( 42) -tagOf_PrimOp IntRemOp = ILIT( 43) -tagOf_PrimOp IntNegOp = ILIT( 44) -tagOf_PrimOp IntAbsOp = ILIT( 45) -tagOf_PrimOp WordQuotOp = ILIT( 46) -tagOf_PrimOp WordRemOp = ILIT( 47) -tagOf_PrimOp AndOp = ILIT( 48) -tagOf_PrimOp OrOp = ILIT( 49) -tagOf_PrimOp NotOp = ILIT( 50) -tagOf_PrimOp XorOp = ILIT( 51) -tagOf_PrimOp SllOp = ILIT( 52) -tagOf_PrimOp SrlOp = ILIT( 53) -tagOf_PrimOp ISllOp = ILIT( 54) -tagOf_PrimOp ISraOp = ILIT( 55) -tagOf_PrimOp ISrlOp = ILIT( 56) -tagOf_PrimOp IntAddCOp = ILIT( 57) -tagOf_PrimOp IntSubCOp = ILIT( 58) -tagOf_PrimOp IntMulCOp = ILIT( 59) -tagOf_PrimOp Int2WordOp = ILIT( 60) -tagOf_PrimOp Word2IntOp = ILIT( 61) -tagOf_PrimOp Int2AddrOp = ILIT( 62) -tagOf_PrimOp Addr2IntOp = ILIT( 63) - -tagOf_PrimOp FloatAddOp = ILIT( 64) -tagOf_PrimOp FloatSubOp = ILIT( 65) -tagOf_PrimOp FloatMulOp = ILIT( 66) -tagOf_PrimOp FloatDivOp = ILIT( 67) -tagOf_PrimOp FloatNegOp = ILIT( 68) -tagOf_PrimOp Float2IntOp = ILIT( 69) -tagOf_PrimOp Int2FloatOp = ILIT( 70) -tagOf_PrimOp FloatExpOp = ILIT( 71) -tagOf_PrimOp FloatLogOp = ILIT( 72) -tagOf_PrimOp FloatSqrtOp = ILIT( 73) -tagOf_PrimOp FloatSinOp = ILIT( 74) -tagOf_PrimOp FloatCosOp = ILIT( 75) -tagOf_PrimOp FloatTanOp = ILIT( 76) -tagOf_PrimOp FloatAsinOp = ILIT( 77) -tagOf_PrimOp FloatAcosOp = ILIT( 78) -tagOf_PrimOp FloatAtanOp = ILIT( 79) -tagOf_PrimOp FloatSinhOp = ILIT( 80) -tagOf_PrimOp FloatCoshOp = ILIT( 81) -tagOf_PrimOp FloatTanhOp = ILIT( 82) -tagOf_PrimOp FloatPowerOp = ILIT( 83) - -tagOf_PrimOp DoubleAddOp = ILIT( 84) -tagOf_PrimOp DoubleSubOp = ILIT( 85) -tagOf_PrimOp DoubleMulOp = ILIT( 86) -tagOf_PrimOp DoubleDivOp = ILIT( 87) -tagOf_PrimOp DoubleNegOp = ILIT( 88) -tagOf_PrimOp Double2IntOp = ILIT( 89) -tagOf_PrimOp Int2DoubleOp = ILIT( 90) -tagOf_PrimOp Double2FloatOp = ILIT( 91) -tagOf_PrimOp Float2DoubleOp = ILIT( 92) -tagOf_PrimOp DoubleExpOp = ILIT( 93) -tagOf_PrimOp DoubleLogOp = ILIT( 94) -tagOf_PrimOp DoubleSqrtOp = ILIT( 95) -tagOf_PrimOp DoubleSinOp = ILIT( 96) -tagOf_PrimOp DoubleCosOp = ILIT( 97) -tagOf_PrimOp DoubleTanOp = ILIT( 98) -tagOf_PrimOp DoubleAsinOp = ILIT( 99) -tagOf_PrimOp DoubleAcosOp = ILIT(100) -tagOf_PrimOp DoubleAtanOp = ILIT(101) -tagOf_PrimOp DoubleSinhOp = ILIT(102) -tagOf_PrimOp DoubleCoshOp = ILIT(103) -tagOf_PrimOp DoubleTanhOp = ILIT(104) -tagOf_PrimOp DoublePowerOp = ILIT(105) - -tagOf_PrimOp IntegerAddOp = ILIT(106) -tagOf_PrimOp IntegerSubOp = ILIT(107) -tagOf_PrimOp IntegerMulOp = ILIT(108) -tagOf_PrimOp IntegerGcdOp = ILIT(109) -tagOf_PrimOp IntegerQuotRemOp = ILIT(110) -tagOf_PrimOp IntegerDivModOp = ILIT(111) -tagOf_PrimOp IntegerNegOp = ILIT(112) -tagOf_PrimOp IntegerCmpOp = ILIT(113) -tagOf_PrimOp IntegerCmpIntOp = ILIT(114) -tagOf_PrimOp Integer2IntOp = ILIT(115) -tagOf_PrimOp Integer2WordOp = ILIT(116) -tagOf_PrimOp Int2IntegerOp = ILIT(117) -tagOf_PrimOp Word2IntegerOp = ILIT(118) -tagOf_PrimOp Addr2IntegerOp = ILIT(119) -tagOf_PrimOp IntegerToInt64Op = ILIT(120) -tagOf_PrimOp Int64ToIntegerOp = ILIT(121) -tagOf_PrimOp IntegerToWord64Op = ILIT(122) -tagOf_PrimOp Word64ToIntegerOp = ILIT(123) -tagOf_PrimOp FloatDecodeOp = ILIT(125) -tagOf_PrimOp DoubleDecodeOp = ILIT(127) - -tagOf_PrimOp NewArrayOp = ILIT(128) -tagOf_PrimOp (NewByteArrayOp CharRep) = ILIT(129) -tagOf_PrimOp (NewByteArrayOp IntRep) = ILIT(130) -tagOf_PrimOp (NewByteArrayOp WordRep) = ILIT(131) -tagOf_PrimOp (NewByteArrayOp AddrRep) = ILIT(132) -tagOf_PrimOp (NewByteArrayOp FloatRep) = ILIT(133) -tagOf_PrimOp (NewByteArrayOp DoubleRep) = ILIT(134) -tagOf_PrimOp (NewByteArrayOp StablePtrRep) = ILIT(135) - -tagOf_PrimOp SameMutableArrayOp = ILIT(136) -tagOf_PrimOp SameMutableByteArrayOp = ILIT(137) -tagOf_PrimOp ReadArrayOp = ILIT(138) -tagOf_PrimOp WriteArrayOp = ILIT(139) -tagOf_PrimOp IndexArrayOp = ILIT(140) - -tagOf_PrimOp (ReadByteArrayOp CharRep) = ILIT(141) -tagOf_PrimOp (ReadByteArrayOp IntRep) = ILIT(142) -tagOf_PrimOp (ReadByteArrayOp WordRep) = ILIT(143) -tagOf_PrimOp (ReadByteArrayOp AddrRep) = ILIT(144) -tagOf_PrimOp (ReadByteArrayOp FloatRep) = ILIT(145) -tagOf_PrimOp (ReadByteArrayOp DoubleRep) = ILIT(146) -tagOf_PrimOp (ReadByteArrayOp StablePtrRep) = ILIT(147) -tagOf_PrimOp (ReadByteArrayOp Int64Rep) = ILIT(148) -tagOf_PrimOp (ReadByteArrayOp Word64Rep) = ILIT(149) - -tagOf_PrimOp (WriteByteArrayOp CharRep) = ILIT(150) -tagOf_PrimOp (WriteByteArrayOp IntRep) = ILIT(151) -tagOf_PrimOp (WriteByteArrayOp WordRep) = ILIT(152) -tagOf_PrimOp (WriteByteArrayOp AddrRep) = ILIT(153) -tagOf_PrimOp (WriteByteArrayOp FloatRep) = ILIT(154) -tagOf_PrimOp (WriteByteArrayOp DoubleRep) = ILIT(155) -tagOf_PrimOp (WriteByteArrayOp StablePtrRep) = ILIT(156) -tagOf_PrimOp (WriteByteArrayOp Int64Rep) = ILIT(157) -tagOf_PrimOp (WriteByteArrayOp Word64Rep) = ILIT(158) - -tagOf_PrimOp (IndexByteArrayOp CharRep) = ILIT(159) -tagOf_PrimOp (IndexByteArrayOp IntRep) = ILIT(160) -tagOf_PrimOp (IndexByteArrayOp WordRep) = ILIT(161) -tagOf_PrimOp (IndexByteArrayOp AddrRep) = ILIT(162) -tagOf_PrimOp (IndexByteArrayOp FloatRep) = ILIT(163) -tagOf_PrimOp (IndexByteArrayOp DoubleRep) = ILIT(164) -tagOf_PrimOp (IndexByteArrayOp StablePtrRep) = ILIT(165) -tagOf_PrimOp (IndexByteArrayOp Int64Rep) = ILIT(166) -tagOf_PrimOp (IndexByteArrayOp Word64Rep) = ILIT(167) - -tagOf_PrimOp (IndexOffAddrOp CharRep) = ILIT(168) -tagOf_PrimOp (IndexOffAddrOp IntRep) = ILIT(169) -tagOf_PrimOp (IndexOffAddrOp WordRep) = ILIT(170) -tagOf_PrimOp (IndexOffAddrOp AddrRep) = ILIT(171) -tagOf_PrimOp (IndexOffAddrOp FloatRep) = ILIT(172) -tagOf_PrimOp (IndexOffAddrOp DoubleRep) = ILIT(173) -tagOf_PrimOp (IndexOffAddrOp StablePtrRep) = ILIT(174) -tagOf_PrimOp (IndexOffAddrOp Int64Rep) = ILIT(175) -tagOf_PrimOp (IndexOffAddrOp Word64Rep) = ILIT(176) - -tagOf_PrimOp (IndexOffForeignObjOp CharRep) = ILIT(177) -tagOf_PrimOp (IndexOffForeignObjOp IntRep) = ILIT(178) -tagOf_PrimOp (IndexOffForeignObjOp WordRep) = ILIT(179) -tagOf_PrimOp (IndexOffForeignObjOp AddrRep) = ILIT(180) -tagOf_PrimOp (IndexOffForeignObjOp FloatRep) = ILIT(181) -tagOf_PrimOp (IndexOffForeignObjOp DoubleRep) = ILIT(182) -tagOf_PrimOp (IndexOffForeignObjOp StablePtrRep) = ILIT(183) -tagOf_PrimOp (IndexOffForeignObjOp Int64Rep) = ILIT(184) -tagOf_PrimOp (IndexOffForeignObjOp Word64Rep) = ILIT(185) - -tagOf_PrimOp (WriteOffAddrOp CharRep) = ILIT(186) -tagOf_PrimOp (WriteOffAddrOp IntRep) = ILIT(187) -tagOf_PrimOp (WriteOffAddrOp WordRep) = ILIT(188) -tagOf_PrimOp (WriteOffAddrOp AddrRep) = ILIT(189) -tagOf_PrimOp (WriteOffAddrOp FloatRep) = ILIT(190) -tagOf_PrimOp (WriteOffAddrOp DoubleRep) = ILIT(191) -tagOf_PrimOp (WriteOffAddrOp StablePtrRep) = ILIT(192) -tagOf_PrimOp (WriteOffAddrOp ForeignObjRep) = ILIT(193) -tagOf_PrimOp (WriteOffAddrOp Int64Rep) = ILIT(194) -tagOf_PrimOp (WriteOffAddrOp Word64Rep) = ILIT(195) - -tagOf_PrimOp UnsafeFreezeArrayOp = ILIT(196) -tagOf_PrimOp UnsafeFreezeByteArrayOp = ILIT(197) -tagOf_PrimOp UnsafeThawArrayOp = ILIT(198) -tagOf_PrimOp UnsafeThawByteArrayOp = ILIT(199) -tagOf_PrimOp SizeofByteArrayOp = ILIT(200) -tagOf_PrimOp SizeofMutableByteArrayOp = ILIT(201) - -tagOf_PrimOp NewMVarOp = ILIT(202) -tagOf_PrimOp TakeMVarOp = ILIT(203) -tagOf_PrimOp PutMVarOp = ILIT(204) -tagOf_PrimOp SameMVarOp = ILIT(205) -tagOf_PrimOp IsEmptyMVarOp = ILIT(206) -tagOf_PrimOp MakeForeignObjOp = ILIT(207) -tagOf_PrimOp WriteForeignObjOp = ILIT(208) -tagOf_PrimOp MkWeakOp = ILIT(209) -tagOf_PrimOp DeRefWeakOp = ILIT(210) -tagOf_PrimOp FinalizeWeakOp = ILIT(211) -tagOf_PrimOp MakeStableNameOp = ILIT(212) -tagOf_PrimOp EqStableNameOp = ILIT(213) -tagOf_PrimOp StableNameToIntOp = ILIT(214) -tagOf_PrimOp MakeStablePtrOp = ILIT(215) -tagOf_PrimOp DeRefStablePtrOp = ILIT(216) -tagOf_PrimOp EqStablePtrOp = ILIT(217) -tagOf_PrimOp (CCallOp _ _ _ _) = ILIT(218) -tagOf_PrimOp ReallyUnsafePtrEqualityOp = ILIT(219) -tagOf_PrimOp SeqOp = ILIT(220) -tagOf_PrimOp ParOp = ILIT(221) -tagOf_PrimOp ForkOp = ILIT(222) -tagOf_PrimOp KillThreadOp = ILIT(223) -tagOf_PrimOp YieldOp = ILIT(224) -tagOf_PrimOp MyThreadIdOp = ILIT(225) -tagOf_PrimOp DelayOp = ILIT(226) -tagOf_PrimOp WaitReadOp = ILIT(227) -tagOf_PrimOp WaitWriteOp = ILIT(228) -tagOf_PrimOp ParGlobalOp = ILIT(229) -tagOf_PrimOp ParLocalOp = ILIT(230) -tagOf_PrimOp ParAtOp = ILIT(231) -tagOf_PrimOp ParAtAbsOp = ILIT(232) -tagOf_PrimOp ParAtRelOp = ILIT(233) -tagOf_PrimOp ParAtForNowOp = ILIT(234) -tagOf_PrimOp CopyableOp = ILIT(235) -tagOf_PrimOp NoFollowOp = ILIT(236) -tagOf_PrimOp NewMutVarOp = ILIT(237) -tagOf_PrimOp ReadMutVarOp = ILIT(238) -tagOf_PrimOp WriteMutVarOp = ILIT(239) -tagOf_PrimOp SameMutVarOp = ILIT(240) -tagOf_PrimOp CatchOp = ILIT(241) -tagOf_PrimOp RaiseOp = ILIT(242) -tagOf_PrimOp BlockAsyncExceptionsOp = ILIT(243) -tagOf_PrimOp UnblockAsyncExceptionsOp = ILIT(244) -tagOf_PrimOp DataToTagOp = ILIT(245) -tagOf_PrimOp TagToEnumOp = ILIT(246) +tagOf_PrimOp IntGcdOp = ILIT( 43) +tagOf_PrimOp IntRemOp = ILIT( 44) +tagOf_PrimOp IntNegOp = ILIT( 45) +tagOf_PrimOp IntAbsOp = ILIT( 46) +tagOf_PrimOp WordQuotOp = ILIT( 47) +tagOf_PrimOp WordRemOp = ILIT( 48) +tagOf_PrimOp AndOp = ILIT( 49) +tagOf_PrimOp OrOp = ILIT( 50) +tagOf_PrimOp NotOp = ILIT( 51) +tagOf_PrimOp XorOp = ILIT( 52) +tagOf_PrimOp SllOp = ILIT( 53) +tagOf_PrimOp SrlOp = ILIT( 54) +tagOf_PrimOp ISllOp = ILIT( 55) +tagOf_PrimOp ISraOp = ILIT( 56) +tagOf_PrimOp ISrlOp = ILIT( 57) +tagOf_PrimOp IntAddCOp = ILIT( 58) +tagOf_PrimOp IntSubCOp = ILIT( 59) +tagOf_PrimOp IntMulCOp = ILIT( 60) +tagOf_PrimOp Int2WordOp = ILIT( 61) +tagOf_PrimOp Word2IntOp = ILIT( 62) +tagOf_PrimOp Int2AddrOp = ILIT( 63) +tagOf_PrimOp Addr2IntOp = ILIT( 64) +tagOf_PrimOp FloatAddOp = ILIT( 65) +tagOf_PrimOp FloatSubOp = ILIT( 66) +tagOf_PrimOp FloatMulOp = ILIT( 67) +tagOf_PrimOp FloatDivOp = ILIT( 68) +tagOf_PrimOp FloatNegOp = ILIT( 69) +tagOf_PrimOp Float2IntOp = ILIT( 70) +tagOf_PrimOp Int2FloatOp = ILIT( 71) +tagOf_PrimOp FloatExpOp = ILIT( 72) +tagOf_PrimOp FloatLogOp = ILIT( 73) +tagOf_PrimOp FloatSqrtOp = ILIT( 74) +tagOf_PrimOp FloatSinOp = ILIT( 75) +tagOf_PrimOp FloatCosOp = ILIT( 76) +tagOf_PrimOp FloatTanOp = ILIT( 77) +tagOf_PrimOp FloatAsinOp = ILIT( 78) +tagOf_PrimOp FloatAcosOp = ILIT( 79) +tagOf_PrimOp FloatAtanOp = ILIT( 80) +tagOf_PrimOp FloatSinhOp = ILIT( 81) +tagOf_PrimOp FloatCoshOp = ILIT( 82) +tagOf_PrimOp FloatTanhOp = ILIT( 83) +tagOf_PrimOp FloatPowerOp = ILIT( 84) +tagOf_PrimOp DoubleAddOp = ILIT( 85) +tagOf_PrimOp DoubleSubOp = ILIT( 86) +tagOf_PrimOp DoubleMulOp = ILIT( 87) +tagOf_PrimOp DoubleDivOp = ILIT( 88) +tagOf_PrimOp DoubleNegOp = ILIT( 89) +tagOf_PrimOp Double2IntOp = ILIT( 90) +tagOf_PrimOp Int2DoubleOp = ILIT( 91) +tagOf_PrimOp Double2FloatOp = ILIT( 92) +tagOf_PrimOp Float2DoubleOp = ILIT( 93) +tagOf_PrimOp DoubleExpOp = ILIT( 94) +tagOf_PrimOp DoubleLogOp = ILIT( 95) +tagOf_PrimOp DoubleSqrtOp = ILIT( 96) +tagOf_PrimOp DoubleSinOp = ILIT( 97) +tagOf_PrimOp DoubleCosOp = ILIT( 98) +tagOf_PrimOp DoubleTanOp = ILIT( 99) +tagOf_PrimOp DoubleAsinOp = ILIT(100) +tagOf_PrimOp DoubleAcosOp = ILIT(101) +tagOf_PrimOp DoubleAtanOp = ILIT(102) +tagOf_PrimOp DoubleSinhOp = ILIT(103) +tagOf_PrimOp DoubleCoshOp = ILIT(104) +tagOf_PrimOp DoubleTanhOp = ILIT(105) +tagOf_PrimOp DoublePowerOp = ILIT(106) +tagOf_PrimOp IntegerAddOp = ILIT(107) +tagOf_PrimOp IntegerSubOp = ILIT(108) +tagOf_PrimOp IntegerMulOp = ILIT(109) +tagOf_PrimOp IntegerGcdOp = ILIT(110) +tagOf_PrimOp IntegerIntGcdOp = ILIT(111) +tagOf_PrimOp IntegerDivExactOp = ILIT(112) +tagOf_PrimOp IntegerQuotOp = ILIT(113) +tagOf_PrimOp IntegerRemOp = ILIT(114) +tagOf_PrimOp IntegerQuotRemOp = ILIT(115) +tagOf_PrimOp IntegerDivModOp = ILIT(116) +tagOf_PrimOp IntegerNegOp = ILIT(117) +tagOf_PrimOp IntegerCmpOp = ILIT(118) +tagOf_PrimOp IntegerCmpIntOp = ILIT(119) +tagOf_PrimOp Integer2IntOp = ILIT(120) +tagOf_PrimOp Integer2WordOp = ILIT(121) +tagOf_PrimOp Int2IntegerOp = ILIT(122) +tagOf_PrimOp Word2IntegerOp = ILIT(123) +tagOf_PrimOp Addr2IntegerOp = ILIT(125) +tagOf_PrimOp IntegerToInt64Op = ILIT(127) +tagOf_PrimOp Int64ToIntegerOp = ILIT(128) +tagOf_PrimOp IntegerToWord64Op = ILIT(129) +tagOf_PrimOp Word64ToIntegerOp = ILIT(130) +tagOf_PrimOp FloatDecodeOp = ILIT(131) +tagOf_PrimOp DoubleDecodeOp = ILIT(132) +tagOf_PrimOp NewArrayOp = ILIT(133) +tagOf_PrimOp (NewByteArrayOp CharRep) = ILIT(134) +tagOf_PrimOp (NewByteArrayOp IntRep) = ILIT(135) +tagOf_PrimOp (NewByteArrayOp WordRep) = ILIT(136) +tagOf_PrimOp (NewByteArrayOp AddrRep) = ILIT(137) +tagOf_PrimOp (NewByteArrayOp FloatRep) = ILIT(138) +tagOf_PrimOp (NewByteArrayOp DoubleRep) = ILIT(139) +tagOf_PrimOp (NewByteArrayOp StablePtrRep) = ILIT(140) +tagOf_PrimOp SameMutableArrayOp = ILIT(141) +tagOf_PrimOp SameMutableByteArrayOp = ILIT(142) +tagOf_PrimOp ReadArrayOp = ILIT(143) +tagOf_PrimOp WriteArrayOp = ILIT(144) +tagOf_PrimOp IndexArrayOp = ILIT(145) +tagOf_PrimOp (ReadByteArrayOp CharRep) = ILIT(146) +tagOf_PrimOp (ReadByteArrayOp IntRep) = ILIT(147) +tagOf_PrimOp (ReadByteArrayOp WordRep) = ILIT(148) +tagOf_PrimOp (ReadByteArrayOp AddrRep) = ILIT(149) +tagOf_PrimOp (ReadByteArrayOp FloatRep) = ILIT(150) +tagOf_PrimOp (ReadByteArrayOp DoubleRep) = ILIT(151) +tagOf_PrimOp (ReadByteArrayOp StablePtrRep) = ILIT(152) +tagOf_PrimOp (ReadByteArrayOp Int64Rep) = ILIT(153) +tagOf_PrimOp (ReadByteArrayOp Word64Rep) = ILIT(154) +tagOf_PrimOp (WriteByteArrayOp CharRep) = ILIT(155) +tagOf_PrimOp (WriteByteArrayOp IntRep) = ILIT(156) +tagOf_PrimOp (WriteByteArrayOp WordRep) = ILIT(157) +tagOf_PrimOp (WriteByteArrayOp AddrRep) = ILIT(158) +tagOf_PrimOp (WriteByteArrayOp FloatRep) = ILIT(159) +tagOf_PrimOp (WriteByteArrayOp DoubleRep) = ILIT(160) +tagOf_PrimOp (WriteByteArrayOp StablePtrRep) = ILIT(161) +tagOf_PrimOp (WriteByteArrayOp Int64Rep) = ILIT(162) +tagOf_PrimOp (WriteByteArrayOp Word64Rep) = ILIT(163) +tagOf_PrimOp (IndexByteArrayOp CharRep) = ILIT(164) +tagOf_PrimOp (IndexByteArrayOp IntRep) = ILIT(165) +tagOf_PrimOp (IndexByteArrayOp WordRep) = ILIT(166) +tagOf_PrimOp (IndexByteArrayOp AddrRep) = ILIT(167) +tagOf_PrimOp (IndexByteArrayOp FloatRep) = ILIT(168) +tagOf_PrimOp (IndexByteArrayOp DoubleRep) = ILIT(169) +tagOf_PrimOp (IndexByteArrayOp StablePtrRep) = ILIT(170) +tagOf_PrimOp (IndexByteArrayOp Int64Rep) = ILIT(171) +tagOf_PrimOp (IndexByteArrayOp Word64Rep) = ILIT(172) +tagOf_PrimOp (IndexOffAddrOp CharRep) = ILIT(173) +tagOf_PrimOp (IndexOffAddrOp IntRep) = ILIT(174) +tagOf_PrimOp (IndexOffAddrOp WordRep) = ILIT(175) +tagOf_PrimOp (IndexOffAddrOp AddrRep) = ILIT(176) +tagOf_PrimOp (IndexOffAddrOp FloatRep) = ILIT(177) +tagOf_PrimOp (IndexOffAddrOp DoubleRep) = ILIT(178) +tagOf_PrimOp (IndexOffAddrOp StablePtrRep) = ILIT(179) +tagOf_PrimOp (IndexOffAddrOp Int64Rep) = ILIT(180) +tagOf_PrimOp (IndexOffAddrOp Word64Rep) = ILIT(181) +tagOf_PrimOp (IndexOffForeignObjOp CharRep) = ILIT(182) +tagOf_PrimOp (IndexOffForeignObjOp IntRep) = ILIT(183) +tagOf_PrimOp (IndexOffForeignObjOp WordRep) = ILIT(184) +tagOf_PrimOp (IndexOffForeignObjOp AddrRep) = ILIT(185) +tagOf_PrimOp (IndexOffForeignObjOp FloatRep) = ILIT(186) +tagOf_PrimOp (IndexOffForeignObjOp DoubleRep) = ILIT(187) +tagOf_PrimOp (IndexOffForeignObjOp StablePtrRep) = ILIT(188) +tagOf_PrimOp (IndexOffForeignObjOp Int64Rep) = ILIT(189) +tagOf_PrimOp (IndexOffForeignObjOp Word64Rep) = ILIT(190) +tagOf_PrimOp (WriteOffAddrOp CharRep) = ILIT(191) +tagOf_PrimOp (WriteOffAddrOp IntRep) = ILIT(192) +tagOf_PrimOp (WriteOffAddrOp WordRep) = ILIT(193) +tagOf_PrimOp (WriteOffAddrOp AddrRep) = ILIT(194) +tagOf_PrimOp (WriteOffAddrOp FloatRep) = ILIT(195) +tagOf_PrimOp (WriteOffAddrOp DoubleRep) = ILIT(196) +tagOf_PrimOp (WriteOffAddrOp StablePtrRep) = ILIT(197) +tagOf_PrimOp (WriteOffAddrOp ForeignObjRep) = ILIT(198) +tagOf_PrimOp (WriteOffAddrOp Int64Rep) = ILIT(199) +tagOf_PrimOp (WriteOffAddrOp Word64Rep) = ILIT(200) +tagOf_PrimOp UnsafeFreezeArrayOp = ILIT(201) +tagOf_PrimOp UnsafeFreezeByteArrayOp = ILIT(202) +tagOf_PrimOp UnsafeThawArrayOp = ILIT(203) +tagOf_PrimOp UnsafeThawByteArrayOp = ILIT(204) +tagOf_PrimOp SizeofByteArrayOp = ILIT(205) +tagOf_PrimOp SizeofMutableByteArrayOp = ILIT(206) +tagOf_PrimOp NewMVarOp = ILIT(207) +tagOf_PrimOp TakeMVarOp = ILIT(208) +tagOf_PrimOp PutMVarOp = ILIT(209) +tagOf_PrimOp SameMVarOp = ILIT(210) +tagOf_PrimOp IsEmptyMVarOp = ILIT(211) +tagOf_PrimOp MakeForeignObjOp = ILIT(212) +tagOf_PrimOp WriteForeignObjOp = ILIT(213) +tagOf_PrimOp MkWeakOp = ILIT(214) +tagOf_PrimOp DeRefWeakOp = ILIT(215) +tagOf_PrimOp FinalizeWeakOp = ILIT(216) +tagOf_PrimOp MakeStableNameOp = ILIT(217) +tagOf_PrimOp EqStableNameOp = ILIT(218) +tagOf_PrimOp StableNameToIntOp = ILIT(219) +tagOf_PrimOp MakeStablePtrOp = ILIT(220) +tagOf_PrimOp DeRefStablePtrOp = ILIT(221) +tagOf_PrimOp EqStablePtrOp = ILIT(222) +tagOf_PrimOp (CCallOp _ _ _ _) = ILIT(223) +tagOf_PrimOp ReallyUnsafePtrEqualityOp = ILIT(224) +tagOf_PrimOp SeqOp = ILIT(225) +tagOf_PrimOp ParOp = ILIT(226) +tagOf_PrimOp ForkOp = ILIT(227) +tagOf_PrimOp KillThreadOp = ILIT(228) +tagOf_PrimOp YieldOp = ILIT(229) +tagOf_PrimOp MyThreadIdOp = ILIT(230) +tagOf_PrimOp DelayOp = ILIT(231) +tagOf_PrimOp WaitReadOp = ILIT(232) +tagOf_PrimOp WaitWriteOp = ILIT(233) +tagOf_PrimOp ParGlobalOp = ILIT(234) +tagOf_PrimOp ParLocalOp = ILIT(235) +tagOf_PrimOp ParAtOp = ILIT(236) +tagOf_PrimOp ParAtAbsOp = ILIT(237) +tagOf_PrimOp ParAtRelOp = ILIT(238) +tagOf_PrimOp ParAtForNowOp = ILIT(239) +tagOf_PrimOp CopyableOp = ILIT(240) +tagOf_PrimOp NoFollowOp = ILIT(241) +tagOf_PrimOp NewMutVarOp = ILIT(242) +tagOf_PrimOp ReadMutVarOp = ILIT(243) +tagOf_PrimOp WriteMutVarOp = ILIT(244) +tagOf_PrimOp SameMutVarOp = ILIT(245) +tagOf_PrimOp CatchOp = ILIT(246) +tagOf_PrimOp RaiseOp = ILIT(247) +tagOf_PrimOp BlockAsyncExceptionsOp = ILIT(248) +tagOf_PrimOp UnblockAsyncExceptionsOp = ILIT(249) +tagOf_PrimOp DataToTagOp = ILIT(250) +tagOf_PrimOp TagToEnumOp = ILIT(251) tagOf_PrimOp op = pprPanic# "tagOf_PrimOp: pattern-match" (ppr op) --panic# "tagOf_PrimOp: pattern-match" @@ -635,6 +630,7 @@ allThePrimOps IntMulOp, IntQuotOp, IntRemOp, + IntGcdOp, IntNegOp, WordQuotOp, WordRemOp, @@ -701,6 +697,10 @@ allThePrimOps IntegerSubOp, IntegerMulOp, IntegerGcdOp, + IntegerIntGcdOp, + IntegerDivExactOp, + IntegerQuotOp, + IntegerRemOp, IntegerQuotRemOp, IntegerDivModOp, IntegerNegOp, @@ -1024,14 +1024,15 @@ primOpInfo ChrOp = mkGenPrimOp SLIT("chr#") [] [intPrimTy] charPrimTy %************************************************************************ \begin{code} -primOpInfo IntAddOp = mkDyadic SLIT("+#") intPrimTy -primOpInfo IntSubOp = mkDyadic SLIT("-#") intPrimTy -primOpInfo IntMulOp = mkDyadic SLIT("*#") intPrimTy -primOpInfo IntQuotOp = mkDyadic SLIT("quotInt#") intPrimTy -primOpInfo IntRemOp = mkDyadic SLIT("remInt#") intPrimTy +primOpInfo IntAddOp = mkDyadic SLIT("+#") intPrimTy +primOpInfo IntSubOp = mkDyadic SLIT("-#") intPrimTy +primOpInfo IntMulOp = mkDyadic SLIT("*#") intPrimTy +primOpInfo IntQuotOp = mkDyadic SLIT("quotInt#") intPrimTy +primOpInfo IntRemOp = mkDyadic SLIT("remInt#") intPrimTy +primOpInfo IntGcdOp = mkDyadic SLIT("gcdInt#") intPrimTy primOpInfo IntNegOp = mkMonadic SLIT("negateInt#") intPrimTy -primOpInfo IntAbsOp = mkMonadic SLIT("absInt#") intPrimTy +primOpInfo IntAbsOp = mkMonadic SLIT("absInt#") intPrimTy primOpInfo IntAddCOp = mkGenPrimOp SLIT("addIntC#") [] [intPrimTy, intPrimTy] @@ -1173,6 +1174,10 @@ primOpInfo IntegerAddOp = integerDyadic SLIT("plusInteger#") primOpInfo IntegerSubOp = integerDyadic SLIT("minusInteger#") primOpInfo IntegerMulOp = integerDyadic SLIT("timesInteger#") primOpInfo IntegerGcdOp = integerDyadic SLIT("gcdInteger#") +primOpInfo IntegerIntGcdOp = mkGenPrimOp SLIT("gcdIntegerInt#") [] an_Integer_and_Int_tys intPrimTy +primOpInfo IntegerDivExactOp = integerDyadic SLIT("divExactInteger#") +primOpInfo IntegerQuotOp = integerDyadic SLIT("quotInteger#") +primOpInfo IntegerRemOp = integerDyadic SLIT("remInteger#") primOpInfo IntegerCmpOp = integerCompare SLIT("cmpInteger#") primOpInfo IntegerCmpIntOp @@ -1976,6 +1981,9 @@ primOpOutOfLine op IntegerSubOp -> True IntegerMulOp -> True IntegerGcdOp -> True + IntegerDivExactOp -> True + IntegerQuotOp -> True + IntegerRemOp -> True IntegerQuotRemOp -> True IntegerDivModOp -> True Int2IntegerOp -> True @@ -2388,6 +2396,7 @@ commutableOp IntNeOp = True commutableOp IntegerAddOp = True commutableOp IntegerMulOp = True commutableOp IntegerGcdOp = True +commutableOp IntegerIntGcdOp = True commutableOp FloatAddOp = True commutableOp FloatMulOp = True commutableOp FloatEqOp = True diff --git a/ghc/includes/PrimOps.h b/ghc/includes/PrimOps.h index cad9a20..505a892 100644 --- a/ghc/includes/PrimOps.h +++ b/ghc/includes/PrimOps.h @@ -1,5 +1,5 @@ /* ----------------------------------------------------------------------------- - * $Id: PrimOps.h,v 1.40 1999/12/01 14:34:48 simonmar Exp $ + * $Id: PrimOps.h,v 1.41 1999/12/08 14:21:54 simonmar Exp $ * * (c) The GHC Team, 1998-1999 * @@ -355,6 +355,20 @@ typedef union { (r) = RET_PRIM_STGCALL2(I_,mpz_cmp_si,&arg,i); \ } +/* I think mp_limb_t must be the same size as StgInt for this to work + * properly --SDM + */ +#define gcdIntzh(r,a,b) \ +{ StgInt aa = a; \ + r = (aa) ? (b) ? \ + RET_STGCALL3(StgInt, mpn_gcd_1, (mp_limb_t *)(&aa), 1, (mp_limb_t)(b)) \ + : abs(aa) \ + : abs(b); \ +} + +#define gcdIntegerIntzh_fast(r,a,sb,b) \ + RET_STGCALL3(StgInt, mpn_gcd_1, (unsigned long int *) b, sb, (mp_limb_t)(a)) + /* The rest are all out-of-line: -------- */ /* Integer arithmetic */ @@ -363,6 +377,9 @@ EF_(minusIntegerzh_fast); EF_(timesIntegerzh_fast); EF_(gcdIntegerzh_fast); EF_(quotRemIntegerzh_fast); +EF_(quotIntegerzh_fast); +EF_(remIntegerzh_fast); +EF_(divExactIntegerzh_fast); EF_(divModIntegerzh_fast); /* Conversions */ diff --git a/ghc/lib/std/PrelGHC.hi-boot b/ghc/lib/std/PrelGHC.hi-boot index abeeabf..dba3e67 100644 --- a/ghc/lib/std/PrelGHC.hi-boot +++ b/ghc/lib/std/PrelGHC.hi-boot @@ -83,6 +83,7 @@ __export PrelGHC zszh quotIntzh remIntzh + gcdIntzh negateIntzh iShiftLzh iShiftRAzh @@ -191,6 +192,11 @@ __export PrelGHC minusIntegerzh timesIntegerzh gcdIntegerzh + quotIntegerzh + remIntegerzh + gcdIntegerzh + gcdIntegerIntzh + divExactIntegerzh quotRemIntegerzh divModIntegerzh integer2Intzh diff --git a/ghc/lib/std/PrelNum.lhs b/ghc/lib/std/PrelNum.lhs index 34ce296..9cb3d55 100644 --- a/ghc/lib/std/PrelNum.lhs +++ b/ghc/lib/std/PrelNum.lhs @@ -276,29 +276,13 @@ instance Integral Integer where (# s3, d3, s4, d4 #) -> (J# s3 d3, J# s4 d4) -{- USING THE UNDERLYING "GMP" CODE IS DUBIOUS FOR NOW: - - divMod (J# a1 s1 d1) (J# a2 s2 d2) - = case (divModInteger# a1 s1 d1 a2 s2 d2) of - Return2GMPs a3 s3 d3 a4 s4 d4 - -> (J# a3 s3 d3, J# a4 s4 d4) --} toInteger n = n toInt (S# i) = I# i toInt (J# s d) = case (integer2Int# s d) of { n# -> I# n# } - -- the rest are identical to the report default methods; - -- you get slightly better code if you let the compiler - -- see them right here: - (S# n) `quot` (S# d) = S# (n `quotInt#` d) - n `quot` d = if d /= 0 then q else - error "Prelude.Integral.quot{Integer}: divide by 0" - where (q,_) = quotRem n d - - (S# n) `rem` (S# d) = S# (n `remInt#` d) - n `rem` d = if d /= 0 then r else - error "Prelude.Integral.rem{Integer}: divide by 0" - where (_,r) = quotRem n d + -- we've got specialised quot/rem methods for Integer (see below) + n `quot` d = n `quotInteger` d + n `rem` d = n `remInteger` d n `div` d = q where (q,_) = divMod n d n `mod` d = r where (_,r) = divMod n d @@ -312,6 +296,48 @@ instance Integral Integer where (# s3, d3, s4, d4 #) -> (J# s3 d3, J# s4 d4) +remInteger :: Integer -> Integer -> Integer +remInteger ia 0 + = error "Prelude.Integral.rem{Integer}: divide by 0" +remInteger (S# a) (S# b) = S# (remInt# a b) +remInteger ia@(S# a) (J# sb b) + = if sb ==# 1# + then + S# (remInt# a (word2Int# (integer2Word# sb b))) + else if sb ==# -1# then + S# (remInt# a (0# -# (word2Int# (integer2Word# sb b)))) + else if 0# <# sb then + ia + else + S# (0# -# a) +remInteger (J# sa a) (S# b) + = case int2Integer# b of { (# sb, b #) -> + case remInteger# sa a sb b of { (# sr, r #) -> + S# (sr *# (word2Int# (integer2Word# sr r))) }} +remInteger (J# sa a) (J# sb b) + = case remInteger# sa a sb b of (# sr, r #) -> J# sr r + +quotInteger :: Integer -> Integer -> Integer +quotInteger ia 0 + = error "Prelude.Integral.quot{Integer}: divide by 0" +quotInteger (S# a) (S# b) = S# (quotInt# a b) +quotInteger (S# a) (J# sb b) + = if sb ==# 1# + then + S# (quotInt# a (word2Int# (integer2Word# sb b))) + else if sb ==# -1# then + S# (quotInt# a (0# -# (word2Int# (integer2Word# sb b)))) + else + zeroInteger +quotInteger (J# sa a) (S# b) + = case int2Integer# b of { (# sb, b #) -> + case quotInteger# sa a sb b of (# sq, q #) -> J# sq q } +quotInteger (J# sa a) (J# sb b) + = case quotInteger# sa a sb b of (# sg, g #) -> J# sg g + +zeroInteger :: Integer +zeroInteger = S# 0# + ------------------------------------------------------------------------ instance Enum Integer where succ x = x + 1 @@ -448,9 +474,6 @@ even, odd :: (Integral a) => a -> Bool even n = n `rem` 2 == 0 odd = not . even -{-# SPECIALISE gcd :: - Int -> Int -> Int, - Integer -> Integer -> Integer #-} gcd :: (Integral a) => a -> a -> a gcd 0 0 = error "Prelude.gcd: gcd 0 0 is undefined" gcd x y = gcd' (abs x) (abs y) @@ -485,3 +508,55 @@ _ ^ _ = error "Prelude.^: negative exponent" x ^^ n = if n >= 0 then x^n else recip (x^(negate n)) \end{code} +%********************************************************* +%* * +\subsection{Specialized versions of gcd/lcm for Int/Integer} +%* * +%********************************************************* + +\begin{code} +{-# RULES +"Int.gcd" forall a b . gcd a b = gcdInt a b +"Integer.gcd" forall a b . gcd a b = gcdInteger a b +"Integer.lcm" forall a b . lcm a b = lcmInteger a b + #-} + +gcdInt :: Int -> Int -> Int +gcdInt (I# a) (I# b) + = I# (gcdInt# a b) + +gcdInteger :: Integer -> Integer -> Integer +gcdInteger (S# a) (S# b) + = case gcdInt# a b of g -> S# g +gcdInteger ia@(S# a) ib@(J# sb b) + | a ==# 0# = abs ib + | sb ==# 0# = abs ia + | otherwise = case gcdIntegerInt# sb b a of g -> S# g +gcdInteger ia@(J# sa a) ib@(S# b) + | sa ==# 0# = abs ib + | b ==# 0# = abs ia + | otherwise = case gcdIntegerInt# sa a b of g -> S# g +gcdInteger (J# sa a) (J# sb b) + = case gcdInteger# sa a sb b of (# sg, g #) -> J# sg g + +lcmInteger :: Integer -> Integer -> Integer +lcmInteger a 0 + = zeroInteger +lcmInteger 0 b + = zeroInteger +lcmInteger a b + = (divExact aa (gcdInteger aa ab)) * ab + where aa = abs a + ab = abs b + +divExact :: Integer -> Integer -> Integer +divExact (S# a) (S# b) + = S# (quotInt# a b) +divExact (S# a) (J# sb b) + = S# (quotInt# a (sb *# (word2Int# (integer2Word# sb b)))) +divExact (J# sa a) (S# b) + = case int2Integer# b of + (# sb, b #) -> case divExactInteger# sa a sb b of (# sd, d #) -> J# sd d +divExact (J# sa a) (J# sb b) + = case divExactInteger# sa a sb b of (# sd, d #) -> J# sd d +\end{code} diff --git a/ghc/rts/PrimOps.hc b/ghc/rts/PrimOps.hc index e9ed855..1f48c3b 100644 --- a/ghc/rts/PrimOps.hc +++ b/ghc/rts/PrimOps.hc @@ -1,5 +1,5 @@ /* ----------------------------------------------------------------------------- - * $Id: PrimOps.hc,v 1.35 1999/12/01 14:34:38 simonmar Exp $ + * $Id: PrimOps.hc,v 1.36 1999/12/08 14:21:52 simonmar Exp $ * * (c) The GHC Team, 1998-1999 * @@ -704,10 +704,13 @@ FN_(name) \ FE_ \ } -GMP_TAKE2_RET1(plusIntegerzh_fast, mpz_add); -GMP_TAKE2_RET1(minusIntegerzh_fast, mpz_sub); -GMP_TAKE2_RET1(timesIntegerzh_fast, mpz_mul); -GMP_TAKE2_RET1(gcdIntegerzh_fast, mpz_gcd); +GMP_TAKE2_RET1(plusIntegerzh_fast, mpz_add); +GMP_TAKE2_RET1(minusIntegerzh_fast, mpz_sub); +GMP_TAKE2_RET1(timesIntegerzh_fast, mpz_mul); +GMP_TAKE2_RET1(gcdIntegerzh_fast, mpz_gcd); +GMP_TAKE2_RET1(quotIntegerzh_fast, mpz_tdiv_q); +GMP_TAKE2_RET1(remIntegerzh_fast, mpz_tdiv_r); +GMP_TAKE2_RET1(divExactIntegerzh_fast, mpz_divexact); GMP_TAKE2_RET2(quotRemIntegerzh_fast, mpz_tdiv_qr); GMP_TAKE2_RET2(divModIntegerzh_fast, mpz_fdiv_qr);