[FuncSpec] Move invariant computation for spec cost out of loop (NFC-ish)

[ChuanqiXu]

Summary

Noticed that the computation for function specialization cost of a function wouldn't change during the traversal of the arguments for the function. We could hoist the computation out of the traversal. I observed about ~1% improvement on compile time for spec2017. But I guess it may not be precise. This should be NFC and fine.

Test Plan: check-all, spec2017 int rate

[SjoerdMeijer]

Nice one, looks like a good change to me.

llvm/lib/Transforms/IPO/FunctionSpecialization.cpp

bool specializeFunction(Function *F,
 
     // Exit if the function is not executable. There's no point in specializing
     // a dead function.
     if (!Solver.isBlockExecutable(&F->getEntryBlock()))
       return false;
 
     LLVM_DEBUG(dbgs() << "FnSpecialization: Try function: " << F->getName()
                       << "\n");
+
+    // Determine if it would be profitable to create a specialization of the
+    // function where the argument takes on the given constant value. If so,
+    // add the constant to Constants.
+    auto FnSpecCost = getSpecializationCost(F);
+    if (!FnSpecCost.isValid()) {
+      LLVM_DEBUG(dbgs() << "FnSpecialization: Invalid specialisation cost.\n");
+      return false;
+    }
+
+    LLVM_DEBUG(dbgs() << "FnSpecialization: func specialisation cost: ";
+               FnSpecCost.print(dbgs()); dbgs() << "\n");
+
     // Determine if we should specialize the function based on the values the
     // argument can take on. If specialization is not profitable, we continue
     // on to the next argument.
     for (Argument &A : F->args()) {
       LLVM_DEBUG(dbgs() << "FnSpecialization: Analysing arg: " << A.getName()
                         << "\n");
       // True if this will be a partial specialization. We will need to keep
       // the original function around in addition to the added specializations.
       bool IsPartial = true;
 
       // 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).
       SmallVector<Constant *, 4> Constants;
-      if (!isArgumentInteresting(&A, Constants, IsPartial)) {
+      if (!isArgumentInteresting(&A, Constants, FnSpecCost, IsPartial)) {
         LLVM_DEBUG(dbgs() << "FnSpecialization: Argument is not interesting\n");
         continue;
       }
 
       assert(!Constants.empty() && "No constants on which to specialize");
       LLVM_DEBUG(dbgs() << "FnSpecialization: Argument is interesting!\n"
                         << "FnSpecialization: Specializing '" << F->getName()
                         << "' on argument: " << A << "\n"
private:
   /// \p Constants represent the complete set of values that \p A can take on,
   /// the function will be completely specialized, and the \p IsPartial flag is
   /// set to false.
   ///
   /// \returns true if the function should be specialized on the given
   /// argument.
   bool isArgumentInteresting(Argument *A,
                              SmallVectorImpl<Constant *> &Constants,
+                             const InstructionCost &FnSpecCost,
                              bool &IsPartial) {
     Function *F = A->getParent();
 
     // For now, don't attempt to specialize functions based on the values of
     // composite types.
     if (!A->getType()->isSingleValueType() || A->user_empty())
       return false;
 
if (PossibleConstants.empty()) {
       return false;
     }
     if (PossibleConstants.size() > MaxConstantsThreshold) {
       LLVM_DEBUG(dbgs() << "FnSpecialization: number of constants found exceed "
                         << "the maximum number of constants threshold.\n");
       return false;
     }
 
-    // Determine if it would be profitable to create a specialization of the
-    // function where the argument takes on the given constant value. If so,
-    // add the constant to Constants.
-    auto FnSpecCost = getSpecializationCost(F);
-    if (!FnSpecCost.isValid()) {
-      LLVM_DEBUG(dbgs() << "FnSpecialization: Invalid specialisation cost.\n");
-      return false;
-    }
-
-    LLVM_DEBUG(dbgs() << "FnSpecialization: func specialisation cost: ";
-               FnSpecCost.print(dbgs()); dbgs() << "\n");
-
     for (auto *C : PossibleConstants) {
       LLVM_DEBUG(dbgs() << "FnSpecialization: Constant: " << *C << "\n");
       if (ForceFunctionSpecialization) {
         LLVM_DEBUG(dbgs() << "FnSpecialization: Forced!\n");
         Constants.push_back(C);
         continue;
       }
       if (getSpecializationBonus(A, C) > FnSpecCost) {