[mlir][AsmPrinter] Refactor printing to only print aliases for attributes/types that will exist in the output.

[rriddle]

Summary

This revision refactors the way that attributes/types are considered when generating aliases. Instead of considering all of the attributes/types of every operation, we perform a "fake" print step that prints the operations using a dummy printer to collect the attributes and types that would actually be printed during the real process. This removes a lot of attributes/types from consideration that generally won't end up in the final output, e.g. affine map attributes in an affine.apply/affine.for.

This resolves a long standing TODO w.r.t aliases, and helps to have a much cleaner textual output format. As a datapoint to the latter, as part of this change several tests were identified as testing for the presence of attributes aliases that weren't actually referenced by the custom form of any operation.

To ensure that this wouldn't cause a large degradation in compile time due to the second full print, I benchmarked this change on a very large module with a lot of operations(The file is ~673M/~4.7 million lines long). This file before this change take ~6.9 seconds to print in the custom form, and ~7 seconds after this change. In the custom assembly case, this added an average of a little over ~100 miliseconds to the compile time. This increase was due to the way that argument attributes on functions are structured and how they get printed; i.e. with a better representation the negative impact here can be greatly decreased. When printing in the generic form, this revision had no observable impact on the compile time. This benchmarking leads me to believe that the impact of this change on compile time w.r.t printing is closely related to print methods that perform a lot of additional/complex processing outside of the OpAsmPrinter.

[mehdi_amini]

mlir/lib/IR/AsmPrinter.cpp

396

Why is this useful?

[mehdi_amini]

LGTM overall

[rriddle]

Resolve comments

mlir/lib/IR/AsmPrinter.cpp

396

Callers of this method rely on the output somewhat resembling an SSA value name, so to maintain this invariant we need to emit something even if it inevitably goes unused. Added a comment.

[mehdi_amini]

mlir/lib/IR/AsmPrinter.cpp

396

OK! Still LGTM :)

mlir/lib/IR/AsmPrinter.cpp

 } // end anonymous namespace
 
 static raw_ostream &operator<<(raw_ostream &os, NewLineCounter &newLine) {
   ++newLine.curLine;
   return os << '\n';
 }
 
 //===----------------------------------------------------------------------===//
