[BOLT] Fix --max-funcs=<N> option

[maksfb]

Summary

Fix off-by-one error while handling of the --max-funcs=<N> option.
We used to process N+1 functions when N was requested.

bolt/lib/Rewrite/RewriteInstance.cpp

for (const std::string &Function :
       ReorderFunctionsUserSet.insert(Function);
       if (std::optional<StringRef> LTOCommonName = getLTOCommonName(Function))
         ReorderFunctionsLTOCommonSet.insert(*LTOCommonName);
     }
   }
 
   uint64_t NumFunctionsToProcess = 0;
   auto mustSkip = [&](const BinaryFunction &Function) {
-    if (opts::MaxFunctions && NumFunctionsToProcess > opts::MaxFunctions)
+    if (opts::MaxFunctions.getNumOccurrences() &&
+        NumFunctionsToProcess >= opts::MaxFunctions)
       return true;
     for (std::string &Name : opts::SkipFunctionNames)
       if (Function.hasNameRegex(Name))
         return true;
 
     return false;
   };
 
for (auto &BFI : BC->getBinaryFunctions()) {
     if (!shouldProcess(Function)) {
       if (opts::Verbosity >= 1) {
         outs() << "BOLT-INFO: skipping processing " << Function
                << " per user request\n";
       }
       Function.setIgnored();
     } else {
       ++NumFunctionsToProcess;
-      if (opts::MaxFunctions && NumFunctionsToProcess == opts::MaxFunctions)
+      if (opts::MaxFunctions.getNumOccurrences() &&
+          NumFunctionsToProcess == opts::MaxFunctions)
         outs() << "BOLT-INFO: processing ending on " << Function << '\n';
     }
   }
 
   if (!BC->HasSplitFunctions)
     return;
 
   // Fragment overrides:
if (Function->isSplit() && !SplitFragmentsHaveAddress) {
       assert(llvm::all_of(Function->getLayout().getSplitFragments(),
                           HasNoAddress) &&
              "Some split fragments have an address while others do not");
       (void)HasNoAddress;
       continue;
     }
 
     OverwrittenScore += Function->getFunctionScore();
+    ++CountOverwrittenFunctions;
+
     // Overwrite function in the output file.
     if (opts::Verbosity >= 2)
       outs() << "BOLT: rewriting function \"" << *Function << "\"\n";
 
     OS.pwrite(reinterpret_cast<char *>(Function->getImageAddress()),
               Function->getImageSize(), Function->getFileOffset());
 
     // Write nops at the end of the function.
     if (Function->getMaxSize() != std::numeric_limits<uint64_t>::max()) {
       uint64_t Pos = OS.tell();
       OS.seek(Function->getFileOffset() + Function->getImageSize());
       MAB->writeNopData(OS, Function->getMaxSize() - Function->getImageSize(),
                         &*BC->STI);
 
       OS.seek(Pos);
     }
 
-    if (!Function->isSplit()) {
-      ++CountOverwrittenFunctions;
-      if (opts::MaxFunctions &&
-          CountOverwrittenFunctions == opts::MaxFunctions) {
-        outs() << "BOLT: maximum number of functions reached\n";
-        break;
-      }
+    if (!Function->isSplit())
       continue;
-    }
 
     // Write cold part
-    if (opts::Verbosity >= 2)
+    if (opts::Verbosity >= 2) {
       outs() << formatv("BOLT: rewriting function \"{0}\" (split parts)\n",
                         *Function);
+    }
 
     for (const FunctionFragment &FF :
          Function->getLayout().getSplitFragments()) {
       OS.pwrite(reinterpret_cast<char *>(FF.getImageAddress()),
                 FF.getImageSize(), FF.getFileOffset());
     }
-
-    ++CountOverwrittenFunctions;
-    if (opts::MaxFunctions && CountOverwrittenFunctions == opts::MaxFunctions) {
-      outs() << "BOLT: maximum number of functions reached\n";
-      break;
-    }
   }
 
   // Print function statistics for non-relocation mode.
   if (!BC->HasRelocations) {
     outs() << "BOLT: " << CountOverwrittenFunctions << " out of "
            << BC->getBinaryFunctions().size()
            << " functions were overwritten.\n";
     if (BC->TotalScore != 0) {

bolt/test/max-funcs.test

+## Check that --max-funcs=<N> option works properly in llvm-bolt,
+## resulting in processing of no more than N functions in the binary.
+
+REQUIRES: system-linux
+
+RUN: %clangxx %p/Inputs/bolt_icf.cpp -g -Wl,-q -o %t.exe
+RUN: llvm-bolt %t.exe --relocs -o %t --max-funcs=2
+RUN: llvm-objdump -d -j .text %t | FileCheck %s
+
+## Check that there are only two functions in the dump of .text
+CHECK: <{{.*}}>:
+CHECK: <{{.*}}>:
+CHECK-NOT: <{{.*}}>: