[ConstraintElimination] Move Value2Index map to ConstraintSystem (NFC)

[zjaffal]

Summary

Move Value2Index from ConstraintElimination to ConstraintSystem to support dumping the constraintSystem equations with llvm ir variable names instead of using generic variables. Improving the overall debug output

[fhahn]

llvm/include/llvm/Analysis/ConstraintSystem.h

16

Not needed, you can instead forward declare Value as in class Value;

26–30

This needs documenting. and newlines around.

63

nit: newline.

[zjaffal]

Add comments to explain Value2Index map.
Address nit comments

[fhahn]

LGTM with the inline comments addressed.

llvm/include/llvm/Analysis/ConstraintSystem.h

20

nit: newline before and after/

27

A map of variables (IR values) to their corresponding index in the constraint system. Better not mention any specific pass here.

[fhahn]

Could you also update the patch description/commit message to explain the motivation for the change.

llvm/include/llvm/Analysis/ConstraintSystem.h

 //===- ConstraintSystem.h -  A system of linear constraints. --------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_ANALYSIS_CONSTRAINTSYSTEM_H
 #define LLVM_ANALYSIS_CONSTRAINTSYSTEM_H
 
 #include "llvm/ADT/APInt.h"
 #include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SmallVector.h"
 
 #include <string>
 
 namespace llvm {
-
+class Value;
 class ConstraintSystem {
   /// Current linear constraints in the system.
   /// An entry of the form c0, c1, ... cn represents the following constraint:
   ///   c0 >= v0 * c1 + .... + v{n-1} * cn
   SmallVector<SmallVector<int64_t, 8>, 4> Constraints;
 
+  /// a Map between variabled collected in ConstraintElimination and their
+  /// corresponding index in the constraint system solver.
+  DenseMap<Value *, unsigned> Value2Index;
+
   /// Current greatest common divisor for all coefficients in the system.
   uint32_t GCD = 1;
 
   // Eliminate constraints from the system using Fourier–Motzkin elimination.
   bool eliminateUsingFM();
 
   /// Print the constraints in the system, using x0...xn as variable names.
   void dump() const;
for (const auto &C : R) {
       auto A = std::abs(C);
       GCD = APIntOps::GreatestCommonDivisor({32, (uint32_t)A}, {32, GCD})
                 .getZExtValue();
     }
     Constraints.emplace_back(R.begin(), R.end());
     return true;
   }
 
+  DenseMap<Value *, unsigned> &getValue2Index() { return Value2Index; }
+  const DenseMap<Value *, unsigned> &getValue2Index() const {
+    return Value2Index;
+  }
+
   bool addVariableRowFill(ArrayRef<int64_t> R) {
     // If all variable coefficients are 0, the constraint does not provide any
     // usable information.
     if (all_of(ArrayRef(R).drop_front(1), [](int64_t C) { return C == 0; }))
       return false;
 
     for (auto &CR : Constraints) {
       while (CR.size() != R.size())

llvm/lib/Transforms/Scalar/ConstraintElimination.cpp

 
 /// Wrapper encapsulating separate constraint systems and corresponding value
 /// mappings for both unsigned and signed information. Facts are added to and
 /// conditions are checked against the corresponding system depending on the
 /// signed-ness of their predicates. While the information is kept separate
 /// based on signed-ness, certain conditions can be transferred between the two
 /// systems.
 class ConstraintInfo {
-  DenseMap<Value *, unsigned> UnsignedValue2Index;
-  DenseMap<Value *, unsigned> SignedValue2Index;
 
   ConstraintSystem UnsignedCS;
   ConstraintSystem SignedCS;
 
   const DataLayout &DL;
 
 public:
   ConstraintInfo(const DataLayout &DL) : DL(DL) {}
 
   DenseMap<Value *, unsigned> &getValue2Index(bool Signed) {
-    return Signed ? SignedValue2Index : UnsignedValue2Index;
+    return Signed ? SignedCS.getValue2Index() : UnsignedCS.getValue2Index();
   }
   const DenseMap<Value *, unsigned> &getValue2Index(bool Signed) const {
-    return Signed ? SignedValue2Index : UnsignedValue2Index;
+    return Signed ? SignedCS.getValue2Index() : UnsignedCS.getValue2Index();
   }
 
   ConstraintSystem &getCS(bool Signed) {
     return Signed ? SignedCS : UnsignedCS;
   }
   const ConstraintSystem &getCS(bool Signed) const {
     return Signed ? SignedCS : UnsignedCS;
   }