[FuncSpec][NFC] Variable renaming.

[labrinea]

Summary

Just preparing the ground for follow up patches to make the reviews easier.

[ChuanqiXu]

LGTM.

llvm/lib/Transforms/IPO/FunctionSpecialization.cpp

static cl::opt<bool> EnableSpecializationForLiteralConstant(
     cl::desc("Enable specialization of functions that take a literal constant "
              "as an argument."));
 
 namespace {
 // Bookkeeping struct to pass data from the analysis and profitability phase
 // to the actual transform helper functions.
 struct ArgInfo {
   Function *Fn;         // The function to perform specialisation on.
-  Argument *Arg;        // The Formal argument being analysed.
-  Constant *Const;      // A corresponding actual constant argument.
+  Argument *Formal;     // The Formal argument being analysed.
+  Constant *Actual;     // A corresponding actual constant argument.
   InstructionCost Gain; // Profitability: Gain = Bonus - Cost.
 
   // Flag if this will be a partial specialization, in which case we will need
   // to keep the original function around in addition to the added
   // specializations.
   bool Partial = false;
 
   ArgInfo(Function *F, Argument *A, Constant *C, InstructionCost G)
-      : Fn(F), Arg(A), Const(C), Gain(G){};
+      : Fn(F), Formal(A), Actual(C), Gain(G){};
 };
 } // Anonymous namespace
 
 using FuncList = SmallVectorImpl<Function *>;
 using ConstList = SmallVectorImpl<Constant *>;
 
 // Helper to check if \p LV is either a constant or a constant
 // range with a single element. This should cover exactly the same cases as the
FunctionSpecializer(SCCPSolver &Solver,
                       std::function<TargetTransformInfo &(Function &)> GetTTI,
                       std::function<TargetLibraryInfo &(Function &)> GetTLI)
       : Solver(Solver), GetAC(GetAC), GetTTI(GetTTI), GetTLI(GetTLI) {}
 
   /// Attempt to specialize functions in the module to enable constant
   /// propagation across function boundaries.
   ///
   /// \returns true if at least one function is specialized.
