[NFC] [LLVM] Fix MaxFixPointIterations typo to match documentation

[gAlfonso-bit]

Summary

This should avoid documentation related warnings and make the code and documentation consistent

[jdoerfert]

We do not want to talk about "fixed point" (as the alternative to "floating point") iterations but "fixpoint" iterations (in the sense of https://xavierleroy.org/courses/DSSS-2017/compiler.Fixpoint.html).

That said, the current Attributor docs are wrong once:

llvm/include/llvm/Transforms/IPO/Attributor.h
2007:  /// Maximum number of fixedpoint iterations.

and the code uses the wrong wording a few times:

llvm/lib/Transforms/IPO/Attributor.cpp
1331:  unsigned MaxFixedPointIterations;
1333:    MaxFixedPointIterations = MaxFixpointIterations.getValue();
1335:    MaxFixedPointIterations = SetFixpointIterations;
1415:  } while (!Worklist.empty() && (IterationCounter++ < MaxFixedPointIterations ||
1418:  if (IterationCounter > MaxFixedPointIterations && !Worklist.empty()) {
1421:                 << ore::NV("Iterations", MaxFixedPointIterations)
1425:    emitRemark<OptimizationRemarkMissed>(F, "FixedPoint", Remark);
1464:      IterationCounter != MaxFixedPointIterations) {
1466:           << IterationCounter << "/" << MaxFixedPointIterations

But this patch changes it in the wrong way.

[gAlfonso-bit]

Addressed issues

[jdoerfert]

LG, thanks for the cleanup

[gAlfonso-bit]

@jdoerfert Thank you, but I do not have commit permissions. Could you please commit this?

[jdoerfert]

I need a name and email to attribute the patch to. Arc is not great doing this automagically.

[gAlfonso-bit]

This comment was removed by gAlfonso-bit.

[gAlfonso-bit]

This comment was removed by gAlfonso-bit.

[gAlfonso-bit]

This comment was removed by gAlfonso-bit.

[gAlfonso-bit]

Obsolete

llvm/include/llvm/Transforms/IPO/Attributor.h

private:
   const DenseSet<const char *> *Allowed;
 
   /// Whether to delete functions.
   const bool DeleteFns;
 
   /// Whether to rewrite signatures.
   const bool RewriteSignatures;
 
-  /// Maximum number of fixedpoint iterations.
+  /// Maximum number of fixpoint iterations.
   Optional<unsigned> MaxFixpointIterations;
 
   /// A set to remember the functions we already assume to be live and visited.
   DenseSet<const Function *> VisitedFunctions;
 
   /// Uses we replace with a new value after manifest is done. We will remove
   /// then trivially dead instructions as well.
   DenseMap<Use *, Value *> ToBeChangedUses;

llvm/lib/Transforms/IPO/Attributor.cpp

void Attributor::runTillFixpoint() {
   TimeTraceScope TimeScope("Attributor::runTillFixpoint");
   LLVM_DEBUG(dbgs() << "[Attributor] Identified and initialized "
                     << DG.SyntheticRoot.Deps.size()
                     << " abstract attributes.\n");
 
   // Now that all abstract attributes are collected and initialized we start
   // the abstract analysis.
 
-  unsigned IterationCounter = 1;
-  unsigned MaxFixedPointIterations;
-  if (MaxFixpointIterations)
-    MaxFixedPointIterations = MaxFixpointIterations.getValue();
-  else
-    MaxFixedPointIterations = SetFixpointIterations;
-
   SmallVector<AbstractAttribute *, 32> ChangedAAs;
   SetVector<AbstractAttribute *> Worklist, InvalidAAs;
   Worklist.insert(DG.SyntheticRoot.begin(), DG.SyntheticRoot.end());
 
+  unsigned MaxFixpointIterationsValue = MaxFixpointIterations
+                                            ? MaxFixpointIterations.getValue()
+                                            : SetFixpointIterations;
+  unsigned IterationCounter = 1;
+
   do {
     // Remember the size to determine new attributes.
     size_t NumAAs = DG.SyntheticRoot.Deps.size();
     LLVM_DEBUG(dbgs() << "\n\n[Attributor] #Iteration: " << IterationCounter
                       << ", Worklist size: " << Worklist.size() << "\n");
 
     // For invalid AAs we can fix dependent AAs that have a required dependence,
     // thereby folding long dependence chains in a single step without the need
do {
     ChangedAAs.append(DG.SyntheticRoot.begin() + NumAAs,
                       DG.SyntheticRoot.end());
 
     // Reset the work list and repopulate with the changed abstract attributes.
     // Note that dependent ones are added above.
     Worklist.clear();
     Worklist.insert(ChangedAAs.begin(), ChangedAAs.end());
 
-  } while (!Worklist.empty() && (IterationCounter++ < MaxFixedPointIterations ||
-                                 VerifyMaxFixpointIterations));
+  } while (!Worklist.empty() &&
+           (IterationCounter++ < MaxFixpointIterationsValue ||
 
-  if (IterationCounter > MaxFixedPointIterations && !Worklist.empty()) {
+  if (IterationCounter > MaxFixpointIterationsValue && !Worklist.empty()) {
     auto Remark = [&](OptimizationRemarkMissed ORM) {
       return ORM << "Attributor did not reach a fixpoint after "
-                 << ore::NV("Iterations", MaxFixedPointIterations)
+                 << ore::NV("Iterations", MaxFixpointIterationsValue)
                  << " iterations.";
     };
     Function *F = Worklist.front()->getIRPosition().getAssociatedFunction();
-    emitRemark<OptimizationRemarkMissed>(F, "FixedPoint", Remark);
+    emitRemark<OptimizationRemarkMissed>(F, "Fixpoint", Remark);
   }
 
   LLVM_DEBUG(dbgs() << "\n[Attributor] Fixpoint iteration done after: "
                     << IterationCounter << "/" << MaxFixpointIterations
                     << " iterations\n");
 
   // Reset abstract arguments not settled in a sound fixpoint by now. This
   // happens when we stopped the fixpoint iteration early. Note that only the
void Attributor::runTillFixpoint() {
 
   LLVM_DEBUG({
     if (!Visited.empty())
       dbgs() << "\n[Attributor] Finalized " << Visited.size()
              << " abstract attributes.\n";
   });
 
   if (VerifyMaxFixpointIterations &&
-      IterationCounter != MaxFixedPointIterations) {
+      IterationCounter != MaxFixpointIterationsValue) {
     errs() << "\n[Attributor] Fixpoint iteration done after: "
-           << IterationCounter << "/" << MaxFixedPointIterations
+           << IterationCounter << "/" << MaxFixpointIterationsValue
            << " iterations\n";
     llvm_unreachable("The fixpoint was not reached with exactly the number of "
                      "specified iterations!");
   }
 }
 
 ChangeStatus Attributor::manifestAttributes() {
   TimeTraceScope TimeScope("Attributor::manifestAttributes");

llvm/lib/Transforms/IPO/OpenMPOpt.cpp

bool runOnSCC(CallGraphSCC &CGSCC) override {
 
     AnalysisGetter AG;
     SetVector<Function *> Functions(SCC.begin(), SCC.end());
     BumpPtrAllocator Allocator;
     OMPInformationCache InfoCache(*(Functions.back()->getParent()), AG,
                                   Allocator,
                                   /*CGSCC*/ Functions, Kernels);
 
-    unsigned MaxFixpointIterations =
+    unsigned MaxFixedpointIterations =
         (isOpenMPDevice(M)) ? SetFixpointIterations : 32;
     Attributor A(Functions, InfoCache, CGUpdater, nullptr, false, true,
-                 MaxFixpointIterations, OREGetter, DEBUG_TYPE);
+                 MaxFixedPointIterations, OREGetter, DEBUG_TYPE);
 
     OpenMPOpt OMPOpt(SCC, CGUpdater, OREGetter, InfoCache, A);
     bool Result = OMPOpt.run(false);
 
     if (PrintModuleAfterOptimizations)
       LLVM_DEBUG(dbgs() << TAG << "Module after OpenMPOpt CGSCC Pass:\n" << M);
 
     return Result;