Adapt to new Cmm syntax
authorSimon Marlow <marlowsd@gmail.com>
Wed, 3 Oct 2012 13:02:26 +0000 (14:02 +0100)
committerSimon Marlow <marlowsd@gmail.com>
Thu, 4 Oct 2012 15:08:51 +0000 (16:08 +0100)
cbits/gmp-wrappers.cmm

index 3cfcd4a..9868434 100644 (file)
@@ -1,6 +1,6 @@
 /* -----------------------------------------------------------------------------
  *
- * (c) The GHC Team, 1998-2004
+ * (c) The GHC Team, 1998-2012
  *
  * Out-of-line primitive operations
  *
@@ -59,14 +59,11 @@ import "integer-gmp" integer_cbits_decodeDouble;
    the case for all the platforms that GHC supports, currently.
    -------------------------------------------------------------------------- */
 
-integer_cmm_int2Integerzh
+integer_cmm_int2Integerzh (W_ val)
 {
-   /* arguments: R1 = Int# */
+   W_ s, p; /* to avoid aliasing */
 
-   W_ val, s, p; /* to avoid aliasing */
-
-   val = R1;
-   ALLOC_PRIM( SIZEOF_StgArrWords + WDS(1), NO_PTRS, integer_cmm_int2Integerzh );
+   ALLOC_PRIM_N (SIZEOF_StgArrWords + WDS(1), integer_cmm_int2Integerzh, val);
 
    p = Hp - SIZEOF_StgArrWords;
    SET_HDR(p, stg_ARR_WORDS_info, CCCS);
@@ -89,18 +86,14 @@ integer_cmm_int2Integerzh
                  data  :: ByteArray#
                #)
    */
-   RET_NP(s,p);
+   return (s,p);
 }
 
-integer_cmm_word2Integerzh
+integer_cmm_word2Integerzh (W_ val)
 {
-   /* arguments: R1 = Word# */
-
-   W_ val, s, p; /* to avoid aliasing */
+   W_ s, p; /* to avoid aliasing */
 
-   val = R1;
-
-   ALLOC_PRIM( SIZEOF_StgArrWords + WDS(1), NO_PTRS, integer_cmm_word2Integerzh);
+   ALLOC_PRIM_N (SIZEOF_StgArrWords + WDS(1), integer_cmm_word2Integerzh, val);
 
    p = Hp - SIZEOF_StgArrWords;
    SET_HDR(p, stg_ARR_WORDS_info, CCCS);
@@ -116,7 +109,7 @@ integer_cmm_word2Integerzh
    /* returns (# size  :: Int#,
                  data  :: ByteArray# #)
    */
-   RET_NP(s,p);
+   return (s,p);
 }
 
 
@@ -126,14 +119,10 @@ integer_cmm_word2Integerzh
 
 #if WORD_SIZE_IN_BITS < 64
 
-integer_cmm_int64ToIntegerzh
+integer_cmm_int64ToIntegerzh (L_ val)
 {
-   /* arguments: L1 = Int64# */
-
-   L_ val;
    W_ hi, lo, s, neg, words_needed, p;
 
-   val = L1;
    neg = 0;
 
    hi = TO_W_(val >> 32);
@@ -146,8 +135,7 @@ integer_cmm_int64ToIntegerzh
        words_needed = 2;
    }
 
-   ALLOC_PRIM( SIZEOF_StgArrWords + WDS(words_needed),
-               NO_PTRS, integer_cmm_int64ToIntegerzh );
+   ALLOC_PRIM (SIZEOF_StgArrWords + WDS(words_needed));
 
    p = Hp - SIZEOF_StgArrWords - WDS(words_needed) + WDS(1);
    SET_HDR(p, stg_ARR_WORDS_info, CCCS);
@@ -182,16 +170,12 @@ integer_cmm_int64ToIntegerzh
    /* returns (# size  :: Int#,
                  data  :: ByteArray# #)
    */
-   RET_NP(s,p);
+   return (s,p);
 }
-integer_cmm_word64ToIntegerzh
+integer_cmm_word64ToIntegerzh (L_ val)
 {
-   /* arguments: L1 = Word64# */
-
-   L_ val;
    W_ hi, lo, s, words_needed, p;
 
-   val = L1;
    hi = TO_W_(val >> 32);
    lo = TO_W_(val);
 
@@ -201,8 +185,7 @@ integer_cmm_word64ToIntegerzh
       words_needed = 1;
    }
 
