projects / ghc-hetmet.git / commitdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | patch | inline | side by side (parent: 60741e4)
[project @ 1999-12-08 14:21:52 by simonmar]
authorsimonmar <unknown>
Wed, 8 Dec 1999 14:22:00 +0000 (14:22 +0000)
committersimonmar <unknown>
Wed, 8 Dec 1999 14:22:00 +0000 (14:22 +0000)
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.

ghc/compiler/prelude/PrimOp.lhs patch | blob | history
ghc/includes/PrimOps.h patch | blob | history
ghc/lib/std/PrelGHC.hi-boot patch | blob | history
ghc/lib/std/PrelNum.lhs patch | blob | history
ghc/rts/PrimOps.hc patch | blob | history

diff --git a/ghc/compiler/prelude/PrimOp.lhs b/ghc/compiler/prelude/PrimOp.lhs
index ad858b2..54f4b01 100644 (file)
--- 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 (file)
--- 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 (file)
--- 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 (file)
--- 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 (file)
--- 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);
Glasgow Haskell Compiler with heterogeneous metaprogramming (generalized arrows and modal types)