[LogicCombine 1/?] Implement a general way to simplify logical operations.

This patch involves boolean ring to simplify logical operations. We can treat `&` as ring multiplication and `^` as ring addition.
So we need to canonicalize all other operations to `*` `+`. Like:
```
a & b -> a * b
a ^ b -> a + b
~a -> a + 1
a | b -> a * b + a + b
c ? a : b -> c * a + (c + 1) * b
```
In the code, we use a mask set to represent an expression. Every value that is not comes from logical operations could be a bit in the mask.
The mask itself is a multiplication chain. The mask set is an addiction chain.
We can calculate two expressions based on boolean algebras.

For now, the initial patch only enabled on and/or/xor,  Later we can enhance the code step by step.

Reference: https://en.wikipedia.org/wiki/Boolean_ring

Reviewed By: spatel

Differential Revision: https://reviews.llvm.org/D142803

Author: bcl5980

llvm/include/llvm/Analysis/LogicCombine.h

@@ -0,0 +1,68 @@
+//===------------------ LogicCombine.h --------------------------*- 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "LogicalExpr.h"
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/SetVector.h"
+#include "llvm/ADT/Statistic.h"
+#include "llvm/IR/InstrTypes.h"
+#include "llvm/IR/Instruction.h"
+#include "llvm/Support/Allocator.h"
+
+namespace llvm {
+
+class LogicCombiner;
+
+class LogicalOpNode {
+private:
+  LogicCombiner *Helper;
+  Value *Val;
+  LogicalExpr Expr;
+  // TODO: Add weight to measure cost for more than one use value
+
+  void printAndChain(raw_ostream &OS, uint64_t LeafBits) const;
+
+public:
+  LogicalOpNode(LogicCombiner *OpsHelper, Value *SrcVal,
+                const LogicalExpr &SrcExpr)
+      : Helper(OpsHelper), Val(SrcVal), Expr(SrcExpr) {}
+  ~LogicalOpNode() {}
+
+  Value *getValue() const { return Val; }
+  const LogicalExpr &getExpr() const { return Expr; }
+  void print(raw_ostream &OS) const;
+};
+
+class LogicCombiner {
+public:
+  LogicCombiner() {}
+  ~LogicCombiner() { clear(); }
+
+  Value *simplify(Value *Root);
+
+private:
+  friend class LogicalOpNode;
+
+  SpecificBumpPtrAllocator<LogicalOpNode> Alloc;
+  SmallDenseMap<Value *, LogicalOpNode *, 16> LogicalOpNodes;
+  SmallSetVector<Value *, 8> LeafValues;
+
+  void clear();
+
+  LogicalOpNode *visitLeafNode(Value *Val, unsigned Depth);
+  LogicalOpNode *visitBinOp(BinaryOperator *BO, unsigned Depth);
+  LogicalOpNode *getLogicalOpNode(Value *Val, unsigned Depth = 0);
+  Value *logicalOpToValue(LogicalOpNode *Node);
+};
+
+inline raw_ostream &operator<<(raw_ostream &OS, const LogicalOpNode &I) {
+  I.print(OS);
+  return OS;
+}
+
+} // namespace llvm

llvm/include/llvm/Analysis/LogicalExpr.h

