[MLIR][Presburger] Provide functions to convert between arrays of MPInt and int64_t

[Groverkss]

Can you fix the failing build, please? It looks like you cannot include MPInt.h and MathExtras.h together and use mod, ceilDiv, etc.

[arjunp]

Rebase.

[Groverkss]

LGTM.

[Groverkss]

Accidently requested changes instead of accepting.

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

 llvm::hash_code hash_value(const MPInt &x); // NOLINT
 
 /// This just calls through to the operator int64_t, but it's useful when a
 /// function pointer is required. (Although this is marked inline, it is still
 /// possible to obtain and use a function pointer to this.)
 LLVM_ATTRIBUTE_ALWAYS_INLINE int64_t int64FromMPInt(const MPInt &x) {
   return int64_t(x);
 }
+LLVM_ATTRIBUTE_ALWAYS_INLINE MPInt mpintFromInt64(int64_t x) {
+  return MPInt(x);
+}
 
 llvm::raw_ostream &operator<<(llvm::raw_ostream &os, const MPInt &x);
 
 // 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);
 
 namespace detail {

mlir/include/mlir/Analysis/Presburger/Utils.h

 //===- Utils.h - General utilities for Presburger library ------*- 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Utility functions required by the Presburger Library.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_ANALYSIS_PRESBURGER_UTILS_H
 #define MLIR_ANALYSIS_PRESBURGER_UTILS_H
 
+#include "mlir/Analysis/Presburger/MPInt.h"
 #include "mlir/Support/LLVM.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallBitVector.h"
 
 #include "mlir/Analysis/Presburger/Matrix.h"
 
 namespace mlir {
 namespace presburger {

 
 llvm::SmallBitVector getSubrangeBitVector(unsigned len, unsigned setOffset,
                                           unsigned numSet);
 
 /// Check if the pos^th variable can be expressed as a floordiv of an affine
 /// function of other variables (where the divisor is a positive constant).
 /// `foundRepr` contains a boolean for each variable indicating if the
 /// explicit representation for that variable has already been computed.
+/// Return the given array as an array of MPInts.
+SmallVector<MPInt, 8> getMPIntVec(ArrayRef<int64_t> range);
+/// Return the given array as an array of int64_t.
+SmallVector<int64_t, 8> getInt64Vec(ArrayRef<MPInt> range);
 /// Returns the `MaybeLocalRepr` struct which contains the indices of the
 /// constraints that can be expressed as a floordiv of an affine function. If
 /// the representation could be computed, `dividend` and `denominator` are set.
 /// If the representation could not be computed, the kind attribute in
 /// `MaybeLocalRepr` is set to None.
 MaybeLocalRepr computeSingleVarRepr(const IntegerRelation &cst,
                                     ArrayRef<bool> foundRepr, unsigned pos,
                                     MutableArrayRef<int64_t> dividend,

mlir/lib/Analysis/Presburger/Utils.cpp

void DivisionRepr::print(raw_ostream &os) const {
   dividends.print(os);
   os << "Denominators\n";
   for (unsigned i = 0, e = denoms.size(); i < e; ++i)
     os << denoms[i] << " ";
   os << "\n";
 }
 
 void DivisionRepr::dump() const { print(llvm::errs()); }
+
+SmallVector<MPInt, 8> presburger::getMPIntVec(ArrayRef<int64_t> range) {
+  SmallVector<MPInt, 8> result(range.size());
+  std::transform(range.begin(), range.end(), result.begin(), mpintFromInt64);
+  return result;
+}
+
+SmallVector<int64_t, 8> presburger::getInt64Vec(ArrayRef<MPInt> range) {
+  SmallVector<int64_t, 8> result(range.size());
+  std::transform(range.begin(), range.end(), result.begin(), int64FromMPInt);
+  return result;
+}