[FuncSpec][NFC] Improve debug messages.

[labrinea]

Summary

Adds diagnostic messages when debugging the pass.

[ChuanqiXu]

LGTM.

llvm/lib/Transforms/IPO/FunctionSpecialization.cpp

for (auto *F : Candidates) {
 
       auto Cost = getSpecializationCost(F);
       if (!Cost.isValid()) {
         LLVM_DEBUG(
             dbgs() << "FnSpecialization: Invalid specialisation cost.\n");
         continue;
       }
 
+      LLVM_DEBUG(dbgs() << "FnSpecialization: Specialization cost for "
+                        << F->getName() << " is " << Cost << "\n");
+
       auto ConstArgs = calculateGains(F, Cost);
       if (ConstArgs.empty()) {
         LLVM_DEBUG(dbgs() << "FnSpecialization: no possible constants found\n");
         continue;
       }
 
       for (auto &CA : ConstArgs) {
         specializeFunction(CA, WorkList);
private:
   /// interesting argument. Specializations based on additional arguments will
   /// be evaluated on following iterations of the main IPSCCP solve loop.
   SmallVector<ArgInfo> calculateGains(Function *F, InstructionCost Cost) {
     SmallVector<ArgInfo> Worklist;
     // 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 &FormalArg : F->args()) {
-      LLVM_DEBUG(dbgs() << "FnSpecialization: Analysing arg: "
-                        << 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 *> ActualArgs;
       if (!isArgumentInteresting(&FormalArg, ActualArgs, IsPartial)) {
-        LLVM_DEBUG(dbgs() << "FnSpecialization: Argument is not interesting\n");
+        LLVM_DEBUG(dbgs() << "FnSpecialization: Argument "
+                          << FormalArg.getNameOrAsOperand()
+                          << " is not interesting\n");
         continue;
       }
 
       for (auto *ActualArg : ActualArgs) {
         InstructionCost Gain =
             ForceFunctionSpecialization
                 ? 1
                 : getSpecializationBonus(&FormalArg, ActualArg) - Cost;
for (Argument &FormalArg : F->args()) {
       // Sort the candidates in descending order.
       llvm::stable_sort(Worklist, [](const ArgInfo &L, const ArgInfo &R) {
         return L.Gain > R.Gain;
       });
 
       // Truncate the worklist to 'MaxClonesThreshold' candidates if
       // necessary.
       if (Worklist.size() > MaxClonesThreshold) {
-        LLVM_DEBUG(dbgs() << "FnSpecialization: number of candidates exceed "
+        LLVM_DEBUG(dbgs() << "FnSpecialization: Number of candidates exceed "
                           << "the maximum number of clones threshold.\n"
-                    << "Truncating worklist to " << MaxClonesThreshold
-                    << " candidates.\n");
+                          << "FnSpecialization: Truncating worklist to "
+                          << MaxClonesThreshold << " candidates.\n");
         Worklist.erase(Worklist.begin() + MaxClonesThreshold,
                        Worklist.end());
       }
 
       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.Formal->getName() << ", ";
-                   dbgs() << "ActualArg = " << C.Actual->getName() << ", ";
-                   dbgs() << "Gain = " << C.Gain << "\n";
-                 });
+      LLVM_DEBUG(
+        dbgs() << "FnSpecialization: Specializations for function "
+               << F->getName() << "\n";
+        for (auto &C : Worklist) {
+          dbgs() << "FnSpecialization:   FormalArg = "
+                 << C.Formal->getNameOrAsOperand() << ", ActualArg = "
+                 << C.Actual->getNameOrAsOperand() << ", Gain = "
+                 << C.Gain << "\n";
+        }
+      );
 
       // FIXME: Only one argument per function.
       break;
     }
     return Worklist;
   }
 
   bool isCandidateFunction(Function *F) {
private:
   }
 
   /// Compute a bonus for replacing argument \p A with constant \p C.
   InstructionCost getSpecializationBonus(Argument *A, Constant *C) {
     Function *F = A->getParent();
     DominatorTree DT(*F);
     LoopInfo LI(DT);
     auto &TTI = (GetTTI)(*F);
-    LLVM_DEBUG(dbgs() << "FnSpecialization: Analysing bonus for: " << *A
-                      << "\n");
+    LLVM_DEBUG(dbgs() << "FnSpecialization: Analysing bonus for constant: "
+                      << C->getNameOrAsOperand() << "\n");
 
     InstructionCost TotalCost = 0;
     for (auto *U : A->users()) {
       TotalCost += getUserBonus(U, TTI, LI);
-      LLVM_DEBUG(dbgs() << "FnSpecialization: User cost ";
+      LLVM_DEBUG(dbgs() << "FnSpecialization:   User cost ";
                  TotalCost.print(dbgs()); dbgs() << " for: " << *U << "\n");
     }
 
     // The below heuristic is only concerned with exposing inlining
     // opportunities via indirect call promotion. If the argument is not a
     // function pointer, give up.
     if (!isa<PointerType>(A->getType()) ||
         !isa<FunctionType>(A->getType()->getPointerElementType()))
for (User *U : A->users()) {
           getInlineCost(*CS, CalledFunction, Params, CalleeTTI, GetAC, GetTLI);
 
       // We clamp the bonus for this call to be between zero and the default
       // threshold.
       if (IC.isAlways())
         Bonus += Params.DefaultThreshold;
       else if (IC.isVariable() && IC.getCostDelta() > 0)
         Bonus += IC.getCostDelta();
+
+      LLVM_DEBUG(dbgs() << "FnSpecialization:   Inlining bonus " << Bonus
+                        << " for user " << *U << "\n");
     }
 
     return TotalCost + Bonus;
   }
 
   /// Determine if we should specialize a function based on the incoming values
   /// of the given argument.
   ///
bool isArgumentInteresting(Argument *A, ConstList &Constants,
     // 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 the argument isn't overdefined, there's nothing to do. It should
     // already be constant.
     if (!Solver.getLatticeValueFor(A).isOverdefined()) {
-      LLVM_DEBUG(dbgs() << "FnSpecialization: nothing to do, arg is already "
-                        << "constant?\n");
+      LLVM_DEBUG(dbgs() << "FnSpecialization: Nothing to do, argument "
+                        << A->getNameOrAsOperand()
+                        << " is already constant?\n");
       return false;
     }
 
     // Collect the constant values that the argument can take on. If the
     // argument can't take on any constant values, we aren't going to
     // specialize the function. While it's possible to specialize the function
     // based on non-constant arguments, there's likely not much benefit to
     // constant propagation in doing so.
     //
     // TODO 1: currently it won't specialize if there are over the threshold of
     // calls using the same argument, e.g foo(a) x 4 and foo(b) x 1, but it
     // might be beneficial to take the occurrences into account in the cost
     // model, so we would need to find the unique constants.
     //
     // TODO 2: this currently does not support constants, i.e. integer ranges.
     //
     IsPartial = !getPossibleConstants(A, Constants);
-    LLVM_DEBUG(dbgs() << "FnSpecialization: interesting arg: " << *A << "\n");
+    LLVM_DEBUG(dbgs() << "FnSpecialization: Found interesting argument "
+                      << A->getNameOrAsOperand() << "\n");
     return true;
   }
 
   /// Collect in \p Constants all the constant values that argument \p A can
   /// take on.
   ///
   /// \returns true if all of the values the argument can take on are constant
   /// (e.g., the argument's parent function cannot be called with an
void rewriteCallSites(Function *F, Function *Clone, Argument &Arg,
     for (auto *U : F->users()) {
       if (!isa<CallInst>(U) && !isa<InvokeInst>(U))
         continue;
       auto &CS = *cast<CallBase>(U);
       if (!CS.getCalledFunction() || CS.getCalledFunction() != F)
         continue;
       CallSitesToRewrite.push_back(&CS);
     }
+
+    LLVM_DEBUG(dbgs() << "FnSpecialization: Replacing call sites of "
+                      << F->getName() << " with "
+                      << Clone->getName() << "\n");
+
     for (auto *CS : CallSitesToRewrite) {
+      LLVM_DEBUG(dbgs() << "FnSpecialization:   "
+                        << CS->getFunction()->getName() << " ->"
+                        << *CS << "\n");
       if ((CS->getFunction() == Clone && CS->getArgOperand(ArgNo) == &Arg) ||
           CS->getArgOperand(ArgNo) == C) {
         CS->setCalledFunction(Clone);
         Solver.markOverdefined(CS);
       }
     }
   }
 
for (auto *F : WorkList) {
       Solver.addArgumentTrackedFunction(F);
       Candidates.push_back(F);
       Solver.markBlockExecutable(&F->front());
 
       // Replace the function arguments for the specialized functions.
       for (Argument &Arg : F->args())
         if (!Arg.use_empty() && tryToReplaceWithConstant(&Arg))
           LLVM_DEBUG(dbgs() << "FnSpecialization: Replaced constant argument: "
-                            << Arg.getName() << "\n");
+                            << Arg.getNameOrAsOperand() << "\n");
     }
   }
 };
 } // namespace
 
 bool llvm::runFunctionSpecialization(
     Module &M, const DataLayout &DL,
     std::function<TargetLibraryInfo &(Function &)> GetTLI,
#endif
 
   // Initially resolve the constants in all the argument tracked functions.
   RunSCCPSolver(FuncDecls);
 
   SmallVector<Function *, 2> WorkList;
   unsigned I = 0;
   while (FuncSpecializationMaxIters != I++ &&
          FS.specializeFunctions(FuncDecls, WorkList)) {
+    LLVM_DEBUG(dbgs() << "FnSpecialization: Finished iteration " << I << "\n");
 
     // Run the solver for the specialized functions.
     RunSCCPSolver(WorkList);
 
     // Replace some unresolved constant arguments.
     constantArgPropagation(FuncDecls, M, Solver);
 
     WorkList.clear();
     Changed = true;
   }
 
+  LLVM_DEBUG(dbgs() << "FnSpecialization: Number of specializations = "
+                    << NumFuncSpecialized <<"\n");
+
   // 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,
 
   // 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 (Argument *OldArg = F->arg_begin(), *NewArg = A->getParent()->arg_begin(),
                 *End = F->arg_end();
-       OldArg != End; ++OldArg, ++NewArg)
+       OldArg != End; ++OldArg, ++NewArg) {
+
+    LLVM_DEBUG(dbgs() << "SCCP: Marking argument "
+                      << NewArg->getNameOrAsOperand() << "\n");
+
     if (NewArg != A && ValueState.count(OldArg)) {
       // Note: This previously looked like this:
       // ValueState[NewArg] = ValueState[OldArg];
       // This is incorrect because the DenseMap class may resize the underlying
       // 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);
 }