@@ -0,0 +1,140 @@
+//===------------------- LogicalExpr.h --------------------------*- 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
+//
+//===----------------------------------------------------------------------===//
+/// \file
+/// This file defines LogicalExpr, a class that represent a logical value by
+/// a set of bitsets.
+///
+/// For a logical expression represented by bitset, the "and" logic
+/// operator represented by "&" is translated to "*" and is then evaluated as
+/// the "or" of the bitset. For example, pattern "a & b" is represented by the
+/// logical expression "01 * 10", and the expression is reduced to "11". So the
+/// operation "&" between two logical expressions (not "xor", only "and" chain)
+/// is actually bitwise "or" of the masks. There are two exceptions:
+///    If one of the operands is constant 0, the entire bitset represents 0.
+///    If one of the operands is constant -1, the result is the other one.
+///
+/// The evaluation of a pattern for bitwise "xor" is represented by a "+" math
+/// operator. But it also has one exception to normal math rules: if two masks
+/// are identical, we remove them. For example with "a ^ a", the logical
+/// expression is "1 + 1". We eliminate them from the logical expression.
+///
+/// We use commutative, associative, and distributive laws of arithmetic
+/// multiplication and addition to reduce the expression. An example for the
+/// LogicalExpr caculation:
+///     ((a & b) | (a ^ c)) ^ (!(b & c) & a)
+/// Mask for the leafs are: a --> 001, b --> 010, c -->100
+/// First step is expand the pattern to:
+///      (((a & b) & (a ^ c)) ^ (a & b) ^ (a ^ c)) ^ (((b & c) ^ -1) & a)
+/// Use logical expression to represent the pattern:
+///      001 * 010 * (001 + 100) + 001 * 010 + 001 + 100 + (010 * 100 + -1C) *
+///      001
+/// Expression after distributive laws:
+///      001 * 010 * 001 + 001 * 010 * 100 + 001 * 010 + 001 + 100 + 010 * 100 *
+///      001 + -1C * 001
+/// Calculate multiplication:
+///      011 + 111 + 011 + 001 + 100 + 111 + 001
+/// Calculate addition:
+///      100
+/// Restore to value
+///      c
+//===----------------------------------------------------------------------===//
+
+#include "llvm/ADT/DenseSet.h"
+
+namespace llvm {
+// TODO: can we use APInt define the mask to enlarge the max leaf number?
+typedef SmallDenseSet<uint64_t, 8> ExprAddChain;
+
+class LogicalExpr {
+private:
+  ExprAddChain AddChain;
+
+public:
+  static const uint64_t ExprAllOne = 0x8000000000000000;
+
+  LogicalExpr() {}
+  LogicalExpr(uint64_t BitSet) {
+    if (BitSet != 0)
+      AddChain.insert(BitSet);
+  }
+  LogicalExpr(const ExprAddChain &SrcAddChain) : AddChain(SrcAddChain) {
+  }
+
+  unsigned size() const { return AddChain.size(); }
+  ExprAddChain::iterator begin() { return AddChain.begin(); }
+  ExprAddChain::iterator end() { return AddChain.end(); }
+  ExprAddChain::const_iterator begin() const { return AddChain.begin(); }
+  ExprAddChain::const_iterator end() const { return AddChain.end(); }
+
+  LogicalExpr &operator*=(const LogicalExpr &RHS) {
+    ExprAddChain NewChain;
+    for (auto LHS : AddChain) {
+      for (auto RHS : RHS.AddChain) {
+        uint64_t NewBitSet;
+        // Except the special case one value "*" -1 is just return itself, the
+        // other "*" operation is actually "|" LHS and RHS 's bitset. For
+        // example: ab * bd  = abd The expression ab * bd convert to bitset will
+        // be 0b0011 * 0b1010. The result abd convert to bitset will become
+        // 0b1011.
+        if (LHS == ExprAllOne)
+          NewBitSet = RHS;
+        else if (RHS == ExprAllOne)
+          NewBitSet = LHS;
+        else
+          NewBitSet = LHS | RHS;
+        assert(NewBitSet == ExprAllOne || (NewBitSet & ExprAllOne) == 0);
+        // a ^ a -> 0
+        auto InsertPair = NewChain.insert(NewBitSet);
+        if (!InsertPair.second)
+          NewChain.erase(InsertPair.first);
+      }
+    }
+
+    AddChain = NewChain;
+    return *this;
+  }
+
+  LogicalExpr &operator+=(const LogicalExpr &RHS) {
+    for (auto RHS : RHS.AddChain) {
+      // a ^ a -> 0
+      auto InsertPair = AddChain.insert(RHS);
+      if (!InsertPair.second)
+        AddChain.erase(InsertPair.first);
+    }
+    return *this;
+  }
+};
+
+inline LogicalExpr operator*(LogicalExpr a, const LogicalExpr &b) {
+  a *= b;
+  return a;
+}
+
+inline LogicalExpr operator+(LogicalExpr a, const LogicalExpr &b) {
+  a += b;
+  return a;
+}
+
+inline LogicalExpr operator&(const LogicalExpr &a, const LogicalExpr &b) {
+  return a * b;
+}
+
+inline LogicalExpr operator^(const LogicalExpr &a, const LogicalExpr &b) {
+  return a + b;
+}
+
+inline LogicalExpr operator|(const LogicalExpr &a, const LogicalExpr &b) {
+  return a * b + a + b;
+}
+
+inline LogicalExpr operator~(const LogicalExpr &a) {
+  LogicalExpr AllOneExpr(LogicalExpr::ExprAllOne);
+  return a + AllOneExpr;
+}
+
+} // namespace llvm

llvm/lib/Analysis/CMakeLists.txt

@@ -87,6 +87,7 @@ add_llvm_component_library(LLVMAnalysis
   Lint.cpp
   Loads.cpp
   Local.cpp
+  LogicCombine.cpp
   LoopAccessAnalysis.cpp
   LoopAnalysisManager.cpp
   LoopCacheAnalysis.cpp