[MLIR][Presburger] reintroduce int64_t versions of floorDiv, ceilDiv in mlir::presburger namespace

[arjunp]

Summary

This is useful because MPInt.h defines identically-named functions that
operate on MPInts, which would otherwie become the only candidates of
overload resolution when calling e.g. ceilDiv from the mlir::presburger
namespace (iff MPInt.h is included). So to access the 64-bit overloads, an
explict call to mlir::ceilDiv would be required. This patch adds using
declarations allowing overload resolution to transparently call the right
function.

[Groverkss]

LGTM.

mlir/include/mlir/Analysis/Presburger/MPInt.h

 
 #include "mlir/Analysis/Presburger/SlowMPInt.h"
 #include "mlir/Support/MathExtras.h"
 #include "llvm/Support/raw_ostream.h"
 
 namespace mlir {
 namespace presburger {
 
+/// Redefine these functions, which operate on 64-bit ints, to also be part of
+/// the mlir::presburger namespace. This is useful because this file defines
+/// identically-named functions that operate on MPInts, which would otherwie
+/// become the only candidates of overload resolution when calling e.g. ceilDiv
+/// from the mlir::presburger namespace. So to access the 64-bit overloads, an
+/// explict call to mlir::ceilDiv would be required. These using declarations
+/// allow overload resolution to transparently call the right function.
+using ::mlir::ceilDiv;
+using ::mlir::floorDiv;
+using ::mlir::mod;
+
 namespace detail {
 /// If builtin intrinsics for overflow-checked arithmetic are available,
 /// use them. Otherwise, call through to LLVM's overflow-checked arithmetic
 /// functionality. Those functions also have such macro-gated uses of intrinsics
 /// but they are not always_inlined, which is important for us to achieve
 /// high-performance; calling the functions directly would result in a slowdown
 /// of 1.15x.
 LLVM_ATTRIBUTE_ALWAYS_INLINE bool addOverflow(int64_t x, int64_t y,

 LLVM_ATTRIBUTE_ALWAYS_INLINE MPInt abs(const MPInt &x) {
   return MPInt(x >= 0 ? x : -x);
 }
 // Division overflows only occur when negating the minimal possible value.
 LLVM_ATTRIBUTE_ALWAYS_INLINE MPInt ceilDiv(const MPInt &lhs, const MPInt &rhs) {
   if (LLVM_LIKELY(lhs.isSmall() && rhs.isSmall())) {
     if (LLVM_UNLIKELY(detail::divWouldOverflow(lhs.getSmall(), rhs.getSmall())))
       return -lhs;
-    return MPInt(mlir::ceilDiv(lhs.getSmall(), rhs.getSmall()));
+    return MPInt(ceilDiv(lhs.getSmall(), rhs.getSmall()));
   }
   return MPInt(ceilDiv(detail::SlowMPInt(lhs), detail::SlowMPInt(rhs)));
 }
 LLVM_ATTRIBUTE_ALWAYS_INLINE MPInt floorDiv(const MPInt &lhs,
                                             const MPInt &rhs) {
   if (LLVM_LIKELY(lhs.isSmall() && rhs.isSmall())) {
     if (LLVM_UNLIKELY(detail::divWouldOverflow(lhs.getSmall(), rhs.getSmall())))
       return -lhs;
-    return MPInt(mlir::floorDiv(lhs.getSmall(), rhs.getSmall()));
+    return MPInt(floorDiv(lhs.getSmall(), rhs.getSmall()));
   }
   return MPInt(floorDiv(detail::SlowMPInt(lhs), detail::SlowMPInt(rhs)));
 }
 // The RHS is always expected to be positive, and the result
 /// is always non-negative.
 LLVM_ATTRIBUTE_ALWAYS_INLINE MPInt mod(const MPInt &lhs, const MPInt &rhs) {
   if (LLVM_LIKELY(lhs.isSmall() && rhs.isSmall()))
-    return MPInt(mlir::mod(lhs.getSmall(), rhs.getSmall()));
+    return MPInt(mod(lhs.getSmall(), rhs.getSmall()));
   return MPInt(mod(detail::SlowMPInt(lhs), detail::SlowMPInt(rhs)));
 }
 
 LLVM_ATTRIBUTE_ALWAYS_INLINE MPInt gcd(const MPInt &a, const MPInt &b) {
   assert(a >= 0 && b >= 0 && "operands must be non-negative!");
   if (LLVM_LIKELY(a.isSmall() && b.isSmall()))
     return MPInt(llvm::greatestCommonDivisor(a.getSmall(), b.getSmall()));
   return MPInt(gcd(detail::SlowMPInt(a), detail::SlowMPInt(b)));