[llvm] Remove std::clamp equivalent in `Transforms/Utils/MisExpect.cpp`

[jloser]

Summary

Use std::clamp directly from the standard library now that LLVM is built with
C++17 standards mode.

[jloser]

Fix deduction of std::clamp by casting Tolerance.

[paulkirth]

LGTM.

If you’re up for it, cleaning up how we parse tolerance in clang and how we store it in the context would be nice.

If not, I’ll probably do it later today so no worries.

Thanks for the clean up!

llvm/lib/Transforms/Utils/MisExpect.cpp

171

I don’t know what I was thinking when I implemented the tolerance option. There’s no reason they need to be 64-bit.

Really, we should fix how we parse and store the tolerance values.

That would allow us to ditch all these casts here and also choose more reasonable types.

Especially since they can’t exceed 100 …

[paulkirth]

llvm/lib/Transforms/Utils/MisExpect.cpp

75

Ugh. in D131935 I think I forgot to update the return type here, despite changing everything else to uint32_t.

When you rebase, could you update this?

[jloser]

Rebase since D131869 landed. Remove use of static_cast for the tolerance.

[jloser]

llvm/lib/Transforms/Utils/MisExpect.cpp

75

Yeah, I noticed this. Not a biggie - just fixed and rebased.

[paulkirth]

Perfect! Thanks so much!

[jloser]

Reintroduce cast for MisExpectTolerance to go from cl::opt<uint32_t> to uint32_t.

[jloser]

Rebase to see if CI is happy

llvm/lib/Transforms/Utils/MisExpect.cpp

 #include "llvm/IR/Instruction.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/ProfDataUtils.h"
 #include "llvm/Support/BranchProbability.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/FormatVariadic.h"
+#include <algorithm>
 #include <cstdint>
 #include <functional>
 #include <numeric>
 
 #define DEBUG_TYPE "misexpect"
 
 using namespace llvm;
 using namespace misexpect;

 } // namespace llvm
 
 namespace {
 
 bool isMisExpectDiagEnabled(LLVMContext &Ctx) {
   return PGOWarnMisExpect || Ctx.getMisExpectWarningRequested();
 }
 
-uint64_t getMisExpectTolerance(LLVMContext &Ctx) {
+uint32_t getMisExpectTolerance(LLVMContext &Ctx) {
   return std::max(static_cast<uint32_t>(MisExpectTolerance),
                   Ctx.getDiagnosticsMisExpectTolerance());
 }
 
 Instruction *getInstCondition(Instruction *I) {
   assert(I != nullptr && "MisExpect target Instruction cannot be nullptr");
   Instruction *Ret = nullptr;
   if (auto *B = dyn_cast<BranchInst>(I)) {
void emitMisexpectDiagnostic(Instruction *I, LLVMContext &Ctx,
   ORE.emit(OptimizationRemark(DEBUG_TYPE, "misexpect", Cond) << RemStr.str());
 }
 
 } // namespace
 
 namespace llvm {
 namespace misexpect {
 
-// TODO: when clang allows c++17, use std::clamp instead
-uint32_t clamp(uint64_t value, uint32_t low, uint32_t hi) {
-  if (value > hi)
-    return hi;
-  if (value < low)
-    return low;
-  return value;
-}
-
 void verifyMisExpect(Instruction &I, ArrayRef<uint32_t> RealWeights,
                      ArrayRef<uint32_t> ExpectedWeights) {
   // To determine if we emit a diagnostic, we need to compare the branch weights
   // from the profile to those added by the llvm.expect intrinsic.
   // So first, we extract the "likely" and "unlikely" weights from
   // ExpectedWeights And determine the correct weight in the profile to compare
   // against.
   uint64_t LikelyBranchWeight = 0,
void verifyMisExpect(Instruction &I, ArrayRef<uint32_t> RealWeights,
   // our threshold based on the collected profile data.
   auto LikelyProbablilty = BranchProbability::getBranchProbability(
       LikelyBranchWeight, TotalBranchWeight);
 
   uint64_t ScaledThreshold = LikelyProbablilty.scale(RealWeightsTotal);
 
   // clamp tolerance range to [0, 100)
   auto Tolerance = getMisExpectTolerance(I.getContext());
-  Tolerance = clamp(Tolerance, 0, 99);
+  Tolerance = std::clamp(Tolerance, 0u, 99u);
 
   // Allow users to relax checking by N%  i.e., if they use a 5% tolerance,
   // then we check against 0.95*ScaledThreshold
   if (Tolerance > 0)
     ScaledThreshold *= (1.0 - Tolerance / 100.0);
 
   // When the profile weight is below the threshold, we emit the diagnostic
   if (ProfiledWeight < ScaledThreshold)