GitLab

Marge Bot pushed to branch master at Glasgow Haskell Compiler / GHC

Commits:

5729418c

by Cheng Shao at 2025-12-18T13:22:29-05:00

rts: use __builtin_mul_overflow for hs_mulIntMayOflo

This patch uses `__builtin_mul_overflow` to implement
`hs_mulIntMayOflo`. This is a GNU C checked arithmetic builtin
function supported by gcc/clang, is type-generic so works for both
32-bit/64-bit, and makes the code both more efficient and easier to
read/maintain than the previous hand rolled logic.

3 changed files:

compiler/GHC/CmmToC.hs
rts/include/Stg.h
rts/prim/mulIntMayOflo.c

Changes:

compiler/GHC/CmmToC.hs

@@ -426,7 +426,7 @@ pprMachOpApp :: Platform -> MachOp -> [CmmExpr] -> SDoc
  pprMachOpApp platform op args
    | isMulMayOfloOp op
 -  = text "mulIntMayOflo" <> parens (commafy (map (pprExpr platform) args))
 +  = text "hs_mulIntMayOflo" <> parens (commafy (map (pprExpr platform) args))
    where isMulMayOfloOp (MO_S_MulMayOflo _) = True
          isMulMayOfloOp _ = False

rts/include/Stg.h

@@ -519,79 +519,3 @@ INLINE_HEADER StgInt64 PK_Int64(W_ p_src[])
+ }
  #endif /* SIZEOF_HSWORD == 4 */
+-
 -/* -----------------------------------------------------------------------------
 -   Integer multiply with overflow
 -   -------------------------------------------------------------------------- */
+-
 -/* Multiply with overflow checking.
 - *
 - * This is tricky - the usual sign rules for add/subtract don't apply.
 - *
 - * On 32-bit machines we use gcc's 'long long' types, finding
 - * overflow with some careful bit-twiddling.
 - *
 - * On 64-bit machines where gcc's 'long long' type is also 64-bits,
 - * we use a crude approximation, testing whether either operand is
 - * larger than 32-bits; if neither is, then we go ahead with the
 - * multiplication.
 - *
 - * Return non-zero if there is any possibility that the signed multiply
 - * of a and b might overflow.  Return zero only if you are absolutely sure
 - * that it won't overflow.  If in doubt, return non-zero.
 - */
+-
 -#if SIZEOF_VOID_P == 4
+-
 -#if defined(WORDS_BIGENDIAN)
 -#define RTS_CARRY_IDX__ 0
 -#define RTS_REM_IDX__  1
 -#else
 -#define RTS_CARRY_IDX__ 1
 -#define RTS_REM_IDX__ 0
 -#endif
+-
 -typedef union {
 -    StgInt64 l;
 -    StgInt32 i[2];
 -} long_long_u ;
+-
 -#define mulIntMayOflo(a,b)       \
 -({                                              \
 -  StgInt32 r, c;           \
 -  long_long_u z;           \
 -  z.l = (StgInt64)a * (StgInt64)b;     \
 -  r = z.i[RTS_REM_IDX__];        \
 -  c = z.i[RTS_CARRY_IDX__];         \
 -  if (c == 0 || c == -1) {       \
 -    c = ((StgWord)((a^b) ^ r))         \
 -      >> (BITS_IN (I_) - 1);        \
 -  }                  \
 -  c;                                            \
 -})
+-
 -/* Careful: the carry calculation above is extremely delicate.  Make sure
 - * you test it thoroughly after changing it.
 - */
+-
 -#else
+-
 -/* Approximate version when we don't have long arithmetic (on 64-bit archs) */
+-
 -/* If we have n-bit words then we have n-1 bits after accounting for the
 - * sign bit, so we can fit the result of multiplying 2 (n-1)/2-bit numbers */
 -#define HALF_POS_INT  (((I_)1) << ((BITS_IN (I_) - 1) / 2))
 -#define HALF_NEG_INT  (-HALF_POS_INT)
+-
 -#define mulIntMayOflo(a,b)       \
 -({                                              \
 -  I_ c;              \
 -  if ((I_)a <= HALF_NEG_INT || a >= HALF_POS_INT    \
 -      || (I_)b <= HALF_NEG_INT || b >= HALF_POS_INT) {\
 -    c = 1;              \
 -  } else {              \
 -    c = 0;              \
 -  }                  \
 -  c;                                            \
 -})
 -#endif

rts/prim/mulIntMayOflo.c

  #include "Rts.h"
 -W_ hs_mulIntMayOflo(W_ a, W_ b) { return mulIntMayOflo(a, b); }
 +W_ hs_mulIntMayOflo(W_ a, W_ b) {
 +  I_ r;
 +  return (W_)__builtin_mul_overflow((I_)a, (I_)b, &r);
 +}