[NFC][compiler-rt] Factor out __mulo[sdt]i3 implementations to .inc file

[atrosinenko]

Summary

The existing implementations are almost identical except for width of the integer type.

Factor them out to int_mulo_impl.inc for better maintainability.

The following command may help understanding the changes:

diff int_mulo_impl.inc \
     <(git show master:./mulosi4.c | sed 's/si_int/fixint_t/g')

The si and di variants has three lines different (with two of them being comments) and ti has a bit larger diff.

Note: this patch is almost identical to D86277: [NFC][compiler-rt] Factor out __mulv[sdt]i3 implementations to .inc file.

[atrosinenko]

Explicitly mark .inc file as a C source like is already done for almost all *_impl.inc files.

[MaskRay]

LGTM, but let's give others a chance to comment.

[atrosinenko]

Uploaded because it was already approved and no other review comments received since then. Anyway, please feel free to request followup changes if needed.

compiler-rt/lib/builtins/int_mulo_impl.inc

-//===-- mulodi4.c - Implement __mulodi4 -----------------------------------===//
+//===-- int_mulo_impl.inc - Implement __mulo[sdt]i3 ---------------*- C -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
-// This file implements __mulodi4 for the compiler_rt library.
+// Helper used by __mulosi3, __mulodi3 and __muloti3.
 //
 //===----------------------------------------------------------------------===//
 
 #include "int_lib.h"
 
 // Returns: a * b
 
 // Effects: sets *overflow to 1  if a * b overflows
 
