Bump LLVM to 9344b2196cbc36cdc577314bbb2b889606ba6820. (#8404)

There were series of patches to llvm::EquivalenceClasses this week,
and we updated accordingly:

* There is no longer a template parameter for the comparator
* The idiom for iterating over EquivalenceClasses was updated
* The idiom for iterating over members was updated

There was a change to the InlinerUtils functions to now include a
required callback for ops that are cloned. To update our call sites,
this default constructs an InlinerConfig and uses the default
clone callback.

Finally, there was a change to the memref.subview verifier to actually
check bounds when statically possible. Since memref.subview is
technically supposed to "represent a reduced-size view of the
original memref", I think our previous lowering was technically
supposed to be interpreted as out of bound accesses.

In any case, it seems this is the expected use for
memref.collapse_shape, so this was adopted instead of memref.subview
for this use case.

Author: mikeurbach

lib/Dialect/FIRRTL/Transforms/CheckCombLoops.cpp

@@ -613,14 +613,12 @@ class DiscoverLoops {
         llvm::dbgs() << "\n node:" << getName(drivenBy[node.first].first)
                      << "=> probe:" << getName(drivenBy[node.second].first);
       }
-      for (auto i = rwProbeClasses.begin(), e = rwProbeClasses.end(); i != e;
-           ++i) { // Iterate over all of the equivalence sets.
+      for (const auto &i :
+           rwProbeClasses) { // Iterate over all of the equivalence sets.
         if (!i->isLeader())
           continue; // Ignore non-leader sets.
         // Print members in this set.
-        llvm::interleave(llvm::make_range(rwProbeClasses.member_begin(i),
-                                          rwProbeClasses.member_end()),
-                         llvm::dbgs(), "\n");
+        llvm::interleave(rwProbeClasses.members(*i), llvm::dbgs(), "\n");
         llvm::dbgs() << "\n dataflow at leader::" << i->getData() << "\n =>"
                      << rwProbeRefersTo[i->getData()];
         llvm::dbgs() << "\n Done\n"; // Finish set.
@@ -653,10 +651,7 @@ class DiscoverLoops {
             rwProbeClasses.getLeaderValue(getOrAddNode(defOp.getDataRef()));
         // For all the probes, that are in the same eqv class, i.e., refer to
         // the same value.
-        for (auto probe :
-             llvm::make_range(rwProbeClasses.member_begin(
-                                  rwProbeClasses.findValue(rwProbeNode)),
-                              rwProbeClasses.member_end())) {
+        for (auto probe : rwProbeClasses.members(rwProbeNode)) {
           auto probeVal = drivenBy[probe].first;
           // If the probe is a port, then record the path from the probe to the
           // input port.

lib/Dialect/FIRRTL/Transforms/InferResets.cpp

@@ -1028,12 +1028,10 @@ LogicalResult InferResetsPass::inferAndUpdateResets() {
     llvm::dbgs() << "\n";
     debugHeader("Infer reset types") << "\n\n";
   });
-  for (auto it = resetClasses.begin(), end = resetClasses.end(); it != end;
-       ++it) {
+  for (const auto &it : resetClasses) {
     if (!it->isLeader())
       continue;
-    ResetNetwork net = llvm::make_range(resetClasses.member_begin(it),
-                                        resetClasses.member_end());
+    ResetNetwork net = resetClasses.members(*it);
 
     // Infer whether this should be a sync or async reset.
     auto kind = inferReset(net);

lib/Dialect/FIRRTL/Transforms/LowerXMR.cpp

@@ -130,7 +130,7 @@ class LowerXMRPass : public circt::firrtl::impl::LowerXMRBase<LowerXMRPass> {
     CircuitNamespace ns(getOperation());
     circuitNamespace = &ns;
 
-    llvm::EquivalenceClasses<Value, ValueComparator> eq;
+    llvm::EquivalenceClasses<Value> eq;
     dataFlowClasses = &eq;
 
     InstanceGraph &instanceGraph = getAnalysis<InstanceGraph>();
@@ -370,14 +370,12 @@ class LowerXMRPass : public circt::firrtl::impl::LowerXMRBase<LowerXMRPass> {
     }
 
     LLVM_DEBUG({
-      for (auto I = dataFlowClasses->begin(), E = dataFlowClasses->end();
-           I != E; ++I) { // Iterate over all of the equivalence sets.
+      for (const auto &I :
+           *dataFlowClasses) { // Iterate over all of the equivalence sets.
         if (!I->isLeader())
           continue; // Ignore non-leader sets.
         // Print members in this set.
-        llvm::interleave(llvm::make_range(dataFlowClasses->member_begin(I),
-                                          dataFlowClasses->member_end()),
-                         llvm::dbgs(), "\n");
+        llvm::interleave(dataFlowClasses->members(*I), llvm::dbgs(), "\n");
         llvm::dbgs() << "\n dataflow at leader::" << I->getData() << "\n =>";
         auto iter = dataflowAt.find(I->getData());
         if (iter != dataflowAt.end()) {
@@ -887,15 +885,7 @@ class LowerXMRPass : public circt::firrtl::impl::LowerXMRBase<LowerXMRPass> {
   /// no NextNodeOnPath, which denotes a leaf node on the path.
   SmallVector<XMRNode> refSendPathList;
 
-  /// llvm::EquivalenceClasses wants comparable elements. This comparator uses
-  /// uses pointer comparison on the Impl.
-  struct ValueComparator {
-    bool operator()(const Value &lhs, const Value &rhs) const {
-      return lhs.getImpl() < rhs.getImpl();
-    }
-  };
-
-  llvm::EquivalenceClasses<Value, ValueComparator> *dataFlowClasses;
+  llvm::EquivalenceClasses<Value> *dataFlowClasses;
   // Instance and module ref ports that needs to be removed.
   DenseMap<Operation *, llvm::BitVector> refPortsToRemoveMap;
 

lib/Dialect/HW/Transforms/FlattenModules.cpp

@@ -12,6 +12,7 @@
 #include "circt/Support/BackedgeBuilder.h"
 #include "mlir/IR/IRMapping.h"
 #include "mlir/Pass/Pass.h"
+#include "mlir/Transforms/Inliner.h"
 #include "mlir/Transforms/InliningUtils.h"
 #include "llvm/ADT/PostOrderIterator.h"
 #include "llvm/Support/Debug.h"
@@ -28,6 +29,7 @@ namespace hw {
 using namespace circt;
 using namespace hw;
 using namespace igraph;
+using mlir::InlinerConfig;
 using mlir::InlinerInterface;
 
 namespace {
@@ -97,6 +99,8 @@ void FlattenModulesPass::runOnOperation() {
   auto &instanceGraph = getAnalysis<hw::InstanceGraph>();
   DenseSet<Operation *> handled;
 
+  InlinerConfig config;
+
   // Iterate over all instances in the instance graph. This ensures we visit
   // every module, even private top modules (private and never instantiated).
   for (auto *startNode : instanceGraph) {
@@ -130,7 +134,8 @@ void FlattenModulesPass::runOnOperation() {
         bool isLastModuleUse = --numUsesLeft == 0;
 
         PrefixingInliner inliner(&getContext(), inst.getInstanceName());
-        if (failed(mlir::inlineRegion(inliner, &module.getBody(), inst,
+        if (failed(mlir::inlineRegion(inliner, config.getCloneCallback(),
+                                      &module.getBody(), inst,
                                       inst.getOperands(), inst.getResults(),
                                       std::nullopt, !isLastModuleUse))) {
           inst.emitError("failed to inline '")

lib/Dialect/LLHD/Transforms/FunctionEliminationPass.cpp

@@ -18,6 +18,7 @@
 #include "mlir/IR/Visitors.h"
 #include "mlir/Interfaces/CallInterfaces.h"
 #include "mlir/Pass/Pass.h"
+#include "mlir/Transforms/Inliner.h"
 #include "mlir/Transforms/InliningUtils.h"
 #include "llvm/Support/LogicalResult.h"
 
@@ -68,6 +69,7 @@ void FunctionEliminationPass::runOnOperation() {
 LogicalResult FunctionEliminationPass::runOnModule(hw::HWModuleOp module) {
   FunctionInliner inliner(&getContext());
   SymbolTableCollection table;
+  mlir::InlinerConfig config;
 
   SmallVector<CallOpInterface> calls;
   module.walk([&](func::CallOp op) { calls.push_back(op); });
@@ -81,8 +83,8 @@ LogicalResult FunctionEliminationPass::runOnModule(hw::HWModuleOp module) {
     auto func = cast<CallableOpInterface>(
         table.lookupNearestSymbolFrom(module, symbol.getLeafReference()));
 
-    if (succeeded(
-            mlir::inlineCall(inliner, call, func, func.getCallableRegion()))) {
+    if (succeeded(mlir::inlineCall(inliner, config.getCloneCallback(), call,
+                                   func, func.getCallableRegion()))) {
       call->erase();
       continue;
     }

lib/Transforms/FlattenMemRefs.cpp

@@ -18,6 +18,7 @@
 #include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.h"
 #include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/Dialect/MemRef/IR/MemRef.h"
+#include "mlir/Dialect/Utils/ReshapeOpsUtils.h"
 #include "mlir/IR/BuiltinDialect.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/ImplicitLocOpBuilder.h"
@@ -397,26 +398,26 @@ static void populateFlattenMemRefsLegality(ConversionTarget &target) {
 }
 
 // Materializes a multidimensional memory to unidimensional memory by using a
-// memref.subview operation.
+// memref.collapse_shape operation.
 // TODO: This is also possible for dynamically shaped memories.
-static Value materializeSubViewFlattening(OpBuilder &builder, MemRefType type,
-                                          ValueRange inputs, Location loc) {
+static Value materializeCollapseShapeFlattening(OpBuilder &builder,
+                                                MemRefType type,
+                                                ValueRange inputs,
+                                                Location loc) {
   assert(type.hasStaticShape() &&
          "Can only subview flatten memref's with static shape (for now...).");
   MemRefType sourceType = cast<MemRefType>(inputs[0].getType());
   int64_t memSize = sourceType.getNumElements();
-  unsigned dims = sourceType.getShape().size();
+  ArrayRef<int64_t> sourceShape = sourceType.getShape();
+  ArrayRef<int64_t> targetShape = ArrayRef<int64_t>(memSize);
 
-  // Build offset, sizes and strides
-  SmallVector<OpFoldResult> sizes(dims, builder.getIndexAttr(0));
-  SmallVector<OpFoldResult> offsets(dims, builder.getIndexAttr(1));
-  offsets[offsets.size() - 1] = builder.getIndexAttr(memSize);
-  SmallVector<OpFoldResult> strides(dims, builder.getIndexAttr(1));
+  // Build ReassociationIndices to collapse completely to 1D MemRef.
+  auto indices = getReassociationIndicesForCollapse(sourceShape, targetShape);
+  assert(indices.has_value() && "expected a valid collapse");
 
   // Generate the appropriate return type:
-  MemRefType outType = MemRefType::get({memSize}, type.getElementType());
-  return builder.create<memref::SubViewOp>(loc, outType, inputs[0], sizes,
-                                           offsets, strides);
+  return builder.create<memref::CollapseShapeOp>(loc, inputs[0],
+                                                 indices.value());
 }
 
 static void populateTypeConversionPatterns(TypeConverter &typeConverter) {
@@ -489,7 +490,7 @@ struct FlattenMemRefCallsPass
 
     // Add a target materializer to handle memory flattening through
     // memref.subview operations.
-    typeConverter.addTargetMaterialization(materializeSubViewFlattening);
+    typeConverter.addTargetMaterialization(materializeCollapseShapeFlattening);
 
     if (applyPartialConversion(getOperation(), target, std::move(patterns))
             .failed()) {

llvm

@@ -2,13 +2,14 @@
 
 // CHECK-LABEL:   func private @foo(memref<900xi32>) -> i32
 
-// CHECK-LABEL:   func @main() {
-// CHECK:           %[[VAL_0:.*]] = arith.constant 0 : index
-// CHECK:           %[[VAL_1:.*]] = memref.alloca() : memref<30x30xi32>
-// CHECK:           %[[VAL_2:.*]] = memref.subview %[[VAL_1]][0, 0] [1, 900] [1, 1] : memref<30x30xi32> to memref<900xi32>
-// CHECK:           %[[VAL_3:.*]] = call @foo(%[[VAL_2]]) : (memref<900xi32>) -> i32
-// CHECK:           return
-// CHECK:         }
+// CHECK-LABEL:       func @main() {
+// CHECK:               %[[VAL_0:.*]] = arith.constant 0 : index
+// CHECK:               %[[VAL_1:.*]] = memref.alloca() : memref<30x30xi32>
+// CHECK:               %[[VAL_2:.*]] = memref.collapse_shape %[[VAL_1]]
+// CHECK-SAME{LITERAL}:   [[0, 1]] : memref<30x30xi32> into memref<900xi32>
+// CHECK:               %[[VAL_3:.*]] = call @foo(%[[VAL_2]]) : (memref<900xi32>) -> i32
+// CHECK:               return
+// CHECK:             }
 module  {
   func.func private @foo(memref<30x30xi32>) -> i32
   func.func @main() {