[project @ 1997-11-20 16:51:04 by simonm]

add two new primitive operations:

	quotWord#
	remWord#

for unsigned divides.

diff --git a/ghc/compiler/nativeGen/AsmCodeGen.lhs b/ghc/compiler/nativeGen/AsmCodeGen.lhs
index b94efa4..5e1243e 100644 (file)
--- a/ghc/compiler/nativeGen/AsmCodeGen.lhs
+++ b/ghc/compiler/nativeGen/AsmCodeGen.lhs
@@ -226,6 +226,7 @@ primOpt op args@[StInt x, StInt y]
        IntNeOp -> StInt (if x /= y then 1 else 0)
        IntLtOp -> StInt (if x < y  then 1 else 0)
        IntLeOp -> StInt (if x <= y then 1 else 0)
+       -- ToDo: WordQuotOp, WordRemOp.
        _ -> StPrim op args
 \end{code}
 

diff --git a/ghc/compiler/nativeGen/MachCode.lhs b/ghc/compiler/nativeGen/MachCode.lhs
index 8c2b594..51e6197 100644 (file)
--- a/ghc/compiler/nativeGen/MachCode.lhs
+++ b/ghc/compiler/nativeGen/MachCode.lhs
@@ -392,6 +392,9 @@ getRegister (StPrim primop [x, y]) -- dyadic PrimOps
       IntQuotOp -> trivialCode (DIV Q False) x y
       IntRemOp  -> trivialCode (REM Q False) x y
 
+      WordQuotOp -> trivialCode (DIV Q True) x y
+      WordRemOp  -> trivialCode (REM Q True) x y
+
       FloatAddOp -> trivialFCode  FloatRep (FADD TF) x y
       FloatSubOp -> trivialFCode  FloatRep (FSUB TF) x y
       FloatMulOp -> trivialFCode  FloatRep (FMUL TF) x y

diff --git a/ghc/compiler/prelude/PrimOp.lhs b/ghc/compiler/prelude/PrimOp.lhs
index fd1a666..72445f6 100644 (file)
--- a/ghc/compiler/prelude/PrimOp.lhs
+++ b/ghc/compiler/prelude/PrimOp.lhs
@@ -79,11 +79,12 @@ data PrimOp
     -- IntAbsOp unused?? ADR
     | IntAddOp | IntSubOp | IntMulOp | IntQuotOp
     | IntRemOp | IntNegOp | IntAbsOp
+    | ISllOp | ISraOp | ISrlOp -- shift {left,right} {arithmetic,logical}
 
     -- Word#-related ops:
+    | WordQuotOp | WordRemOp
     | AndOp  | OrOp   | NotOp | XorOp
     | SllOp  | SraOp  | SrlOp  -- shift {left,right} {arithmetic,logical}
-    | ISllOp | ISraOp | ISrlOp -- equivs on Int#s
     | Int2WordOp | Word2IntOp -- casts
 
     -- Addr#-related ops:
@@ -305,143 +306,144 @@ tagOf_PrimOp IntMulOp                         = ILIT( 41)
 tagOf_PrimOp IntQuotOp                       = ILIT( 42)
 tagOf_PrimOp IntRemOp                        = ILIT( 44)
 tagOf_PrimOp IntNegOp                        = ILIT( 45)
