From c51aae8f14a7a7d546839d97c1b32491a8080c6a Mon Sep 17 00:00:00 2001 From: rrt Date: Fri, 13 Jul 2001 11:03:47 +0000 Subject: [PATCH] [project @ 2001-07-13 11:03:47 by rrt] Move 64-bit arithmetic support into std_cbits; there's no reason for it to be in the RTS. --- ghc/lib/std/PrelInt.lhs | 50 +++++++++++------------ ghc/lib/std/PrelWord.lhs | 46 ++++++++++----------- ghc/lib/std/cbits/longlong.c | 89 +++++++++++++++++++++++++++++++++++++++++ ghc/rts/StgLongLong.c | 91 ------------------------------------------ 4 files changed, 137 insertions(+), 139 deletions(-) create mode 100644 ghc/lib/std/cbits/longlong.c delete mode 100644 ghc/rts/StgLongLong.c diff --git a/ghc/lib/std/PrelInt.lhs b/ghc/lib/std/PrelInt.lhs index 2041e57..43f9db9 100644 --- a/ghc/lib/std/PrelInt.lhs +++ b/ghc/lib/std/PrelInt.lhs @@ -463,31 +463,31 @@ instance Bits Int64 where bitSize _ = 64 isSigned _ = True -foreign import "stg_eqInt64" unsafe eqInt64# :: Int64# -> Int64# -> Bool -foreign import "stg_neInt64" unsafe neInt64# :: Int64# -> Int64# -> Bool -foreign import "stg_ltInt64" unsafe ltInt64# :: Int64# -> Int64# -> Bool -foreign import "stg_leInt64" unsafe leInt64# :: Int64# -> Int64# -> Bool -foreign import "stg_gtInt64" unsafe gtInt64# :: Int64# -> Int64# -> Bool -foreign import "stg_geInt64" unsafe geInt64# :: Int64# -> Int64# -> Bool -foreign import "stg_plusInt64" unsafe plusInt64# :: Int64# -> Int64# -> Int64# -foreign import "stg_minusInt64" unsafe minusInt64# :: Int64# -> Int64# -> Int64# -foreign import "stg_timesInt64" unsafe timesInt64# :: Int64# -> Int64# -> Int64# -foreign import "stg_negateInt64" unsafe negateInt64# :: Int64# -> Int64# -foreign import "stg_quotInt64" unsafe quotInt64# :: Int64# -> Int64# -> Int64# -foreign import "stg_remInt64" unsafe remInt64# :: Int64# -> Int64# -> Int64# -foreign import "stg_intToInt64" unsafe intToInt64# :: Int# -> Int64# -foreign import "stg_int64ToInt" unsafe int64ToInt# :: Int64# -> Int# -foreign import "stg_wordToWord64" unsafe wordToWord64# :: Word# -> Word64# -foreign import "stg_int64ToWord64" unsafe int64ToWord64# :: Int64# -> Word64# -foreign import "stg_word64ToInt64" unsafe word64ToInt64# :: Word64# -> Int64# -foreign import "stg_and64" unsafe and64# :: Word64# -> Word64# -> Word64# -foreign import "stg_or64" unsafe or64# :: Word64# -> Word64# -> Word64# -foreign import "stg_xor64" unsafe xor64# :: Word64# -> Word64# -> Word64# -foreign import "stg_not64" unsafe not64# :: Word64# -> Word64# -foreign import "stg_iShiftL64" unsafe iShiftL64# :: Int64# -> Int# -> Int64# -foreign import "stg_iShiftRA64" unsafe iShiftRA64# :: Int64# -> Int# -> Int64# -foreign import "stg_shiftL64" unsafe shiftL64# :: Word64# -> Int# -> Word64# -foreign import "stg_shiftRL64" unsafe shiftRL64# :: Word64# -> Int# -> Word64# +foreign import "eqInt64" unsafe eqInt64# :: Int64# -> Int64# -> Bool +foreign import "neInt64" unsafe neInt64# :: Int64# -> Int64# -> Bool +foreign import "ltInt64" unsafe ltInt64# :: Int64# -> Int64# -> Bool +foreign import "leInt64" unsafe leInt64# :: Int64# -> Int64# -> Bool +foreign import "gtInt64" unsafe gtInt64# :: Int64# -> Int64# -> Bool +foreign import "geInt64" unsafe geInt64# :: Int64# -> Int64# -> Bool +foreign import "plusInt64" unsafe plusInt64# :: Int64# -> Int64# -> Int64# +foreign import "minusInt64" unsafe minusInt64# :: Int64# -> Int64# -> Int64# +foreign import "timesInt64" unsafe timesInt64# :: Int64# -> Int64# -> Int64# +foreign import "negateInt64" unsafe negateInt64# :: Int64# -> Int64# +foreign import "quotInt64" unsafe quotInt64# :: Int64# -> Int64# -> Int64# +foreign import "remInt64" unsafe remInt64# :: Int64# -> Int64# -> Int64# +foreign import "intToInt64" unsafe intToInt64# :: Int# -> Int64# +foreign import "int64ToInt" unsafe int64ToInt# :: Int64# -> Int# +foreign import "wordToWord64" unsafe wordToWord64# :: Word# -> Word64# +foreign import "int64ToWord64" unsafe int64ToWord64# :: Int64# -> Word64# +foreign import "word64ToInt64" unsafe word64ToInt64# :: Word64# -> Int64# +foreign import "and64" unsafe and64# :: Word64# -> Word64# -> Word64# +foreign import "or64" unsafe or64# :: Word64# -> Word64# -> Word64# +foreign import "xor64" unsafe xor64# :: Word64# -> Word64# -> Word64# +foreign import "not64" unsafe not64# :: Word64# -> Word64# +foreign import "iShiftL64" unsafe iShiftL64# :: Int64# -> Int# -> Int64# +foreign import "iShiftRA64" unsafe iShiftRA64# :: Int64# -> Int# -> Int64# +foreign import "shiftL64" unsafe shiftL64# :: Word64# -> Int# -> Word64# +foreign import "shiftRL64" unsafe shiftRL64# :: Word64# -> Int# -> Word64# {-# RULES "fromIntegral/Int->Int64" fromIntegral = \(I# x#) -> I64# (intToInt64# x#) diff --git a/ghc/lib/std/PrelWord.lhs b/ghc/lib/std/PrelWord.lhs index 0a8bc1d..95f84e4 100644 --- a/ghc/lib/std/PrelWord.lhs +++ b/ghc/lib/std/PrelWord.lhs @@ -598,29 +598,29 @@ instance Bits Word64 where bitSize _ = 64 isSigned _ = False -foreign import "stg_eqWord64" unsafe eqWord64# :: Word64# -> Word64# -> Bool -foreign import "stg_neWord64" unsafe neWord64# :: Word64# -> Word64# -> Bool -foreign import "stg_ltWord64" unsafe ltWord64# :: Word64# -> Word64# -> Bool -foreign import "stg_leWord64" unsafe leWord64# :: Word64# -> Word64# -> Bool -foreign import "stg_gtWord64" unsafe gtWord64# :: Word64# -> Word64# -> Bool -foreign import "stg_geWord64" unsafe geWord64# :: Word64# -> Word64# -> Bool -foreign import "stg_int64ToWord64" unsafe int64ToWord64# :: Int64# -> Word64# -foreign import "stg_word64ToInt64" unsafe word64ToInt64# :: Word64# -> Int64# -foreign import "stg_plusInt64" unsafe plusInt64# :: Int64# -> Int64# -> Int64# -foreign import "stg_minusInt64" unsafe minusInt64# :: Int64# -> Int64# -> Int64# -foreign import "stg_timesInt64" unsafe timesInt64# :: Int64# -> Int64# -> Int64# -foreign import "stg_negateInt64" unsafe negateInt64# :: Int64# -> Int64# -foreign import "stg_intToInt64" unsafe intToInt64# :: Int# -> Int64# -foreign import "stg_wordToWord64" unsafe wordToWord64# :: Word# -> Word64# -foreign import "stg_word64ToWord" unsafe word64ToWord# :: Word64# -> Word# -foreign import "stg_quotWord64" unsafe quotWord64# :: Word64# -> Word64# -> Word64# -foreign import "stg_remWord64" unsafe remWord64# :: Word64# -> Word64# -> Word64# -foreign import "stg_and64" unsafe and64# :: Word64# -> Word64# -> Word64# -foreign import "stg_or64" unsafe or64# :: Word64# -> Word64# -> Word64# -foreign import "stg_xor64" unsafe xor64# :: Word64# -> Word64# -> Word64# -foreign import "stg_not64" unsafe not64# :: Word64# -> Word64# -foreign import "stg_shiftL64" unsafe shiftL64# :: Word64# -> Int# -> Word64# -foreign import "stg_shiftRL64" unsafe shiftRL64# :: Word64# -> Int# -> Word64# +foreign import "eqWord64" unsafe eqWord64# :: Word64# -> Word64# -> Bool +foreign import "neWord64" unsafe neWord64# :: Word64# -> Word64# -> Bool +foreign import "ltWord64" unsafe ltWord64# :: Word64# -> Word64# -> Bool +foreign import "leWord64" unsafe leWord64# :: Word64# -> Word64# -> Bool +foreign import "gtWord64" unsafe gtWord64# :: Word64# -> Word64# -> Bool +foreign import "geWord64" unsafe geWord64# :: Word64# -> Word64# -> Bool +foreign import "int64ToWord64" unsafe int64ToWord64# :: Int64# -> Word64# +foreign import "word64ToInt64" unsafe word64ToInt64# :: Word64# -> Int64# +foreign import "plusInt64" unsafe plusInt64# :: Int64# -> Int64# -> Int64# +foreign import "minusInt64" unsafe minusInt64# :: Int64# -> Int64# -> Int64# +foreign import "timesInt64" unsafe timesInt64# :: Int64# -> Int64# -> Int64# +foreign import "negateInt64" unsafe negateInt64# :: Int64# -> Int64# +foreign import "intToInt64" unsafe intToInt64# :: Int# -> Int64# +foreign import "wordToWord64" unsafe wordToWord64# :: Word# -> Word64# +foreign import "word64ToWord" unsafe word64ToWord# :: Word64# -> Word# +foreign import "quotWord64" unsafe quotWord64# :: Word64# -> Word64# -> Word64# +foreign import "remWord64" unsafe remWord64# :: Word64# -> Word64# -> Word64# +foreign import "and64" unsafe and64# :: Word64# -> Word64# -> Word64# +foreign import "or64" unsafe or64# :: Word64# -> Word64# -> Word64# +foreign import "xor64" unsafe xor64# :: Word64# -> Word64# -> Word64# +foreign import "not64" unsafe not64# :: Word64# -> Word64# +foreign import "shiftL64" unsafe shiftL64# :: Word64# -> Int# -> Word64# +foreign import "shiftRL64" unsafe shiftRL64# :: Word64# -> Int# -> Word64# {-# RULES "fromIntegral/Int->Word64" fromIntegral = \(I# x#) -> W64# (int64ToWord64# (intToInt64# x#)) diff --git a/ghc/lib/std/cbits/longlong.c b/ghc/lib/std/cbits/longlong.c new file mode 100644 index 0000000..6578504 --- /dev/null +++ b/ghc/lib/std/cbits/longlong.c @@ -0,0 +1,89 @@ +/* ----------------------------------------------------------------------------- + * $Id: longlong.c,v 1.1 2001/07/13 11:03:47 rrt Exp $ + * + * (c) The GHC Team, 1998-1999 + * + * Primitive operations over (64-bit) long longs + * (only used on 32-bit platforms.) + * + * ---------------------------------------------------------------------------*/ + + +/* +Miscellaneous primitive operations on StgInt64 and StgWord64s. +N.B. These are not primops! + +Instead of going the normal (boring) route of making the list +of primitive operations even longer to cope with operations +over 64-bit entities, we implement them instead 'out-of-line'. + +The primitive ops get their own routine (in C) that implements +the operation, requiring the caller to _ccall_ out. This has +performance implications of course, but we currently don't +expect intensive use of either Int64 or Word64 types. + +The exceptions to the rule are primops that cast to and from +64-bit entities (these are defined in PrimOps.h) +*/ + +#include "Stg.h" + +#ifdef SUPPORT_LONG_LONGS + +/* Relational operators */ + +StgBool gtWord64 (StgWord64 a, StgWord64 b) {return a > b;} +StgBool geWord64 (StgWord64 a, StgWord64 b) {return a >= b;} +StgBool eqWord64 (StgWord64 a, StgWord64 b) {return a == b;} +StgBool neWord64 (StgWord64 a, StgWord64 b) {return a != b;} +StgBool ltWord64 (StgWord64 a, StgWord64 b) {return a < b;} +StgBool leWord64 (StgWord64 a, StgWord64 b) {return a <= b;} + +StgBool gtInt64 (StgInt64 a, StgInt64 b) {return a > b;} +StgBool geInt64 (StgInt64 a, StgInt64 b) {return a >= b;} +StgBool eqInt64 (StgInt64 a, StgInt64 b) {return a == b;} +StgBool neInt64 (StgInt64 a, StgInt64 b) {return a != b;} +StgBool ltInt64 (StgInt64 a, StgInt64 b) {return a < b;} +StgBool leInt64 (StgInt64 a, StgInt64 b) {return a <= b;} + +/* Arithmetic operators */ + +StgWord64 remWord64 (StgWord64 a, StgWord64 b) {return a % b;} +StgWord64 quotWord64 (StgWord64 a, StgWord64 b) {return a / b;} +StgInt64 remInt64 (StgInt64 a, StgInt64 b) {return a % b;} +StgInt64 quotInt64 (StgInt64 a, StgInt64 b) {return a / b;} +StgInt64 negateInt64 (StgInt64 a) {return -a;} +StgInt64 plusInt64 (StgInt64 a, StgInt64 b) {return a + b;} +StgInt64 minusInt64 (StgInt64 a, StgInt64 b) {return a - b;} +StgInt64 timesInt64 (StgInt64 a, StgInt64 b) {return a * b;} + +/* Logical operators: */ + +StgWord64 and64 (StgWord64 a, StgWord64 b) {return a & b;} +StgWord64 or64 (StgWord64 a, StgWord64 b) {return a | b;} +StgWord64 xor64 (StgWord64 a, StgWord64 b) {return a ^ b;} +StgWord64 not64 (StgWord64 a) {return ~a;} +StgWord64 shiftL64 (StgWord64 a, StgInt b) {return a << b;} +StgWord64 shiftRL64 (StgWord64 a, StgInt b) {return a >> b;} +/* Right shifting of signed quantities is not portable in C, so + the behaviour you'll get from using these primops depends + on the whatever your C compiler is doing. ToDo: fix. -- sof 8/98 +*/ +StgInt64 iShiftL64 (StgInt64 a, StgInt b) {return a << b;} +StgInt64 iShiftRA64 (StgInt64 a, StgInt b) {return a >> b;} +StgInt64 iShiftRL64 (StgInt64 a, StgInt b) +{return (StgInt64) ((StgWord64) a >> b);} + +/* Casting between longs and longer longs: + (the primops that cast between Integers and long longs are + expressed as macros, since these may cause some heap allocation). +*/ + +StgInt64 intToInt64 (StgInt i) {return (StgInt64) i;} +StgInt int64ToInt (StgInt64 i) {return (StgInt) i;} +StgWord64 int64ToWord64 (StgInt64 i) {return (StgWord64) i;} +StgWord64 wordToWord64 (StgWord w) {return (StgWord64) w;} +StgWord word64ToWord (StgWord64 w) {return (StgWord) w;} +StgInt64 word64ToInt64 (StgWord64 w) {return (StgInt64) w;} + +#endif /* SUPPORT_LONG_LONGS */ diff --git a/ghc/rts/StgLongLong.c b/ghc/rts/StgLongLong.c deleted file mode 100644 index a2d884f..0000000 --- a/ghc/rts/StgLongLong.c +++ /dev/null @@ -1,91 +0,0 @@ -/* ----------------------------------------------------------------------------- - * $Id: StgLongLong.c,v 1.5 2001/02/28 00:01:04 qrczak Exp $ - * - * (c) The GHC Team, 1998-1999 - * - * Primitive operations over (64-bit) long longs - * (only used on 32-bit platforms.) - * - * ---------------------------------------------------------------------------*/ - - -/* -Miscellaneous primitive operations on StgInt64 and StgWord64s. - -Instead of going the normal (boring) route of making the list -of primitive operations even longer to cope with operations -over 64-bit entities, we implement them instead 'out-of-line'. - -The primitive ops get their own routine (in C) that implements -the operation, requiring the caller to _ccall_ out. This has -performance implications of course, but we currently don't -expect intensive use of either Int64 or Word64 types. - -The exceptions to the rule are primops that cast to and from -64-bit entities (these are defined in PrimOps.h) - -NOTE: We prefix all these primops with "stg_". No particular -reason why. -*/ - -#include "Rts.h" - -#ifdef SUPPORT_LONG_LONGS - -/* Relational operators */ - -StgBool stg_gtWord64 (StgWord64 a, StgWord64 b) {return a > b;} -StgBool stg_geWord64 (StgWord64 a, StgWord64 b) {return a >= b;} -StgBool stg_eqWord64 (StgWord64 a, StgWord64 b) {return a == b;} -StgBool stg_neWord64 (StgWord64 a, StgWord64 b) {return a != b;} -StgBool stg_ltWord64 (StgWord64 a, StgWord64 b) {return a < b;} -StgBool stg_leWord64 (StgWord64 a, StgWord64 b) {return a <= b;} - -StgBool stg_gtInt64 (StgInt64 a, StgInt64 b) {return a > b;} -StgBool stg_geInt64 (StgInt64 a, StgInt64 b) {return a >= b;} -StgBool stg_eqInt64 (StgInt64 a, StgInt64 b) {return a == b;} -StgBool stg_neInt64 (StgInt64 a, StgInt64 b) {return a != b;} -StgBool stg_ltInt64 (StgInt64 a, StgInt64 b) {return a < b;} -StgBool stg_leInt64 (StgInt64 a, StgInt64 b) {return a <= b;} - -/* Arithmetic operators */ - -StgWord64 stg_remWord64 (StgWord64 a, StgWord64 b) {return a % b;} -StgWord64 stg_quotWord64 (StgWord64 a, StgWord64 b) {return a / b;} -StgInt64 stg_remInt64 (StgInt64 a, StgInt64 b) {return a % b;} -StgInt64 stg_quotInt64 (StgInt64 a, StgInt64 b) {return a / b;} -StgInt64 stg_negateInt64 (StgInt64 a) {return -a;} -StgInt64 stg_plusInt64 (StgInt64 a, StgInt64 b) {return a + b;} -StgInt64 stg_minusInt64 (StgInt64 a, StgInt64 b) {return a - b;} -StgInt64 stg_timesInt64 (StgInt64 a, StgInt64 b) {return a * b;} - -/* Logical operators: */ - -StgWord64 stg_and64 (StgWord64 a, StgWord64 b) {return a & b;} -StgWord64 stg_or64 (StgWord64 a, StgWord64 b) {return a | b;} -StgWord64 stg_xor64 (StgWord64 a, StgWord64 b) {return a ^ b;} -StgWord64 stg_not64 (StgWord64 a) {return ~a;} -StgWord64 stg_shiftL64 (StgWord64 a, StgInt b) {return a << b;} -StgWord64 stg_shiftRL64 (StgWord64 a, StgInt b) {return a >> b;} -/* Right shifting of signed quantities is not portable in C, so - the behaviour you'll get from using these primops depends - on the whatever your C compiler is doing. ToDo: fix. -- sof 8/98 -*/ -StgInt64 stg_iShiftL64 (StgInt64 a, StgInt b) {return a << b;} -StgInt64 stg_iShiftRA64 (StgInt64 a, StgInt b) {return a >> b;} -StgInt64 stg_iShiftRL64 (StgInt64 a, StgInt b) -{return (StgInt64) ((StgWord64) a >> b);} - -/* Casting between longs and longer longs: - (the primops that cast between Integers and long longs are - expressed as macros, since these may cause some heap allocation). -*/ - -StgInt64 stg_intToInt64 (StgInt i) {return (StgInt64) i;} -StgInt stg_int64ToInt (StgInt64 i) {return (StgInt) i;} -StgWord64 stg_int64ToWord64 (StgInt64 i) {return (StgWord64) i;} -StgWord64 stg_wordToWord64 (StgWord w) {return (StgWord64) w;} -StgWord stg_word64ToWord (StgWord64 w) {return (StgWord) w;} -StgInt64 stg_word64ToInt64 (StgWord64 w) {return (StgInt64) w;} - -#endif /* SUPPORT_LONG_LONGS */ -- 1.7.10.4