Coverage Report

Created: 2017-10-03 07:32

/Users/buildslave/jenkins/sharedspace/clang-stage2-coverage-R@2/llvm/include/llvm/Support/BlockFrequency.h
Line
Count
Source
1
//===-------- BlockFrequency.h - Block Frequency 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
// This file implements Block Frequency class.
11
//
12
//===----------------------------------------------------------------------===//
13
14
#ifndef LLVM_SUPPORT_BLOCKFREQUENCY_H
15
#define LLVM_SUPPORT_BLOCKFREQUENCY_H
16
17
#include "llvm/Support/BranchProbability.h"
18
#include "llvm/Support/DataTypes.h"
19
20
namespace llvm {
21
22
class raw_ostream;
23
24
// This class represents Block Frequency as a 64-bit value.
25
class BlockFrequency {
26
  uint64_t Frequency;
27
28
public:
29
619M
  BlockFrequency(uint64_t Freq = 0) : Frequency(Freq) { }
30
31
  /// \brief Returns the maximum possible frequency, the saturation value.
32
19.8M
  static uint64_t getMaxFrequency() { return -1ULL; }
33
34
  /// \brief Returns the frequency as a fixpoint number scaled by the entry
35
  /// frequency.
36
60.4M
  uint64_t getFrequency() const { return Frequency; }
37
38
  /// \brief Multiplies with a branch probability. The computation will never
39
  /// overflow.
40
  BlockFrequency &operator*=(BranchProbability Prob);
41
  BlockFrequency operator*(BranchProbability Prob) const;
42
43
  /// \brief Divide by a non-zero branch probability using saturating
44
  /// arithmetic.
45
  BlockFrequency &operator/=(BranchProbability Prob);
46
  BlockFrequency operator/(BranchProbability Prob) const;
47
48
  /// \brief Adds another block frequency using saturating arithmetic.
49
  BlockFrequency &operator+=(BlockFrequency Freq);
50
  BlockFrequency operator+(BlockFrequency Freq) const;
51
52
  /// \brief Subtracts another block frequency using saturating arithmetic.
53
  BlockFrequency &operator-=(BlockFrequency Freq);
54
  BlockFrequency operator-(BlockFrequency Freq) const;
55
56
  /// \brief Shift block frequency to the right by count digits saturating to 1.
57
  BlockFrequency &operator>>=(const unsigned count);
58
59
3.95M
  bool operator<(BlockFrequency RHS) const {
60
3.95M
    return Frequency < RHS.Frequency;
61
3.95M
  }
62
63
11.3k
  bool operator<=(BlockFrequency RHS) const {
64
11.3k
    return Frequency <= RHS.Frequency;
65
11.3k
  }
66
67
3.64M
  bool operator>(BlockFrequency RHS) const {
68
3.64M
    return Frequency > RHS.Frequency;
69
3.64M
  }
70
71
381M
  bool operator>=(BlockFrequency RHS) const {
72
381M
    return Frequency >= RHS.Frequency;
73
381M
  }
74
75
2.79M
  bool operator==(BlockFrequency RHS) const {
76
2.79M
    return Frequency == RHS.Frequency;
77
2.79M
  }
78
};
79
80
}
81
82
#endif