-tagOf_PrimOp IntAbsOp                        = ILIT( 46)
-tagOf_PrimOp AndOp                           = ILIT( 47)
-tagOf_PrimOp OrOp                            = ILIT( 48)
-tagOf_PrimOp NotOp                           = ILIT( 49)
-tagOf_PrimOp XorOp                           = ILIT( 50)
-tagOf_PrimOp SllOp                           = ILIT( 51)
-tagOf_PrimOp SraOp                           = ILIT( 52)
-tagOf_PrimOp SrlOp                           = ILIT( 53)
-tagOf_PrimOp ISllOp                          = ILIT( 54)
-tagOf_PrimOp ISraOp                          = ILIT( 55)
-tagOf_PrimOp ISrlOp                          = ILIT( 56)
-tagOf_PrimOp Int2WordOp                              = ILIT( 57)
-tagOf_PrimOp Word2IntOp                              = ILIT( 58)
-tagOf_PrimOp Int2AddrOp                              = ILIT( 59)
-tagOf_PrimOp Addr2IntOp                              = ILIT( 60)
-tagOf_PrimOp FloatAddOp                              = ILIT( 61)
-tagOf_PrimOp FloatSubOp                              = ILIT( 62)
-tagOf_PrimOp FloatMulOp                              = ILIT( 63)
-tagOf_PrimOp FloatDivOp                              = ILIT( 64)
-tagOf_PrimOp FloatNegOp                              = ILIT( 65)
-tagOf_PrimOp Float2IntOp                     = ILIT( 66)
-tagOf_PrimOp Int2FloatOp                     = ILIT( 67)
-tagOf_PrimOp FloatExpOp                              = ILIT( 68)
-tagOf_PrimOp FloatLogOp                              = ILIT( 69)
-tagOf_PrimOp FloatSqrtOp                     = ILIT( 70)
-tagOf_PrimOp FloatSinOp                              = ILIT( 71)
-tagOf_PrimOp FloatCosOp                              = ILIT( 72)
-tagOf_PrimOp FloatTanOp                              = ILIT( 73)
-tagOf_PrimOp FloatAsinOp                     = ILIT( 74)
-tagOf_PrimOp FloatAcosOp                     = ILIT( 75)
-tagOf_PrimOp FloatAtanOp                     = ILIT( 76)
-tagOf_PrimOp FloatSinhOp                     = ILIT( 77)
-tagOf_PrimOp FloatCoshOp                     = ILIT( 78)
-tagOf_PrimOp FloatTanhOp                     = ILIT( 79)
-tagOf_PrimOp FloatPowerOp                    = ILIT( 80)
-tagOf_PrimOp DoubleAddOp                     = ILIT( 81)
-tagOf_PrimOp DoubleSubOp                     = ILIT( 82)
-tagOf_PrimOp DoubleMulOp                     = ILIT( 83)
-tagOf_PrimOp DoubleDivOp                     = ILIT( 84)
-tagOf_PrimOp DoubleNegOp                     = ILIT( 85)
-tagOf_PrimOp Double2IntOp                    = ILIT( 86)
-tagOf_PrimOp Int2DoubleOp                    = ILIT( 87)
-tagOf_PrimOp Double2FloatOp                  = ILIT( 88)
-tagOf_PrimOp Float2DoubleOp                  = ILIT( 89)
-tagOf_PrimOp DoubleExpOp                     = ILIT( 90)
-tagOf_PrimOp DoubleLogOp                     = ILIT( 91)
-tagOf_PrimOp DoubleSqrtOp                    = ILIT( 92)
-tagOf_PrimOp DoubleSinOp                     = ILIT( 93)
-tagOf_PrimOp DoubleCosOp                     = ILIT( 94)
-tagOf_PrimOp DoubleTanOp                     = ILIT( 95)
-tagOf_PrimOp DoubleAsinOp                    = ILIT( 96)
-tagOf_PrimOp DoubleAcosOp                    = ILIT( 97)
-tagOf_PrimOp DoubleAtanOp                    = ILIT( 98)
-tagOf_PrimOp DoubleSinhOp                    = ILIT( 99)
-tagOf_PrimOp DoubleCoshOp                    = ILIT(100)
-tagOf_PrimOp DoubleTanhOp                    = ILIT(101)
-tagOf_PrimOp DoublePowerOp                   = ILIT(102)
-tagOf_PrimOp IntegerAddOp                    = ILIT(103)
-tagOf_PrimOp IntegerSubOp                    = ILIT(104)
-tagOf_PrimOp IntegerMulOp                    = ILIT(105)
-tagOf_PrimOp IntegerQuotRemOp                = ILIT(106)
-tagOf_PrimOp IntegerDivModOp                 = ILIT(107)
-tagOf_PrimOp IntegerNegOp                    = ILIT(108)
-tagOf_PrimOp IntegerCmpOp                    = ILIT(109)
-tagOf_PrimOp Integer2IntOp                   = ILIT(110)
-tagOf_PrimOp Int2IntegerOp                   = ILIT(111)
-tagOf_PrimOp Word2IntegerOp                  = ILIT(112)
-tagOf_PrimOp Addr2IntegerOp                  = ILIT(113)
-tagOf_PrimOp FloatEncodeOp                   = ILIT(114)
-tagOf_PrimOp FloatDecodeOp                   = ILIT(115)
-tagOf_PrimOp DoubleEncodeOp                  = ILIT(116)
-tagOf_PrimOp DoubleDecodeOp                  = ILIT(117)
-tagOf_PrimOp NewArrayOp                              = ILIT(118)
-tagOf_PrimOp (NewByteArrayOp CharRep)        = ILIT(119)
-tagOf_PrimOp (NewByteArrayOp IntRep)         = ILIT(120)
-tagOf_PrimOp (NewByteArrayOp AddrRep)        = ILIT(121)
-tagOf_PrimOp (NewByteArrayOp FloatRep)       = ILIT(122)
-tagOf_PrimOp (NewByteArrayOp DoubleRep)       = ILIT(123)
-tagOf_PrimOp SameMutableArrayOp                      = ILIT(124)
-tagOf_PrimOp SameMutableByteArrayOp          = ILIT(125)
-tagOf_PrimOp ReadArrayOp                     = ILIT(126)
-tagOf_PrimOp WriteArrayOp                    = ILIT(127)
-tagOf_PrimOp IndexArrayOp                    = ILIT(128)
-tagOf_PrimOp (ReadByteArrayOp CharRep)       = ILIT(129)
-tagOf_PrimOp (ReadByteArrayOp IntRep)        = ILIT(130)
-tagOf_PrimOp (ReadByteArrayOp AddrRep)       = ILIT(131)
-tagOf_PrimOp (ReadByteArrayOp FloatRep)       = ILIT(132)
-tagOf_PrimOp (ReadByteArrayOp DoubleRep)      = ILIT(133)
-tagOf_PrimOp (WriteByteArrayOp CharRep)       = ILIT(134)
-tagOf_PrimOp (WriteByteArrayOp IntRep)       = ILIT(135)
-tagOf_PrimOp (WriteByteArrayOp AddrRep)       = ILIT(136)
-tagOf_PrimOp (WriteByteArrayOp FloatRep)      = ILIT(137)
-tagOf_PrimOp (WriteByteArrayOp DoubleRep)     = ILIT(138)
-tagOf_PrimOp (IndexByteArrayOp CharRep)       = ILIT(139)
-tagOf_PrimOp (IndexByteArrayOp IntRep)       = ILIT(140)
-tagOf_PrimOp (IndexByteArrayOp AddrRep)       = ILIT(141)
-tagOf_PrimOp (IndexByteArrayOp FloatRep)      = ILIT(142)
-tagOf_PrimOp (IndexByteArrayOp DoubleRep)     = ILIT(143)
-tagOf_PrimOp (IndexOffAddrOp CharRep)        = ILIT(144)
-tagOf_PrimOp (IndexOffAddrOp IntRep)         = ILIT(145)
-tagOf_PrimOp (IndexOffAddrOp AddrRep)        = ILIT(146)
-tagOf_PrimOp (IndexOffAddrOp FloatRep)       = ILIT(147)
-tagOf_PrimOp (IndexOffAddrOp DoubleRep)       = ILIT(148)
-tagOf_PrimOp (IndexOffForeignObjOp CharRep)   = ILIT(149)
-tagOf_PrimOp (IndexOffForeignObjOp IntRep)    = ILIT(150)
-tagOf_PrimOp (IndexOffForeignObjOp AddrRep)   = ILIT(151)
-tagOf_PrimOp (IndexOffForeignObjOp FloatRep)  = ILIT(152)
-tagOf_PrimOp (IndexOffForeignObjOp DoubleRep) = ILIT(153)
-tagOf_PrimOp UnsafeFreezeArrayOp             = ILIT(154)
-tagOf_PrimOp UnsafeFreezeByteArrayOp         = ILIT(155)
-tagOf_PrimOp NewSynchVarOp                   = ILIT(156)
-tagOf_PrimOp TakeMVarOp                              = ILIT(157)
-tagOf_PrimOp PutMVarOp                       = ILIT(158)
-tagOf_PrimOp ReadIVarOp                              = ILIT(159)
-tagOf_PrimOp WriteIVarOp                     = ILIT(160)
-tagOf_PrimOp MakeForeignObjOp                = ILIT(161)
-tagOf_PrimOp WriteForeignObjOp               = ILIT(162)
-tagOf_PrimOp MakeStablePtrOp                 = ILIT(163)
-tagOf_PrimOp DeRefStablePtrOp                = ILIT(164)
-tagOf_PrimOp (CCallOp _ _ _ _ _)             = ILIT(165)
-tagOf_PrimOp ErrorIOPrimOp                   = ILIT(166)
-tagOf_PrimOp ReallyUnsafePtrEqualityOp       = ILIT(167)
-tagOf_PrimOp SeqOp                           = ILIT(168)
-tagOf_PrimOp ParOp                           = ILIT(169)
-tagOf_PrimOp ForkOp                          = ILIT(170)
-tagOf_PrimOp DelayOp                         = ILIT(171)
-tagOf_PrimOp WaitReadOp                              = ILIT(172)
-tagOf_PrimOp WaitWriteOp                     = ILIT(173)
-
-tagOf_PrimOp ParGlobalOp                     = ILIT(174)
-tagOf_PrimOp ParLocalOp                              = ILIT(175)
-tagOf_PrimOp ParAtOp                         = ILIT(176)
-tagOf_PrimOp ParAtAbsOp                              = ILIT(177)
-tagOf_PrimOp ParAtRelOp                              = ILIT(178)
-tagOf_PrimOp ParAtForNowOp                   = ILIT(179)
-tagOf_PrimOp CopyableOp                              = ILIT(180)
-tagOf_PrimOp NoFollowOp                              = ILIT(181)
+tagOf_PrimOp IntAbsOp                        = ILIT( 47)
+tagOf_PrimOp WordQuotOp                              = ILIT( 48)
+tagOf_PrimOp WordRemOp                       = ILIT( 49)
+tagOf_PrimOp AndOp                           = ILIT( 50)
+tagOf_PrimOp OrOp                            = ILIT( 51)
+tagOf_PrimOp NotOp                           = ILIT( 52)
+tagOf_PrimOp XorOp                           = ILIT( 53)
+tagOf_PrimOp SllOp                           = ILIT( 54)
+tagOf_PrimOp SraOp                           = ILIT( 55)
+tagOf_PrimOp SrlOp                           = ILIT( 56)
+tagOf_PrimOp ISllOp                          = ILIT( 57)
+tagOf_PrimOp ISraOp                          = ILIT( 58)
+tagOf_PrimOp ISrlOp                          = 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 IntegerQuotRemOp                = ILIT(109)
+tagOf_PrimOp IntegerDivModOp                 = ILIT(110)
+tagOf_PrimOp IntegerNegOp                    = ILIT(111)
+tagOf_PrimOp IntegerCmpOp                    = ILIT(112)
+tagOf_PrimOp Integer2IntOp                   = ILIT(113)
+tagOf_PrimOp Int2IntegerOp                   = ILIT(114)
+tagOf_PrimOp Word2IntegerOp                  = ILIT(115)
+tagOf_PrimOp Addr2IntegerOp                  = ILIT(116)
+tagOf_PrimOp FloatEncodeOp                   = ILIT(117)
+tagOf_PrimOp FloatDecodeOp                   = ILIT(118)
+tagOf_PrimOp DoubleEncodeOp                  = ILIT(119)
+tagOf_PrimOp DoubleDecodeOp                  = ILIT(120)
+tagOf_PrimOp NewArrayOp                              = ILIT(121)
+tagOf_PrimOp (NewByteArrayOp CharRep)        = ILIT(122)
+tagOf_PrimOp (NewByteArrayOp IntRep)         = ILIT(123)
+tagOf_PrimOp (NewByteArrayOp AddrRep)        = ILIT(124)
+tagOf_PrimOp (NewByteArrayOp FloatRep)       = ILIT(125)
+tagOf_PrimOp (NewByteArrayOp DoubleRep)       = ILIT(126)
+tagOf_PrimOp SameMutableArrayOp                      = ILIT(127)
+tagOf_PrimOp SameMutableByteArrayOp          = ILIT(128)
+tagOf_PrimOp ReadArrayOp                     = ILIT(129)
+tagOf_PrimOp WriteArrayOp                    = ILIT(130)
+tagOf_PrimOp IndexArrayOp                    = ILIT(131)
+tagOf_PrimOp (ReadByteArrayOp CharRep)       = ILIT(132)
+tagOf_PrimOp (ReadByteArrayOp IntRep)        = ILIT(133)
+tagOf_PrimOp (ReadByteArrayOp AddrRep)       = ILIT(134)
+tagOf_PrimOp (ReadByteArrayOp FloatRep)       = ILIT(135)
+tagOf_PrimOp (ReadByteArrayOp DoubleRep)      = ILIT(136)
+tagOf_PrimOp (WriteByteArrayOp CharRep)       = ILIT(137)
+tagOf_PrimOp (WriteByteArrayOp IntRep)       = ILIT(138)
+tagOf_PrimOp (WriteByteArrayOp AddrRep)       = ILIT(139)
+tagOf_PrimOp (WriteByteArrayOp FloatRep)      = ILIT(140)
+tagOf_PrimOp (WriteByteArrayOp DoubleRep)     = ILIT(141)
+tagOf_PrimOp (IndexByteArrayOp CharRep)       = ILIT(142)
+tagOf_PrimOp (IndexByteArrayOp IntRep)       = ILIT(143)
+tagOf_PrimOp (IndexByteArrayOp AddrRep)       = ILIT(144)
+tagOf_PrimOp (IndexByteArrayOp FloatRep)      = ILIT(145)
+tagOf_PrimOp (IndexByteArrayOp DoubleRep)     = ILIT(146)
+tagOf_PrimOp (IndexOffAddrOp CharRep)        = ILIT(147)
+tagOf_PrimOp (IndexOffAddrOp IntRep)         = ILIT(148)
+tagOf_PrimOp (IndexOffAddrOp AddrRep)        = ILIT(149)
+tagOf_PrimOp (IndexOffAddrOp FloatRep)       = ILIT(150)
+tagOf_PrimOp (IndexOffAddrOp DoubleRep)       = ILIT(151)
+tagOf_PrimOp (IndexOffForeignObjOp CharRep)   = ILIT(152)
+tagOf_PrimOp (IndexOffForeignObjOp IntRep)    = ILIT(153)
+tagOf_PrimOp (IndexOffForeignObjOp AddrRep)   = ILIT(154)
+tagOf_PrimOp (IndexOffForeignObjOp FloatRep)  = ILIT(155)
+tagOf_PrimOp (IndexOffForeignObjOp DoubleRep) = ILIT(156)
+tagOf_PrimOp UnsafeFreezeArrayOp             = ILIT(157)
+tagOf_PrimOp UnsafeFreezeByteArrayOp         = ILIT(158)
+tagOf_PrimOp NewSynchVarOp                   = ILIT(159)
+tagOf_PrimOp TakeMVarOp                              = ILIT(160)
+tagOf_PrimOp PutMVarOp                       = ILIT(161)
+tagOf_PrimOp ReadIVarOp                              = ILIT(162)
+tagOf_PrimOp WriteIVarOp                     = ILIT(163)
+tagOf_PrimOp MakeForeignObjOp                = ILIT(164)
+tagOf_PrimOp WriteForeignObjOp               = ILIT(165)
+tagOf_PrimOp MakeStablePtrOp                 = ILIT(166)
+tagOf_PrimOp DeRefStablePtrOp                = ILIT(167)
+tagOf_PrimOp (CCallOp _ _ _ _ _)             = ILIT(168)
+tagOf_PrimOp ErrorIOPrimOp                   = ILIT(169)
+tagOf_PrimOp ReallyUnsafePtrEqualityOp       = ILIT(170)
+tagOf_PrimOp SeqOp                           = ILIT(171)
+tagOf_PrimOp ParOp                           = ILIT(172)
+tagOf_PrimOp ForkOp                          = ILIT(173)
+tagOf_PrimOp DelayOp                         = ILIT(174)
+tagOf_PrimOp WaitReadOp                              = ILIT(175)
+tagOf_PrimOp WaitWriteOp                     = ILIT(176)
+tagOf_PrimOp ParGlobalOp                     = ILIT(177)
+tagOf_PrimOp ParLocalOp                              = ILIT(178)
+tagOf_PrimOp ParAtOp                         = ILIT(179)
+tagOf_PrimOp ParAtAbsOp                              = ILIT(180)
+tagOf_PrimOp ParAtRelOp                              = ILIT(181)
+tagOf_PrimOp ParAtForNowOp                   = ILIT(182)
+tagOf_PrimOp CopyableOp                              = ILIT(183)
+tagOf_PrimOp NoFollowOp                              = ILIT(184)
 
 tagOf_PrimOp _ = panic# "tagOf_PrimOp: pattern-match"
 