-  bool
-  specializeFunctions(FuncList &FuncDecls,
-                      FuncList &CurrentSpecializations) {
+  bool specializeFunctions(FuncList &Candidates, FuncList &WorkList) {
     bool Changed = false;
-    for (auto *F : FuncDecls) {
-      if (!isCandidateFunction(F, CurrentSpecializations))
+    for (auto *F : Candidates) {
+      if (!isCandidateFunction(F))
         continue;
 
       auto Cost = getSpecializationCost(F);
       if (!Cost.isValid()) {
         LLVM_DEBUG(
             dbgs() << "FnSpecialization: Invalid specialisation cost.\n");
         continue;
       }
 
       auto ConstArgs = calculateGains(F, Cost);
       if (ConstArgs.empty()) {
         LLVM_DEBUG(dbgs() << "FnSpecialization: no possible constants found\n");
         continue;
       }
 
       for (auto &CA : ConstArgs) {
-        specializeFunction(CA, CurrentSpecializations);
+        specializeFunction(CA, WorkList);
         Changed = true;
       }
     }
 
-    updateSpecializedFuncs(FuncDecls, CurrentSpecializations);
+    updateSpecializedFuncs(Candidates, WorkList);
     NumFuncSpecialized += NbFunctionsSpecialized;
     return Changed;
   }
 
   void removeDeadInstructions() {
     for (auto *I : ReplacedWithConstant) {
       LLVM_DEBUG(dbgs() << "FnSpecialization: Removing dead instruction "
                         << *I << "\n");
for (Argument &FormalArg : F->args()) {
                         << FormalArg.getName() << "\n");
       // Determine if this argument is interesting. If we know the argument can
       // take on any constant values, they are collected in Constants. If the
       // argument can only ever equal a constant value in Constants, the
       // function will be completely specialized, and the IsPartial flag will
       // be set to false by isArgumentInteresting (that function only adds
       // values to the Constants list that are deemed profitable).
       bool IsPartial = true;
-      SmallVector<Constant *> ActualConstArg;
-      if (!isArgumentInteresting(&FormalArg, ActualConstArg, IsPartial)) {
+      SmallVector<Constant *> ActualArgs;
+      if (!isArgumentInteresting(&FormalArg, ActualArgs, IsPartial)) {
         LLVM_DEBUG(dbgs() << "FnSpecialization: Argument is not interesting\n");
         continue;
       }
 
-      for (auto *ActualArg : ActualConstArg) {
+      for (auto *ActualArg : ActualArgs) {
         InstructionCost Gain =
             ForceFunctionSpecialization
                 ? 1
                 : getSpecializationBonus(&FormalArg, ActualArg) - Cost;
 
         if (Gain <= 0)
           continue;
         Worklist.push_back({F, &FormalArg, ActualArg, Gain});
for (Argument &FormalArg : F->args()) {
         LLVM_DEBUG(dbgs() << "FnSpecialization: number of candidates exceed "
                     << "the maximum number of clones threshold.\n"
                     << "Truncating worklist to " << MaxClonesThreshold
                     << " candidates.\n");
         Worklist.erase(Worklist.begin() + MaxClonesThreshold,
                        Worklist.end());
       }
 
-      if (IsPartial || Worklist.size() < ActualConstArg.size())
+      if (IsPartial || Worklist.size() < ActualArgs.size())
         for (auto &ActualArg : Worklist)
           ActualArg.Partial = true;
 
       LLVM_DEBUG(dbgs() << "Sorted list of candidates by gain:\n";
                  for (auto &C
                       : Worklist) {
                    dbgs() << "- Function = " << C.Fn->getName() << ", ";
-                   dbgs() << "FormalArg = " << C.Arg->getName() << ", ";
-                   dbgs() << "ActualArg = " << C.Const->getName() << ", ";
+                   dbgs() << "FormalArg = " << C.Formal->getName() << ", ";
+                   dbgs() << "ActualArg = " << C.Actual->getName() << ", ";
                    dbgs() << "Gain = " << C.Gain << "\n";
                  });
 
       // FIXME: Only one argument per function.
       break;
     }
     return Worklist;
   }
 
-  bool isCandidateFunction(Function *F, FuncList &Specializations) {
+  bool isCandidateFunction(Function *F) {
     // Do not specialize the cloned function again.
     if (SpecializedFuncs.contains(F))
       return false;
 
     // If we're optimizing the function for size, we shouldn't specialize it.
     if (F->hasOptSize() ||
         shouldOptimizeForSize(F, nullptr, nullptr, PGSOQueryType::IRPass))
       return false;
 
     // Exit if the function is not executable. There's no point in specializing
     // a dead function.
     if (!Solver.isBlockExecutable(&F->getEntryBlock()))
       return false;
 
     // It wastes time to specialize a function which would get inlined finally.
     if (F->hasFnAttribute(Attribute::AlwaysInline))
       return false;
 
     LLVM_DEBUG(dbgs() << "FnSpecialization: Try function: " << F->getName()
                       << "\n");
     return true;
   }
 
-  void specializeFunction(ArgInfo &AI, FuncList &Specializations) {
+  void specializeFunction(ArgInfo &AI, FuncList &WorkList) {
     Function *Clone = cloneCandidateFunction(AI.Fn);
-    Argument *ClonedArg = Clone->getArg(AI.Arg->getArgNo());
+    Argument *ClonedArg = Clone->getArg(AI.Formal->getArgNo());
 
     // Rewrite calls to the function so that they call the clone instead.
-    rewriteCallSites(AI.Fn, Clone, *ClonedArg, AI.Const);
+    rewriteCallSites(AI.Fn, Clone, *ClonedArg, AI.Actual);
 
     // Initialize the lattice state of the arguments of the function clone,
     // marking the argument on which we specialized the function constant
     // with the given value.
-    Solver.markArgInFuncSpecialization(AI.Fn, ClonedArg, AI.Const);
+    Solver.markArgInFuncSpecialization(AI.Fn, ClonedArg, AI.Actual);
 
     // Mark all the specialized functions
-    Specializations.push_back(Clone);
+    WorkList.push_back(Clone);
     NbFunctionsSpecialized++;
 
     // If the function has been completely specialized, the original function
     // is no longer needed. Mark it unreachable.
     if (!AI.Partial)
       Solver.markFunctionUnreachable(AI.Fn);
   }
 
for (auto *CS : CallSitesToRewrite) {
       if ((CS->getFunction() == Clone && CS->getArgOperand(ArgNo) == &Arg) ||
           CS->getArgOperand(ArgNo) == C) {
         CS->setCalledFunction(Clone);
         Solver.markOverdefined(CS);
       }
     }
   }
 
-  void updateSpecializedFuncs(FuncList &FuncDecls,
-                              FuncList &CurrentSpecializations) {
-    for (auto *SpecializedFunc : CurrentSpecializations) {
-      SpecializedFuncs.insert(SpecializedFunc);
+  void updateSpecializedFuncs(FuncList &Candidates, FuncList &WorkList) {
+    for (auto *F : WorkList) {
+      SpecializedFuncs.insert(F);
 
       // Initialize the state of the newly created functions, marking them
       // argument-tracked and executable.
-      if (SpecializedFunc->hasExactDefinition() &&
-          !SpecializedFunc->hasFnAttribute(Attribute::Naked))
-        Solver.addTrackedFunction(SpecializedFunc);
-
-      Solver.addArgumentTrackedFunction(SpecializedFunc);
-      FuncDecls.push_back(SpecializedFunc);
-      Solver.markBlockExecutable(&SpecializedFunc->front());
+      if (F->hasExactDefinition() && !F->hasFnAttribute(Attribute::Naked))
+        Solver.addTrackedFunction(F);
+
+      Solver.addArgumentTrackedFunction(F);
+      Candidates.push_back(F);
+      Solver.markBlockExecutable(&F->front());
 
       // Replace the function arguments for the specialized functions.
-      for (Argument &Arg : SpecializedFunc->args())
+      for (Argument &Arg : F->args())
         if (!Arg.use_empty() && tryToReplaceWithConstant(&Arg))
           LLVM_DEBUG(dbgs() << "FnSpecialization: Replaced constant argument: "
                             << Arg.getName() << "\n");
     }
   }
 };
 } // namespace
 
#ifndef NDEBUG
   LLVM_DEBUG(dbgs() << "FnSpecialization: Worklist fn decls:\n");
   for (auto *F : FuncDecls)
     LLVM_DEBUG(dbgs() << "FnSpecialization: *) " << F->getName() << "\n");
 #endif
 
   // Initially resolve the constants in all the argument tracked functions.
   RunSCCPSolver(FuncDecls);
 
-  SmallVector<Function *, 2> CurrentSpecializations;
+  SmallVector<Function *, 2> WorkList;
   unsigned I = 0;
   while (FuncSpecializationMaxIters != I++ &&
-         FS.specializeFunctions(FuncDecls, CurrentSpecializations)) {
+         FS.specializeFunctions(FuncDecls, WorkList)) {
 
     // Run the solver for the specialized functions.
-    RunSCCPSolver(CurrentSpecializations);
+    RunSCCPSolver(WorkList);
 
     // Replace some unresolved constant arguments.
     constantArgPropagation(FuncDecls, M, Solver);
 
-    CurrentSpecializations.clear();
+    WorkList.clear();
     Changed = true;
   }
 
   // Clean up the IR by removing dead instructions and ssa_copy intrinsics.
   FS.removeDeadInstructions();
   removeSSACopy(M);
   return Changed;
 }

llvm/lib/Transforms/Utils/SCCPSolver.cpp

void SCCPInstVisitor::markArgInFuncSpecialization(Function *F, Argument *A,
   assert(F->arg_size() == A->getParent()->arg_size() &&
          "Functions should have the same number of arguments");
 
   // Mark the argument constant in the new function.
   markConstant(A, C);
 
   // For the remaining arguments in the new function, copy the lattice state
   // over from the old function.
-  for (auto I = F->arg_begin(), J = A->getParent()->arg_begin(),
-            E = F->arg_end();
-       I != E; ++I, ++J)
-    if (J != A && ValueState.count(I)) {
+  for (Argument *OldArg = F->arg_begin(), *NewArg = A->getParent()->arg_begin(),
+                *End = F->arg_end();
+       OldArg != End; ++OldArg, ++NewArg)
+    if (NewArg != A && ValueState.count(OldArg)) {
       // Note: This previously looked like this:
-      // ValueState[J] = ValueState[I];
+      // ValueState[NewArg] = ValueState[OldArg];
       // This is incorrect because the DenseMap class may resize the underlying
-      // memory when inserting `J`, which will invalidate the reference to `I`.
-      // Instead, we make sure `J` exists, then set it to `I` afterwards.
-      auto &NewValue = ValueState[J];
-      NewValue = ValueState[I];
-      pushToWorkList(NewValue, J);
+      // memory when inserting `NewArg`, which will invalidate the reference to
+      // `OldArg`. Instead, we make sure `NewArg` exists before setting it.
+      auto &NewValue = ValueState[NewArg];
+      NewValue = ValueState[OldArg];
+      pushToWorkList(NewValue, NewArg);
     }
 }
 
 void SCCPInstVisitor::visitInstruction(Instruction &I) {
   // All the instructions we don't do any special handling for just
   // go to overdefined.
   LLVM_DEBUG(dbgs() << "SCCP: Don't know how to handle: " << I << '\n');
   markOverdefined(&I);