-COMPILER_RT_ABI di_int __mulodi4(di_int a, di_int b, int *overflow) {
-  const int N = (int)(sizeof(di_int) * CHAR_BIT);
-  const di_int MIN = (di_int)1 << (N - 1);
-  const di_int MAX = ~MIN;
+static __inline fixint_t __muloXi4(fixint_t a, fixint_t b, int *overflow) {
+  const int N = (int)(sizeof(fixint_t) * CHAR_BIT);
+  const fixint_t MIN = (fixint_t)1 << (N - 1);
+  const fixint_t MAX = ~MIN;
   *overflow = 0;
-  di_int result = a * b;
+  fixint_t result = a * b;
   if (a == MIN) {
     if (b != 0 && b != 1)
       *overflow = 1;
     return result;
   }
   if (b == MIN) {
     if (a != 0 && a != 1)
       *overflow = 1;
     return result;
   }
-  di_int sa = a >> (N - 1);
-  di_int abs_a = (a ^ sa) - sa;
-  di_int sb = b >> (N - 1);
-  di_int abs_b = (b ^ sb) - sb;
+  fixint_t sa = a >> (N - 1);
+  fixint_t abs_a = (a ^ sa) - sa;
+  fixint_t sb = b >> (N - 1);
+  fixint_t abs_b = (b ^ sb) - sb;
   if (abs_a < 2 || abs_b < 2)
     return result;
   if (sa == sb) {
     if (abs_a > MAX / abs_b)
       *overflow = 1;
   } else {
     if (abs_a > MIN / -abs_b)
       *overflow = 1;
   }
   return result;
 }

compiler-rt/lib/builtins/mulodi4.c

 //===-- mulodi4.c - Implement __mulodi4 -----------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements __mulodi4 for the compiler_rt library.
 //
 //===----------------------------------------------------------------------===//
 
-#include "int_lib.h"
+#define fixint_t di_int
+#include "int_mulo_impl.inc"
 
 // Returns: a * b
 
 // Effects: sets *overflow to 1  if a * b overflows
 
 COMPILER_RT_ABI di_int __mulodi4(di_int a, di_int b, int *overflow) {
-  const int N = (int)(sizeof(di_int) * CHAR_BIT);
-  const di_int MIN = (di_int)1 << (N - 1);
-  const di_int MAX = ~MIN;
-  *overflow = 0;
-  di_int result = a * b;
-  if (a == MIN) {
-    if (b != 0 && b != 1)
-      *overflow = 1;
-    return result;
-  }
-  if (b == MIN) {
-    if (a != 0 && a != 1)
-      *overflow = 1;
-    return result;
-  }
-  di_int sa = a >> (N - 1);
-  di_int abs_a = (a ^ sa) - sa;
-  di_int sb = b >> (N - 1);
-  di_int abs_b = (b ^ sb) - sb;
-  if (abs_a < 2 || abs_b < 2)
-    return result;
-  if (sa == sb) {
-    if (abs_a > MAX / abs_b)
-      *overflow = 1;
-  } else {
-    if (abs_a > MIN / -abs_b)
-      *overflow = 1;
-  }
-  return result;
+  return __muloXi4(a, b, overflow);
 }

compiler-rt/lib/builtins/mulosi4.c

 //===-- mulosi4.c - Implement __mulosi4 -----------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements __mulosi4 for the compiler_rt library.
 //
 //===----------------------------------------------------------------------===//
 
-#include "int_lib.h"
+#define fixint_t si_int
+#include "int_mulo_impl.inc"
 
 // Returns: a * b
 
 // Effects: sets *overflow to 1  if a * b overflows
 
 COMPILER_RT_ABI si_int __mulosi4(si_int a, si_int b, int *overflow) {
-  const int N = (int)(sizeof(si_int) * CHAR_BIT);
-  const si_int MIN = (si_int)1 << (N - 1);
-  const si_int MAX = ~MIN;
-  *overflow = 0;
-  si_int result = a * b;
-  if (a == MIN) {
-    if (b != 0 && b != 1)
-      *overflow = 1;
-    return result;
-  }
-  if (b == MIN) {
-    if (a != 0 && a != 1)
-      *overflow = 1;
-    return result;
-  }
-  si_int sa = a >> (N - 1);
-  si_int abs_a = (a ^ sa) - sa;
-  si_int sb = b >> (N - 1);
-  si_int abs_b = (b ^ sb) - sb;
-  if (abs_a < 2 || abs_b < 2)
-    return result;
-  if (sa == sb) {
-    if (abs_a > MAX / abs_b)
-      *overflow = 1;
-  } else {
-    if (abs_a > MIN / -abs_b)
-      *overflow = 1;
-  }
-  return result;
+  return __muloXi4(a, b, overflow);
 }

compiler-rt/lib/builtins/muloti4.c

 #include "int_lib.h"
 
 #ifdef CRT_HAS_128BIT
 
 // Returns: a * b
 
 // Effects: sets *overflow to 1  if a * b overflows
 
+#define fixint_t ti_int
+#include "int_mulo_impl.inc"
+
 COMPILER_RT_ABI ti_int __muloti4(ti_int a, ti_int b, int *overflow) {
-  const int N = (int)(sizeof(ti_int) * CHAR_BIT);
-  const ti_int MIN = (ti_int)1 << (N - 1);
-  const ti_int MAX = ~MIN;
-  *overflow = 0;
-  ti_int result = a * b;
-  if (a == MIN) {
-    if (b != 0 && b != 1)
-      *overflow = 1;
-    return result;
-  }
-  if (b == MIN) {
-    if (a != 0 && a != 1)
-      *overflow = 1;
-    return result;
-  }
-  ti_int sa = a >> (N - 1);
-  ti_int abs_a = (a ^ sa) - sa;
-  ti_int sb = b >> (N - 1);
-  ti_int abs_b = (b ^ sb) - sb;
-  if (abs_a < 2 || abs_b < 2)
-    return result;
-  if (sa == sb) {
-    if (abs_a > MAX / abs_b)
-      *overflow = 1;
-  } else {
-    if (abs_a > MIN / -abs_b)
-      *overflow = 1;
-  }
-  return result;
+  return __muloXi4(a, b, overflow);
 }
 
 #endif // CRT_HAS_128BIT