[NFC] Fixes -Wrange-loop-analysis warnings

[Mordante]

Summary

This avoids new warnings due to D68912 adds -Wrange-loop-analysis to -Wall.

It seems my previous build didn't enable all targets so this should really be the last patch of the series.

[merge_guards_bot]

Unit tests: unknown.

clang-tidy: unknown.

clang-format: unknown.

Build artifacts: diff.json, console-log.txt

[rriddle]

MLIR looks fine to me.

[MaskRay]

You can drop changes to lld. I've fixed lld -Wrange-loop-analysis a few days ago in 681b1be774964a804beabfb7c5e3bdab8f979e4a . (Archive::Child c was also deleted).

For mlir, only mlir/lib/Dialect/Linalg/Utils/Utils.cpp:117:8 needs a fix. I've fixed others in eeef50b1fee91dbe993187324003d2665ceae331.

[Mordante]

In D72210#1804355, @MaskRay wrote:

You can drop changes to lld. I've fixed lld -Wrange-loop-analysis a few days ago in 681b1be774964a804beabfb7c5e3bdab8f979e4a . (Archive::Child c was also deleted).

For mlir, only mlir/lib/Dialect/Linalg/Utils/Utils.cpp:117:8 needs a fix. I've fixed others in eeef50b1fee91dbe993187324003d2665ceae331.

Thanks for fixing those!

[Mordante]

Rebased on master. This adds one new fix and removes the ones done by others.

[nicolasvasilache]

LGTM

[MaskRay]

polly/lib/Analysis/ScopGraphPrinter.cpp

181

auto -> BasicBlock

lld/COFF/InputFiles.cpp

