[ADT] Support iterating size-based integer ranges.

[kosarev]

Summary

It seems the ranges start with 0 in most cases.

[dblaikie]

SGTM - might be nice to add some simple unit test coverage too

[gchatelet]

LGTM
Agreed w/ dblaikie@ : a small test could help.

[kosarev]

Add a test.

llvm/include/llvm/ADT/Sequence.h

 /// forward iteration (resp. [INTMAX_MIN + 1, INTMAX_MAX] for reverse
 /// iteration).
 template <typename T, typename = std::enable_if_t<std::is_integral<T>::value &&
                                                   !std::is_enum<T>::value>>
 auto seq(T Begin, T End) {
   return iota_range<T>(Begin, End, false);
 }
 
+/// Iterate over an integral type from 0 up to - but not including - Size.
+/// Note: Size value has to be within [INTMAX_MIN, INTMAX_MAX - 1] for
+/// forward iteration (resp. [INTMAX_MIN + 1, INTMAX_MAX - 1] for reverse
+/// iteration).
+template <typename T, typename = std::enable_if_t<std::is_integral<T>::value &&
+                                                  !std::is_enum<T>::value>>
+auto seq(T Size) {
+  return seq<T>(0, Size);
+}
+
 /// Iterate over an integral type from Begin to End inclusive.
 /// Note: Begin and End values have to be within [INTMAX_MIN, INTMAX_MAX - 1]
 /// for forward iteration (resp. [INTMAX_MIN + 1, INTMAX_MAX - 1] for reverse
 /// iteration).
 template <typename T, typename = std::enable_if_t<std::is_integral<T>::value &&
                                                   !std::is_enum<T>::value>>
 auto seq_inclusive(T Begin, T End) {
   return iota_range<T>(Begin, End, true);

llvm/lib/Analysis/ScalarEvolution.cpp

if (const auto *LInst = dyn_cast<Instruction>(LV)) {
     }
 
     // Compare the number of operands.
     unsigned LNumOps = LInst->getNumOperands(),
              RNumOps = RInst->getNumOperands();
     if (LNumOps != RNumOps)
       return (int)LNumOps - (int)RNumOps;
 
-    for (unsigned Idx : seq(0u, LNumOps)) {
+    for (unsigned Idx : seq(LNumOps)) {
       int Result =
           CompareValueComplexity(EqCacheValue, LI, LInst->getOperand(Idx),
                                  RInst->getOperand(Idx), Depth + 1);
       if (Result != 0)
         return Result;
     }
   }
 

llvm/lib/IR/Instructions.cpp

bool ShuffleVectorInst::isConcat() const {
   return isIdentityMaskImpl(getShuffleMask(), NumMaskElts);
 }
 
 static bool isReplicationMaskWithParams(ArrayRef<int> Mask,
                                         int ReplicationFactor, int VF) {
   assert(Mask.size() == (unsigned)ReplicationFactor * VF &&
          "Unexpected mask size.");
 
-  for (int CurrElt : seq(0, VF)) {
+  for (int CurrElt : seq(VF)) {
     ArrayRef<int> CurrSubMask = Mask.take_front(ReplicationFactor);
     assert(CurrSubMask.size() == (unsigned)ReplicationFactor &&
            "Run out of mask?");
     Mask = Mask.drop_front(ReplicationFactor);
     if (!all_of(CurrSubMask, [CurrElt](int MaskElt) {
           return MaskElt == PoisonMaskElem || MaskElt == CurrElt;
         }))
       return false;

llvm/lib/Transforms/Utils/SimplifyCFG.cpp

bool SimplifyCFGOpt::PerformValueComparisonIntoPredecessorFolding(
   // successors.
   SmallPtrSet<BasicBlock *, 2> SuccsOfPred;
   if (DTU) {
     SuccsOfPred = {succ_begin(Pred), succ_end(Pred)};
     Updates.reserve(Updates.size() + NewSuccessors.size());
   }
   for (const std::pair<BasicBlock *, int /*Num*/> &NewSuccessor :
        NewSuccessors) {
-    for (auto I : seq(0, NewSuccessor.second)) {
+    for (auto I : seq(NewSuccessor.second)) {
       (void)I;
       AddPredecessorToBlock(NewSuccessor.first, Pred, BB);
     }
     if (DTU && !SuccsOfPred.contains(NewSuccessor.first))
       Updates.push_back({DominatorTree::Insert, Pred, NewSuccessor.first});
   }
 
   Builder.SetInsertPoint(PTI);

llvm/tools/llvm-exegesis/lib/SnippetRepetitor.cpp

return [this, Instructions, MinInstructions, LoopBodySize,
         // The live ins are: the loop counter, the registers that were setup by
         // the entry block, and entry block live ins.
         Loop.MBB->addLiveIn(LoopCounter);
         for (unsigned Reg : Filler.getRegistersSetUp())
           Loop.MBB->addLiveIn(Reg);
         for (const auto &LiveIn : Entry.MBB->liveins())
           Loop.MBB->addLiveIn(LiveIn);
       }
-      for (auto _ : seq(0U, LoopUnrollFactor)) {
+      for (auto _ : seq(LoopUnrollFactor)) {
         (void)_;
         Loop.addInstructions(Instructions);
       }
       ET.decrementLoopCounterAndJump(*Loop.MBB, *Loop.MBB,
                                      State.getInstrInfo());
 
       // Set up the exit basic block.
       Loop.MBB->addSuccessor(Exit.MBB, BranchProbability::getZero());

llvm/tools/llvm-reduce/deltas/ReduceOperandBundles.cpp

void visitCallBase(CallBase &Call) {
     if (!Call.hasOperandBundles())
       return; // No bundles to begin with.
 
     // Insert this call into map, we will likely want to rebuild it.
     auto &OperandBundlesToKeepIndexes = CallsToRefine[&Call];
     OperandBundlesToKeepIndexes.reserve(Call.getNumOperandBundles());
 
     // Enumerate every operand bundle on this call.
-    for (unsigned BundleIndex : seq(0U, Call.getNumOperandBundles()))
+    for (unsigned BundleIndex : seq(Call.getNumOperandBundles()))
       if (O.shouldKeep()) // Should we keep this one?
         OperandBundlesToKeepIndexes.emplace_back(BundleIndex);
   }
 };
 
 struct OperandBundleCounter : public InstVisitor<OperandBundleCounter> {
   /// How many features (in this case, operand bundles) did we count, total?
   int OperandBundeCount = 0;

llvm/unittests/ADT/SequenceTest.cpp

TEST(SafeIntIteratorTest, Operations) {
   EXPECT_EQ(Reverse - Reverse, 0);
   EXPECT_EQ((Forward + 1) - Forward, 1);
   EXPECT_EQ(Forward - (Forward + 1), -1);
   EXPECT_EQ((Reverse + 1) - Reverse, 1);
   EXPECT_EQ(Reverse - (Reverse + 1), -1);
 }
 
 TEST(SequenceTest, Iteration) {
+  EXPECT_THAT(seq(5), ElementsAre(0, 1, 2, 3, 4));
+
   EXPECT_THAT(seq(-4, 5), ElementsAre(-4, -3, -2, -1, 0, 1, 2, 3, 4));
   EXPECT_THAT(reverse(seq(-4, 5)), ElementsAre(4, 3, 2, 1, 0, -1, -2, -3, -4));
 
   EXPECT_THAT(seq_inclusive(-4, 5),
               ElementsAre(-4, -3, -2, -1, 0, 1, 2, 3, 4, 5));
   EXPECT_THAT(reverse(seq_inclusive(-4, 5)),
               ElementsAre(5, 4, 3, 2, 1, 0, -1, -2, -3, -4));
 }