-   ALLOC_PRIM( SIZEOF_StgArrWords + WDS(words_needed),
-               NO_PTRS, integer_cmm_word64ToIntegerzh );
+   ALLOC_PRIM (SIZEOF_StgArrWords + WDS(words_needed));
 
    p = Hp - SIZEOF_StgArrWords - WDS(words_needed) + WDS(1);
    SET_HDR(p, stg_ARR_WORDS_info, CCCS);
@@ -224,184 +207,166 @@ integer_cmm_word64ToIntegerzh
    /* returns (# size  :: Int#,
                  data  :: ByteArray# #)
    */
-   RET_NP(s,p);
+   return (s,p);
 }
 
 #endif /* WORD_SIZE_IN_BITS < 64 */
 
-#define GMP_TAKE2_RET1(name,mp_fun)                                     \
-name                                                                    \
-{                                                                       \
-  CInt s1, s2;                                                          \
-  W_ d1, d2;                                                            \
-  W_ mp_tmp1;                                                           \
-  W_ mp_tmp2;                                                           \
-  W_ mp_result1;                                                        \
-                                                                        \
-  /* call doYouWantToGC() */                                            \
-  MAYBE_GC(R2_PTR & R4_PTR, name);                                      \
-                                                                        \
-  STK_CHK_GEN( 3 * SIZEOF_MP_INT, R2_PTR & R4_PTR, name );              \
-                                                                        \
-  s1 = W_TO_INT(R1);                                                    \
-  d1 = R2;                                                              \
-  s2 = W_TO_INT(R3);                                                    \
-  d2 = R4;                                                              \
-                                                                        \
-  mp_tmp1    = Sp - 1 * SIZEOF_MP_INT;                                  \
-  mp_tmp2    = Sp - 2 * SIZEOF_MP_INT;                                  \
-  mp_result1 = Sp - 3 * SIZEOF_MP_INT;                                  \
-  MP_INT__mp_alloc(mp_tmp1) = W_TO_INT(BYTE_ARR_WDS(d1));               \
-  MP_INT__mp_size(mp_tmp1)  = (s1);                                     \
-  MP_INT__mp_d(mp_tmp1)     = BYTE_ARR_CTS(d1);                         \
-  MP_INT__mp_alloc(mp_tmp2) = W_TO_INT(BYTE_ARR_WDS(d2));               \
-  MP_INT__mp_size(mp_tmp2)  = (s2);                                     \
-  MP_INT__mp_d(mp_tmp2)     = BYTE_ARR_CTS(d2);                         \
-                                                                        \
-  foreign "C" __gmpz_init(mp_result1 "ptr") [];                         \
-                                                                        \
-  /* Perform the operation */                                           \
-  foreign "C" mp_fun(mp_result1 "ptr",mp_tmp1  "ptr",mp_tmp2  "ptr") []; \
-                                                                        \
-  RET_NP(TO_W_(MP_INT__mp_size(mp_result1)),                            \
-         MP_INT__mp_d(mp_result1) - SIZEOF_StgArrWords);                \
+#define GMP_TAKE2_RET1(name,mp_fun)                             \
+name (W_ ws1, P_ d1, W_ ws2, P_ d2)                             \
+{                                                               \
+  CInt s1, s2;                                                  \
+  W_ mp_tmp1;                                                   \
+  W_ mp_tmp2;                                                   \
+  W_ mp_result1;                                                \
+                                                                \
+again:                                                          \
+  STK_CHK_GEN_N (3 * SIZEOF_MP_INT);                            \
+  MAYBE_GC(again);                                              \
+                                                                \
+  s1 = W_TO_INT(ws1);                                           \
+  s2 = W_TO_INT(ws2);                                           \
+                                                                \
+  mp_tmp1    = Sp - 1 * SIZEOF_MP_INT;                          \
+  mp_tmp2    = Sp - 2 * SIZEOF_MP_INT;                          \
+  mp_result1 = Sp - 3 * SIZEOF_MP_INT;                          \
+  MP_INT__mp_alloc(mp_tmp1) = W_TO_INT(BYTE_ARR_WDS(d1));       \
+  MP_INT__mp_size(mp_tmp1)  = (s1);                             \
+  MP_INT__mp_d(mp_tmp1)     = BYTE_ARR_CTS(d1);                 \
+  MP_INT__mp_alloc(mp_tmp2) = W_TO_INT(BYTE_ARR_WDS(d2));       \
+  MP_INT__mp_size(mp_tmp2)  = (s2);                             \
+  MP_INT__mp_d(mp_tmp2)     = BYTE_ARR_CTS(d2);                 \
+                                                                \
+  ccall __gmpz_init(mp_result1 "ptr");                          \
+                                                                \
+  /* Perform the operation */                                   \
+  ccall mp_fun(mp_result1 "ptr",mp_tmp1  "ptr",mp_tmp2  "ptr"); \
+                                                                \
+  return (TO_W_(MP_INT__mp_size(mp_result1)),                   \
+         MP_INT__mp_d(mp_result1) - SIZEOF_StgArrWords);        \
 }
 
-#define GMP_TAKE1_UL1_RET1(name,mp_fun)                                 \
-name                                                                    \
-{                                                                       \
-  CInt s1;                                                              \
-  W_ d1;                                                                \
-  CLong ul;                                                             \
-  W_ mp_tmp;                                                            \
-  W_ mp_result;                                                         \
-                                                                        \
-  /* call doYouWantToGC() */                                            \
-  MAYBE_GC(R2_PTR, name);                                               \
-                                                                        \
-  STK_CHK_GEN( 2 * SIZEOF_MP_INT, R2_PTR, name );                       \
-                                                                        \
-  s1 = W_TO_INT(R1);                                                    \
-  d1 = R2;                                                              \
-  ul = W_TO_LONG(R3);                                                   \
-                                                                        \
-  mp_tmp     = Sp - 1 * SIZEOF_MP_INT;                                  \
-  mp_result  = Sp - 2 * SIZEOF_MP_INT;                                  \
-  MP_INT__mp_alloc(mp_tmp) = W_TO_INT(BYTE_ARR_WDS(d1));                \
-  MP_INT__mp_size(mp_tmp)  = (s1);                                      \
-  MP_INT__mp_d(mp_tmp)     = BYTE_ARR_CTS(d1);                          \
-                                                                        \
-  foreign "C" __gmpz_init(mp_result "ptr") [];                          \
-                                                                        \
-  /* Perform the operation */                                           \
-  foreign "C" mp_fun(mp_result "ptr",mp_tmp "ptr", ul) [];              \
-                                                                        \
-  RET_NP(TO_W_(MP_INT__mp_size(mp_result)),                             \
-         MP_INT__mp_d(mp_result) - SIZEOF_StgArrWords);                 \
+#define GMP_TAKE1_UL1_RET1(name,mp_fun)                         \
+name (W_ ws1, P_ d1, W_ wul)                                    \
+{                                                               \
+  CInt s1;                                                      \
+  CLong ul;                                                     \
+  W_ mp_tmp;                                                    \
+  W_ mp_result;                                                 \
+                                                                \
+  /* call doYouWantToGC() */                                    \
+again:                                                          \
+  STK_CHK_GEN_N (2 * SIZEOF_MP_INT);                            \
+  MAYBE_GC(again);                                              \
+                                                                \
+  s1 = W_TO_INT(ws1);                                           \
+  ul = W_TO_LONG(wul);                                          \
+                                                                \
+  mp_tmp     = Sp - 1 * SIZEOF_MP_INT;                          \
+  mp_result  = Sp - 2 * SIZEOF_MP_INT;                          \
+  MP_INT__mp_alloc(mp_tmp) = W_TO_INT(BYTE_ARR_WDS(d1));        \
+  MP_INT__mp_size(mp_tmp)  = (s1);                              \
+  MP_INT__mp_d(mp_tmp)     = BYTE_ARR_CTS(d1);                  \
+                                                                \
+  ccall __gmpz_init(mp_result "ptr");                           \
+                                                                \
+  /* Perform the operation */                                   \
+  ccall mp_fun(mp_result "ptr",mp_tmp "ptr", ul);               \
+                                                                \
+  return(TO_W_(MP_INT__mp_size(mp_result)),                     \
+         MP_INT__mp_d(mp_result) - SIZEOF_StgArrWords);         \
 }
 
-#define GMP_TAKE1_UL1_RETI1(name,mp_fun)                                \
-name                                                                    \
-{                                                                       \
-  CInt s1;                                                              \
-  W_ d1;                                                                \
-  CLong ul;                                                             \
-  W_ mp_tmp;                                                            \
-  CInt res;                                                             \
-                                                                        \
-  /* call doYouWantToGC() */                                            \
-  MAYBE_GC(R2_PTR, name);                                               \
-                                                                        \
-  STK_CHK_GEN( SIZEOF_MP_INT, R2_PTR, name );                           \
-                                                                        \
-  s1 = W_TO_INT(R1);                                                    \
-  d1 = R2;                                                              \
-  ul = W_TO_LONG(R3);                                                   \
-                                                                        \
-  mp_tmp     = Sp - 1 * SIZEOF_MP_INT;                                  \
-  MP_INT__mp_alloc(mp_tmp) = W_TO_INT(BYTE_ARR_WDS(d1));                \
-  MP_INT__mp_size(mp_tmp)  = (s1);                                      \
-  MP_INT__mp_d(mp_tmp)     = BYTE_ARR_CTS(d1);                          \
-                                                                        \
-  /* Perform the operation */                                           \
-  (res) = foreign "C" mp_fun(mp_tmp "ptr", ul) [];                      \
-  R1 = res;                                                             \
-                                                                        \
-  jump %ENTRY_CODE(Sp(0));                                              \
+#define GMP_TAKE1_UL1_RETI1(name,mp_fun)                        \
+name (W_ ws1, P_ d1, W_ wul)                                     \
+{                                                               \
+  CInt s1, res;                                                 \
+  CLong ul;                                                     \
+  W_ mp_tmp;                                                    \
+                                                                \
+again:                                                          \
+  STK_CHK_GEN_N (SIZEOF_MP_INT);                                \
+  MAYBE_GC(again);                                              \
+                                                                \
+  s1 = W_TO_INT(ws1);                                           \
+  ul = W_TO_LONG(wul);                                          \
+                                                                \
+  mp_tmp     = Sp - 1 * SIZEOF_MP_INT;                          \
+  MP_INT__mp_alloc(mp_tmp) = W_TO_INT(BYTE_ARR_WDS(d1));        \
+  MP_INT__mp_size(mp_tmp)  = (s1);                              \
+  MP_INT__mp_d(mp_tmp)     = BYTE_ARR_CTS(d1);                  \
+                                                                \
+  /* Perform the operation */                                   \
+  (res) = ccall mp_fun(mp_tmp "ptr", ul);                       \
+                                                                \
+  return (res);                                                 \
+}
+
+#define GMP_TAKE1_RET1(name,mp_fun)                             \
+name (W_ ws1, P_ d1)                                            \
+{                                                               \
+  CInt s1;                                                      \
+  W_ mp_tmp1;                                                   \
+  W_ mp_result1;                                                \
+                                                                \
+again:                                                          \
+  STK_CHK_GEN_N (2 * SIZEOF_MP_INT);                            \
+  MAYBE_GC(again);                                              \
+                                                                \
+  s1 = W_TO_INT(ws1);                                           \
+                                                                \
+  mp_tmp1    = Sp - 1 * SIZEOF_MP_INT;                          \
+  mp_result1 = Sp - 2 * SIZEOF_MP_INT;                          \
+  MP_INT__mp_alloc(mp_tmp1)     = W_TO_INT(BYTE_ARR_WDS(d1));   \
+  MP_INT__mp_size(mp_tmp1)      = (s1);                         \
+  MP_INT__mp_d(mp_tmp1)         = BYTE_ARR_CTS(d1);             \
+                                                                \
+  ccall __gmpz_init(mp_result1 "ptr");                          \
+                                                                \
+  /* Perform the operation */                                   \
+  ccall mp_fun(mp_result1 "ptr",mp_tmp1 "ptr");                 \
+                                                                \
+  return(TO_W_(MP_INT__mp_size(mp_result1)),                    \
+         MP_INT__mp_d(mp_result1) - SIZEOF_StgArrWords);        \
 }
 
-#define GMP_TAKE1_RET1(name,mp_fun)                                     \
-name                                                                    \
+#define GMP_TAKE2_RET2(name,mp_fun)                                     \
+name (W_ ws1, P_ d1, W_ ws2, P_ d2)                                     \
 {                                                                       \
-  CInt s1;                                                              \
-  W_ d1;                                                                \
+  CInt s1, s2;                                                          \
   W_ mp_tmp1;                                                           \
+  W_ mp_tmp2;                                                           \
   W_ mp_result1;                                                        \
+  W_ mp_result2;                                                        \
                                                                         \
-  /* call doYouWantToGC() */                                            \
-  MAYBE_GC(R2_PTR, name);                                               \
-                                                                        \
-  STK_CHK_GEN( 2 * SIZEOF_MP_INT, R2_PTR, name );                       \
+again:                                                                  \
+  STK_CHK_GEN_N (4 * SIZEOF_MP_INT);                                    \
+  MAYBE_GC(again);                                                      \
                                                                         \
-  d1 = R2;                                                              \
-  s1 = W_TO_INT(R1);                                                    \
+  s1 = W_TO_INT(ws1);                                                   \
+  s2 = W_TO_INT(ws2);                                                   \
                                                                         \
   mp_tmp1    = Sp - 1 * SIZEOF_MP_INT;                                  \
-  mp_result1 = Sp - 2 * SIZEOF_MP_INT;                                  \
+  mp_tmp2    = Sp - 2 * SIZEOF_MP_INT;                                  \
+  mp_result1 = Sp - 3 * SIZEOF_MP_INT;                                  \
+  mp_result2 = Sp - 4 * SIZEOF_MP_INT;                                  \
   MP_INT__mp_alloc(mp_tmp1)     = W_TO_INT(BYTE_ARR_WDS(d1));           \
   MP_INT__mp_size(mp_tmp1)      = (s1);                                 \
   MP_INT__mp_d(mp_tmp1)         = BYTE_ARR_CTS(d1);                     \
+  MP_INT__mp_alloc(mp_tmp2)     = W_TO_INT(BYTE_ARR_WDS(d2));           \
+  MP_INT__mp_size(mp_tmp2)      = (s2);                                 \
+  MP_INT__mp_d(mp_tmp2)         = BYTE_ARR_CTS(d2);                     \
                                                                         \
-  foreign "C" __gmpz_init(mp_result1 "ptr") [];                         \
+  ccall __gmpz_init(mp_result1 "ptr");                                  \
+  ccall __gmpz_init(mp_result2 "ptr");                                  \
                                                                         \
   /* Perform the operation */                                           \
-  foreign "C" mp_fun(mp_result1 "ptr",mp_tmp1 "ptr") [];                \
+  ccall mp_fun(mp_result1 "ptr",mp_result2 "ptr",mp_tmp1 "ptr",mp_tmp2 "ptr"); \
                                                                         \
-  RET_NP(TO_W_(MP_INT__mp_size(mp_result1)),                            \
-         MP_INT__mp_d(mp_result1) - SIZEOF_StgArrWords);                \
-}
-
-#define GMP_TAKE2_RET2(name,mp_fun)                                                     \
-name                                                                                    \
-{                                                                                       \
-  CInt s1, s2;                                                                          \
-  W_ d1, d2;                                                                            \
-  W_ mp_tmp1;                                                                           \
-  W_ mp_tmp2;                                                                           \
-  W_ mp_result1;                                                                        \
-  W_ mp_result2;                                                                        \
-                                                                                        \
-  /* call doYouWantToGC() */                                                            \
-  MAYBE_GC(R2_PTR & R4_PTR, name);                                                      \
-                                                                                        \
-  STK_CHK_GEN( 4 * SIZEOF_MP_INT, R2_PTR & R4_PTR, name );                              \
-                                                                                        \
-  s1 = W_TO_INT(R1);                                                                    \
-  d1 = R2;                                                                              \
-  s2 = W_TO_INT(R3);                                                                    \
-  d2 = R4;                                                                              \
-                                                                                        \
-  mp_tmp1    = Sp - 1 * SIZEOF_MP_INT;                                                  \
-  mp_tmp2    = Sp - 2 * SIZEOF_MP_INT;                                                  \
-  mp_result1 = Sp - 3 * SIZEOF_MP_INT;                                                  \
-  mp_result2 = Sp - 4 * SIZEOF_MP_INT;                                                  \
-  MP_INT__mp_alloc(mp_tmp1)     = W_TO_INT(BYTE_ARR_WDS(d1));                           \
-  MP_INT__mp_size(mp_tmp1)      = (s1);                                                 \
-  MP_INT__mp_d(mp_tmp1)         = BYTE_ARR_CTS(d1);                                     \
-  MP_INT__mp_alloc(mp_tmp2)     = W_TO_INT(BYTE_ARR_WDS(d2));                           \
-  MP_INT__mp_size(mp_tmp2)      = (s2);                                                 \
-  MP_INT__mp_d(mp_tmp2)         = BYTE_ARR_CTS(d2);                                     \
-                                                                                        \
-  foreign "C" __gmpz_init(mp_result1 "ptr") [];                                         \
-  foreign "C" __gmpz_init(mp_result2 "ptr") [];                                         \
-                                                                                        \
-  /* Perform the operation */                                                           \
-  foreign "C" mp_fun(mp_result1 "ptr",mp_result2 "ptr",mp_tmp1 "ptr",mp_tmp2 "ptr") []; \
-                                                                                        \
-  RET_NPNP(TO_W_(MP_INT__mp_size(mp_result1)),                                          \
-           MP_INT__mp_d(mp_result1) - SIZEOF_StgArrWords,                               \
-           TO_W_(MP_INT__mp_size(mp_result2)),                                          \
-           MP_INT__mp_d(mp_result2) - SIZEOF_StgArrWords);                              \
+  return (TO_W_(MP_INT__mp_size(mp_result1)),                           \
+           MP_INT__mp_d(mp_result1) - SIZEOF_StgArrWords,               \
+           TO_W_(MP_INT__mp_size(mp_result2)),                          \
+           MP_INT__mp_d(mp_result2) - SIZEOF_StgArrWords);              \
 }
 
 GMP_TAKE2_RET1(integer_cmm_plusIntegerzh,           __gmpz_add)
@@ -424,45 +389,35 @@ GMP_TAKE1_RET1(integer_cmm_complementIntegerzh,     __gmpz_com)
 GMP_TAKE2_RET2(integer_cmm_quotRemIntegerzh,        __gmpz_tdiv_qr)
 GMP_TAKE2_RET2(integer_cmm_divModIntegerzh,         __gmpz_fdiv_qr)
 
-integer_cmm_gcdIntzh
+integer_cmm_gcdIntzh (W_ int1, W_ int2)
 {
-    /* R1 = the first Int#; R2 = the second Int# */
     W_ r;
     W_ mp_tmp_w;
 
-    STK_CHK_GEN( 1 * SIZEOF_MP_INT, NO_PTRS, integer_cmm_gcdIntzh );
+    STK_CHK_GEN_N (1 * SIZEOF_MP_INT);
 
     mp_tmp_w = Sp - 1 * SIZEOF_MP_INT;
 
-    W_[mp_tmp_w] = R1;
-    (r) = foreign "C" __gmpn_gcd_1(mp_tmp_w "ptr", 1, R2) [];
+    W_[mp_tmp_w] = int1;
+    (r) = ccall __gmpn_gcd_1(mp_tmp_w "ptr", 1, int2);
 
-    R1 = r;
-    /* Result parked in R1, return via info-pointer at TOS */
-    jump %ENTRY_CODE(Sp(0));
+    return (r);
 }
 
 
-integer_cmm_gcdIntegerIntzh
+integer_cmm_gcdIntegerIntzh (W_ s1, P_ d1, W_ int)
 {
-    /* R1 = s1; R2 = d1; R3 = the int */
-    W_ s1;
-    (s1) = foreign "C" __gmpn_gcd_1( BYTE_ARR_CTS(R2) "ptr", R1, R3) [];
-    R1 = s1;
-
-    /* Result parked in R1, return via info-pointer at TOS */
-    jump %ENTRY_CODE(Sp(0));
+    W_ r;
+    (r) = ccall __gmpn_gcd_1 (BYTE_ARR_CTS(d1) "ptr", s1, int);
+    return (r);
 }
 
 
-integer_cmm_cmpIntegerIntzh
+integer_cmm_cmpIntegerIntzh (W_ usize, P_ d1, W_ v_digit)
 {
-    /* R1 = s1; R2 = d1; R3 = the int */
-    W_ usize, vsize, v_digit, u_digit;
+    W_ vsize, u_digit;
 
-    usize = R1;
     vsize = 0;
-    v_digit = R3;
 
     // paraphrased from __gmpz_cmp_si() in the GMP sources
     if (%gt(v_digit,0)) {
@@ -475,49 +430,39 @@ integer_cmm_cmpIntegerIntzh
     }
 
     if (usize != vsize) {
-        R1 = usize - vsize;
-        jump %ENTRY_CODE(Sp(0));
+        return (usize - vsize);
     }
 
     if (usize == 0) {
-        R1 = 0;
-        jump %ENTRY_CODE(Sp(0));
+        return (0);
     }
 
-    u_digit = W_[BYTE_ARR_CTS(R2)];
+    u_digit = W_[BYTE_ARR_CTS(d1)];
 
     if (u_digit == v_digit) {
-        R1 = 0;
-        jump %ENTRY_CODE(Sp(0));
+        return (0);
     }
 
     if (%gtu(u_digit,v_digit)) { // NB. unsigned: these are mp_limb_t's
-        R1 = usize;
+        return (usize);
     } else {
-        R1 = -usize;
+        return (-usize);
     }
-
-    jump %ENTRY_CODE(Sp(0));
 }
 
-integer_cmm_cmpIntegerzh
+integer_cmm_cmpIntegerzh (W_ usize, P_ d1, W_ vsize, P_ d2)
 {
-    /* R1 = s1; R2 = d1; R3 = s2; R4 = d2 */
-    W_ usize, vsize, size, up, vp;
+    W_ size, up, vp;
     CInt cmp;
 
     // paraphrased from __gmpz_cmp() in the GMP sources
-    usize = R1;
-    vsize = R3;
 
     if (usize != vsize) {
-        R1 = usize - vsize;
-        jump %ENTRY_CODE(Sp(0));
+        return (usize - vsize);
     }
 
     if (usize == 0) {
-        R1 = 0;
-        jump %ENTRY_CODE(Sp(0));
+        return (0);
     }
 
     if (%lt(usize,0)) { // NB. not <, which is unsigned
@@ -526,45 +471,38 @@ integer_cmm_cmpIntegerzh
         size = usize;
     }
 
-    up = BYTE_ARR_CTS(R2);
-    vp = BYTE_ARR_CTS(R4);
+    up = BYTE_ARR_CTS(d1);
+    vp = BYTE_ARR_CTS(d2);
 
-    (cmp) = foreign "C" __gmpn_cmp(up "ptr", vp "ptr", size) [];
+    (cmp) = ccall __gmpn_cmp(up "ptr", vp "ptr", size);
 
     if (cmp == 0 :: CInt) {
-        R1 = 0;
-        jump %ENTRY_CODE(Sp(0));
+        return (0);
     }
 
     if (%lt(cmp,0 :: CInt) == %lt(usize,0)) {
-        R1 = 1;
+        return (1);
     } else {
-        R1 = (-1);
+        return (-1);
     }
-    /* Result parked in R1, return via info-pointer at TOS */
-    jump %ENTRY_CODE(Sp(0));
 }
 
 #define DOUBLE_MANTISSA_SIZE SIZEOF_DOUBLE
 #define ARR_SIZE (SIZEOF_StgArrWords + DOUBLE_MANTISSA_SIZE)
 
-integer_cmm_decodeDoublezh
+integer_cmm_decodeDoublezh (D_ arg)
 {
     D_ arg;
     W_ p;
     W_ mp_tmp1;
     W_ mp_tmp_w;
 
-    STK_CHK_GEN( 2 * SIZEOF_MP_INT, NO_PTRS, integer_cmm_decodeDoublezh );
+    STK_CHK_GEN_N (2 * SIZEOF_MP_INT);
+    ALLOC_PRIM (ARR_SIZE);
 
     mp_tmp1  = Sp - 1 * SIZEOF_MP_INT;
     mp_tmp_w = Sp - 2 * SIZEOF_MP_INT;
 
-    /* arguments: D1 = Double# */
-    arg = D1;
-
-    ALLOC_PRIM( ARR_SIZE, NO_PTRS, integer_cmm_decodeDoublezh );
-
     /* Be prepared to tell Lennart-coded integer_cbits_decodeDouble
        where mantissa.d can be put (it does not care about the rest) */
     p = Hp - ARR_SIZE + WDS(1);
@@ -573,8 +511,8 @@ integer_cmm_decodeDoublezh
     MP_INT__mp_d(mp_tmp1) = BYTE_ARR_CTS(p);
 
     /* Perform the operation */
-    foreign "C" integer_cbits_decodeDouble(mp_tmp1 "ptr", mp_tmp_w "ptr",arg) [];
+    ccall integer_cbits_decodeDouble(mp_tmp1 "ptr", mp_tmp_w "ptr",arg);
 
     /* returns: (Int# (expn), Int#, ByteArray#) */
-    RET_NNP(W_[mp_tmp_w], TO_W_(MP_INT__mp_size(mp_tmp1)), p);
+    return (W_[mp_tmp_w], TO_W_(MP_INT__mp_size(mp_tmp1)), p);
 }