@@ -496,6 +498,8 @@ allThePrimOps
        IntQuotOp,
        IntRemOp,
        IntNegOp,
+       WordQuotOp,
+       WordRemOp,
        AndOp,
        OrOp,
        NotOp,
@@ -791,6 +795,9 @@ primOpInfo IntAbsOp  = Monadic SLIT("absInt#") intPrimTy
 A @Word#@ is an unsigned @Int#@.
 
 \begin{code}
+primOpInfo WordQuotOp = Dyadic SLIT("quotWord#") wordPrimTy
+primOpInfo WordRemOp  = Dyadic SLIT("remWord#")         wordPrimTy
+
 primOpInfo AndOp    = Dyadic  SLIT("and#")     wordPrimTy
 primOpInfo OrOp            = Dyadic  SLIT("or#")       wordPrimTy
 primOpInfo XorOp    = Dyadic  SLIT("xor#")     wordPrimTy

diff --git a/ghc/includes/StgMacros.lh b/ghc/includes/StgMacros.lh
index a1bf60b..c612a12 100644 (file)
--- a/ghc/includes/StgMacros.lh
+++ b/ghc/includes/StgMacros.lh
@@ -454,6 +454,7 @@ I_ stg_div PROTO((I_ a, I_ b));
 #define ZmZh(r,a,b)            r=(a)-(b)
 #define ZtZh(r,a,b)            r=(a)*(b)
 #define quotIntZh(r,a,b)       r=(a)/(b)
+/* ZdZh not used??? --SDM */
 #define ZdZh(r,a,b)            r=ULTRASAFESTGCALL2(I_,(void *, I_, I_),stg_div,(a),(b))
 #define remIntZh(r,a,b)                r=(a)%(b)
 #define negateIntZh(r,a)       r=-(a)
@@ -468,6 +469,9 @@ I_ stg_div PROTO((I_ a, I_ b));
 %************************************************************************
 
 \begin{code}
+#define quotWordZh(r,a,b)      r=((W_)a)/((W_)b)
+#define remWordZh(r,a,b)       r=((W_)a)%((W_)b)
+
 #define andZh(r,a,b)   r=(a)&(b)
 #define orZh(r,a,b)    r=(a)|(b)
 #define xorZh(r,a,b)   r=(a)^(b)

diff --git a/ghc/lib/ghc/GHC.hi-boot b/ghc/lib/ghc/GHC.hi-boot
index 3abdbd9..b4b12d0 100644 (file)
--- a/ghc/lib/ghc/GHC.hi-boot
+++ b/ghc/lib/ghc/GHC.hi-boot
@@ -74,6 +74,8 @@ GHC
   neWord#
   ltWord#
   leWord#
+  quotWord#
+  remWord#
   and#
   or#
   not#