Demo fix for performance-for-range-copy (WIP)

[mehdi_amini]

Full repo run

mlir/lib/Dialect/Async/Transforms/AsyncRuntimeRefCounting.cpp

for (Block *successor : successors) {
       builder.create<RuntimeDropRefOp>(value.getLoc(), value,
                                        builder.getI64IntegerAttr(1));
 
       // No need to update the terminator operation.
       if (successor == refCountingBlock)
         continue;
 
       // Update terminator `successor` block to `refCountingBlock`.
-      for (auto pair : llvm::enumerate(terminator->getSuccessors()))
+      for (const auto &pair : llvm::enumerate(terminator->getSuccessors()))
         if (pair.value() == successor)
           terminator->setSuccessor(refCountingBlock, pair.index());
     }
   }
 
   return success();
 }
 

mlir/lib/Dialect/Math/Transforms/PolynomialApproximation.cpp

handleMultidimensionalVectors(ImplicitLocOpBuilder &builder,
 
   // Compute results for each one dimensional vector.
   SmallVector<Value> results(maxLinearIndex);
 
   for (int64_t i = 0; i < maxLinearIndex; ++i) {
     auto offsets = delinearize(strides, i);
 
     SmallVector<Value> extracted(expandedOperands.size());
-    for (auto tuple : llvm::enumerate(expandedOperands))
+    for (const auto &tuple : llvm::enumerate(expandedOperands))
       extracted[tuple.index()] =
           builder.create<vector::ExtractOp>(tuple.value(), offsets);
 
     results[i] = compute(extracted);
   }
 
   // Stitch results together into one large vector.
   Type resultEltType = results[0].getType().cast<VectorType>().getElementType();

mlir/lib/Dialect/StandardOps/Transforms/DecomposeCallGraphTypes.cpp

struct DecomposeCallGraphTypesForFuncArgs
 
   LogicalResult
   matchAndRewrite(FuncOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const final {
     auto functionType = op.getType();
 
     // Convert function arguments using the provided TypeConverter.
     TypeConverter::SignatureConversion conversion(functionType.getNumInputs());
-    for (auto argType : llvm::enumerate(functionType.getInputs())) {
+    for (const auto &argType : llvm::enumerate(functionType.getInputs())) {
       SmallVector<Type, 2> decomposedTypes;
       if (failed(typeConverter->convertType(argType.value(), decomposedTypes)))
         return failure();
       if (!decomposedTypes.empty())
         conversion.addInputs(argType.index(), decomposedTypes);
     }
 
     // If the SignatureConversion doesn't apply, bail out.

mlir/lib/Dialect/Tosa/IR/TosaOps.cpp

for (auto operand : yieldOps.front().getOperands()) {
     resultKnowledge.push_back(
         ValueKnowledge::getKnowledgeFromType(operand.getType()));
   }
 
   for (auto yieldOp : yieldOps) {
     if (resultKnowledge.size() != yieldOp.getNumOperands())
       return failure();
 
-    for (auto it : llvm::enumerate(yieldOp.getOperands())) {
+    for (const auto &it : llvm::enumerate(yieldOp.getOperands())) {
       int32_t index = it.index();
       auto meet = ValueKnowledge::meet(
           resultKnowledge[index],
           ValueKnowledge::getKnowledgeFromType(it.value().getType()));
       if (!meet)
         continue;
       resultKnowledge[index] = meet;
     }
for (auto operand : yieldOps.front().getOperands()) {
     resultKnowledge.push_back(
         ValueKnowledge::getKnowledgeFromType(operand.getType()));
   }
 
   for (auto yieldOp : yieldOps) {
     if (resultKnowledge.size() != yieldOp.getNumOperands())
       return failure();
 
-    for (auto it : llvm::enumerate(yieldOp.getOperands())) {
+    for (const auto &it : llvm::enumerate(yieldOp.getOperands())) {
       int32_t index = it.index();
       if (auto meet = ValueKnowledge::meet(
               resultKnowledge[index],
               ValueKnowledge::getKnowledgeFromType(it.value().getType()))) {
         resultKnowledge[index] = meet;
       };
     }
   }

mlir/lib/Dialect/Tosa/Transforms/TosaInferShapes.cpp

while (hasNewTypes) {
 
     // Using the new tosa.yield operand types, infer the new subtypes.
     llvm::SmallVector<ValueKnowledge> yieldTypeInfo;
     for (auto ty : argTypes) {
       yieldTypeInfo.push_back(ValueKnowledge::getKnowledgeFromType(ty));
     }
 
     for (auto yieldOp : yieldOps) {
-      for (auto it : llvm::enumerate(yieldOp.getOperands())) {
+      for (const auto &it : llvm::enumerate(yieldOp.getOperands())) {
         auto newKnowledge =
             ValueKnowledge::getKnowledgeFromType(it.value().getType());
         yieldTypeInfo[it.index()] =
             ValueKnowledge::meet(yieldTypeInfo[it.index()], newKnowledge);
       }
     }
 
     // This should never happen.

mlir/lib/Dialect/Utils/ReshapeOpsUtils.cpp

mlir::getSymbolLessAffineMaps(ArrayRef<ReassociationExprs> reassociation) {
   return maps;
 }
 bool mlir::isReassociationValid(ArrayRef<AffineMap> reassociation,
                                 int *invalidIndex) {
   if (reassociation.empty())
     return true;
   unsigned nDims = reassociation[0].getNumDims();
   unsigned nextExpectedDim = 0;
-  for (auto it : llvm::enumerate(reassociation)) {
+  for (const auto &it : llvm::enumerate(reassociation)) {
     auto m = it.value();
     if (m.getNumDims() != nDims || m.getNumSymbols() != 0) {
       if (invalidIndex)
         *invalidIndex = it.index();
       return false;
     }
     for (auto e : m.getResults()) {
       auto d = e.dyn_cast<AffineDimExpr>();

mlir/test/lib/Dialect/Test/TestPatterns.cpp

static void reifyReturnShape(Operation *op) {
   OpBuilder b(op);
 
   // Use permutations of 2 args as operands.
   auto shapedOp = cast<OpWithShapedTypeInferTypeInterfaceOp>(op);
   SmallVector<Value, 2> shapes;
   if (failed(shapedOp.reifyReturnTypeShapes(b, op->getOperands(), shapes)) ||
       !llvm::hasSingleElement(shapes))
     return;
-  for (auto it : llvm::enumerate(shapes)) {
+  for (const auto &it : llvm::enumerate(shapes)) {
     op->emitRemark() << "value " << it.index() << ": "
                      << it.value().getDefiningOp();
   }
 }
 
 struct TestReturnTypeDriver
     : public PassWrapper<TestReturnTypeDriver, FunctionPass> {
   void getDependentDialects(DialectRegistry &registry) const override {

mlir/test/lib/IR/TestPrintDefUse.cpp

getOperation()->walk([](Operation *op) {
           auto blockArg = operand.cast<BlockArgument>();
           llvm::outs() << "  - Operand produced by Block argument, number "
                        << blockArg.getArgNumber() << "\n";
         }
       }
 
       // Print information about the user of each of the result.
       llvm::outs() << "Has " << op->getNumResults() << " results:\n";
-      for (auto indexedResult : llvm::enumerate(op->getResults())) {
+      for (const auto &indexedResult : llvm::enumerate(op->getResults())) {
         Value result = indexedResult.value();
         llvm::outs() << "  - Result " << indexedResult.index();
         if (result.use_empty()) {
           llvm::outs() << " has no uses\n";
           continue;
         }
         if (result.hasOneUse()) {
           llvm::outs() << " has a single use: ";

mlir/test/lib/IR/TestSlicing.cpp

static LogicalResult createBackwardSliceFunction(Operation *op,
   FuncOp parentFuncOp = op->getParentOfType<FuncOp>();
   OpBuilder builder(parentFuncOp);
   Location loc = op->getLoc();
   std::string clonedFuncOpName = parentFuncOp.getName().str() + suffix.str();
   FuncOp clonedFuncOp =
       builder.create<FuncOp>(loc, clonedFuncOpName, parentFuncOp.getType());
   BlockAndValueMapping mapper;
   builder.setInsertionPointToEnd(clonedFuncOp.addEntryBlock());
-  for (auto arg : enumerate(parentFuncOp.getArguments()))
+  for (const auto &arg : enumerate(parentFuncOp.getArguments()))
     mapper.map(arg.value(), clonedFuncOp.getArgument(arg.index()));
   SetVector<Operation *> slice;
   getBackwardSlice(op, &slice);
   for (Operation *slicedOp : slice)
     builder.clone(*slicedOp, mapper);
   builder.create<ReturnOp>(loc);
   return success();
 }

mlir/tools/mlir-linalg-ods-gen/mlir-linalg-ods-yaml-gen.cpp

static std::string interleaveToString(Container &container,
   llvm::raw_string_ostream ss(result);
   llvm::interleave(container, ss, separator);
   ss.flush();
   return result;
 }
 
 static Optional<int>
 findTensorDefArgIndex(StringRef name, SmallVectorImpl<LinalgOperandDef> &args) {
-  for (auto it : llvm::enumerate(args)) {
+  for (const auto &it : llvm::enumerate(args)) {
     if (it.value().name == name)
       return it.index();
   }
   return None;
 }
 
 // Try to map the TypeVar to a predefined or an argument type.
 static Optional<std::string>
 findTypeValue(StringRef typeVar, SmallVectorImpl<LinalgOperandDef> &args) {
   // Handle all predefined types.
   if (typeVar == "I32")
     return std::string("helper.getIntegerType(32)");
   if (typeVar == "I64")
     return std::string("helper.getIntegerType(64)");
   if (typeVar == "F32")
     return std::string("helper.getFloat32Type()");
   if (typeVar == "F64")
     return std::string("helper.getFloat64Type()");
 
   // Search all argument types.
-  for (auto it : llvm::enumerate(args)) {
+  for (const auto &it : llvm::enumerate(args)) {
     if (it.value().typeVar == typeVar)
       return llvm::formatv("block.getArgument({0}).getType()", it.index())
           .str();
   }
 
   return None;
 }
 

mlir/tools/mlir-tblgen/AttrOrTypeDefGen.cpp

Method *construct = storageCls->addMethod<Method::Inline>(
       strfmt("{0} *", def.getStorageClassName()), "construct",
       def.hasStorageCustomConstructor() ? Method::StaticDeclaration
                                         : Method::Static,
       MethodParameter(strfmt("::mlir::{0}StorageAllocator &", valueType),
                       "allocator"),
       MethodParameter("const KeyTy &", "tblgenKey"));
   if (!def.hasStorageCustomConstructor()) {
     auto &body = construct->body().indent();
-    for (auto it : llvm::enumerate(params)) {
+    for (const auto &it : llvm::enumerate(params)) {
       body << formatv("auto {0} = std::get<{1}>(tblgenKey);\n",
                       it.value().getName(), it.index());
     }
     // Use the parameters' custom allocator code, if provided.
     FmtContext ctx = FmtContext().addSubst("_allocator", "allocator");
     for (auto &param : params) {
       if (Optional<StringRef> allocCode = param.getAllocator()) {
         ctx.withSelf(param.getName()).addSubst("_dst", param.getName());

mlir/tools/mlir-tblgen/AttrOrTypeFormatGen.cpp

FormatParser::parseDirective(ParserContext ctx) {
   }
 }
 
 FailureOr<std::unique_ptr<Element>> FormatParser::parseParamsDirective() {
   consumeToken();
   /// Collect all of the attribute's or type's parameters.
   SmallVector<std::unique_ptr<Element>> vars;
   /// Ensure that none of the parameters have already been captured.
-  for (auto it : llvm::enumerate(def.getParameters())) {
+  for (const auto &it : llvm::enumerate(def.getParameters())) {
     if (seenParams.test(it.index())) {
       return emitError("`params` captures duplicate parameter: " +
                        it.value().getName());
     }
     seenParams.set(it.index());
     vars.push_back(std::make_unique<VariableElement>(it.value()));
   }
   return {std::make_unique<ParamsDirective>(std::move(vars))};

mlir/tools/mlir-tblgen/LLVMIRIntrinsicGen.cpp

 }
 
 /// Return the indices of the definitions in a list of definitions that
 /// represent overloadable types
 static IndicesTy getOverloadableTypeIdxs(const llvm::Record &record,
                                          const char *listName) {
   auto results = record.getValueAsListOfDefs(listName);
   IndicesTy overloadedOps(results.size());
-  for (auto r : llvm::enumerate(results)) {
+  for (const auto &r : llvm::enumerate(results)) {
     llvm::MVT::SimpleValueType vt = getValueType(r.value());
     switch (vt) {
     case llvm::MVT::iAny:
     case llvm::MVT::fAny:
     case llvm::MVT::Any:
     case llvm::MVT::iPTRAny:
     case llvm::MVT::vAny:
       overloadedOps.set(r.index());

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

)";
   };
   if (values.empty() || llvm::all_of(values, canSkip))
     return;
 
   FmtContext fctx;
 
   body << "  {\n    unsigned index = 0; (void)index;\n";
 
-  for (auto staticValue : llvm::enumerate(values)) {
+  for (const auto &staticValue : llvm::enumerate(values)) {
     const NamedTypeConstraint &value = staticValue.value();
 
     bool hasPredicate = value.hasPredicate();
     bool isOptional = value.isOptional();
     bool isVariadicOfVariadic = value.isVariadicOfVariadic();
     if (!hasPredicate && !isOptional && !isVariadicOfVariadic)
       continue;
     body << formatv("    auto valueGroup{2} = getODS{0}{1}s({2});\n",
)";
   const auto canSkip = [](const NamedRegion &region) {
     return region.constraint.getPredicate().isNull();
   };
   auto regions = op.getRegions();
   if (regions.empty() && llvm::all_of(regions, canSkip))
     return;
 
   body << "  {\n    unsigned index = 0; (void)index;\n";
-  for (auto it : llvm::enumerate(regions)) {
+  for (const auto &it : llvm::enumerate(regions)) {
     const auto &region = it.value();
     if (canSkip(region))
       continue;
 
     auto getRegion = region.isVariadic()
                          ? formatv("{0}()", op.getGetterName(region.name)).str()
                          : formatv(getSingleRegion, it.index()).str();
     auto constraintFn =

mlir/tools/mlir-tblgen/OpDocGen.cpp

static void emitAttrOrTypeDefAssemblyFormat(const AttrOrTypeDef &def,
   if (parameters.empty()) {
     os << "\nSyntax: `!" << def.getDialect().getName() << "."
        << def.getMnemonic() << "`\n";
     return;
   }
 
   os << "\nSyntax:\n\n```\n!" << def.getDialect().getName() << "."
      << def.getMnemonic() << "<\n";
-  for (auto it : llvm::enumerate(parameters)) {
+  for (const auto &it : llvm::enumerate(parameters)) {
     const AttrOrTypeParameter &param = it.value();
     os << "  " << param.getSyntax();
     if (it.index() < (parameters.size() - 1))
       os << ",";
     os << "   # " << param.getName() << "\n";
   }
   os << ">\n```\n";
 }

mlir/tools/mlir-tblgen/OpPythonBindingGen.cpp

static void emitRegionAttributes(const Operator &op, raw_ostream &os) {
   // Note that the base OpView class defines this as (0, True).
   unsigned minRegionCount = op.getNumRegions() - op.getNumVariadicRegions();
   os << llvm::formatv(opClassRegionSpecTemplate, minRegionCount,
                       op.hasNoVariadicRegions() ? "True" : "False");
 }
 
 /// Emits named accessors to regions.
 static void emitRegionAccessors(const Operator &op, raw_ostream &os) {
-  for (auto en : llvm::enumerate(op.getRegions())) {
+  for (const auto &en : llvm::enumerate(op.getRegions())) {
     const NamedRegion &region = en.value();
     if (region.name.empty())
       continue;
 
     assert((!region.isVariadic() || en.index() == op.getNumRegions() - 1) &&
            "expected only the last region to be variadic");
     os << llvm::formatv(regionAccessorTemplate, sanitizeName(region.name),
                         std::to_string(en.index()) +