NFC: Silence unused function 'scaleAndAdd' in release build.

[stellaraccident]

Summary

If this were C++17, we would just use a [[maybe_unused]] annotation. I'm not sure what the best way to do this without such a thing.

[mehdi_amini]

If this were C++17, we would just use a [[maybe_unused]] annotation. I'm not sure what the best way to do this without such a thing.

There is LLVM_ATTRIBUTE_UNUSED: https://github.com/llvm/llvm-project/blob/main/llvm/include/llvm/Support/Compiler.h#L180

[stellaraccident]

In D123354#3437988, @mehdi_amini wrote:

If this were C++17, we would just use a [[maybe_unused]] annotation. I'm not sure what the best way to do this without such a thing.

There is LLVM_ATTRIBUTE_UNUSED: https://github.com/llvm/llvm-project/blob/main/llvm/include/llvm/Support/Compiler.h#L180

Thanks - that is what I was reaching for. Updated.

[stellaraccident]

Comment.

mlir/lib/Analysis/Presburger/Simplex.cpp

 //===- Simplex.cpp - MLIR Simplex Class -----------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Analysis/Presburger/Simplex.h"
 #include "mlir/Analysis/Presburger/Matrix.h"
 #include "mlir/Support/MathExtras.h"
 #include "llvm/ADT/Optional.h"
+#include "llvm/Support/Compiler.h"
 
 using namespace mlir;
 using namespace presburger;
 
 using Direction = Simplex::Direction;
 
 const int nullIndex = std::numeric_limits<int>::max();
 
+// Return a + scale*b;
+LLVM_ATTRIBUTE_UNUSED
+static SmallVector<int64_t, 8>
+scaleAndAddForAssert(ArrayRef<int64_t> a, int64_t scale, ArrayRef<int64_t> b) {
+  assert(a.size() == b.size());
+  SmallVector<int64_t, 8> res;
+  res.reserve(a.size());
+  for (unsigned i = 0, e = a.size(); i < e; ++i)
+    res.push_back(a[i] + scale * b[i]);
+  return res;
+}
+
 SimplexBase::SimplexBase(unsigned nVar, bool mustUseBigM, unsigned symbolOffset,
                          unsigned nSymbol)
     : usingBigM(mustUseBigM), nRow(0), nCol(getNumFixedCols() + nVar),
       nRedundant(0), nSymbol(nSymbol), tableau(0, nCol), empty(false) {
   assert(symbolOffset + nSymbol <= nVar);
 
   colUnknown.insert(colUnknown.begin(), getNumFixedCols(), nullIndex);
   for (unsigned i = 0; i < nVar; ++i) {
private:
   Simplex simplex;
   /// The first index of the equality constraints, the index immediately after
   /// the last constraint in the initial product simplex.
   unsigned simplexConstraintOffset;
   /// A stack of snapshots, used for rolling back.
   SmallVector<unsigned, 8> snapshotStack;
 };
 
-// Return a + scale*b;
-static SmallVector<int64_t, 8> scaleAndAdd(ArrayRef<int64_t> a, int64_t scale,
-                                           ArrayRef<int64_t> b) {
-  assert(a.size() == b.size());
-  SmallVector<int64_t, 8> res;
-  res.reserve(a.size());
-  for (unsigned i = 0, e = a.size(); i < e; ++i)
-    res.push_back(a[i] + scale * b[i]);
-  return res;
-}
-
 /// Reduce the basis to try and find a direction in which the polytope is
 /// "thin". This only works for bounded polytopes.
 ///
 /// This is an implementation of the algorithm described in the paper
 /// "An Implementation of Generalized Basis Reduction for Integer Programming"
 /// by W. Cook, T. Rutherford, H. E. Scarf, D. Shallcross.
 ///
 /// Let b_{level}, b_{level + 1}, ... b_n be the current basis.
if (dual[i - level] % dualDenom != 0) {
       // width_i(b{i+1} + u*b_i) should be minimized at our value of u.
       // We assert that this holds by checking that the values of width_i at
       // u - 1 and u + 1 are greater than or equal to the value at u. If the
       // width is lesser at either of the adjacent values, then our computed
       // value of u is clearly not the minimizer. Otherwise by convexity the
       // computed value of u is really the minimizer.
 
       // Check the value at u - 1.
-      assert(gbrSimplex.computeWidth(scaleAndAdd(
+      assert(gbrSimplex.computeWidth(scaleAndAddForAssert(
                  basis.getRow(i + 1), -1, basis.getRow(i))) >= widthI[j] &&
              "Computed u value does not minimize the width!");
       // Check the value at u + 1.
-      assert(gbrSimplex.computeWidth(scaleAndAdd(
+      assert(gbrSimplex.computeWidth(scaleAndAddForAssert(
                  basis.getRow(i + 1), +1, basis.getRow(i))) >= widthI[j] &&
              "Computed u value does not minimize the width!");
 
       dual = std::move(candidateDual[j]);
       dualDenom = candidateDualDenom[j];
       return widthI[j];
     }