[Float2Int] Use a type alias for the RootSet. NFC

[bjope]

Summary

Use a type alias for the RootSet declaration in Float2IntPass.

This is just a minor refactoring in case we want to change the
type in the future (e.g. to something with deterministic iteration
order).

[bjope]

(not sure whom to add as reviewer to patches like this, added some random people who has contributed to this pass earlier)

[craig.topper]

llvm/include/llvm/Transforms/Scalar/Float2Int.h

48

Why is Roots both a member variable and passed to multiple member functions?

[bjope]

I'm removing the passing of Roots as arguments directly in D74534 instead.

llvm/include/llvm/Transforms/Scalar/Float2Int.h

 class Float2IntPass : public PassInfoMixin<Float2IntPass> {
 public:
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
 
   // Glue for old PM.
   bool runImpl(Function &F, const DominatorTree &DT);
 
 private:
+  using RootSet = SmallPtrSet<Instruction *, 8>;
+
   void findRoots(Function &F, const DominatorTree &DT,
-                 SmallPtrSet<Instruction *, 8> &Roots);
+                 RootSet &Roots);
   void seen(Instruction *I, ConstantRange R);
   ConstantRange badRange();
   ConstantRange unknownRange();
   ConstantRange validateRange(ConstantRange R);
-  void walkBackwards(const SmallPtrSetImpl<Instruction *> &Roots);
+  void walkBackwards(const RootSet &Roots);
   void walkForwards();
   bool validateAndTransform();
   Value *convert(Instruction *I, Type *ToTy);
   void cleanup();
 
   MapVector<Instruction *, ConstantRange> SeenInsts;
-  SmallPtrSet<Instruction *, 8> Roots;
+  RootSet Roots;
   EquivalenceClasses<Instruction *> ECs;
   MapVector<Instruction *, Value *> ConvertedInsts;
   LLVMContext *Ctx;
 };
 }
 #endif // LLVM_TRANSFORMS_SCALAR_FLOAT2INT_H

llvm/lib/Transforms/Scalar/Float2Int.cpp

static Instruction::BinaryOps mapBinOpcode(unsigned Opcode) {
   case Instruction::FSub: return Instruction::Sub;
   case Instruction::FMul: return Instruction::Mul;
   }
 }
 
 // Find the roots - instructions that convert from the FP domain to
 // integer domain.
 void Float2IntPass::findRoots(Function &F, const DominatorTree &DT,
-                              SmallPtrSet<Instruction*,8> &Roots) {
+                              RootSet &Roots) {
   for (BasicBlock &BB : F) {
     // Unreachable code can take on strange forms that we are not prepared to
     // handle. For example, an instruction may have itself as an operand.
     if (!DT.isReachableFromEntry(&BB))
       continue;
 
     for (Instruction &I : BB) {
       if (isa<VectorType>(I.getType()))

 //                     instructions and poison values if they're obvious and
 //                     cheap to compute. Calculate the equivalance set structure
 //                     while we're here too.
 //   - walkForwards:  Iterate over SeenInsts in reverse order, so we visit
 //                     defs before their uses. Calculate the real range info.
 
 // Breadth-first walk of the use-def graph; determine the set of nodes
 // we care about and eagerly determine if some of them are poisonous.
-void Float2IntPass::walkBackwards(const SmallPtrSetImpl<Instruction*> &Roots) {
+void Float2IntPass::walkBackwards(const RootSet &Roots) {
   std::deque<Instruction*> Worklist(Roots.begin(), Roots.end());
   while (!Worklist.empty()) {
     Instruction *I = Worklist.back();
     Worklist.pop_back();
 
     if (SeenInsts.find(I) != SeenInsts.end())
       // Seen already.
       continue;