[NFC][BlockFrequency] Move operator definitions into header

[0xdc03]

Summary

While BlockFrequency::operator+= is a very simple operation, it's
definition is present in another TU which means that it doesn't get
inlined in non-LTO builds. This means that there is some performance
left on the table in those builds, as this operator is called many
times.

This patch moves that operator (and a few others) into the
BlockFrequency.h header which gives a small speedup (~0.1%):
https://llvm-compile-time-tracker.com/compare.php?from=6ee594be53e7efaa12086ad20f0d0268092a4c73&to=6ac6cd99e211fae5ae5de41ad608604aa22f1882&stat=instructions%3Au

[nikic]

LGTM. Tradeoff is potentially longer LLVM build times, but given how tiny these are, I'm not overly concerned.

llvm/include/llvm/Support/BlockFrequency.h

 //===-------- BlockFrequency.h - Block Frequency Wrapper --------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements Block Frequency class.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_SUPPORT_BLOCKFREQUENCY_H
 #define LLVM_SUPPORT_BLOCKFREQUENCY_H
 
+#include <cassert>
 #include <cstdint>
 
 namespace llvm {
 
 class BranchProbability;
 
 // This class represents Block Frequency as a 64-bit value.
 class BlockFrequency {
public:
   BlockFrequency operator*(BranchProbability Prob) const;
 
   /// Divide by a non-zero branch probability using saturating
   /// arithmetic.
   BlockFrequency &operator/=(BranchProbability Prob);
   BlockFrequency operator/(BranchProbability Prob) const;
 
   /// Adds another block frequency using saturating arithmetic.
-  BlockFrequency &operator+=(BlockFrequency Freq);
-  BlockFrequency operator+(BlockFrequency Freq) const;
+  BlockFrequency &operator+=(BlockFrequency Freq) {
+    uint64_t Before = Freq.Frequency;
+    Frequency += Freq.Frequency;
+
+    // If overflow, set frequency to the maximum value.
+    if (Frequency < Before)
+      Frequency = UINT64_MAX;
+
+    return *this;
+  }
+  BlockFrequency operator+(BlockFrequency Freq) const {
+    BlockFrequency NewFreq(Frequency);
+    NewFreq += Freq;
+    return NewFreq;
+  }
 
   /// Subtracts another block frequency using saturating arithmetic.
-  BlockFrequency &operator-=(BlockFrequency Freq);
-  BlockFrequency operator-(BlockFrequency Freq) const;
+  BlockFrequency &operator-=(BlockFrequency Freq) {
+    // If underflow, set frequency to 0.
+    if (Frequency <= Freq.Frequency)
+      Frequency = 0;
+    else
+      Frequency -= Freq.Frequency;
+    return *this;
+  }
+  BlockFrequency operator-(BlockFrequency Freq) const {
+    BlockFrequency NewFreq(Frequency);
+    NewFreq -= Freq;
+    return NewFreq;
+  }
 
   /// Shift block frequency to the right by count digits saturating to 1.
-  BlockFrequency &operator>>=(const unsigned count);
+  BlockFrequency &operator>>=(const unsigned count) {
+    // Frequency can never be 0 by design.
+    assert(Frequency != 0);
+
+    // Shift right by count.
+    Frequency >>= count;
+
+    // Saturate to 1 if we are 0.
+    Frequency |= Frequency == 0;
+    return *this;
+  }
 
   bool operator<(BlockFrequency RHS) const {
     return Frequency < RHS.Frequency;
   }
 
   bool operator<=(BlockFrequency RHS) const {
     return Frequency <= RHS.Frequency;
   }

llvm/lib/Support/BlockFrequency.cpp

 //====--------------- lib/Support/BlockFrequency.cpp -----------*- C++ -*-====//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements Block Frequency class.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Support/BlockFrequency.h"
 #include "llvm/Support/BranchProbability.h"
-#include <cassert>
 
 using namespace llvm;
 
 BlockFrequency &BlockFrequency::operator*=(BranchProbability Prob) {
   Frequency = Prob.scale(Frequency);
   return *this;
 }
 
 BlockFrequency BlockFrequency::operator*(BranchProbability Prob) const {
   BlockFrequency Freq(Frequency);
   Freq *= Prob;
   return Freq;
 }
 
 BlockFrequency &BlockFrequency::operator/=(BranchProbability Prob) {
   Frequency = Prob.scaleByInverse(Frequency);
   return *this;
 }
 
 BlockFrequency BlockFrequency::operator/(BranchProbability Prob) const {
   BlockFrequency Freq(Frequency);
   Freq /= Prob;
   return Freq;
 }
-
-BlockFrequency &BlockFrequency::operator+=(BlockFrequency Freq) {
-  uint64_t Before = Freq.Frequency;
-  Frequency += Freq.Frequency;
-
-  // If overflow, set frequency to the maximum value.
-  if (Frequency < Before)
-    Frequency = UINT64_MAX;
-
-  return *this;
-}
-
-BlockFrequency BlockFrequency::operator+(BlockFrequency Freq) const {
-  BlockFrequency NewFreq(Frequency);
-  NewFreq += Freq;
-  return NewFreq;
-}
-
-BlockFrequency &BlockFrequency::operator-=(BlockFrequency Freq) {
-  // If underflow, set frequency to 0.
-  if (Frequency <= Freq.Frequency)
-    Frequency = 0;
-  else
-    Frequency -= Freq.Frequency;
-  return *this;
-}
-
-BlockFrequency BlockFrequency::operator-(BlockFrequency Freq) const {
-  BlockFrequency NewFreq(Frequency);
-  NewFreq -= Freq;
-  return NewFreq;
-}
-
-BlockFrequency &BlockFrequency::operator>>=(const unsigned count) {
-  // Frequency can never be 0 by design.
-  assert(Frequency != 0);
-
-  // Shift right by count.
-  Frequency >>= count;
-
-  // Saturate to 1 if we are 0.
-  Frequency |= Frequency == 0;
-  return *this;
-}