Pass BranchProbability/BlockMass by value instead of const& as they are small. NFC.
[oota-llvm.git] / include / llvm / Support / BranchProbability.h
1 //===- BranchProbability.h - Branch Probability Wrapper ---------*- C++ -*-===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // Definition of BranchProbability shared by IR and Machine Instructions.
11 //
12 //===----------------------------------------------------------------------===//
13
14 #ifndef LLVM_SUPPORT_BRANCHPROBABILITY_H
15 #define LLVM_SUPPORT_BRANCHPROBABILITY_H
16
17 #include "llvm/Support/DataTypes.h"
18 #include <cassert>
19
20 namespace llvm {
21
22 class raw_ostream;
23
24 // This class represents Branch Probability as a non-negative fraction.
25 class BranchProbability {
26   // Numerator
27   uint32_t N;
28
29   // Denominator
30   uint32_t D;
31
32 public:
33   BranchProbability(uint32_t Numerator, uint32_t Denominator)
34       : N(Numerator), D(Denominator) {
35     assert(D > 0 && "Denominator cannot be 0!");
36     assert(N <= D && "Probability cannot be bigger than 1!");
37   }
38
39   static BranchProbability getZero() { return BranchProbability(0, 1); }
40   static BranchProbability getOne() { return BranchProbability(1, 1); }
41
42   uint32_t getNumerator() const { return N; }
43   uint32_t getDenominator() const { return D; }
44
45   // Return (1 - Probability).
46   BranchProbability getCompl() const {
47     return BranchProbability(D - N, D);
48   }
49
50   raw_ostream &print(raw_ostream &OS) const;
51
52   void dump() const;
53
54   /// \brief Scale a large integer.
55   ///
56   /// Scales \c Num.  Guarantees full precision.  Returns the floor of the
57   /// result.
58   ///
59   /// \return \c Num times \c this.
60   uint64_t scale(uint64_t Num) const;
61
62   /// \brief Scale a large integer by the inverse.
63   ///
64   /// Scales \c Num by the inverse of \c this.  Guarantees full precision.
65   /// Returns the floor of the result.
66   ///
67   /// \return \c Num divided by \c this.
68   uint64_t scaleByInverse(uint64_t Num) const;
69
70   bool operator==(BranchProbability RHS) const {
71     return (uint64_t)N * RHS.D == (uint64_t)D * RHS.N;
72   }
73   bool operator!=(BranchProbability RHS) const {
74     return !(*this == RHS);
75   }
76   bool operator<(BranchProbability RHS) const {
77     return (uint64_t)N * RHS.D < (uint64_t)D * RHS.N;
78   }
79   bool operator>(BranchProbability RHS) const { return RHS < *this; }
80   bool operator<=(BranchProbability RHS) const { return !(RHS < *this); }
81   bool operator>=(BranchProbability RHS) const { return !(*this < RHS); }
82 };
83
84 inline raw_ostream &operator<<(raw_ostream &OS, BranchProbability Prob) {
85   return Prob.print(OS);
86 }
87
88 }
89
90 #endif