if (!seen.insert(c.getChildOffset()).second)
     return;
 
   driver->enqueueArchiveMember(c, sym, getName());
 }
 
 std::vector<MemoryBufferRef> getArchiveMembers(Archive *file) {
   std::vector<MemoryBufferRef> v;
   Error err = Error::success();
-  for (const ErrorOr<Archive::Child> &cOrErr : file->children(err)) {
+  for (ErrorOr<Archive::Child> cOrErr : file->children(err)) {
     Archive::Child c =
         CHECK(cOrErr,
               file->getFileName() + ": could not get the child of the archive");
     MemoryBufferRef mbref =
         CHECK(c.getMemoryBufferRef(),
               file->getFileName() +
                   ": could not get the buffer for a child of the archive");
     v.push_back(mbref);

lld/ELF/Driver.cpp

std::vector<std::pair<MemoryBufferRef, uint64_t>> static getArchiveMembers(
     MemoryBufferRef mb) {
   std::unique_ptr<Archive> file =
       CHECK(Archive::create(mb),
             mb.getBufferIdentifier() + ": failed to parse archive");
 
   std::vector<std::pair<MemoryBufferRef, uint64_t>> v;
   Error err = Error::success();
   bool addToTar = file->isThin() && tar;
-  for (const ErrorOr<Archive::Child> &cOrErr : file->children(err)) {
+  for (ErrorOr<Archive::Child> cOrErr : file->children(err)) {
     Archive::Child c =
         CHECK(cOrErr, mb.getBufferIdentifier() +
                           ": could not get the child of the archive");
     MemoryBufferRef mbref =
         CHECK(c.getMemoryBufferRef(),
               mb.getBufferIdentifier() +
                   ": could not get the buffer for a child of the archive");
     if (addToTar)

lld/ELF/Relocations.cpp

forEachInputSectionDescription(
                        [](const std::pair<ThunkSection *, uint32_t> &ts) {
                          return ts.first->getSize() == 0;
                        });
 
         // ISD->ThunkSections contains all created ThunkSections, including
         // those inserted in previous passes. Extract the Thunks created this
         // pass and order them in ascending outSecOff.
         std::vector<ThunkSection *> newThunks;
-        for (const std::pair<ThunkSection *, uint32_t> ts : isd->thunkSections)
+        for (std::pair<ThunkSection *, uint32_t> ts : isd->thunkSections)
           if (ts.second == pass)
             newThunks.push_back(ts.first);
         llvm::stable_sort(newThunks,
                           [](const ThunkSection *a, const ThunkSection *b) {
                             return a->outSecOff < b->outSecOff;
                           });
 
         // Merge sorted vectors of Thunks and InputSections by outSecOff

lld/ELF/SyntheticSections.cpp

for (const FileGot &g : gots) {
     // initialized by zero. Write down adjusted TLS symbol's values otherwise.
     // To calculate the adjustments use offsets for thread-local storage.
     // https://www.linux-mips.org/wiki/NPTL
     for (const std::pair<GotEntry, size_t> &p : g.local16)
       write(p.second, p.first.first, p.first.second);
     // Write VA to the primary GOT only. For secondary GOTs that
     // will be done by REL32 dynamic relocations.
     if (&g == &gots.front())
-      for (const std::pair<const Symbol *, size_t> &p : g.global)
+      for (const std::pair<Symbol *, size_t> &p : g.global)
         write(p.second, p.first, 0);
     for (const std::pair<Symbol *, size_t> &p : g.relocs)
       write(p.second, p.first, 0);
     for (const std::pair<Symbol *, size_t> &p : g.tls)
       write(p.second, p.first, p.first->isPreemptible ? 0 : -0x7000);
     for (const std::pair<Symbol *, size_t> &p : g.dynTlsSymbols) {
       if (p.first == nullptr && !config->isPic)
         write(p.second, nullptr, 1);

lld/lib/ReaderWriter/MachO/MachONormalizedFileFromAtoms.cpp

for (const AtomInfo &info : sect->atomsAndOffsets) {
         }
       }
     }
   }
 }
 
 void Util::fixLazyReferenceImm(const DefinedAtom *atom, uint32_t offset,
                                NormalizedFile &file) {
-  for (const auto &ref : *atom) {
+  for (const auto *ref : *atom) {
     const DefinedAtom *da = dyn_cast<DefinedAtom>(ref->target());
     if (da == nullptr)
       return;
 
     const Reference *helperRef = nullptr;
     for (const Reference *hr : *da) {
       if (hr->kindValue() == _archHandler.lazyImmediateLocationKind()) {
         helperRef = hr;

lld/wasm/Driver.cpp

 // Each slice consists of a member file in the archive.
 std::vector<MemoryBufferRef> static getArchiveMembers(MemoryBufferRef mb) {
   std::unique_ptr<Archive> file =
       CHECK(Archive::create(mb),
             mb.getBufferIdentifier() + ": failed to parse archive");
 
   std::vector<MemoryBufferRef> v;
   Error err = Error::success();
-  for (const ErrorOr<Archive::Child> &cOrErr : file->children(err)) {
+  for (ErrorOr<Archive::Child> cOrErr : file->children(err)) {
     Archive::Child c =
         CHECK(cOrErr, mb.getBufferIdentifier() +
                           ": could not get the child of the archive");
     MemoryBufferRef mbref =
         CHECK(c.getMemoryBufferRef(),
               mb.getBufferIdentifier() +
                   ": could not get the buffer for a child of the archive");
     v.push_back(mbref);

mlir/lib/Conversion/LoopsToGPU/LoopsToGPU.cpp

auto launchOp = builder.create<gpu::LaunchOp>(
       workGroupSize3D[2], valuesToForward);
   if (failed(createLaunchBody(builder, rootForOp, launchOp,
                               numWorkGroups.size(), workGroupSizes.size()))) {
     return failure();
   }
 
   // Replace values that are used within the region of the launchOp but are
   // defined outside. They all are replaced with kernel arguments.
-  for (const auto &pair :
+  for (auto pair :
        llvm::zip_first(valuesToForward, launchOp.getKernelArguments())) {
     Value from = std::get<0>(pair);
     Value to = std::get<1>(pair);
     replaceAllUsesInRegionWith(from, to, launchOp.body());
   }
   return success();
 }
 
replaceAllUsesInRegionWith(steps[en.index()], *stepArgumentIt,
                                launchOp.body());
     std::advance(lbArgumentIt, 1);
     std::advance(stepArgumentIt, 1);
   }
 
   // Remap the values defined outside the body to use kernel arguments instead.
   // The list of kernel arguments also contains the lower bounds for loops at
   // trailing positions, make sure we don't touch those.
-  for (const auto &pair :
+  for (auto pair :
        llvm::zip_first(valuesToForward, launchOp.getKernelArguments())) {
     Value from = std::get<0>(pair);
     Value to = std::get<1>(pair);
     replaceAllUsesInRegionWith(from, to, launchOp.body());
   }
 
   // We are done and can erase the original outermost loop.
   rootForOp.erase();

mlir/lib/Dialect/Traits.cpp

 
 static bool areCompatibleShapes(ArrayRef<int64_t> shape1,
                                 ArrayRef<int64_t> shape2) {
   auto isCompatible = [](int64_t dim1, int64_t dim2) {
     return dim1 == dim2 || dim1 == -1 || dim2 == -1;
   };
   if (shape1.size() != shape2.size())
     return false;
-  for (const auto &p : llvm::zip(shape1, shape2))
+  for (auto p : llvm::zip(shape1, shape2))
     if (!isCompatible(std::get<0>(p), std::get<1>(p)))
       return false;
   return true;
 }
 
 LogicalResult OpTrait::impl::verifyCompatibleOperandBroadcast(Operation *op) {
   assert(op->getNumOperands() == 2 &&
          "only support broadcast check on two operands");

mlir/lib/Dialect/VectorOps/VectorOps.cpp

PatternMatchResult matchAndRewrite(StridedSliceOp stridedSliceOp,
     SmallVector<int64_t, 4> sliceOffsets;
     populateFromInt64AttrArray(stridedSliceOp.offsets(), sliceOffsets);
     SmallVector<int64_t, 4> sliceSizes;
     populateFromInt64AttrArray(stridedSliceOp.sizes(), sliceSizes);
 
     // Compute slice of vector mask region.
     SmallVector<int64_t, 4> sliceMaskDimSizes;
     assert(sliceOffsets.size() == maskDimSizes.size());
-    for (const auto &it : llvm::zip(maskDimSizes, sliceOffsets, sliceSizes)) {
+    for (auto it : llvm::zip(maskDimSizes, sliceOffsets, sliceSizes)) {
       int64_t maskDimSize = std::get<0>(it);
       int64_t sliceOffset = std::get<1>(it);
       int64_t sliceSize = std::get<2>(it);
       int64_t sliceMaskDimSize = std::max(
           static_cast<int64_t>(0),
           std::min(sliceOffset + sliceSize, maskDimSize) - sliceOffset);
       sliceMaskDimSizes.push_back(sliceMaskDimSize);
     }

mlir/lib/IR/TypeUtilities.cpp

 
 /// Returns success if the given two shapes are compatible. That is, they have
 /// the same size and each pair of the elements are equal or one of them is
 /// dynamic.
 LogicalResult mlir::verifyCompatibleShape(ArrayRef<int64_t> shape1,
                                           ArrayRef<int64_t> shape2) {
   if (shape1.size() != shape2.size())
     return failure();
-  for (const auto &dims : llvm::zip(shape1, shape2)) {
+  for (auto dims : llvm::zip(shape1, shape2)) {
     int64_t dim1 = std::get<0>(dims);
     int64_t dim2 = std::get<1>(dims);
     if (!ShapedType::isDynamic(dim1) && !ShapedType::isDynamic(dim2) &&
         dim1 != dim2)
       return failure();
   }
   return success();
 }

mlir/lib/Parser/Parser.cpp

Operation *OperationParser::parseGenericOperation() {
   // Resolve all of the operands.
   for (unsigned i = 0, e = operandInfos.size(); i != e; ++i) {
     result.operands.push_back(resolveSSAUse(operandInfos[i], operandTypes[i]));
     if (!result.operands.back())
       return nullptr;
   }
 
   // Add the successors, and their operands after the proper operands.
-  for (const auto &succ : llvm::zip(successors, successorOperands)) {
+  for (auto succ : llvm::zip(successors, successorOperands)) {
     Block *successor = std::get<0>(succ);
     const SmallVector<Value, 4> &operands = std::get<1>(succ);
     result.addSuccessor(successor, operands);
   }
 
   // Parse a location if one is present.
   if (parseOptionalTrailingLocation(result.location))
     return nullptr;
public:
   ParseResult parseRegion(Region &region, ArrayRef<OperandType> arguments,
                           ArrayRef<Type> argTypes,
                           bool enableNameShadowing) override {
     assert(arguments.size() == argTypes.size() &&
            "mismatching number of arguments and types");
 
     SmallVector<std::pair<OperationParser::SSAUseInfo, Type>, 2>
         regionArguments;
-    for (const auto &pair : llvm::zip(arguments, argTypes)) {
+    for (auto pair : llvm::zip(arguments, argTypes)) {
       const OperandType &operand = std::get<0>(pair);
       Type type = std::get<1>(pair);
       OperationParser::SSAUseInfo operandInfo = {operand.name, operand.number,
                                                  operand.location};
       regionArguments.emplace_back(operandInfo, type);
     }
 
     // Try to parse the region.

mlir/lib/Target/LLVMIR/ModuleTranslation.cpp

LogicalResult ModuleTranslation::convertOneFunction(LLVMFuncOp func) {
   // Clear the block and value mappings, they are only relevant within one
   // function.
   blockMapping.clear();
   valueMapping.clear();
   llvm::Function *llvmFunc = functionMapping.lookup(func.getName());
   // Add function arguments to the value remapping table.
   // If there was noalias info then we decorate each argument accordingly.
   unsigned int argIdx = 0;
-  for (const auto &kvp : llvm::zip(func.getArguments(), llvmFunc->args())) {
+  for (auto kvp : llvm::zip(func.getArguments(), llvmFunc->args())) {
     llvm::Argument &llvmArg = std::get<1>(kvp);
     BlockArgument mlirArg = std::get<0>(kvp);
 
     if (auto attr = func.getArgAttrOfType<BoolAttr>(argIdx, "llvm.noalias")) {
       // NB: Attribute already verified to be boolean, so check if we can indeed
       // attach the attribute to this argument, based on its type.
       auto argTy = mlirArg->getType().dyn_cast<LLVM::LLVMType>();
       if (!argTy.getUnderlyingType()->isPointerTy())

mlir/tools/mlir-tblgen/StructsGen.cpp

for (auto field : fields) {
     os << llvm::formatv(getInfoDeclArg, storage, name);
   }
   os << getInfoDeclEnd;
 
   // Declares an accessor for the fields owned by the tablegen structure.
   //   namespace::storage TblgenStruct::field1() const;
   const char *fieldInfo = R"(  {0} {1}() const;
 )";
-  for (const auto field : fields) {
+  for (auto field : fields) {
     auto name = field.getName();
     auto type = field.getType();
     auto storage = type.getStorageType();
     os << formatv(fieldInfo, storage, name);
   }
 
   os << "};\n\n";
 }

polly/lib/Analysis/ScopGraphPrinter.cpp

if (SD->isMaxRegionInScop(*R)) {
       O.indent(2 * (depth + 1)) << "color = " << color << "\n";
     }
 
     for (const auto &SubRegion : *R)
       printRegionCluster(SD, SubRegion.get(), O, depth + 1);
 
     RegionInfo *RI = R->getRegionInfo();
 
-    for (const auto &BB : R->blocks())
+    for (auto *BB : R->blocks())
       if (RI->getRegionFor(BB) == R)
         O.indent(2 * (depth + 1))
             << "Node"
             << static_cast<void *>(RI->getTopLevelRegion()->getBBNode(BB))
             << ";\n";
 
     O.indent(2 * depth) << "}\n";
   }