NFC: Migrate LoopUnrollPass to work on InstructionCost

[sdesmalen]

Summary

This patch migrates cost values and arithmetic to work on InstructionCost.
When the interfaces to TargetTransformInfo are changed, any InstructionCost
state will propagate naturally.

See this patch for the introduction of the type: https://reviews.llvm.org/D91174
See this thread for context: http://lists.llvm.org/pipermail/llvm-dev/2020-November/146408.html

[david-arm]

LGTM!

[fhahn]

llvm/lib/Transforms/Scalar/LoopUnrollPass.cpp

650

should we add an accessor that returns the value directly? The extra dereferences look odd, especially because we already check that the cost is valid.

[sdesmalen]

llvm/lib/Transforms/Scalar/LoopUnrollPass.cpp

650

When @david-arm created the class I initially argued against that because I didn't want people to assume getValue() always returns a value, and crashes when the value isn't valid. I agree with you that the current interface is cumbersome in these cases, but fortunately this use-case is quite rare; in most places InstructionCost is either propagated, accumulated or compared directly.

I could add some getValidValue() where the name hints the cost must be valid (and where the method asserts it is), but given the limited use-cases in practice, I think I still prefer to stick to the current interface where it returns an Optional, because that makes it unequivocally clear the value may not be set if the InstructionCost is invalid.

[fhahn]

llvm/lib/Transforms/Scalar/LoopUnrollPass.cpp

650

Is it that uncommon? It looks like the majority of uses in LoopVectorize.cpp for example use *Cost.getValue() for example.

[sdesmalen]

llvm/lib/Transforms/Scalar/LoopUnrollPass.cpp

650

That's only temporary, until we finish migrating places to work with InstructionCost directly, so most of these *Cost.getValue() statements will go away.

[fhahn]

LGTM

llvm/lib/Transforms/Scalar/LoopUnrollPass.cpp

650

Ok, sounds like it's probably not worth worrying about it too much then.

llvm/lib/Transforms/Scalar/LoopUnrollPass.cpp

static Optional<EstimatedUnrollCost> analyzeLoopUnrollCost(
 
   SmallSetVector<BasicBlock *, 16> BBWorklist;
   SmallSetVector<std::pair<BasicBlock *, BasicBlock *>, 4> ExitWorklist;
   DenseMap<Value *, Constant *> SimplifiedValues;
   SmallVector<std::pair<Value *, Constant *>, 4> SimplifiedInputValues;
 
   // The estimated cost of the unrolled form of the loop. We try to estimate
   // this by simplifying as much as we can while computing the estimate.
-  unsigned UnrolledCost = 0;
+  InstructionCost UnrolledCost = 0;
 
   // We also track the estimated dynamic (that is, actually executed) cost in
   // the rolled form. This helps identify cases when the savings from unrolling
   // aren't just exposing dead control flows, but actual reduced dynamic
   // instructions due to the simplifications which we expect to occur after
   // unrolling.
-  unsigned RolledDynamicCost = 0;
+  InstructionCost RolledDynamicCost = 0;
 
   // We track the simplification of each instruction in each iteration. We use
   // this to recursively merge costs into the unrolled cost on-demand so that
   // we don't count the cost of any dead code. This is essentially a map from
   // <instruction, int> to <bool, bool>, but stored as a densely packed struct.
   DenseSet<UnrolledInstState, UnrolledInstStateKeyInfo> InstCostMap;
 
   // A small worklist used to accumulate cost of instructions from each
for (Instruction &I : *ExitBB) {
 
       Value *Op = PN->getIncomingValueForBlock(ExitingBB);
       if (auto *OpI = dyn_cast<Instruction>(Op))
         if (L->contains(OpI))
           AddCostRecursively(*OpI, TripCount - 1);
     }
   }
 
+  assert(UnrolledCost.isValid() && RolledDynamicCost.isValid() &&
+         "All instructions must have a valid cost, whether the "
+         "loop is rolled or unrolled.");
+
   LLVM_DEBUG(dbgs() << "Analysis finished:\n"
                     << "UnrolledCost: " << UnrolledCost << ", "
                     << "RolledDynamicCost: " << RolledDynamicCost << "\n");
-  return {{UnrolledCost, RolledDynamicCost}};
+  return {{unsigned(*UnrolledCost.getValue()),
+           unsigned(*RolledDynamicCost.getValue())}};
 }
 
 /// ApproximateLoopSize - Approximate the size of the loop.
 unsigned llvm::ApproximateLoopSize(
     const Loop *L, unsigned &NumCalls, bool &NotDuplicatable, bool &Convergent,
     const TargetTransformInfo &TTI,
     const SmallPtrSetImpl<const Value *> &EphValues, unsigned BEInsns) {
   CodeMetrics Metrics;