-// AliasState
+// AliasInitializer
 //===----------------------------------------------------------------------===//
 
 namespace {
-/// This class manages the state for type and attribute aliases.
-class AliasState {
-public:
-  // Initialize the internal aliases.
-  void
-  initialize(Operation *op,
-             DialectInterfaceCollection<OpAsmDialectInterface> &interfaces);
-
-  /// Get an alias for the given attribute if it has one and print it in `os`.
-  /// Returns success if an alias was printed, failure otherwise.
-  LogicalResult getAlias(Attribute attr, raw_ostream &os) const;
-
-  /// Print all of the referenced attribute aliases.
-  void printAttributeAliases(raw_ostream &os, NewLineCounter &newLine) const;
-
-  /// Get an alias for the given type if it has one and print it in `os`.
-  /// Returns success if an alias was printed, failure otherwise.
-  LogicalResult getAlias(Type ty, raw_ostream &os) const;
-
-  /// Print all of the referenced type aliases.
-  void printTypeAliases(raw_ostream &os, NewLineCounter &newLine) const;
-
-private:
-  /// This class represents a utility that initializes the set of attribute and
-  /// type aliases, without the need to store the extra information within the
-  /// main AliasState class or pass it around via function arguments.
-  class AliasInitializer {
-  public:
-    AliasInitializer(
-        DialectInterfaceCollection<OpAsmDialectInterface> &interfaces,
-        llvm::BumpPtrAllocator &aliasAllocator)
-        : interfaces(interfaces), aliasAllocator(aliasAllocator),
-          aliasOS(aliasBuffer) {}
 
-    void
-    initialize(Operation *op,
-               llvm::MapVector<Attribute, std::pair<StringRef, Optional<int>>>
-                   &attrToAlias,
-               llvm::MapVector<Type, std::pair<StringRef, Optional<int>>>
-                   &typeToAlias);
+  void initialize(
+      Operation *op, const OpPrintingFlags &printerFlags,
+      llvm::MapVector<Type, std::pair<StringRef, Optional<int>>> &typeToAlias);
 
-  private:
-    void visit(Attribute attr);
-    void visit(Type type);
+  /// Visit the given attribute to see if it has an alias.
+
+  /// Visit the given type to see if it has an alias.
 
-    /// Try to generate an alias for the provided symbol. If an alias is
-    /// generated, the provided alias mapping and reverse mapping are updated.
-    template <typename T>
-    void
-    generateAlias(T symbol,
+private:
+  void generateAlias(T symbol,
                      llvm::MapVector<StringRef, std::vector<T>> &aliasToSymbol);
 
-    /// The set of asm interfaces within the context.
-    DialectInterfaceCollection<OpAsmDialectInterface> &interfaces;
 
-    /// Mapping between an alias and the set of symbols mapped to it.
-    llvm::MapVector<StringRef, std::vector<Attribute>> aliasToAttr;
-    llvm::MapVector<StringRef, std::vector<Type>> aliasToType;
 
-    /// An allocator used for alias names.
-    llvm::BumpPtrAllocator &aliasAllocator;
 
-    /// The set of visited attributes.
-    DenseSet<Attribute> visitedAttributes;
 
-    /// The set of visited types.
-    DenseSet<Type> visitedTypes;
 
-    /// Storage and stream used when generating an alias.
-    SmallString<32> aliasBuffer;
-    llvm::raw_svector_ostream aliasOS;
-  };
 
-  /// Mapping between attribute and a pair comprised of a base alias name and a
-  /// count suffix. If the suffix is set to None, it is not displayed.
-  llvm::MapVector<Attribute, std::pair<StringRef, Optional<int>>> attrToAlias;
-  llvm::MapVector<Type, std::pair<StringRef, Optional<int>>> typeToAlias;
+/// This class implements a dummy OpAsmPrinter that doesn't print any output,
+/// and merely collects the attributes and types that *would* be printed in a
+/// normal print invocation so that we can generate proper aliases. This allows
+/// for us to generate aliases only for the attributes and types that would be
+/// in the output, and trims down unnecessary output.
+class DummyAliasOperationPrinter : private OpAsmPrinter {
+public:
+  explicit DummyAliasOperationPrinter(const OpPrintingFlags &flags,
+                                      AliasInitializer &initializer)
+      : printerFlags(flags), initializer(initializer) {}
+
+  /// Print the given operation.
+  void print(Operation *op) {
+    // TODO: Consider the operation location for an alias.
 
-  /// An allocator used for alias names.
-  llvm::BumpPtrAllocator aliasAllocator;
+    // If requested, always print the generic form.
+    if (!printerFlags.shouldPrintGenericOpForm()) {
+      // Check to see if this is a known operation.  If so, use the registered
+      // custom printer hook.
+      if (auto *opInfo = op->getAbstractOperation()) {
+        opInfo->printAssembly(op, *this);
+        return;
+      }
+    }
+
+    // Otherwise print with the generic assembly form.
+    printGenericOp(op);
+  }
+
+private:
+  /// Print the given operation in the generic form.
+  void printGenericOp(Operation *op) override {
+    // Consider nested opertions for aliases.
+    if (op->getNumRegions() != 0) {
+      for (Region &region : op->getRegions())
+        printRegion(region, /*printEntryBlockArgs=*/true,
+                    /*printBlockTerminators=*/true);
+    }
+
+    // Visit all the types used in the operation.
+    for (Type type : op->getOperandTypes())
+      printType(type);
+    for (Type type : op->getResultTypes())
+      printType(type);
+
+    // Consider the attributes of the operation for aliases.
+    for (const NamedAttribute &attr : op->getAttrs())
+      printAttribute(attr.second);
+  }
+
+  /// Print the given block. If 'printBlockArgs' is false, the arguments of the
+  /// block are not printed. If 'printBlockTerminator' is false, the terminator
+  /// operation of the block is not printed.
+  void print(Block *block, bool printBlockArgs = true,
+             bool printBlockTerminator = true) {
+    // Consider the types of the block arguments for aliases if 'printBlockArgs'
+    // is set to true.
+    if (printBlockArgs) {
+      for (Type type : block->getArgumentTypes())
+        printType(type);
+    }
+
+    // Consider the operations within this block, ignoring the terminator if
+    // requested.
+    auto range = llvm::make_range(
+        block->begin(), std::prev(block->end(), printBlockTerminator ? 0 : 1));
+    for (Operation &op : range)
+      print(&op);
+  }
+
+  /// Print the given region.
+  void printRegion(Region &region, bool printEntryBlockArgs,
+                   bool printBlockTerminators) override {
+    if (region.empty())
+      return;
+
+    auto *entryBlock = &region.front();
+    print(entryBlock, printEntryBlockArgs, printBlockTerminators);
+    for (Block &b : llvm::drop_begin(region, 1))
+      print(&b);
+  }
+
+  /// Consider the given type to be printed for an alias.
+  void printType(Type type) override { initializer.visit(type); }
+
+  /// Consider the given attribute to be printed for an alias.
+  void printAttribute(Attribute attr) override { initializer.visit(attr); }
+  void printAttributeWithoutType(Attribute attr) override {
+    printAttribute(attr);
+  }
+
+  /// Print the given set of attributes with names not included within
+  /// 'elidedAttrs'.
+  void printOptionalAttrDict(ArrayRef<NamedAttribute> attrs,
+                             ArrayRef<StringRef> elidedAttrs = {}) override {
+    // Filter out any attributes that shouldn't be included.
+    SmallVector<NamedAttribute, 8> filteredAttrs(
+        llvm::make_filter_range(attrs, [&](NamedAttribute attr) {
+          return !llvm::is_contained(elidedAttrs, attr.first.strref());
+        }));
+    for (const NamedAttribute &attr : filteredAttrs)
+      printAttribute(attr.second);
+  }
+  void printOptionalAttrDictWithKeyword(
+      ArrayRef<NamedAttribute> attrs,
+      ArrayRef<StringRef> elidedAttrs = {}) override {
+    printOptionalAttrDict(attrs, elidedAttrs);
+  }
+
+  /// Return 'nulls' as the output stream, this will ignore any data fed to it.
+  raw_ostream &getStream() const override { return llvm::nulls(); }
+
+  /// The following are hooks of `OpAsmPrinter` that are not necessary for
+  /// determining potential aliases.
+  void printAffineMapOfSSAIds(AffineMapAttr, ValueRange) override {}
+  void printOperand(Value) override {}
+  void printOperand(Value, raw_ostream &os) override {
+    // Users expect the output string to have at least the prefixed % to signal
+    // a value name. To maintain this invariant, emit a name even if it is
+    // guaranteed to go unused.
+    os << "%";
+  }
+  void printSymbolName(StringRef) override {}
+  void printSuccessor(Block *) override {}
+  void printSuccessorAndUseList(Block *, ValueRange) override {}
+  void shadowRegionArgs(Region &, ValueRange) override {}
+
+  /// The printer flags to use when determining potential aliases.
+  const OpPrintingFlags &printerFlags;
+
+  /// The initializer to use when identifying aliases.
+  AliasInitializer &initializer;
 };
 } // end anonymous namespace
 
 /// Sanitize the given name such that it can be used as a valid identifier. If
 /// the string needs to be modified in any way, the provided buffer is used to
 /// store the new copy,
 static StringRef sanitizeIdentifier(StringRef name, SmallString<16> &buffer,
                                     StringRef allowedPunctChars = "$._-",
if (it.second.size() == 1) {
       continue;
     }
     // Otherwise, add the index to the name.
     for (int i = 0, e = it.second.size(); i < e; ++i)
       symbolToAlias.insert({it.second[i], {it.first, i}});
   }
 }
 
-void AliasState::AliasInitializer::initialize(
-    Operation *op,
+void AliasInitializer::initialize(
+    Operation *op, const OpPrintingFlags &printerFlags,
     llvm::MapVector<Attribute, std::pair<StringRef, Optional<int>>>
         &attrToAlias,
     llvm::MapVector<Type, std::pair<StringRef, Optional<int>>> &typeToAlias) {
-  op->walk([&](Operation *op) {
-    // Visit all the types used in the operation.
-    for (auto type : op->getOperandTypes())
-      visit(type);
-    for (auto type : op->getResultTypes())
-      visit(type);
-    for (auto &region : op->getRegions())
-      for (auto &block : region)
-        for (auto arg : block.getArguments())
-          visit(arg.getType());
-
-    // Visit each of the attributes.
-    for (auto elt : op->getAttrs())
-      visit(elt.second);
-  });
+  // Use a dummy printer when walking the IR so that we can collect the
+  // attributes/types that will actually be used during printing when
+  // considering aliases.
+  DummyAliasOperationPrinter aliasPrinter(printerFlags, *this);
+  aliasPrinter.print(op);
 
   // Initialize the aliases sorted by name.
   initializeAliases(aliasToAttr, attrToAlias);
   initializeAliases(aliasToType, typeToAlias);
 }
 
-void AliasState::AliasInitializer::visit(Attribute attr) {
+void AliasInitializer::visit(Attribute attr) {
   if (!visitedAttributes.insert(attr).second)
     return;
 
   if (auto arrayAttr = attr.dyn_cast<ArrayAttr>()) {
     for (Attribute element : arrayAttr.getValue())
       visit(element);
+  } else if (auto dictAttr = attr.dyn_cast<DictionaryAttr>()) {
+    for (const NamedAttribute &attr : dictAttr)
+      visit(attr.second);
   } else if (auto typeAttr = attr.dyn_cast<TypeAttr>()) {
     visit(typeAttr.getValue());
   }
 
   // Try to generate an alias for this attribute.
   generateAlias(attr, aliasToAttr);
 }
 
-void AliasState::AliasInitializer::visit(Type type) {
+void AliasInitializer::visit(Type type) {
   if (!visitedTypes.insert(type).second)
     return;
 
   // Visit several subtypes that contain types or atttributes.
   if (auto funcType = type.dyn_cast<FunctionType>()) {
     // Visit input and result types for functions.
     for (auto input : funcType.getInputs())
       visit(input);
     for (auto result : funcType.getResults())
       visit(result);
   } else if (auto shapedType = type.dyn_cast<ShapedType>()) {
     visit(shapedType.getElementType());
 
     // Visit affine maps in memref type.
     if (auto memref = type.dyn_cast<MemRefType>())
       for (auto map : memref.getAffineMaps())
         visit(AffineMapAttr::get(map));
   }
 
   // Try to generate an alias for this type.
   generateAlias(type, aliasToType);
 }
 
 template <typename T>
-void AliasState::AliasInitializer::generateAlias(
+void AliasInitializer::generateAlias(
     T symbol, llvm::MapVector<StringRef, std::vector<T>> &aliasToSymbol) {
   SmallString<16> tempBuffer;
   for (const auto &interface : interfaces) {
     interface.getAlias(symbol, aliasOS);
     StringRef name = aliasOS.str();
     if (name.empty())
       continue;
     name = sanitizeIdentifier(name, tempBuffer, /*allowedPunctChars=*/"$_-",
                               /*allowTrailingDigit=*/false);
     name = name.copy(aliasAllocator);
 
     aliasToSymbol[name].push_back(symbol);
     aliasBuffer.clear();
     break;
   }
 }
 
+//===----------------------------------------------------------------------===//
+// AliasState
+//===----------------------------------------------------------------------===//
+
+namespace {
+/// This class manages the state for type and attribute aliases.
+class AliasState {
+public:
+  // Initialize the internal aliases.
+  void
+  initialize(Operation *op, const OpPrintingFlags &printerFlags,
+             DialectInterfaceCollection<OpAsmDialectInterface> &interfaces);
+
+  /// Get an alias for the given attribute if it has one and print it in `os`.
+  /// Returns success if an alias was printed, failure otherwise.
+  LogicalResult getAlias(Attribute attr, raw_ostream &os) const;
+
+  /// Print all of the referenced attribute aliases.
+  void printAttributeAliases(raw_ostream &os, NewLineCounter &newLine) const;
+
+  /// Get an alias for the given type if it has one and print it in `os`.
+  /// Returns success if an alias was printed, failure otherwise.
+  LogicalResult getAlias(Type ty, raw_ostream &os) const;
+
+  /// Print all of the referenced type aliases.
+  void printTypeAliases(raw_ostream &os, NewLineCounter &newLine) const;
+
+private:
+  /// Mapping between attribute and a pair comprised of a base alias name and a
+  /// count suffix. If the suffix is set to None, it is not displayed.
+  llvm::MapVector<Attribute, std::pair<StringRef, Optional<int>>> attrToAlias;
+  llvm::MapVector<Type, std::pair<StringRef, Optional<int>>> typeToAlias;
+
+  /// An allocator used for alias names.
+  llvm::BumpPtrAllocator aliasAllocator;
+};
+} // end anonymous namespace
+
 void AliasState::initialize(
-    Operation *op,
+    Operation *op, const OpPrintingFlags &printerFlags,
     DialectInterfaceCollection<OpAsmDialectInterface> &interfaces) {
   AliasInitializer initializer(interfaces, aliasAllocator);
-  initializer.initialize(op, attrToAlias, typeToAlias);
+  initializer.initialize(op, printerFlags, attrToAlias, typeToAlias);
 }
 
 static void printAlias(raw_ostream &os,
                        const std::pair<StringRef, Optional<int>> &alias,
                        char prefix) {
   os << prefix << alias.first;
   if (alias.second)
     os << *alias.second;

 namespace detail {
 class AsmStateImpl {
 public:
   explicit AsmStateImpl(Operation *op, AsmState::LocationMap *locationMap)
       : interfaces(op->getContext()), nameState(op, interfaces),
         locationMap(locationMap) {}
 
   /// Initialize the alias state to enable the printing of aliases.
-  void initializeAliases(Operation *op) {
-    aliasState.initialize(op, interfaces);
+  void initializeAliases(Operation *op, const OpPrintingFlags &printerFlags) {
+    aliasState.initialize(op, printerFlags, interfaces);
   }
 
   /// Get an instance of the OpAsmDialectInterface for the given dialect, or
   /// null if one wasn't registered.
   const OpAsmDialectInterface *getOpAsmInterface(Dialect *dialect) {
     return interfaces.getInterfaceFor(dialect);
   }
 
if (!block->getParent()) {
         printBlockName(pred.second);
       });
     }
     os << newLine;
   }
 
   currentIndent += indentWidth;
   auto range = llvm::make_range(
-      block->getOperations().begin(),
-      std::prev(block->getOperations().end(), printBlockTerminator ? 0 : 1));
+      block->begin(), std::prev(block->end(), printBlockTerminator ? 0 : 1));
   for (auto &op : range) {
     print(&op);
     os << newLine;
   }
   currentIndent -= indentWidth;
 }
 
 void OperationPrinter::printValueID(Value value, bool printResultNo,
void Block::printAsOperand(raw_ostream &os, AsmState &state) {
   printer.printBlockName(this);
 }
 
 void ModuleOp::print(raw_ostream &os, OpPrintingFlags flags) {
   AsmState state(*this);
 
   // Don't populate aliases when printing at local scope.
   if (!flags.shouldUseLocalScope())
-    state.getImpl().initializeAliases(*this);
+    state.getImpl().initializeAliases(*this, flags);
   print(os, state, flags);
 }
 void ModuleOp::print(raw_ostream &os, AsmState &state, OpPrintingFlags flags) {
   OperationPrinter(os, flags, state.getImpl()).print(*this);
 }
 
 void ModuleOp::dump() { print(llvm::errs()); }

mlir/test/Conversion/LinalgToVector/linalg-to-vector.mlir

 // RUN: mlir-opt %s -test-conv-vectorization="tile-sizes=1,3" --cse | FileCheck %s
 
 // CHECK-DAG:  #[[$map0:.*]] = affine_map<(d0)[s0] -> (1, -d0 + s0)>
 // CHECK-DAG:  #[[$map1:.*]] = affine_map<(d0)[s0] -> (d0 + s0)>
 // CHECK-DAG:  #[[$map2:.*]] = affine_map<(d0, d1) -> (d0 + d1)>
 // CHECK-DAG:  #[[$map3:.*]] = affine_map<(d0, d1)[s0] -> (3, -d0 - d1 + s0)>
 // CHECK-DAG:  #[[$map4:.*]] = affine_map<(d0)[s0] -> (3, -d0 + s0)>
-// CHECK-DAG:  #[[$map5:.*]] = affine_map<(d0) -> (d0)>
 
 func @conv_1d(%arg0: memref<?xf32>, %arg1: memref<?xf32>, %arg2: memref<?xf32>) {
   linalg.conv_1d ins(%arg0, %arg1 : memref<?xf32>, memref<?xf32>)
                 outs(%arg2 : memref<?xf32>)
   return
 }
 
 // CHECK-LABEL: @conv_1d

mlir/test/Conversion/VectorToSCF/vector-to-loops.mlir

func @materialize_read_1d_partially_specialized(%dyn1 : index, %dyn2 : index, %dyn4 : index) {
   // CHECK: %[[tensor:[0-9]+]] = alloc
   // CHECK-NOT: {{.*}} dim %[[tensor]], %c0
   // CHECK-NOT: {{.*}} dim %[[tensor]], %c3
   return
 }
 
 // -----
 
-// CHECK: #[[$ADD:map[0-9]+]] = affine_map<(d0, d1) -> (d0 + d1)>
+// CHECK: #[[$ADD:map.*]] = affine_map<(d0, d1) -> (d0 + d1)>
 
 // CHECK-LABEL: func @materialize_read(%{{.*}}: index, %{{.*}}: index, %{{.*}}: index, %{{.*}}: index) {
 func @materialize_read(%M: index, %N: index, %O: index, %P: index) {
   %f0 = constant 0.0: f32
   // CHECK-DAG:  %[[ALLOC:.*]] = alloca() : memref<5x4xvector<3xf32>>
   // CHECK-DAG:  %[[C0:.*]] = constant 0 : index
   // CHECK-DAG:  %[[C1:.*]] = constant 1 : index
   // CHECK-DAG:  %[[C3:.*]] = constant 3 : index
affine.for %i1 = 0 to %N {
       }
     }
   }
   return
 }
 
 // -----
 
-// CHECK: #[[$ADD:map[0-9]+]] = affine_map<(d0, d1) -> (d0 + d1)>
+// CHECK: #[[$ADD:map.*]] = affine_map<(d0, d1) -> (d0 + d1)>
 
 // CHECK-LABEL:func @materialize_write(%{{.*}}: index, %{{.*}}: index, %{{.*}}: index, %{{.*}}: index) {
 func @materialize_write(%M: index, %N: index, %O: index, %P: index) {
   // CHECK-DAG:  %[[ALLOC:.*]] = alloca() : memref<5x4xvector<3xf32>>
   // CHECK-DAG:  %{{.*}} = constant dense<1.000000e+00> : vector<5x4x3xf32>
   // CHECK-DAG:  %[[C0:.*]] = constant 0 : index
   // CHECK-DAG:  %[[C1:.*]] = constant 1 : index
   // CHECK-DAG:  %[[C3:.*]] = constant 3 : index
affine.for %i0 = 0 to %M step 3 {
     }
   }
   return
 }
 
 // -----
 
 // CHECK-DAG: #[[$MAP0:.*]] = affine_map<(d0)[s0] -> (d0 + s0)>
-// CHECK-DAG: #[[$MAP1:.*]] = affine_map<(d0, d1) -> (d1)>
 
-// FULL-UNROLL-DAG: #[[$MAP0:.*]] = affine_map<(d0, d1) -> (d1)>
 // FULL-UNROLL-DAG: #[[$MAP1:.*]] = affine_map<()[s0] -> (s0 + 1)>
 // FULL-UNROLL-DAG: #[[$MAP2:.*]] = affine_map<()[s0] -> (s0 + 2)>
 
 
 // CHECK-LABEL: transfer_read_progressive(
 //  CHECK-SAME:   %[[A:[a-zA-Z0-9]+]]: memref<?x?xf32>,
 //  CHECK-SAME:   %[[base:[a-zA-Z0-9]+]]: index
 
%f = vector.transfer_read %A[%base, %base], %f7 :
     memref<?x?xf32>, vector<3x15xf32>
 
   return %f: vector<3x15xf32>
 }
 
 // -----
 
 // CHECK-DAG: #[[$MAP0:.*]] = affine_map<(d0)[s0] -> (d0 + s0)>
-// CHECK-DAG: #[[$MAP1:.*]] = affine_map<(d0, d1) -> (d1)>
 
-// FULL-UNROLL-DAG: #[[$MAP0:.*]] = affine_map<(d0, d1) -> (d1)>
 // FULL-UNROLL-DAG: #[[$MAP1:.*]] = affine_map<()[s0] -> (s0 + 1)>
 // FULL-UNROLL-DAG: #[[$MAP2:.*]] = affine_map<()[s0] -> (s0 + 2)>
 
 // CHECK-LABEL: transfer_write_progressive(
 //  CHECK-SAME:   %[[A:[a-zA-Z0-9]+]]: memref<?x?xf32>,
 //  CHECK-SAME:   %[[base:[a-zA-Z0-9]+]]: index,
 //  CHECK-SAME:   %[[vec:[a-zA-Z0-9]+]]: vector<3x15xf32>
 // FULL-UNROLL-LABEL: transfer_write_progressive(
func @transfer_write_progressive(%A : memref<?x?xf32>, %base: index, %vec: vector<3x15xf32>) {
   vector.transfer_write %vec, %A[%base, %base] :
     vector<3x15xf32>, memref<?x?xf32>
   return
 }
 
 // -----
 
 // CHECK-DAG: #[[$MAP0:.*]] = affine_map<(d0)[s0] -> (d0 + s0)>
-// CHECK-DAG: #[[$MAP1:.*]] = affine_map<(d0, d1) -> (d1)>
 
-// FULL-UNROLL-DAG: #[[$MAP0:.*]] = affine_map<(d0, d1) -> (d1)>
 // FULL-UNROLL-DAG: #[[$MAP1:.*]] = affine_map<()[s0] -> (s0 + 1)>
 // FULL-UNROLL-DAG: #[[$MAP2:.*]] = affine_map<()[s0] -> (s0 + 2)>
 
 // CHECK-LABEL: transfer_write_progressive_unmasked(
 //  CHECK-SAME:   %[[A:[a-zA-Z0-9]+]]: memref<?x?xf32>,
 //  CHECK-SAME:   %[[base:[a-zA-Z0-9]+]]: index,
 //  CHECK-SAME:   %[[vec:[a-zA-Z0-9]+]]: vector<3x15xf32>
 // FULL-UNROLL-LABEL: transfer_write_progressive_unmasked(

mlir/test/Dialect/Affine/SuperVectorize/vectorize_2d.mlir

 // RUN: mlir-opt %s -affine-super-vectorize="virtual-vector-size=4,8" | FileCheck %s -check-prefix=VECT
 // RUN: mlir-opt %s -affine-super-vectorize="virtual-vector-size=32,256 test-fastest-varying=1,0" | FileCheck %s
 
 // Permutation maps used in vectorization.
 // CHECK-DAG: #[[$map_id1:map[0-9]+]] = affine_map<(d0) -> (d0)>
-// CHECK-DAG: #[[$map_id2:map[0-9]+]] = affine_map<(d0, d1) -> (d0, d1)>
 // CHECK-DAG: #[[$map_proj_d0d1_zerod1:map[0-9]+]] = affine_map<(d0, d1) -> (0, d1)>
 // CHECK-DAG: #[[$map_proj_d0d1_d0zero:map[0-9]+]] = affine_map<(d0, d1) -> (d0, 0)>
 // VECT-DAG: #[[$map_id1:map[0-9]+]] = affine_map<(d0) -> (d0)>
-// VECT-DAG: #[[$map_id2:map[0-9]+]] = affine_map<(d0, d1) -> (d0, d1)>
 // VECT-DAG: #[[$map_proj_d0d1_zerod1:map[0-9]+]] = affine_map<(d0, d1) -> (0, d1)>
 // VECT-DAG: #[[$map_proj_d0d1_d0zero:map[0-9]+]] = affine_map<(d0, d1) -> (d0, 0)>
 
 func @vec2d(%A : memref<?x?x?xf32>) {
    %c0 = constant 0 : index
    %c1 = constant 1 : index
    %c2 = constant 2 : index
    %M = dim %A, %c0 : memref<?x?x?xf32>

mlir/test/Dialect/Affine/SuperVectorize/vectorize_3d.mlir

 // RUN: mlir-opt %s -affine-super-vectorize="virtual-vector-size=32,64,256 test-fastest-varying=2,1,0" | FileCheck %s
 
-// Permutation maps used in vectorization.
-// CHECK: #[[map_proj_d0d1d2_d0d1d2:map[0-9]+]] = affine_map<(d0, d1, d2) -> (d0, d1, d2)>
-
 func @vec3d(%A : memref<?x?x?xf32>) {
   %c0 = constant 0 : index
   %c1 = constant 1 : index
   %c2 = constant 2 : index
   %0 = dim %A, %c0 : memref<?x?x?xf32>
   %1 = dim %A, %c1 : memref<?x?x?xf32>
   %2 = dim %A, %c2 : memref<?x?x?xf32>
   // CHECK: affine.for %{{.*}} = 0 to %{{.*}} {

mlir/test/Dialect/Affine/SuperVectorize/vectorize_outer_loop_2d.mlir

 // RUN: mlir-opt %s -affine-super-vectorize="virtual-vector-size=32,256 test-fastest-varying=2,0" | FileCheck %s
 
 // Permutation maps used in vectorization.
-// CHECK: #[[map_proj_d0d1d2_d0d2:map[0-9]+]] = affine_map<(d0, d1, d2) -> (d0, d2)>
+// CHECK: #[[map_proj_d0d1d2_d0d2:map[0-9]*]] = affine_map<(d0, d1, d2) -> (d0, d2)>
 
 func @vec2d(%A : memref<?x?x?xf32>) {
   %c0 = constant 0 : index
   %c1 = constant 1 : index
   %c2 = constant 2 : index
   %M = dim %A, %c0 : memref<?x?x?xf32>
   %N = dim %A, %c1 : memref<?x?x?xf32>
   %P = dim %A, %c2 : memref<?x?x?xf32>

mlir/test/Dialect/Affine/SuperVectorize/vectorize_outer_loop_transpose_2d.mlir

 // RUN: mlir-opt %s -affine-super-vectorize="virtual-vector-size=32,256 test-fastest-varying=0,2" | FileCheck %s
 
 // Permutation maps used in vectorization.
-// CHECK: #[[map_proj_d0d1d2_d2d0:map[0-9]+]] = affine_map<(d0, d1, d2) -> (d2, d0)>
+// CHECK: #[[map_proj_d0d1d2_d2d0:map[0-9]*]] = affine_map<(d0, d1, d2) -> (d2, d0)>
 
 func @vec2d(%A : memref<?x?x?xf32>) {
   %c0 = constant 0 : index
   %c1 = constant 1 : index
   %c2 = constant 2 : index
   %M = dim %A, %c0 : memref<?x?x?xf32>
   %N = dim %A, %c1 : memref<?x?x?xf32>
   %P = dim %A, %c2 : memref<?x?x?xf32>

mlir/test/Dialect/Affine/SuperVectorize/vectorize_transpose_2d.mlir

 // RUN: mlir-opt %s -affine-super-vectorize="virtual-vector-size=32,256 test-fastest-varying=0,1" | FileCheck %s
 
 // Permutation maps used in vectorization.
-// CHECK-DAG: #[[map_proj_d0d1d2_d2d1:map[0-9]+]] = affine_map<(d0, d1, d2) -> (d2, d1)>
+// CHECK-DAG: #[[map_proj_d0d1d2_d2d1:map[0-9]*]] = affine_map<(d0, d1, d2) -> (d2, d1)>
 
 func @vec2d(%A : memref<?x?x?xf32>) {
   %c0 = constant 0 : index
   %c1 = constant 1 : index
   %c2 = constant 2 : index
   %M = dim %A, %c0 : memref<?x?x?xf32>
   %N = dim %A, %c1 : memref<?x?x?xf32>
   %P = dim %A, %c2 : memref<?x?x?xf32>

mlir/test/Dialect/Affine/affine-loop-invariant-code-motion.mlir

func @store_affine_apply() -> memref<10xf32> {
   affine.for %arg0 = 0 to 10 {
       %t0 = affine.apply affine_map<(d1) -> (d1 + 1)>(%arg0)
       affine.store %cf7, %m[%t0] : memref<10xf32>
   }
   return %m : memref<10xf32>
 // CHECK:       %cst = constant 7.000000e+00 : f32
 // CHECK-NEXT:  %0 = alloc() : memref<10xf32>
 // CHECK-NEXT:  affine.for %arg0 = 0 to 10 {
-// CHECK-NEXT:      %1 = affine.apply #map{{[0-9]+}}(%arg0)
+// CHECK-NEXT:      %1 = affine.apply #map{{[0-9]*}}(%arg0)
 // CHECK-NEXT:      affine.store %cst, %0[%1] : memref<10xf32>
 // CHECK-NEXT:  }
 // CHECK-NEXT:  return %0 : memref<10xf32>
 }
 
 // -----
 
 func @nested_loops_code_invariant_to_both() {
affine.if affine_set<(d0, d1) : (d1 - d0 >= 0)> (%arg0, %t0) {
         affine.store %cf9, %m[%arg0] : memref<10xf32>
 
     }
   }
 
   // CHECK: %0 = alloc() : memref<10xf32>
   // CHECK-NEXT: %cst = constant 8.000000e+00 : f32
   // CHECK-NEXT: affine.for %arg0 = 0 to 10 {
-  // CHECK-NEXT: %1 = affine.apply #map{{[0-9]+}}(%arg0)
+  // CHECK-NEXT: %1 = affine.apply #map{{[0-9]*}}(%arg0)
   // CHECK-NEXT: affine.if #set(%arg0, %1) {
   // CHECK-NEXT: %2 = addf %cst, %cst : f32
   // CHECK-NEXT: affine.store %2, %0[%arg0] : memref<10xf32>
   // CHECK-NEXT: }
 
 
   return
 }

mlir/test/Dialect/Affine/canonicalize.mlir

func @canonicalize_bounds(%M : index, %N : index) {
   }
   return
 }
 
 // -----
 
 // Compose maps into affine load and store ops.
 
-// CHECK-DAG: #map{{[0-9]+}} = affine_map<(d0) -> (d0 + 1)>
-
 // CHECK-LABEL: @compose_into_affine_load_store
 func @compose_into_affine_load_store(%A : memref<1024xf32>, %u : index) {
   // CHECK: affine.for %[[IV:.*]] = 0 to 1024
   affine.for %i = 0 to 1024 {
     // Make sure the unused operand (%u below) gets dropped as well.
     %idx = affine.apply affine_map<(d0, d1) -> (d0 + 1)> (%i, %u)
     %0 = affine.load %A[%idx] : memref<1024xf32>
     affine.store %0, %A[%idx] : memref<1024xf32>
func @rep(%arg0 : index, %arg1 : index) -> index {
   %0 = affine.apply #map1(%arg0)[%c1024, %c0]
 
   // CHECK: affine.min #[[$MAP]]()[%[[ARG1]], %[[ARG0]]]
   %1 = affine.min #map2(%0)[%arg1]
   return %1 : index
 }
 
 // -----
-// CHECK-DAG: #[[lb:.*]] = affine_map<()[s0] -> (s0)>
+
 // CHECK-DAG: #[[ub:.*]] = affine_map<()[s0] -> (s0 + 2)>
 
 func @drop_duplicate_bounds(%N : index) {
   // affine.for %i = max #lb(%arg0) to min #ub(%arg0)
   affine.for %i = max affine_map<(d0) -> (d0, d0)>(%N) to min affine_map<(d0) -> (d0 + 2, d0 + 2)>(%N) {
     "foo"() : () -> ()
   }
   return

mlir/test/Dialect/Affine/dma-generate.mlir

 // RUN: mlir-opt -allow-unregistered-dialect %s -split-input-file -affine-data-copy-generate="generate-dma fast-mem-space=2 skip-non-unit-stride-loops" -verify-diagnostics | FileCheck %s
 // RUN: mlir-opt -allow-unregistered-dialect %s -split-input-file -affine-data-copy-generate="generate-dma fast-mem-capacity=16 fast-mem-space=2" | FileCheck %s --check-prefix FAST-MEM-16KB
 
 // We run most test cases with -copy-skip-non-unit-stride-loops to allow testing
 // DMA generation at inner levels easily - since the DMA generation would
 // otherwise always generate DMAs at the outermost level (default for fast mem
 // capacity is infinite). Using a specific capacity makes it harder to write
 // a test case as one would have to calculate total footprints. With
 // -copy-skip-non-unit-stride-loops, non-unit strides will always be skipped and
 // its inner loops will be traversed till a unit stride loop is found (or the
 // innermost block is reached).
 
 // -----
 
-// Index of the buffer for the second DMA is remapped.
-// CHECK-DAG: [[MAP0:#map[0-9]+]] = affine_map<(d0) -> (d0)>
-
 // CHECK-LABEL: func @loop_nest_1d() {
 func @loop_nest_1d() {
   %A = alloc() : memref<256 x f32>
   %B = alloc() : memref<512 x f32>
   %F = alloc() : memref<256 x f32, 2>
   // First DMA buffer.
   // CHECK:  alloc() : memref<256xf32>
   // CHECK:  alloc() : memref<256xf32, 2>

mlir/test/Dialect/Affine/dma.mlir

 // RUN: mlir-opt %s -split-input-file | FileCheck %s
 
 // -----
 
-// CHECK: [[MAP0:#map[0-9]+]] = affine_map<(d0, d1) -> (d0, d1)>
-
 // Test with loop IVs.
 func @test0(%arg0 : index, %arg1 : index) {
   %0 = alloc() : memref<100x100xf32>
   %1 = alloc() : memref<100x100xf32, affine_map<(d0, d1) -> (d0, d1)>, 2>
   %2 = alloc() : memref<1xi32>
   %c0 = constant 0 : index
   %c64 = constant 64 : index
   affine.for %i0 = 0 to 10 {
     affine.for %i1 = 0 to 10 {
       affine.dma_start %0[%i0, %i1], %1[%i0, %i1], %2[%c0], %c64
         : memref<100x100xf32>, memref<100x100xf32, 2>, memref<1xi32>
       affine.dma_wait %2[%c0], %c64 : memref<1xi32>
 // CHECK: affine.dma_start %{{.*}}[%{{.*}}, %{{.*}}], %{{.*}}[%{{.*}}, %{{.*}}], %{{.*}}[%{{.*}}], %{{.*}} : memref<100x100xf32>, memref<100x100xf32, 2>, memref<1xi32>
 // CHECK: affine.dma_wait %{{.*}}[%{{.*}}], %{{.*}} : memref<1xi32>
     }
   }
   return
 }
 
 // -----
 
-// CHECK: [[MAP0:#map[0-9]+]] = affine_map<(d0, d1) -> (d0, d1)>
-
 // Test with loop IVs and optional stride arguments.
 func @test1(%arg0 : index, %arg1 : index) {
   %0 = alloc() : memref<100x100xf32>
   %1 = alloc() : memref<100x100xf32, affine_map<(d0, d1) -> (d0, d1)>, 2>
   %2 = alloc() : memref<1xi32>
   %c0 = constant 0 : index
   %c64 = constant 64 : index
   %c128 = constant 128 : index
   %c256 = constant 256 : index
   affine.for %i0 = 0 to 10 {
     affine.for %i1 = 0 to 10 {
       affine.dma_start %0[%i0, %i1], %1[%i0, %i1], %2[%c0], %c64, %c128, %c256
         : memref<100x100xf32>, memref<100x100xf32, 2>, memref<1xi32>
       affine.dma_wait %2[%c0], %c64 : memref<1xi32>
 // CHECK: affine.dma_start %{{.*}}[%{{.*}}, %{{.*}}], %{{.*}}[%{{.*}}, %{{.*}}], %{{.*}}[%{{.*}}], %{{.*}}, %{{.*}}, %{{.*}} : memref<100x100xf32>, memref<100x100xf32, 2>, memref<1xi32>
 // CHECK: affine.dma_wait %{{.*}}[%{{.*}}], %{{.*}} : memref<1xi32>
     }
   }
   return
 }
 
 // -----
 
-// CHECK: [[MAP0:#map[0-9]+]] = affine_map<(d0, d1, d2) -> (d0, d1 + d2 + 5)>
-// CHECK: [[MAP1:#map[0-9]+]] = affine_map<(d0, d1, d2) -> (d0 + d1, d2)>
-
 // Test with loop IVs and symbols (without symbol keyword).
 func @test2(%arg0 : index, %arg1 : index) {
   %0 = alloc() : memref<100x100xf32>
   %1 = alloc() : memref<100x100xf32, affine_map<(d0, d1) -> (d0, d1)>, 2>
   %2 = alloc() : memref<1xi32>
   %c0 = constant 0 : index
   %c64 = constant 64 : index
   affine.for %i0 = 0 to 10 {
     affine.for %i1 = 0 to 10 {
       affine.dma_start %0[%i0 + %arg0, %i1], %1[%i0, %i1 + %arg1 + 5],
                        %2[%c0], %c64
         : memref<100x100xf32>, memref<100x100xf32, 2>, memref<1xi32>
       affine.dma_wait %2[%c0], %c64 : memref<1xi32>
 // CHECK: affine.dma_start %{{.*}}[%{{.*}} + %{{.*}}, %{{.*}}], %{{.*}}[%{{.*}}, %{{.*}} + %{{.*}} + 5], %{{.*}}[%{{.*}}], %{{.*}} : memref<100x100xf32>, memref<100x100xf32, 2>, memref<1xi32>
 // CHECK: affine.dma_wait %{{.*}}[%{{.*}}], %{{.*}} : memref<1xi32>
     }
   }
   return
 }
 
 // -----
 
-// CHECK: [[MAP0:#map[0-9]+]] = affine_map<(d0, d1)[s0] -> (d0, d1 + s0 + 7)>
-// CHECK: [[MAP1:#map[0-9]+]] = affine_map<(d0, d1)[s0] -> (d0 + s0, d1)>
-// CHECK: [[MAP1:#map[0-9]+]] = affine_map<(d0, d1) -> (d0 + d1 + 11)>
-
 // Test with loop IVs and symbols (with symbol keyword).
 func @test3(%arg0 : index, %arg1 : index) {
   %0 = alloc() : memref<100x100xf32>
   %1 = alloc() : memref<100x100xf32, affine_map<(d0, d1) -> (d0, d1)>, 2>
   %2 = alloc() : memref<1xi32>
   %c0 = constant 0 : index
   %c64 = constant 64 : index
   affine.for %i0 = 0 to 10 {
     affine.for %i1 = 0 to 10 {
       affine.dma_start %0[%i0 + symbol(%arg0), %i1],
                        %1[%i0, %i1 + symbol(%arg1) + 7],
                        %2[%i0 + %i1 + 11], %c64
         : memref<100x100xf32>, memref<100x100xf32, 2>, memref<1xi32>
       affine.dma_wait %2[%c0], %c64 : memref<1xi32>
 // CHECK: affine.dma_start %{{.*}}[%{{.*}} + symbol(%{{.*}}), %{{.*}}], %{{.*}}[%{{.*}}, %{{.*}} + symbol(%{{.*}}) + 7], %{{.*}}[%{{.*}} + %{{.*}} + 11], %{{.*}} : memref<100x100xf32>, memref<100x100xf32, 2>, memref<1xi32>
 // CHECK: affine.dma_wait %{{.*}}[%{{.*}}], %{{.*}} : memref<1xi32>
     }
   }
   return
 }
 
 // -----
 
-// CHECK: [[MAP0:#map[0-9]+]] = affine_map<(d0, d1)[s0] -> (d0, (d1 + s0) mod 9 + 7)>
-// CHECK: [[MAP1:#map[0-9]+]] = affine_map<(d0, d1)[s0] -> ((d0 + s0) floordiv 3, d1)>
-// CHECK: [[MAP2:#map[0-9]+]] = affine_map<(d0, d1) -> (d0 + d1 + 11)>
-
 // Test with loop IVs, symbols and constants in nested affine expressions.
 func @test4(%arg0 : index, %arg1 : index) {
   %0 = alloc() : memref<100x100xf32>
   %1 = alloc() : memref<100x100xf32, 2>
   %2 = alloc() : memref<1xi32>
   %c64 = constant 64 : index
   affine.for %i0 = 0 to 10 {
     affine.for %i1 = 0 to 10 {

mlir/test/Dialect/Affine/load-store.mlir

 // RUN: mlir-opt %s -split-input-file | FileCheck %s
 
 // -----
 
-// CHECK: [[MAP0:#map[0-9]+]] = affine_map<(d0, d1) -> (d0, d1)>
-
 // Test with just loop IVs.
 func @test0(%arg0 : index, %arg1 : index) {
   %0 = alloc() : memref<100x100xf32>
   affine.for %i0 = 0 to 10 {
     affine.for %i1 = 0 to 10 {
       %1 = affine.load %0[%i0, %i1] : memref<100x100xf32>
 // CHECK: %{{.*}} = affine.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<100x100xf32>
     }
   }
   return
 }
 
 // -----
 
-// CHECK: [[MAP0:#map[0-9]+]] = affine_map<(d0, d1) -> (d0 + 3, d1 + 7)>
-
 // Test with loop IVs and constants.
 func @test1(%arg0 : index, %arg1 : index) {
   %0 = alloc() : memref<100x100xf32>
   affine.for %i0 = 0 to 10 {
     affine.for %i1 = 0 to 10 {
       %1 = affine.load %0[%i0 + 3, %i1 + 7] : memref<100x100xf32>
       affine.store %1, %0[%i0 + 3, %i1 + 7] : memref<100x100xf32>
 // CHECK: %{{.*}} = affine.load %{{.*}}[%{{.*}} + 3, %{{.*}} + 7] : memref<100x100xf32>
 // CHECK: affine.store %{{.*}}, %{{.*}}[%{{.*}} + 3, %{{.*}} + 7] : memref<100x100xf32>
     }
   }
   return
 }
 
 // -----
 
-// CHECK: [[MAP0:#map[0-9]+]] = affine_map<(d0, d1, d2, d3) -> (d0 + d1, d2 + d3)>
-
 // Test with loop IVs and function args without 'symbol' keyword (should
 // be parsed as dim identifiers).
 func @test2(%arg0 : index, %arg1 : index) {
   %0 = alloc() : memref<100x100xf32>
   affine.for %i0 = 0 to 10 {
     affine.for %i1 = 0 to 10 {
       %1 = affine.load %0[%i0 + %arg0, %i1 + %arg1] : memref<100x100xf32>
       affine.store %1, %0[%i0 + %arg0, %i1 + %arg1] : memref<100x100xf32>
 // CHECK: %{{.*}} = affine.load %{{.*}}[%{{.*}} + %{{.*}}, %{{.*}} + %{{.*}}] : memref<100x100xf32>
 // CHECK: affine.store %{{.*}}, %{{.*}}[%{{.*}} + %{{.*}}, %{{.*}} + %{{.*}}] : memref<100x100xf32>
     }
   }
   return
 }
 
 // -----
 
-// CHECK: [[MAP0:#map[0-9]+]] = affine_map<(d0, d1)[s0, s1] -> (d0 + s0, d1 + s1)>
-
 // Test with loop IVs and function args with 'symbol' keyword (should
 // be parsed as symbol identifiers).
 func @test3(%arg0 : index, %arg1 : index) {
   %0 = alloc() : memref<100x100xf32>
   affine.for %i0 = 0 to 10 {
     affine.for %i1 = 0 to 10 {
       %1 = affine.load %0[%i0 + symbol(%arg0), %i1 + symbol(%arg1)]
         : memref<100x100xf32>
       affine.store %1, %0[%i0 + symbol(%arg0), %i1 + symbol(%arg1)]
         : memref<100x100xf32>
 // CHECK: %{{.*}} = affine.load %{{.*}}[%{{.*}} + symbol(%{{.*}}), %{{.*}} + symbol(%{{.*}})] : memref<100x100xf32>
 // CHECK: affine.store %{{.*}}, %{{.*}}[%{{.*}} + symbol(%{{.*}}), %{{.*}} + symbol(%{{.*}})] : memref<100x100xf32>
     }
   }
   return
 }
 
 // -----
 
-// CHECK: [[MAP0:#map[0-9]+]] = affine_map<(d0, d1)[s0, s1] -> ((d0 + s0) floordiv 3 + 11, (d1 + s1) mod 4 + 7)>
-
 // Test with loop IVs, symbols and constants in nested affine expressions.
 func @test4(%arg0 : index, %arg1 : index) {
   %0 = alloc() : memref<100x100xf32>
   affine.for %i0 = 0 to 10 {
     affine.for %i1 = 0 to 10 {
       %1 = affine.load %0[(%i0 + symbol(%arg0)) floordiv 3 + 11,
                           (%i1 + symbol(%arg1)) mod 4 + 7] : memref<100x100xf32>
       affine.store %1, %0[(%i0 + symbol(%arg0)) floordiv 3 + 11,
                           (%i1 + symbol(%arg1)) mod 4 + 7] : memref<100x100xf32>
 // CHECK: %{{.*}} = affine.load %{{.*}}[(%{{.*}} + symbol(%{{.*}})) floordiv 3 + 11, (%{{.*}} + symbol(%{{.*}})) mod 4 + 7] : memref<100x100xf32>
 // CHECK: affine.store %{{.*}}, %{{.*}}[(%{{.*}} + symbol(%{{.*}})) floordiv 3 + 11, (%{{.*}} + symbol(%{{.*}})) mod 4 + 7] : memref<100x100xf32>
     }
   }
   return
 }
 
 // -----
 
-// CHECK: [[MAP0:#map[0-9]+]] = affine_map<(d0, d1, d2) -> (d0, d1, d2)>
-
 // Test with swizzled loop IVs.
 func @test5(%arg0 : index, %arg1 : index) {
   %0 = alloc() : memref<10x10x10xf32>
   affine.for %i0 = 0 to 10 {
     affine.for %i1 = 0 to 10 {
       affine.for %i2 = 0 to 10 {
         %1 = affine.load %0[%i2, %i0, %i1] : memref<10x10x10xf32>
         affine.store %1, %0[%i2, %i0, %i1] : memref<10x10x10xf32>
 // CHECK: %{{.*}} = affine.load %{{.*}}[%{{.*}}, %{{.*}}, %{{.*}}] : memref<10x10x10xf32>
 // CHECK: affine.store %{{.*}}, %{{.*}}[%{{.*}}, %{{.*}}, %{{.*}}] : memref<10x10x10xf32>
       }
     }
   }
   return
 }
 
 // -----
 
-// CHECK: [[MAP0:#map[0-9]+]] = affine_map<(d0, d1, d2, d3, d4) -> (d0 + d1, d2 + d3, d3 + d1 + d4)>
-
 // Test with swizzled loop IVs, duplicate args, and function args used as dims.
 // Dim identifiers are assigned in parse order:
 // d0 = %i2, d1 = %arg0, d2 = %i0, d3 = %i1, d4 = %arg1
 func @test6(%arg0 : index, %arg1 : index) {
   %0 = alloc() : memref<10x10x10xf32>
   affine.for %i0 = 0 to 10 {
     affine.for %i1 = 0 to 10 {
       affine.for %i2 = 0 to 10 {
         %1 = affine.load %0[%i2 + %arg0, %i0 + %i1, %i1 + %arg0 + %arg1]
           : memref<10x10x10xf32>
         affine.store %1, %0[%i2 + %arg0, %i0 + %i1, %i1 + %arg0 + %arg1]
           : memref<10x10x10xf32>
 // CHECK: %{{.*}} = affine.load %{{.*}}[%{{.*}} + %{{.*}}, %{{.*}} + %{{.*}}, %{{.*}} + %{{.*}} + %{{.*}}] : memref<10x10x10xf32>
 // CHECK: affine.store %{{.*}}, %{{.*}}[%{{.*}} + %{{.*}}, %{{.*}} + %{{.*}}, %{{.*}} + %{{.*}} + %{{.*}}] : memref<10x10x10xf32>
       }
     }
   }
   return
 }
 
 // -----
 
-// CHECK: [[MAP0:#map[0-9]+]] = affine_map<(d0, d1, d2)[s0, s1] -> (d0 + s0, d1 + d2, d2 + s0 + s1)>
-
 // Test with swizzled loop IVs, duplicate args, and function args used as syms.
 // Dim and symbol identifiers are assigned in parse order:
 // d0 = %i2, d1 = %i0, d2 = %i1
 // s0 = %arg0, s1 = %arg1
 func @test6(%arg0 : index, %arg1 : index) {
   %0 = alloc() : memref<10x10x10xf32>
   affine.for %i0 = 0 to 10 {
     affine.for %i1 = 0 to 10 {
// CHECK: affine.store %{{.*}}, %{{.*}}[%{{.*}} + symbol(%{{.*}}), %{{.*}} + %{{.*}}, %{{.*}} + symbol(%{{.*}}) + symbol(%{{.*}})] : memref<10x10x10xf32>
       }
     }
   }
   return
 }
 
 // -----
 
-// CHECK: [[MAP0:#map[0-9]+]] = affine_map<(d0) -> (d0 + 1)>
+// CHECK: [[MAP0:#map[0-9]*]] = affine_map<(d0) -> (d0 + 1)>
 
 // Test with operands without special SSA name.
 func @test7() {
   %0 = alloc() : memref<10xf32>
   affine.for %i0 = 0 to 10 {
     %1 = affine.apply affine_map<(d1) -> (d1 + 1)>(%i0)
     %2 = affine.load %0[%1] : memref<10xf32>
     affine.store %2, %0[%1] : memref<10xf32>
func @zero_dim(%arg0 : memref<i32>, %arg1 : memref<i32>) {
   affine.store %0, %arg1[] : memref<i32>
   // CHECK: affine.load %{{.*}}[] : memref<i32>
   // CHECK: affine.store %{{.*}}, %{{.*}}[] : memref<i32>
   return
 }
 
 // -----
 
-// CHECK: [[MAP0:#map[0-9]+]] = affine_map<(d0, d1) -> (d0 + 3, d1 + 7)>
-// CHECK: [[MAP1:#map[0-9]+]] = affine_map<(d0, d1) -> (d0 + 3, d1 + 11)>
-
 // Test with loop IVs and constants.
 func @test_prefetch(%arg0 : index, %arg1 : index) {
   %0 = alloc() : memref<100x100xf32>
   affine.for %i0 = 0 to 10 {
     affine.for %i1 = 0 to 10 {
       %1 = affine.load %0[%i0 + 3, %i1 + 7] : memref<100x100xf32>
       affine.prefetch %0[%i0 + 3, %i1 + 11], write, locality<0>, data : memref<100x100xf32>
       // CHECK: affine.prefetch %{{.*}}[%{{.*}} + 3, %{{.*}} + 11], write, locality<0>, data : memref<100x100xf32>
       affine.prefetch %0[%i0, %i1 + 1], read, locality<3>, instr : memref<100x100xf32>
       // CHECK: affine.prefetch %{{.*}}[%{{.*}}, %{{.*}} + 1], read, locality<3>, instr : memref<100x100xf32>
     }
   }
   return
 }
 
 // -----
 
-// CHECK: [[MAP_ID:#map[0-9]+]] = affine_map<(d0, d1) -> (d0, d1)>
-
 // Test with just loop IVs.
 func @vector_load_vector_store_iv() {
   %0 = alloc() : memref<100x100xf32>
   affine.for %i0 = 0 to 16 {
     affine.for %i1 = 0 to 16 step 8 {
       %1 = affine.vector_load %0[%i0, %i1] : memref<100x100xf32>, vector<8xf32>
       affine.vector_store %1, %0[%i0, %i1] : memref<100x100xf32>, vector<8xf32>
 // CHECK:      %[[buf:.*]] = alloc
 // CHECK-NEXT: affine.for %[[i0:.*]] = 0
 // CHECK-NEXT:   affine.for %[[i1:.*]] = 0
 // CHECK-NEXT:     %[[val:.*]] = affine.vector_load %[[buf]][%[[i0]], %[[i1]]] : memref<100x100xf32>, vector<8xf32>
 // CHECK-NEXT:     affine.vector_store %[[val]], %[[buf]][%[[i0]], %[[i1]]] : memref<100x100xf32>, vector<8xf32>
     }
   }
   return
 }
 
 // -----
 
-// CHECK: [[MAP0:#map[0-9]+]] = affine_map<(d0, d1) -> (d0 + 3, d1 + 7)>
-
 // Test with loop IVs and constants.
 func @vector_load_vector_store_iv_constant() {
   %0 = alloc() : memref<100x100xf32>
   affine.for %i0 = 0 to 10 {
     affine.for %i1 = 0 to 16 step 4 {
       %1 = affine.vector_load %0[%i0 + 3, %i1 + 7] : memref<100x100xf32>, vector<4xf32>
       affine.vector_store %1, %0[%i0 + 3, %i1 + 7] : memref<100x100xf32>, vector<4xf32>
 // CHECK:      %[[buf:.*]] = alloc
 // CHECK-NEXT: affine.for %[[i0:.*]] = 0
 // CHECK-NEXT:   affine.for %[[i1:.*]] = 0
 // CHECK-NEXT:     %[[val:.*]] = affine.vector_load %{{.*}}[%{{.*}} + 3, %{{.*}} + 7] : memref<100x100xf32>, vector<4xf32>
 // CHECK-NEXT:     affine.vector_store %[[val]], %[[buf]][%[[i0]] + 3, %[[i1]] + 7] : memref<100x100xf32>, vector<4xf32>
     }
   }
   return
 }
 
 // -----
 
-// CHECK: [[MAP0:#map[0-9]+]] = affine_map<(d0, d1) -> (d0, d1)>
-
 func @vector_load_vector_store_2d() {
   %0 = alloc() : memref<100x100xf32>
   affine.for %i0 = 0 to 16 step 2{
     affine.for %i1 = 0 to 16 step 8 {
       %1 = affine.vector_load %0[%i0, %i1] : memref<100x100xf32>, vector<2x8xf32>
       affine.vector_store %1, %0[%i0, %i1] : memref<100x100xf32>, vector<2x8xf32>
 // CHECK:      %[[buf:.*]] = alloc
 // CHECK-NEXT: affine.for %[[i0:.*]] = 0
 // CHECK-NEXT:   affine.for %[[i1:.*]] = 0
 // CHECK-NEXT:     %[[val:.*]] = affine.vector_load %[[buf]][%[[i0]], %[[i1]]] : memref<100x100xf32>, vector<2x8xf32>
 // CHECK-NEXT:     affine.vector_store %[[val]], %[[buf]][%[[i0]], %[[i1]]] : memref<100x100xf32>, vector<2x8xf32>
     }
   }
   return
 }

mlir/test/Dialect/Affine/loop-tiling-parametric.mlir

func @tile_with_loop_upper_bounds_in_two_symbols(%t11 : index, %arg0: memref<?xf32>, %limit: index) {
   return
 }
 
 // -----
 
 // CHECK-DAG: [[LBI0:#map[0-9]+]] = affine_map<(d0)[s0] -> (d0 * s0)>
 // CHECK-DAG: [[UBI1:#map[0-9]+]] = affine_map<(d0, d1)[s0, s1] -> (d1 * s1 + s1, d0 + s0 + 4)>
 // CHECK-DAG: [[UBI0:#map[0-9]+]] = affine_map<(d0, d1)[s0, s1] -> (d1 * s1 + s1, d0 + s0 + 2)>
-// CHECK-DAG: [[LBO0:#map[0-9]+]] = affine_map<() -> (0)>
 // CHECK-DAG: [[UBO1:#map[0-9]+]] = affine_map<(d0)[s0, s1] -> ((d0 + s0 + 4) ceildiv s1)>
 // CHECK-DAG: [[UBO0:#map[0-9]+]] = affine_map<(d0)[s0, s1] -> ((d0 + s0 + 2) ceildiv s1)>
 
 // CHECK: func @tile_with_upper_bounds_in_dimensions_and_symbols([[ARG0:%arg[0-9]+]]: index, [[ARG1:%arg[0-9]+]]: index, [[ARG2:%arg[0-9]+]]: index, [[ARG3:%arg[0-9]+]]: index{{.*}}){{.*}}
 // CHECK-NEXT: affine.for [[ARG4:%arg[0-9]+]] = 0 to [[UBO0]]({{.*}}){{.*}}[[ARG0]]
 // CHECK-NEXT:   affine.for [[ARG5:%arg[0-9]+]] = 0 to [[UBO1]]({{.*}}){{.*}}[[ARG1]]
 // CHECK-NEXT:     affine.for {{.*}} = [[LBI0]]([[ARG4]]){{.*}}[[ARG0]]{{.*}} to min [[UBI0]]({{.*}}, [[ARG4]]){{.*}}[[ARG0]]{{.*}}
 // CHECK-NEXT:       affine.for {{.*}} = [[LBI0]]([[ARG5]]){{.*}}[[ARG1]]{{.*}} to min [[UBI1]]({{.*}}, [[ARG5]]){{.*}}[[ARG1]]{{.*}}
 func @tile_with_upper_bounds_in_dimensions_and_symbols(%t12 : index, %t13 :index, %M: index, %N:  index, %K: index) {
   affine.for %i = 0 to affine_map<(d0)[s0] -> (d0 + s0 + 2)>(%M)[%K] {
     affine.for %j = 0 to affine_map<(d0)[s0] -> (d0 + s0 + 4)>(%N)[%K] {
       "test.foo" () : () -> ()
     }
   }
   return
 }
 
 // -----
 
 // CHECK-DAG: [[LBI0:#map[0-9]+]] = affine_map<(d0)[s0] -> (d0 * s0)>
 // CHECK-DAG: [[UBI1:#map[0-9]+]] = affine_map<(d0, d1)[s0, s1] -> (d1 * s1 + s1 * 4, d0 + s0 + 4)>
 // CHECK-DAG: [[UBI0:#map[0-9]+]] = affine_map<(d0, d1)[s0, s1] -> (d1 * s1 + s1 * 2, d0 + s0 + 2)>
-// CHECK-DAG: [[LBO0:#map[0-9]+]] = affine_map<() -> (0)>
 // CHECK-DAG: [[UBO1:#map[0-9]+]] = affine_map<(d0)[s0, s1] -> ((d0 + s0 + 4) ceildiv s1)>
 // CHECK-DAG: [[UBO0:#map[0-9]+]] = affine_map<(d0)[s0, s1] -> ((d0 + s0 + 2) ceildiv s1)>
 
 // CHECK: func @tile_with_upper_bounds_in_dimensions_and_symbols_non_unit_steps
 // CHECK-SAME: ([[ARG0:%arg[0-9]+]]: index, [[ARG1:%arg[0-9]+]]: index, [[ARG2:%arg[0-9]+]]: index, [[ARG3:%arg[0-9]+]]: index{{.*}}){{.*}}
 // CHECK-NEXT: affine.for [[ARG4:%arg[0-9]+]] = 0 to [[UBO0]]({{.*}}){{.*}}[[ARG0]]{{.*}} step 2{{.*}}
 // CHECK-NEXT:   affine.for [[ARG5:%arg[0-9]+]] = 0 to [[UBO1]]({{.*}}){{.*}}[[ARG1]]{{.*}} step 4{{.*}}
 // CHECK-NEXT:     affine.for {{.*}} = [[LBI0]]([[ARG4]]){{.*}}[[ARG0]]{{.*}} to min [[UBI0]]({{.*}}, [[ARG4]]){{.*}}[[ARG0]]{{.*}} step 2{{.*}}

mlir/test/Dialect/Affine/loop-tiling-validity.mlir

 // RUN: mlir-opt %s  -split-input-file -affine-loop-tile="tile-size=32" -verify-diagnostics | FileCheck %s
 
 // -----
 
 // There is no dependence violated in this case. No error should be raised.
 
 // CHECK-DAG: [[$LB:#map[0-9]+]] = affine_map<(d0) -> (d0)>
 // CHECK-DAG: [[$UB:#map[0-9]+]] = affine_map<(d0) -> (d0 + 32)>
-// CHECK-DAG: [[$ID:#map[0-9]+]] = affine_map<() -> (0)>
-// CHECK-DAG: [[$ID_PLUS_21:#map[0-9]+]] = affine_map<() -> (64)>
 
 // CHECK-LABEL: func @legal_loop()
 func @legal_loop() {
   %0 = alloc() : memref<64xf32>
 
   affine.for %i = 0 to 64 {
     %1 = affine.load %0[%i] : memref<64xf32>
     %2 = addf %1, %1 : f32
     affine.store %2, %0[%i] : memref<64xf32>
   }
 
-  return 
+  return
 }
 
 // CHECK:   affine.for %{{.*}} = 0 to 64 step 32 {
 // CHECK-NEXT:     affine.for %{{.*}} = [[$LB]](%{{.*}}) to [[$UB]](%{{.*}}) {
 
 // -----
 
-// There are dependences along the diagonal of the 2d iteration space, 
+// There are dependences along the diagonal of the 2d iteration space,
 // specifically, they are of direction (+, -).
 // The default tiling method (hyper-rect) will violate tiling legality.
 // We expect a remark that points that issue out to be emitted.
 
 // CHECK-LABEL: func @illegal_loop_with_diag_dependence
 func @illegal_loop_with_diag_dependence() {
   %A = alloc() : memref<64x64xf32>
 
   affine.for %i = 0 to 64 {
     // expected-remark@above {{tiled code is illegal due to dependences}}
     affine.for %j = 0 to 64 {
       %0 = affine.load %A[%j, %i] : memref<64x64xf32>
       %1 = affine.load %A[%i, %j - 1] : memref<64x64xf32>
       %2 = addf %0, %1 : f32
       affine.store %2, %A[%i, %j] : memref<64x64xf32>
     }
   }
 
-  return 
+  return
 }

mlir/test/Dialect/Affine/loop-tiling.mlir

affine.for %i0 = 0 to %0 {
     }
   }
   return
 }
 
 // CHECK:       dim %{{.*}}, %c0 : memref<?x?xf32>
 // CHECK-NEXT:  affine.for %{{.*}} = 0 to %{{.*}} step 32 {
 // CHECK-NEXT:    affine.for %{{.*}} = 0 to %{{.*}} step 32 {
-// CHECK-NEXT:      affine.for %{{.*}} = #map3(%{{.*}}) to min [[$UBMAP]](%{{.*}})[%{{.*}}] {
-// CHECK-NEXT:        affine.for %{{.*}} = #map3(%{{.*}}) to min [[$UBMAP]](%{{.*}})[%{{.*}}] {
+// CHECK-NEXT:      affine.for %{{.*}} = #map0(%{{.*}}) to min [[$UBMAP]](%{{.*}})[%{{.*}}] {
+// CHECK-NEXT:        affine.for %{{.*}} = #map0(%{{.*}}) to min [[$UBMAP]](%{{.*}})[%{{.*}}] {
 // CHECK-NEXT:          affine.store %{{.*}}, %{{.*}}[%{{.*}}, %{{.*}}] : memref<?x?xf32>
 // CHECK-NEXT:          affine.for %{{.*}} = 0 to %{{.*}} {
 // CHECK-NEXT:            affine.load
 // CHECK-NEXT:            affine.load
 // CHECK-NEXT:            mulf
 // CHECK-NEXT:            affine.load
 // CHECK-NEXT:            addf
 // CHECK-NEXT:            affine.store

mlir/test/Dialect/Affine/parallelize.mlir

 // RUN: mlir-opt %s -allow-unregistered-dialect -affine-parallelize| FileCheck %s
 
-// For multiple nested for-loops.
-// CHECK-DAG: [[MAP5:#map[0-9]+]] = affine_map<(d0, d1, d2, d3, d4, d5, d6, d7) -> (d0 + d1, d2 * 2 + d3, d4 * 2 + d5, d6 + d7)>
 // CHECK-LABEL:    func @reduce_window_max() {
 func @reduce_window_max() {
   %cst = constant 0.000000e+00 : f32
   %0 = alloc() : memref<1x8x8x64xf32>
   %1 = alloc() : memref<1x18x18x64xf32>
   affine.for %arg0 = 0 to 1 {
     affine.for %arg1 = 0 to 8 {
       affine.for %arg2 = 0 to 8 {

mlir/test/Dialect/Affine/simplify-affine-structures.mlir

func @affine.apply(%N : index) {
   addi %v, %v : index
   // CHECK: affine.apply #map{{.*}}()[%arg0]
   // CHECK-NEXT: addi
   return
 }
 
 // -----
 
-// CHECK-DAG: #[[MAP_0D:.*]] = affine_map<() -> ()>
-
 // CHECK-LABEL: func @simplify_zero_dim_map
 func @simplify_zero_dim_map(%in : memref<f32>) -> f32 {
   %out = affine.load %in[] : memref<f32>
   return %out : f32
 }
 
 // -----
 

mlir/test/Dialect/GPU/mapping.mlir

 // RUN: mlir-opt -test-gpu-greedy-parallel-loop-mapping -split-input-file %s | FileCheck %s
 
 func @parallel_loop(%arg0 : index, %arg1 : index, %arg2 : index,
                     %arg3 : index) {
   %zero = constant 0 : index
   %one = constant 1 : index
   %four = constant 4 : index
   scf.parallel (%i0, %i1) = (%arg0, %arg1) to (%arg2, %arg3)
                                           step (%four, %four)  {
     scf.parallel (%si0, %si1) = (%zero, %zero) to (%four, %four)
                                             step (%one, %one)  {
     }
   }
   return
 }
 
+// CHECK: #[[$MAP:.*]] = affine_map<(d0) -> (d0)>
 // CHECK-LABEL:   func @parallel_loop(
-// CHECK:           scf.parallel 
-// CHECK:             scf.parallel 
-// CHECK:      {mapping = [{bound = affine_map<(d0) -> (d0)>, map = affine_map<(d0) -> (d0)>, processor = 3 : i64},
-// CHECK-SAME:             {bound = affine_map<(d0) -> (d0)>, map = affine_map<(d0) -> (d0)>, processor = 4 : i64}]}
-// CHECK:      {mapping = [{bound = affine_map<(d0) -> (d0)>, map = affine_map<(d0) -> (d0)>, processor = 0 : i64},
-// CHECK-SAME:             {bound = affine_map<(d0) -> (d0)>, map = affine_map<(d0) -> (d0)>, processor = 1 : i64}]}
+// CHECK:           scf.parallel
+// CHECK:             scf.parallel
+// CHECK:      {mapping = [{bound = #[[$MAP]], map = #[[$MAP]], processor = 3 : i64},
+// CHECK-SAME:             {bound = #[[$MAP]], map = #[[$MAP]], processor = 4 : i64}]}
+// CHECK:      {mapping = [{bound = #[[$MAP]], map = #[[$MAP]], processor = 0 : i64},
+// CHECK-SAME:             {bound = #[[$MAP]], map = #[[$MAP]], processor = 1 : i64}]}
 // CHECK-NOT: mapping
 
 // -----
 
 func @parallel_loop_4d(%arg0 : index, %arg1 : index, %arg2 : index,
                        %arg3 : index) {
   %zero = constant 0 : index
   %one = constant 1 : index
   %four = constant 4 : index
   scf.parallel (%i0, %i1, %i2, %i3) = (%zero, %zero, %zero, %zero) to (%arg0, %arg1, %arg2, %arg3)
                                        step (%four, %four, %four, %four)  {
     scf.parallel (%si0, %si1, %si2, %si3) = (%zero, %zero, %zero, %zero) to (%four, %four, %four, %four)
                                              step (%one, %one, %one, %one)  {
       scf.parallel (%ti0, %ti1, %ti2, %ti3) = (%zero, %zero, %zero, %zero) to (%four, %four, %four, %four)
                                                step (%one, %one, %one, %one)  {
       }
     }
   }
   return
 }
 
+// CHECK: #[[$MAP:.*]] = affine_map<(d0) -> (d0)>
 // CHECK-LABEL:   func @parallel_loop_4d(
-// CHECK:           scf.parallel 
-// CHECK:             scf.parallel 
+// CHECK:           scf.parallel
+// CHECK:             scf.parallel
 // CHECK:               scf.parallel
-// CHECK:      {mapping = [{bound = affine_map<(d0) -> (d0)>, map = affine_map<(d0) -> (d0)>, processor = 6 : i64},
-// CHECK-SAME:             {bound = affine_map<(d0) -> (d0)>, map = affine_map<(d0) -> (d0)>, processor = 6 : i64},
-// CHECK-SAME:             {bound = affine_map<(d0) -> (d0)>, map = affine_map<(d0) -> (d0)>, processor = 6 : i64},
-// CHECK-SAME:             {bound = affine_map<(d0) -> (d0)>, map = affine_map<(d0) -> (d0)>, processor = 6 : i64}]}
-// CHECK:      {mapping = [{bound = affine_map<(d0) -> (d0)>, map = affine_map<(d0) -> (d0)>, processor = 3 : i64},
-// CHECK-SAME:             {bound = affine_map<(d0) -> (d0)>, map = affine_map<(d0) -> (d0)>, processor = 4 : i64},
-// CHECK-SAME:             {bound = affine_map<(d0) -> (d0)>, map = affine_map<(d0) -> (d0)>, processor = 5 : i64},
-// CHECK-SAME:             {bound = affine_map<(d0) -> (d0)>, map = affine_map<(d0) -> (d0)>, processor = 6 : i64}]}
-// CHECK:      {mapping = [{bound = affine_map<(d0) -> (d0)>, map = affine_map<(d0) -> (d0)>, processor = 0 : i64},
-// CHECK-SAME:             {bound = affine_map<(d0) -> (d0)>, map = affine_map<(d0) -> (d0)>, processor = 1 : i64},
-// CHECK-SAME:             {bound = affine_map<(d0) -> (d0)>, map = affine_map<(d0) -> (d0)>, processor = 2 : i64},
-// CHECK-SAME:             {bound = affine_map<(d0) -> (d0)>, map = affine_map<(d0) -> (d0)>, processor = 6 : i64}]}
+// CHECK:      {mapping = [{bound = #[[$MAP]], map = #[[$MAP]], processor = 6 : i64},
+// CHECK-SAME:             {bound = #[[$MAP]], map = #[[$MAP]], processor = 6 : i64},
+// CHECK-SAME:             {bound = #[[$MAP]], map = #[[$MAP]], processor = 6 : i64},
+// CHECK-SAME:             {bound = #[[$MAP]], map = #[[$MAP]], processor = 6 : i64}]}
+// CHECK:      {mapping = [{bound = #[[$MAP]], map = #[[$MAP]], processor = 3 : i64},
+// CHECK-SAME:             {bound = #[[$MAP]], map = #[[$MAP]], processor = 4 : i64},
+// CHECK-SAME:             {bound = #[[$MAP]], map = #[[$MAP]], processor = 5 : i64},
+// CHECK-SAME:             {bound = #[[$MAP]], map = #[[$MAP]], processor = 6 : i64}]}
+// CHECK:      {mapping = [{bound = #[[$MAP]], map = #[[$MAP]], processor = 0 : i64},
+// CHECK-SAME:             {bound = #[[$MAP]], map = #[[$MAP]], processor = 1 : i64},
+// CHECK-SAME:             {bound = #[[$MAP]], map = #[[$MAP]], processor = 2 : i64},
+// CHECK-SAME:             {bound = #[[$MAP]], map = #[[$MAP]], processor = 6 : i64}]}
 // CHECK-NOT: mapping

mlir/test/Dialect/Linalg/roundtrip.mlir

%2 = linalg.reshape %arg2 [affine_map<(i, j, k) -> (i, j)>,
     memref<?x?x?xf32, offset : ?, strides : [?, ?, 1]> into
     memref<?x?xf32, offset : ?, strides : [?, 1]>
   %r2 = linalg.reshape %2 [affine_map<(i, j, k) -> (i, j)>,
                            affine_map<(i, j, k) -> (k)>] :
     memref<?x?xf32, offset : ?, strides : [?, 1]> into
     memref<?x?x?xf32, offset : ?, strides : [?, ?, 1]>
   return
 }
+
+// CHECK-DAG: #[[$reshapeD01:.*]] = affine_map<(d0, d1, d2) -> (d0, d1)>
+// CHECK-DAG: #[[$reshapeD2:.*]] = affine_map<(d0, d1, d2) -> (d2)>
+
 // CHECK-LABEL: func @reshape
 //       CHECK:   linalg.reshape {{.*}} [#[[$reshapeD01]], #[[$reshapeD2]]]
 //  CHECK-SAME:     memref<?x?x?xf32> into memref<?x?xf32>
 //       CHECK:   linalg.reshape {{.*}} [#[[$reshapeD01]], #[[$reshapeD2]]]
 //  CHECK-SAME:     memref<?x?xf32> into memref<?x?x?xf32>
 //       CHECK:   linalg.reshape {{.*}} [#[[$reshapeD01]], #[[$reshapeD2]]]
 //  CHECK-SAME:     memref<?x?x?xf32, #[[$strided3DOFF0]]> into memref<?x?xf32, #[[$strided2DOFF0]]>
 //       CHECK:   linalg.reshape {{.*}} [#[[$reshapeD01]], #[[$reshapeD2]]]

mlir/test/Dialect/Linalg/standard.mlir

 // RUN: mlir-opt %s -convert-linalg-to-std | FileCheck %s
 
 // CHECK-DAG: #[[$map0:.*]] = affine_map<(d0)[s0] -> (d0 + s0)>
 // CHECK-DAG: #[[$map1:.*]] = affine_map<(d0, d1, d2)[s0, s1, s2] -> (d0 * s1 + s0 + d1 * s2 + d2)>
 // CHECK-DAG: #[[$map2:.*]] = affine_map<(d0, d1, d2)[s0, s1, s2] -> (d0 * s1 + s0 + d2 * s2 + d1)>
-// CHECK-DAG: #[[$map3:.*]] = affine_map<(d0, d1, d2) -> (d0, d2, d1)>
 // CHECK-DAG: #[[$map4:.*]] = affine_map<(d0, d1, d2)[s0, s1, s2] -> (d2 * s1 + s0 + d1 * s2 + d0)>
-// CHECK-DAG: #[[$map5:.*]] = affine_map<(d0, d1, d2) -> (d2, d1, d0)>
 // CHECK-DAG: #[[$map6:.*]] = affine_map<(d0)[s0, s1] -> (d0 * s1 + s0)>
 // CHECK-DAG: #[[$map7:.*]] = affine_map<()[s0] -> (s0)>
 // CHECK-DAG: #[[$map8:.*]] = affine_map<(d0, d1, d2)[s0, s1, s2, s3] -> (d0 * s1 + s0 + d1 * s2 + d2 * s3)>
 
 func @dot(%arg0: memref<?xf32, offset: ?, strides: [1]>,
           %arg1: memref<?xf32, offset: ?, strides: [1]>,
           %arg2: memref<f32>) {
   linalg.dot ins(%arg0, %arg1: memref<?xf32, offset: ?, strides: [1]>,

mlir/test/Dialect/Vector/ops.mlir

 // RUN: mlir-opt %s | mlir-opt | FileCheck %s
 
-// CHECK-DAG: #[[MAP0:map[0-9]+]] = affine_map<(d0, d1) -> (d0, d1)>
-
 // CHECK-LABEL: func @vector_transfer_ops(
 func @vector_transfer_ops(%arg0: memref<?x?xf32>,
                           %arg1 : memref<?x?xvector<4x3xf32>>,
                           %arg2 : memref<?x?xvector<4x3xi32>>) {
   // CHECK: %[[C3:.*]] = constant 3 : index
   %c3 = constant 3 : index
   %cst = constant 3.0 : f32
   %f0 = constant 0.0 : f32

mlir/test/Dialect/Vector/vector-distribution.mlir

func @vector_add_read_write(%id : index, %A: memref<32xf32>, %B: memref<32xf32>, %C: memref<32xf32>, %D: memref<32xf32>) {
   %c = vector.transfer_read %C[%c0], %cf0: memref<32xf32>, vector<32xf32>
   %d = addf %acc, %c: vector<32xf32>
   vector.transfer_write %d, %D[%c0]: vector<32xf32>, memref<32xf32>
   return
 }
 
 // -----
 
-// CHECK-DAG: #[[MAP0:map[0-9]+]] = affine_map<()[s0] -> (s0 * 2)>
+// CHECK-DAG: #[[MAP0:map[0-9]*]] = affine_map<()[s0] -> (s0 * 2)>
 
 //       CHECK: func @vector_add_cycle
 //  CHECK-SAME: (%[[ID:.*]]: index
 //       CHECK:    %[[ID1:.*]] = affine.apply #[[MAP0]]()[%[[ID]]]
 //  CHECK-NEXT:    %[[EXA:.*]] = vector.transfer_read %{{.*}}[%[[ID1]]], %{{.*}} : memref<64xf32>, vector<2xf32>
 //  CHECK-NEXT:    %[[ID2:.*]] = affine.apply #[[MAP0]]()[%[[ID]]]
 //  CHECK-NEXT:    %[[EXB:.*]] = vector.transfer_read %{{.*}}[%[[ID2]]], %{{.*}} : memref<64xf32>, vector<2xf32>
 //  CHECK-NEXT:    %[[ADD:.*]] = addf %[[EXA]], %[[EXB]] : vector<2xf32>

mlir/test/Dialect/Vector/vector-transforms.mlir

 // RUN: mlir-opt %s -test-vector-to-vector-conversion | FileCheck %s
 // RUN: mlir-opt %s -test-vector-unrolling-patterns | FileCheck %s
 
-// CHECK-DAG: #[[MAP0:map[0-9]+]] = affine_map<(d0, d1) -> (d0, d1)>
 // CHECK-DAG: #[[MAP1:map[0-9]+]] = affine_map<(d0, d1, d2) -> (d1, d2)>
 
 // CHECK-LABEL: func @add4x2
 //      CHECK: %[[ES1:.*]] = vector.extract_slices %{{.*}}, [2, 2], [1, 1] : vector<4x2xf32> into tuple<vector<2x2xf32>, vector<2x2xf32>>
 // CHECK-NEXT: %[[ES2:.*]] = vector.extract_slices %{{.*}}, [2, 2], [1, 1] : vector<4x2xf32> into tuple<vector<2x2xf32>, vector<2x2xf32>>
 // CHECK-NEXT: %[[TG1:.*]] = vector.tuple_get %[[ES1]], 0 : tuple<vector<2x2xf32>, vector<2x2xf32>>
 // CHECK-NEXT: %[[TG2:.*]] = vector.tuple_get %[[ES2]], 0 : tuple<vector<2x2xf32>, vector<2x2xf32>>
 // CHECK-NEXT: %[[A1:.*]] = addf %[[TG1]], %[[TG2]] : vector<2x2xf32>

mlir/test/Transforms/cse.mlir

 // RUN: mlir-opt -allow-unregistered-dialect %s -pass-pipeline='func(cse)' | FileCheck %s
 
-// CHECK-DAG: #map0 = affine_map<(d0) -> (d0 mod 2)>
+// CHECK-DAG: #[[$MAP:.*]] = affine_map<(d0) -> (d0 mod 2)>
 #map0 = affine_map<(d0) -> (d0 mod 2)>
 
 // CHECK-LABEL: @simple_constant
 func @simple_constant() -> (i32, i32) {
   // CHECK-NEXT: %c1_i32 = constant 1 : i32
   %0 = constant 1 : i32
 
   // CHECK-NEXT: return %c1_i32, %c1_i32 : i32, i32
   %1 = constant 1 : i32
   return %0, %1 : i32, i32
 }
 
 // CHECK-LABEL: @basic
 func @basic() -> (index, index) {
   // CHECK: %c0 = constant 0 : index
   %c0 = constant 0 : index
   %c1 = constant 0 : index
 
-  // CHECK-NEXT: %0 = affine.apply #map0(%c0)
+  // CHECK-NEXT: %0 = affine.apply #[[$MAP]](%c0)
   %0 = affine.apply #map0(%c0)
   %1 = affine.apply #map0(%c1)
 
   // CHECK-NEXT: return %0, %0 : index, index
   return %0, %1 : index, index
 }
 
 // CHECK-LABEL: @many

mlir/test/Transforms/loop-fusion.mlir

func @should_fuse_at_src_depth1_and_dst_depth1() {
   // CHECK-NEXT:      "op2"(%{{.*}}) : (f32) -> ()
   // CHECK-NEXT:    }
   // CHECK-NEXT:  }
   // CHECK-NEXT:  return
   return
 }
 
 // -----
-// CHECK: [[$MAP0:#map[0-9]+]] = affine_map<(d0, d1) -> (d0 * 10 + d1)>
+// CHECK: [[$MAP0:#map[0-9]*]] = affine_map<(d0, d1) -> (d0 * 10 + d1)>
 
 // CHECK-LABEL: func @should_fuse_src_depth1_at_dst_depth2
 func @should_fuse_src_depth1_at_dst_depth2() {
   %a = alloc() : memref<100xf32>
   %c0 = constant 0.0 : f32
 
   affine.for %i0 = 0 to 100 {
     affine.store %c0, %a[%i0] : memref<100xf32>
affine.for %i7 = 0 to 9 {
           %10 = affine.apply #map0(%i6, %i10)
           %11 = affine.load %1[%10, %i8] : memref<144x4xf32>
         }
       }
     }
   }
   return
 }
-// MAXIMAL:      #map0 = affine_map<(d0, d1) -> (d0 * 16 + d1)>
+// MAXIMAL:      #map = affine_map<(d0, d1) -> (d0 * 16 + d1)>
 // MAXIMAL-LABEL: func @fuse_across_dim_mismatch
 // MAXIMAL:        alloc() : memref<1x1xf32>
 // MAXIMAL:        affine.for %{{.*}} = 0 to 9 {
 // MAXIMAL-NEXT:    affine.for %{{.*}} = 0 to 9 {
 // MAXIMAL-NEXT:      affine.for %{{.*}} = 0 to 4 {
 // MAXIMAL-NEXT:        affine.for %{{.*}} = 0 to 16 {
-// MAXIMAL-NEXT:          affine.apply #map0(%{{.*}}, %{{.*}})
+// MAXIMAL-NEXT:          affine.apply #map(%{{.*}}, %{{.*}})
 // MAXIMAL-NEXT:          affine.store %{{.*}}, %{{.*}}[0, 0] : memref<1x1xf32>
-// MAXIMAL-NEXT:          affine.apply #map0(%{{.*}}, %{{.*}})
+// MAXIMAL-NEXT:          affine.apply #map(%{{.*}}, %{{.*}})
 // MAXIMAL-NEXT:          affine.load %{{.*}}[0, 0] : memref<1x1xf32>
 // MAXIMAL-NEXT:        }
 // MAXIMAL-NEXT:      }
 // MAXIMAL-NEXT:    }
 // MAXIMAL-NEXT:  }
 
 // -----
 

mlir/test/Transforms/loop-invariant-code-motion.mlir

affine.if affine_set<(d0, d1) : (d1 - d0 >= 0)> (%arg0, %t0) {
         affine.store %cf9, %m[%arg0] : memref<10xf32>
 
     }
   }
 
   // CHECK: %0 = alloc() : memref<10xf32>
   // CHECK-NEXT: %cst = constant 8.000000e+00 : f32
   // CHECK-NEXT: affine.for %arg0 = 0 to 10 {
-  // CHECK-NEXT: %1 = affine.apply #map0(%arg0)
+  // CHECK-NEXT: %1 = affine.apply #map(%arg0)
   // CHECK-NEXT: affine.if #set(%arg0, %1) {
   // CHECK-NEXT: %2 = addf %cst, %cst : f32
   // CHECK-NEXT: affine.store %2, %0[%arg0] : memref<10xf32>
   // CHECK-NEXT: }
 
 
   return
 }

mlir/test/Transforms/normalize-memrefs-ops.mlir

func @test_norm(%arg0 : memref<1x16x14x14xf32, #map0>) -> () {
     // CHECK: "test.op_norm"(%[[ARG0]], %[[v0]]) : (memref<1x16x1x1x32x64xf32>, memref<1x16x1x1x32x64xf32>) -> ()
     // CHECK: dealloc %[[v0]] : memref<1x16x1x1x32x64xf32>
     return
 }
 
 // Same test with op_nonnorm, with maps in the arguments and the operations in the function.
 
 // CHECK-LABEL: test_nonnorm
-// CHECK-SAME: (%[[ARG0:[a-z0-9]*]]: memref<1x16x14x14xf32, #map0>)
+// CHECK-SAME: (%[[ARG0:[a-z0-9]*]]: memref<1x16x14x14xf32, #map>)
 func @test_nonnorm(%arg0 : memref<1x16x14x14xf32, #map0>) -> () {
     %0 = alloc() : memref<1x16x14x14xf32, #map0>
     "test.op_nonnorm"(%arg0, %0) : (memref<1x16x14x14xf32, #map0>, memref<1x16x14x14xf32, #map0>) -> ()
     dealloc %0 :  memref<1x16x14x14xf32, #map0>
 
-    // CHECK: %[[v0:[a-z0-9]*]] = alloc() : memref<1x16x14x14xf32, #map0>
-    // CHECK: "test.op_nonnorm"(%[[ARG0]], %[[v0]]) : (memref<1x16x14x14xf32, #map0>, memref<1x16x14x14xf32, #map0>) -> ()
-    // CHECK: dealloc %[[v0]] : memref<1x16x14x14xf32, #map0>
+    // CHECK: %[[v0:[a-z0-9]*]] = alloc() : memref<1x16x14x14xf32, #map>
+    // CHECK: "test.op_nonnorm"(%[[ARG0]], %[[v0]]) : (memref<1x16x14x14xf32, #map>, memref<1x16x14x14xf32, #map>) -> ()
+    // CHECK: dealloc %[[v0]] : memref<1x16x14x14xf32, #map>
     return
 }
 
 // Test with op_norm, with maps in the operations in the function.
 
 // CHECK-LABEL: test_norm_mix
 // CHECK-SAME: (%[[ARG0:[a-z0-9]*]]: memref<1x16x1x1x32x64xf32>
 func @test_norm_mix(%arg0 : memref<1x16x1x1x32x64xf32>) -> () {