reference, declarationdefinition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

Declarations

include/llvm/CodeGen/TargetLowering.h
   68 class BranchProbability;

References

include/llvm/ADT/DenseMap.h
   40 struct DenseMapPair : public std::pair<KeyT, ValueT> {
   45   ValueT &getSecond() { return std::pair<KeyT, ValueT>::second; }
   46   const ValueT &getSecond() const { return std::pair<KeyT, ValueT>::second; }
   66   using mapped_type = ValueT;
   69   using iterator = DenseMapIterator<KeyT, ValueT, KeyInfoT, BucketT>;
   71       DenseMapIterator<KeyT, ValueT, KeyInfoT, BucketT, true>;
  123         is_trivially_copyable<ValueT>::value) {
  185   ValueT lookup(const_arg_type_t<KeyT> Val) const {
  195   std::pair<iterator, bool> insert(const std::pair<KeyT, ValueT> &KV) {
  202   std::pair<iterator, bool> insert(std::pair<KeyT, ValueT> &&KV) {
  249   std::pair<iterator, bool> insert_as(std::pair<KeyT, ValueT> &&KV,
  299   ValueT &operator[](const KeyT &Key) {
  311   ValueT &operator[](KeyT &&Key) {
  380         ::new (&DestBucket->getSecond()) ValueT(std::move(B->getSecond()));
  392       const DenseMapBase<OtherBaseT, KeyT, ValueT, KeyInfoT, BucketT> &other) {
  520     ::new (&TheBucket->getSecond()) ValueT(std::forward<ValueArgs>(Values)...);
  526                                       ValueT &&Value, LookupKeyT &Lookup) {
  684 class DenseMap : public DenseMapBase<DenseMap<KeyT, ValueT, KeyInfoT, BucketT>,
  685                                      KeyT, ValueT, KeyInfoT, BucketT> {
  690   using BaseT = DenseMapBase<DenseMap, KeyT, ValueT, KeyInfoT, BucketT>;
 1163   using ConstIterator = DenseMapIterator<KeyT, ValueT, KeyInfoT, Bucket, true>;
 1199       const DenseMapIterator<KeyT, ValueT, KeyInfoT, Bucket, IsConstSrc> &I)
include/llvm/ADT/Optional.h
  144     T value;
  172   T &getValue() LLVM_LVALUE_FUNCTION noexcept {
  176   T const &getValue() const LLVM_LVALUE_FUNCTION noexcept {
  181   T &&getValue() && noexcept {
  206       ::new ((void *)std::addressof(value)) T(std::move(y));
  216   optional_detail::OptionalStorage<T> Storage;
  219   using value_type = T;
  224   Optional(const T &y) : Storage(optional_detail::in_place_t{}, y) {}
  227   Optional(T &&y) : Storage(optional_detail::in_place_t{}, std::move(y)) {}
  230   Optional &operator=(T &&y) {
  241   static inline Optional create(const T *y) {
  245   Optional &operator=(const T &y) {
  253   const T *getPointer() const { return &Storage.getValue(); }
  254   T *getPointer() { return &Storage.getValue(); }
  255   const T &getValue() const LLVM_LVALUE_FUNCTION { return Storage.getValue(); }
  256   T &getValue() LLVM_LVALUE_FUNCTION { return Storage.getValue(); }
  260   const T *operator->() const { return getPointer(); }
  261   T *operator->() { return getPointer(); }
  262   const T &operator*() const LLVM_LVALUE_FUNCTION { return getValue(); }
  263   T &operator*() LLVM_LVALUE_FUNCTION { return getValue(); }
  266   constexpr T getValueOr(U &&value) const LLVM_LVALUE_FUNCTION {
  271   T &&getValue() && { return std::move(Storage.getValue()); }
  272   T &&operator*() && { return std::move(Storage.getValue()); }
  275   T getValueOr(U &&value) && {
include/llvm/ADT/SmallVector.h
   75   AlignedCharArrayUnion<T> FirstEl;
  114   using value_type = T;
  115   using iterator = T *;
  116   using const_iterator = const T *;
  121   using reference = T &;
  122   using const_reference = const T &;
  123   using pointer = T *;
  124   using const_pointer = const T *;
  259 class SmallVectorTemplateBase<T, true> : public SmallVectorTemplateCommon<T> {
  264   static void destroy_range(T *, T *) {}
  264   static void destroy_range(T *, T *) {}
  286       T1 *I, T1 *E, T2 *Dest,
  288                                            T2>::value>::type * = nullptr) {
  294       memcpy(reinterpret_cast<void *>(Dest), I, (E - I) * sizeof(T));
  299   void grow(size_t MinSize = 0) { this->grow_pod(MinSize, sizeof(T)); }
  302   void push_back(const T &Elt) {
  305     memcpy(reinterpret_cast<void *>(this->end()), &Elt, sizeof(T));
  315 class SmallVectorImpl : public SmallVectorTemplateBase<T> {
  316   using SuperClass = SmallVectorTemplateBase<T>;
  357   void resize(size_type N, const T &NV) {
  374   LLVM_NODISCARD T pop_back_val() {
  397   void append(size_type NumInputs, const T &Elt) {
  405   void append(std::initializer_list<T> IL) {
  412   void assign(size_type NumElts, const T &Elt) {
  429   void assign(std::initializer_list<T> IL) {
  467   iterator insert(iterator I, T &&Elt) {
  497   iterator insert(iterator I, const T &Elt) {
  526   iterator insert(iterator I, size_type NumToInsert, const T &Elt) {
  637   void insert(iterator I, std::initializer_list<T> IL) {
  641   template <typename... ArgTypes> reference emplace_back(ArgTypes &&... Args) {
  820   AlignedCharArrayUnion<T> InlineElts[N];
  837 class SmallVector : public SmallVectorImpl<T>, SmallVectorStorage<T, N> {
  837 class SmallVector : public SmallVectorImpl<T>, SmallVectorStorage<T, N> {
  846   explicit SmallVector(size_t Size, const T &Value = T())
  865   SmallVector(std::initializer_list<T> IL) : SmallVectorImpl<T>(N) {
  884   SmallVector(SmallVectorImpl<T> &&RHS) : SmallVectorImpl<T>(N) {
include/llvm/Analysis/BlockFrequencyInfoImpl.h
  121   BlockMass &operator*=(BranchProbability P) {
  149 inline BlockMass operator*(BlockMass L, BranchProbability R) {
  152 inline BlockMass operator*(BranchProbability L, BlockMass R) {
 1303 inline uint32_t getWeightFromBranchProb(const BranchProbability Prob) {
 1401          BranchProbability::getBranchProbability(HotPercentThreshold, 100));
 1451     BranchProbability BP = BPI->getEdgeProbability(Node, EI);
include/llvm/Analysis/BranchProbabilityInfo.h
   87   BranchProbability getEdgeProbability(const BasicBlock *Src,
   93   BranchProbability getEdgeProbability(const BasicBlock *Src,
   96   BranchProbability getEdgeProbability(const BasicBlock *Src,
  126                           BranchProbability Prob);
  128   static BranchProbability getBranchProbStackProtector(bool IsLikely) {
  129     static const BranchProbability LikelyProb((1u << 20) - 1, 1u << 20);
  179   DenseMap<Edge, BranchProbability> Probs;
include/llvm/CodeGen/GlobalISel/IRTranslator.h
  318                                 BranchProbability UnhandledProbs,
  535         BranchProbability Prob = BranchProbability::getUnknown()) override {
  535         BranchProbability Prob = BranchProbability::getUnknown()) override {
  608   BranchProbability getEdgeProbability(const MachineBasicBlock *Src,
  612                             BranchProbability Prob);
include/llvm/CodeGen/MachineBasicBlock.h
   95   std::vector<BranchProbability> Probs;
   96   using probability_iterator = std::vector<BranchProbability>::iterator;
   98       std::vector<BranchProbability>::const_iterator;
  439                     BranchProbability Prob = BranchProbability::getUnknown());
  439                     BranchProbability Prob = BranchProbability::getUnknown());
  448   void setSuccProbability(succ_iterator I, BranchProbability Prob);
  456     BranchProbability::normalizeProbabilities(Probs.begin(), Probs.end());
  826   BranchProbability getSuccProbability(const_succ_iterator Succ) const;
include/llvm/CodeGen/MachineBranchProbabilityInfo.h
   48   BranchProbability getEdgeProbability(const MachineBasicBlock *Src,
   53   BranchProbability
include/llvm/CodeGen/SwitchLoweringUtils.h
   44   BranchProbability Prob;
   47                            MachineBasicBlock *MBB, BranchProbability Prob) {
   58                                unsigned JTCasesIndex, BranchProbability Prob) {
   69                               unsigned BTCasesIndex, BranchProbability Prob) {
   90   BranchProbability ExtraProb;
   94            BranchProbability Prob)
  135   BranchProbability TrueProb, FalseProb;
  141             BranchProbability trueprob = BranchProbability::getUnknown(),
  141             BranchProbability trueprob = BranchProbability::getUnknown(),
  142             BranchProbability falseprob = BranchProbability::getUnknown())
  142             BranchProbability falseprob = BranchProbability::getUnknown())
  152             BranchProbability trueprob = BranchProbability::getUnknown(),
  152             BranchProbability trueprob = BranchProbability::getUnknown(),
  153             BranchProbability falseprob = BranchProbability::getUnknown())
  153             BranchProbability falseprob = BranchProbability::getUnknown())
  193   BranchProbability ExtraProb;
  196               BranchProbability Prob)
  213   BranchProbability Prob;
  214   BranchProbability DefaultProb;
  239   BranchProbability DefaultProb;
  283       BranchProbability Prob = BranchProbability::getUnknown()) = 0;
  283       BranchProbability Prob = BranchProbability::getUnknown()) = 0;
include/llvm/CodeGen/TargetInstrInfo.h
  752                                    BranchProbability Probability) const {
  766                                    BranchProbability Probability) const {
  778                                          BranchProbability Probability) const {
include/llvm/CodeGen/TargetLowering.h
  398   virtual BranchProbability getPredictableBranchThreshold() const;
include/llvm/Support/AlignOf.h
   30   T t;
   39 template <typename T> union SizerImpl<T> { char arr[sizeof(T)]; };
   50       llvm::detail::SizerImpl<T, Ts...>)];
include/llvm/Support/BlockFrequency.h
   39   BlockFrequency &operator*=(BranchProbability Prob);
   40   BlockFrequency operator*(BranchProbability Prob) const;
   44   BlockFrequency &operator/=(BranchProbability Prob);
   45   BlockFrequency operator/(BranchProbability Prob) const;
include/llvm/Support/BranchProbability.h
   49   static BranchProbability getZero() { return BranchProbability(0); }
   50   static BranchProbability getOne() { return BranchProbability(D); }
   51   static BranchProbability getUnknown() { return BranchProbability(UnknownN); }
   54   static BranchProbability getRaw(uint32_t N) { return BranchProbability(N); }
   56   static BranchProbability getBranchProbability(uint64_t Numerator,
   69   BranchProbability getCompl() const { return BranchProbability(D - N); }
   91   BranchProbability &operator+=(BranchProbability RHS) {
   91   BranchProbability &operator+=(BranchProbability RHS) {
   99   BranchProbability &operator-=(BranchProbability RHS) {
   99   BranchProbability &operator-=(BranchProbability RHS) {
  107   BranchProbability &operator*=(BranchProbability RHS) {
  107   BranchProbability &operator*=(BranchProbability RHS) {
  114   BranchProbability &operator*=(uint32_t RHS) {
  121   BranchProbability &operator/=(BranchProbability RHS) {
  121   BranchProbability &operator/=(BranchProbability RHS) {
  128   BranchProbability &operator/=(uint32_t RHS) {
  136   BranchProbability operator+(BranchProbability RHS) const {
  136   BranchProbability operator+(BranchProbability RHS) const {
  137     BranchProbability Prob(*this);
  142   BranchProbability operator-(BranchProbability RHS) const {
  142   BranchProbability operator-(BranchProbability RHS) const {
  143     BranchProbability Prob(*this);
  148   BranchProbability operator*(BranchProbability RHS) const {
  148   BranchProbability operator*(BranchProbability RHS) const {
  149     BranchProbability Prob(*this);
  154   BranchProbability operator*(uint32_t RHS) const {
  155     BranchProbability Prob(*this);
  160   BranchProbability operator/(BranchProbability RHS) const {
  160   BranchProbability operator/(BranchProbability RHS) const {
  161     BranchProbability Prob(*this);
  166   BranchProbability operator/(uint32_t RHS) const {
  167     BranchProbability Prob(*this);
  172   bool operator==(BranchProbability RHS) const { return N == RHS.N; }
  173   bool operator!=(BranchProbability RHS) const { return !(*this == RHS); }
  175   bool operator<(BranchProbability RHS) const {
  181   bool operator>(BranchProbability RHS) const {
  187   bool operator<=(BranchProbability RHS) const {
  193   bool operator>=(BranchProbability RHS) const {
  200 inline raw_ostream &operator<<(raw_ostream &OS, BranchProbability Prob) {
  220     BranchProbability ProbForUnknown = BranchProbability::getZero();
  220     BranchProbability ProbForUnknown = BranchProbability::getZero();
  224     if (Sum < BranchProbability::getDenominator())
  225       ProbForUnknown = BranchProbability::getRaw(
  226           (BranchProbability::getDenominator() - Sum) / UnknownProbCount);
  232     if (Sum <= BranchProbability::getDenominator())
  237     BranchProbability BP(1, std::distance(Begin, End));
include/llvm/Support/type_traits.h
   91     T t;
  122     static auto get(F*) -> decltype(std::declval<F &>() = std::declval<const F &>(), std::true_type{});
  122     static auto get(F*) -> decltype(std::declval<F &>() = std::declval<const F &>(), std::true_type{});
  122     static auto get(F*) -> decltype(std::declval<F &>() = std::declval<const F &>(), std::true_type{});
  130     static auto get(F*) -> decltype(std::declval<F &>() = std::declval<F &&>(), std::true_type{});
  130     static auto get(F*) -> decltype(std::declval<F &>() = std::declval<F &&>(), std::true_type{});
  130     static auto get(F*) -> decltype(std::declval<F &>() = std::declval<F &&>(), std::true_type{});
  145       std::is_copy_constructible<detail::trivial_helper<T>>::value;
  147       !std::is_copy_constructible<T>::value;
  151       std::is_move_constructible<detail::trivial_helper<T>>::value;
  153       !std::is_move_constructible<T>::value;
  157       is_copy_assignable<detail::trivial_helper<T>>::value;
  159       !is_copy_assignable<T>::value;
  163       is_move_assignable<detail::trivial_helper<T>>::value;
  165       !is_move_assignable<T>::value;
  169       std::is_destructible<detail::trivial_helper<T>>::value;
lib/Analysis/BranchProbabilityInfo.cpp
   96 static const BranchProbability UR_TAKEN_PROB = BranchProbability::getRaw(1);
   96 static const BranchProbability UR_TAKEN_PROB = BranchProbability::getRaw(1);
  231     BranchProbability Prob(1, UnreachableEdges.size());
  237   auto UnreachableProb = UR_TAKEN_PROB;
  238   auto ReachableProb =
  239       (BranchProbability::getOne() - UR_TAKEN_PROB * UnreachableEdges.size()) /
  318   SmallVector<BranchProbability, 2> BP;
  325     auto ToDistribute = BranchProbability::getZero();
  325     auto ToDistribute = BranchProbability::getZero();
  326     auto UnreachableProb = UR_TAKEN_PROB;
  335     if (ToDistribute > BranchProbability::getZero()) {
  336       BranchProbability PerEdge = ToDistribute / ReachableIdxs.size();
  377     BranchProbability Prob(1, ColdEdges.size());
  383   auto ColdProb = BranchProbability::getBranchProbability(
  383   auto ColdProb = BranchProbability::getBranchProbability(
  386   auto NormalProb = BranchProbability::getBranchProbability(
  386   auto NormalProb = BranchProbability::getBranchProbability(
  426   BranchProbability TakenProb(PH_TAKEN_WEIGHT,
  627     BranchProbability TakenProb = BranchProbability(LBH_TAKEN_WEIGHT, Denom);
  628     auto Prob = TakenProb / numBackEdges;
  634     BranchProbability TakenProb = BranchProbability(LBH_TAKEN_WEIGHT, Denom);
  635     auto Prob = TakenProb / numInEdges;
  641     BranchProbability NotTakenProb = BranchProbability(LBH_NONTAKEN_WEIGHT,
  643     auto Prob = NotTakenProb / numExitingEdges;
  649     BranchProbability UnlikelyProb = BranchProbability(LBH_UNLIKELY_WEIGHT,
  651     auto Prob = UnlikelyProb / numUnlikelyEdges;
  771   BranchProbability TakenProb(ZH_TAKEN_WEIGHT,
  814   BranchProbability TakenProb(TakenWeight, TakenWeight + NontakenWeight);
  825   BranchProbability TakenProb(IH_TAKEN_WEIGHT,
  858   auto MaxProb = BranchProbability::getZero();
  858   auto MaxProb = BranchProbability::getZero();
  863     auto Prob = getEdgeProbability(BB, Succ);
  881 BranchProbability
  892 BranchProbability
  900 BranchProbability
  903   auto Prob = BranchProbability::getZero();
  903   auto Prob = BranchProbability::getZero();
  921                                                BranchProbability Prob) {
  933   const BranchProbability Prob = getEdgeProbability(Src, Dst);
lib/Analysis/InlineCost.cpp
  823   const BranchProbability ColdProb(ColdCallSiteRelFreq, 100);
lib/CodeGen/BranchFolding.cpp
 1260       auto Prob = BranchProbability::getBranchProbability(
 1260       auto Prob = BranchProbability::getBranchProbability(
lib/CodeGen/CodeGenPrepare.cpp
 5855       auto Probability = BranchProbability::getBranchProbability(Max, Sum);
 5855       auto Probability = BranchProbability::getBranchProbability(Max, Sum);
lib/CodeGen/EarlyIfConversion.cpp
  995                                     BranchProbability::getUnknown());
 1015                                   BranchProbability::getUnknown());
lib/CodeGen/GlobalISel/IRTranslator.cpp
  411                                         BranchProbability Prob) {
  421 BranchProbability
  446     BranchProbability Prob =
  493   auto DefaultProb = getEdgeProbability(SwitchMBB, DefaultMBB);
  657   BranchProbability DefaultProb = W.DefaultProb;
  671   auto JumpProb = I->Prob;
  672   auto FallthroughProb = UnhandledProbs;
  718                                             BranchProbability UnhandledProbs,
  786   BranchProbability DefaultProb = W.DefaultProb;
  787   BranchProbability UnhandledProbs = DefaultProb;
lib/CodeGen/IfConversion.cpp
  227                      BranchProbability Prediction) const;
  230                        BranchProbability Prediction) const;
  283                             BranchProbability Prediction) const {
  290                             BranchProbability Prediction, bool Forked) const {
  647                               BranchProbability Prediction) const {
  673                                 BranchProbability Prediction) const {
 1288     BranchProbability Prediction = MBPI->getEdgeProbability(BB, TrueBBI.BB);
 1666   BranchProbability CvtNext, CvtFalse, BBNext, BBCvt;
 1710     auto NewNext = BBNext + BBCvt * CvtNext;
 1715     auto NewFalse = BBCvt * CvtFalse;
 2093       BBI.BB->addSuccessor(TailBB, BranchProbability::getOne());
 2266   auto To2FromProb = BranchProbability::getZero();
 2266   auto To2FromProb = BranchProbability::getZero();
 2279     auto NewProb = BranchProbability::getZero();
 2279     auto NewProb = BranchProbability::getZero();
lib/CodeGen/InlineSpiller.cpp
 1400     BranchProbability MarginProb = (SpillsInSubTree.size() > 1)
lib/CodeGen/MIRParser/MIParser.cpp
  753     MBB.addSuccessor(SuccMBB, BranchProbability::getRaw(Weight));
lib/CodeGen/MIRPrinter.cpp
  577   SmallVector<BranchProbability,8> Normalized(MBB.Probs.begin(),
  579   BranchProbability::normalizeProbabilities(Normalized.begin(),
  581   SmallVector<BranchProbability,8> Equal(Normalized.size());
  582   BranchProbability::normalizeProbabilities(Equal.begin(), Equal.end());
lib/CodeGen/MachineBasicBlock.cpp
  374         const BranchProbability &BP = getSuccProbability(I);
  644   for (auto Prob : Probs)
  656                                      BranchProbability Prob) {
  687   addSuccessor(New, Probs.empty() ? BranchProbability::getUnknown()
  784       auto Prob = *FromMBB->Probs.begin();
  801       auto Prob = *FromMBB->Probs.begin();
 1328 BranchProbability
 1333   const auto &Prob = *getProbabilityIterator(Succ);
 1338     auto Sum = BranchProbability::getZero();
 1338     auto Sum = BranchProbability::getZero();
 1352                                            BranchProbability Prob) {
lib/CodeGen/MachineBlockPlacement.cpp
  410   BranchProbability
  418       BranchProbability SuccProb, BranchProbability HotProb);
  418       BranchProbability SuccProb, BranchProbability HotProb);
  431       const BlockChain &SuccChain, BranchProbability SuccProb,
  432       BranchProbability RealSuccProb, const BlockChain &Chain,
  490     BranchProbability QProb,
  502       BranchProbability AdjustedSumProb, const BlockChain &Chain,
  629 BranchProbability MachineBlockPlacement::collectViableSuccessors(
  649   auto AdjustedSumProb = BranchProbability::getOne();
  649   auto AdjustedSumProb = BranchProbability::getOne();
  675 static BranchProbability
  676 getAdjustedProbability(BranchProbability OrigProb,
  677                        BranchProbability AdjustedSumProb) {
  678   BranchProbability SuccProb;
  682     SuccProb = BranchProbability::getOne();
  726   BranchProbability ThresholdProb(TailDupPlacementPenalty, 100);
  738     BranchProbability QProb,
  766   auto AdjustedSuccSumProb =
  768   BranchProbability PProb = MBPI->getEdgeProbability(BB, Succ);
  779   auto BestSuccSucc = BranchProbability::getZero();
  779   auto BestSuccSucc = BranchProbability::getZero();
  782     auto Prob = MBPI->getEdgeProbability(Succ, SuccSucc);
  826     BranchProbability UProb = BestSuccSucc;
  827     BranchProbability VProb = AdjustedSuccSumProb - UProb;
  835   BranchProbability UProb = MBPI->getEdgeProbability(Succ, PDom);
  836   BranchProbability VProb = AdjustedSuccSumProb - UProb;
  988     BranchProbability AdjustedSumProb, const BlockChain &Chain,
 1257 static BranchProbability getLayoutSuccessorProbThreshold(
 1291     const BlockChain &SuccChain, BranchProbability SuccProb,
 1292     BranchProbability RealSuccProb, const BlockChain &Chain,
 1412   BranchProbability HotProb = getLayoutSuccessorProbThreshold(BB);
 1472   const BranchProbability HotProb(StaticLikelyProb, 100);
 1475   auto BestProb = BranchProbability::getZero();
 1475   auto BestProb = BranchProbability::getZero();
 1478   auto AdjustedSumProb =
 1505   SmallVector<std::tuple<BranchProbability, MachineBasicBlock *>, 4>
 1508     auto RealSuccProb = MBPI->getEdgeProbability(BB, Succ);
 1509     BranchProbability SuccProb =
 1549     BranchProbability DupProb;
 1815       auto TopProb = MBPI->getEdgeProbability(Pred, Top);
 1818         auto SuccProb = MBPI->getEdgeProbability(Pred, Succ);
 2100       auto SuccProb = MBPI->getEdgeProbability(MBB, Succ);
 2124       BranchProbability Bias(100 - ExitBlockBias, 100);
 2179       auto TopProb = MBPI->getEdgeProbability(Pred, Top);
 2182         auto SuccProb = MBPI->getEdgeProbability(Pred, Succ);
 2332     auto LargestExitEdgeProb = BranchProbability::getZero();
 2332     auto LargestExitEdgeProb = BranchProbability::getZero();
 2337         auto SuccProb = MBPI->getEdgeProbability(BB, Succ);
 2341     if (LargestExitEdgeProb > BranchProbability::getZero()) {
 2395         auto TailToHeadProb = MBPI->getEdgeProbability(TailBB, *Iter);
 2752   const BranchProbability ColdProb(1, 5); // 20%
 2800     BranchProbability LayoutProb =
lib/CodeGen/MachineBranchProbabilityInfo.cpp
   42 BranchProbability MachineBranchProbabilityInfo::getEdgeProbability(
   48 BranchProbability MachineBranchProbabilityInfo::getEdgeProbability(
   57   BranchProbability HotProb(StaticLikelyProb, 100);
   63   auto MaxProb = BranchProbability::getZero();
   63   auto MaxProb = BranchProbability::getZero();
   67     auto Prob = getEdgeProbability(MBB, I);
   74   BranchProbability HotProb(StaticLikelyProb, 100);
   85   const BranchProbability Prob = getEdgeProbability(Src, Dst);
lib/CodeGen/SafeStack.cpp
  468   auto SuccessProb = BranchProbabilityInfo::getBranchProbStackProtector(true);
  469   auto FailureProb = BranchProbabilityInfo::getBranchProbStackProtector(false);
lib/CodeGen/SelectionDAG/FastISel.cpp
 1682     auto BranchProbability = FuncInfo.BPI->getEdgeProbability(
 1697       auto BranchProbability =
lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp
 1651     BranchProbability Prob,
 1652     SmallVectorImpl<std::pair<MachineBasicBlock *, BranchProbability>>
 1685     BranchProbability Prob,
 1686     SmallVectorImpl<std::pair<MachineBasicBlock *, BranchProbability>>
 1740   SmallVector<std::pair<MachineBasicBlock *, BranchProbability>, 1> UnwindDests;
 1743   BranchProbability UnwindDestProb =
 1746           : BranchProbability::getZero();
 1985 BranchProbability
 2002                                                BranchProbability Prob) {
 2027                                                   BranchProbability TProb,
 2028                                                   BranchProbability FProb,
 2075                                                BranchProbability TProb,
 2076                                                BranchProbability FProb,
 2143     auto NewTrueProb = TProb / 2;
 2144     auto NewFalseProb = TProb / 2 + FProb;
 2150     SmallVector<BranchProbability, 2> Probs{TProb / 2, FProb};
 2151     BranchProbability::normalizeProbabilities(Probs.begin(), Probs.end());
 2176     auto NewTrueProb = TProb + FProb / 2;
 2177     auto NewFalseProb = FProb / 2;
 2183     SmallVector<BranchProbability, 2> Probs{TProb, FProb / 2};
 2184     BranchProbability::normalizeProbabilities(Probs.begin(), Probs.end());
 2682                                            BranchProbability BranchProbToNext,
 2805   SmallVector<std::pair<MachineBasicBlock *, BranchProbability>, 1> UnwindDests;
 2807   BranchProbability EHPadBBProb =
 2809           : BranchProbability::getZero();
10136   BranchProbability DefaultProb = W.DefaultProb;
10137   BranchProbability UnhandledProbs = DefaultProb;
10168         auto JumpProb = I->Prob;
10169         auto FallthroughProb = UnhandledProbs;
10304   auto LeftProb = LastLeft->Prob + W.DefaultProb / 2;
10305   auto RightProb = FirstRight->Prob + W.DefaultProb / 2;
10425 static BranchProbability scaleCaseProbality(BranchProbability CaseProb,
10425 static BranchProbability scaleCaseProbality(BranchProbability CaseProb,
10426                                             BranchProbability PeeledCaseProb) {
10427   if (PeeledCaseProb == BranchProbability::getOne())
10428     return BranchProbability::getZero();
10429   BranchProbability SwitchProb = PeeledCaseProb.getCompl();
10444     BranchProbability &PeeledCaseProb) {
10452   BranchProbability TopCaseProb = BranchProbability(SwitchPeelThreshold, 100);
10502     BranchProbability Prob =
10516   BranchProbability PeeledCaseProb = BranchProbability::getZero();
10516   BranchProbability PeeledCaseProb = BranchProbability::getZero();
10557   auto DefaultProb = getEdgeProbability(PeeledSwitchMBB, DefaultMBB);
10560   if (PeeledCaseProb != BranchProbability::getZero() &&
lib/CodeGen/SelectionDAG/SelectionDAGBuilder.h
  170                           BranchProbability &PeeledCaseProb);
  390         BranchProbability Prob = BranchProbability::getUnknown()) override {
  390         BranchProbability Prob = BranchProbability::getUnknown()) override {
  528                             Instruction::BinaryOps Opc, BranchProbability TProb,
  529                             BranchProbability FProb, bool InvertCond);
  534                                     BranchProbability TProb, BranchProbability FProb,
  534                                     BranchProbability TProb, BranchProbability FProb,
  642   BranchProbability getEdgeProbability(const MachineBasicBlock *Src,
  646       BranchProbability Prob = BranchProbability::getUnknown());
  646       BranchProbability Prob = BranchProbability::getUnknown());
  656                         BranchProbability BranchProbToNext, unsigned Reg,
lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp
 1787     BranchProbability UnhandledProb = BTB.Prob;
lib/CodeGen/StackProtector.cpp
  505       auto SuccessProb =
  507       auto FailureProb =
lib/CodeGen/SwitchLoweringUtils.cpp
  192   auto Prob = BranchProbability::getZero();
  192   auto Prob = BranchProbability::getZero();
  195   DenseMap<MachineBasicBlock*, BranchProbability> JTProbs;
  199     JTProbs[Clusters[I].MBB] = BranchProbability::getZero();
  412   auto TotalProb = BranchProbability::getZero();
  412   auto TotalProb = BranchProbability::getZero();
  421           CaseBits(0, Clusters[i].MBB, 0, BranchProbability::getZero()));
lib/CodeGen/TargetLoweringBase.cpp
 1563 BranchProbability TargetLoweringBase::getPredictableBranchThreshold() const {
lib/Support/BlockFrequency.cpp
   18 BlockFrequency &BlockFrequency::operator*=(BranchProbability Prob) {
   23 BlockFrequency BlockFrequency::operator*(BranchProbability Prob) const {
   29 BlockFrequency &BlockFrequency::operator/=(BranchProbability Prob) {
   34 BlockFrequency BlockFrequency::operator/(BranchProbability Prob) const {
lib/Support/BranchProbability.cpp
   51 BranchProbability
lib/Target/AArch64/AArch64ConditionalCompares.cpp
  580   BranchProbability Head2CmpBB = MBPI->getEdgeProbability(Head, CmpBB);
  581   BranchProbability CmpBB2Tail = MBPI->getEdgeProbability(CmpBB, Tail);
  596     BranchProbability Head2Tail = MBPI->getEdgeProbability(Head, Tail);
  606       BranchProbability CmpBB2I = MBPI->getEdgeProbability(CmpBB, *I);
lib/Target/AArch64/AArch64FastISel.cpp
 2501       auto BranchProbability = FuncInfo.BPI->getEdgeProbability(
lib/Target/AMDGPU/R600InstrInfo.cpp
  903                                    BranchProbability Probability) const{
  914                                    BranchProbability Probability) const {
  921                                          BranchProbability Probability)
lib/Target/AMDGPU/R600InstrInfo.h
  185                                  BranchProbability Probability) const override;
  189                            BranchProbability Probability) const override ;
  195                            BranchProbability Probability) const override;
lib/Target/ARM/ARMBaseInstrInfo.cpp
 1995                     BranchProbability Probability) const {
 2023                     BranchProbability Probability) const {
lib/Target/ARM/ARMBaseInstrInfo.h
  267                            BranchProbability Probability) const override;
  272                            BranchProbability Probability) const override;
  275                                  BranchProbability Probability) const override {
lib/Target/ARM/ARMISelLowering.cpp
 9828     BB->addSuccessor(DispatchBB, BranchProbability::getZero());
lib/Target/Hexagon/HexagonEarlyIfConv.cpp
  505   BranchProbability JumpProb(1, 10);
  506   BranchProbability Prob(9, 10);
lib/Target/Hexagon/HexagonInstrInfo.cpp
  771       BranchProbability Probability) const {
  777       unsigned NumFCycles, unsigned ExtraFCycles, BranchProbability Probability)
  783       unsigned NumInstrs, BranchProbability Probability) const {
 3577   const BranchProbability OneHalf(1, 2);
lib/Target/Hexagon/HexagonInstrInfo.h
  144                            BranchProbability Probability) const override;
  156                            BranchProbability Probability) const override;
  165                                  BranchProbability Probability) const override;
lib/Target/Hexagon/HexagonNewValueJump.cpp
  341   const BranchProbability Prediction =
lib/Target/Mips/MipsExpandPseudo.cpp
  132   BB.addSuccessor(loop1MBB, BranchProbability::getOne());
  139   sinkMBB->addSuccessor(exitMBB, BranchProbability::getOne());
  267   BB.addSuccessor(loop1MBB, BranchProbability::getOne());
  399   BB.addSuccessor(loopMBB, BranchProbability::getOne());
  452   sinkMBB->addSuccessor(exitMBB, BranchProbability::getOne());
  587   BB.addSuccessor(loopMBB, BranchProbability::getOne());
lib/Target/Mips/MipsISelLowering.cpp
 1657   BB->addSuccessor(exitMBB, BranchProbability::getOne());
 1835   BB->addSuccessor(exitMBB, BranchProbability::getOne());
lib/Target/PowerPC/PPCISelDAGToDAG.cpp
  529   auto TProb = FuncInfo->BPI->getEdgeProbability(BB, TBB);
  530   auto FProb = FuncInfo->BPI->getEdgeProbability(BB, FBB);
lib/Target/PowerPC/PPCISelLowering.cpp
10715   thisMBB->addSuccessor(mainMBB, BranchProbability::getZero());
10716   thisMBB->addSuccessor(sinkMBB, BranchProbability::getOne());
lib/Target/PowerPC/PPCInstrInfo.cpp
 1410                      BranchProbability Probability) const {
lib/Target/PowerPC/PPCInstrInfo.h
  315                           BranchProbability Probability) const override {
  323                            BranchProbability Probability) const override;
  326                                  BranchProbability Probability) const override {
lib/Target/PowerPC/PPCReduceCRLogicals.cpp
  179   BranchProbability ProbToNewTarget, ProbFallThrough;     // Prob for new Br.
  180   BranchProbability ProbOrigTarget, ProbOrigFallThrough;  // Prob for orig Br.
  181   ProbToNewTarget = ProbFallThrough = BranchProbability::getUnknown();
  182   ProbOrigTarget = ProbOrigFallThrough = BranchProbability::getUnknown();
lib/Target/SystemZ/SystemZInstrInfo.cpp
  685                     BranchProbability Probability) const {
  706                     BranchProbability Probability) const {
  713                           BranchProbability Probability) const {
lib/Target/SystemZ/SystemZInstrInfo.h
  234                            BranchProbability Probability) const override;
  239                            BranchProbability Probability) const override;
  241                             BranchProbability Probability) const override;
lib/Target/X86/X86CondBrFolding.cpp
  201                                  BranchProbability Prob) {
  287   BranchProbability TargetProb = MBPI->getEdgeProbability(&MBB, MBBInfo->TBB);
  348     BranchProbability Prob;
lib/Target/X86/X86FrameLowering.cpp
 2524   checkMBB->addSuccessor(allocMBB, BranchProbability::getZero());
 2525   checkMBB->addSuccessor(&PrologueMBB, BranchProbability::getOne());
lib/Transforms/IPO/GlobalOpt.cpp
 2166   const BranchProbability ColdProb(ColdCCRelFreq, 100);
lib/Transforms/IPO/PartialInlining.cpp
  282   BranchProbability getOutliningCallBBRelativeFreq(FunctionCloner &Cloner);
  460   BranchProbability MinBranchProbability(
  490       BranchProbability SuccProb = BPI.getEdgeProbability(thisBB, *SI);
  720 BranchProbability
  733   auto OutlineRegionRelFreq = BranchProbability::getBranchProbability(
  733   auto OutlineRegionRelFreq = BranchProbability::getBranchProbability(
 1343   BranchProbability RelativeToEntryFreq;
lib/Transforms/Instrumentation/ControlHeightReduction.cpp
  391                    Value *&MergedCondition, BranchProbability &CHRBranchBias);
  395                    Value *&MergedCondition, BranchProbability &CHRBranchBias);
  419   DenseMap<Region *, BranchProbability> BranchBiasMap;
  421   DenseMap<SelectInst *, BranchProbability> SelectBiasMap;
  608 static bool checkMDProf(MDNode *MD, BranchProbability &TrueProb,
  609                         BranchProbability &FalseProb) {
  626   TrueProb = BranchProbability::getBranchProbability(TrueWt, SumWt);
  627   FalseProb = BranchProbability::getBranchProbability(FalseWt, SumWt);
  631 static BranchProbability getCHRBiasThreshold() {
  632   return BranchProbability::getBranchProbability(
  641 static bool checkBias(K *Key, BranchProbability TrueProb,
  642                       BranchProbability FalseProb, S &TrueSet, S &FalseSet,
  644   BranchProbability Threshold = getCHRBiasThreshold();
  662                               DenseMap<Region *, BranchProbability> &BranchBiasMap) {
  665   BranchProbability ThenProb, ElseProb;
  694     DenseMap<SelectInst *, BranchProbability> &SelectBiasMap) {
  695   BranchProbability TrueProb, FalseProb;
 1846   BranchProbability CHRBranchBias(1, 1);
 1885                       BranchProbability &CHRBranchBias) {
 1892   BranchProbability Bias = BranchBiasMap[R];
 1929                       BranchProbability &CHRBranchBias) {
 1935   BranchProbability Bias = SelectBiasMap[SI];
lib/Transforms/Instrumentation/PGOInstrumentation.cpp
 1726     BranchProbability BP(scaleBranchCount(Weights[0], Scale),
lib/Transforms/Scalar/GuardWidening.cpp
  312   Optional<BranchProbability> LikelyTaken = None;
lib/Transforms/Scalar/InductiveRangeCheckElimination.cpp
  397   BranchProbability LikelyTaken(15, 16);
  772   BranchProbability ExitProbability =
  774           : BranchProbability::getZero();
lib/Transforms/Scalar/JumpThreading.cpp
  215   BranchProbability BP;
  254     BP = (CI->isOne() ? BranchProbability::getBranchProbability(
  256                       : BranchProbability::getBranchProbability(
 2194   SmallVector<BranchProbability, 4> BBSuccProbs;
 2201           BranchProbability::getBranchProbability(Freq, MaxBBSuccFreq));
 2203     BranchProbability::normalizeProbabilities(BBSuccProbs.begin(),
 2247     for (auto Prob : BBSuccProbs)
lib/Transforms/Scalar/LoopPredication.cpp
  925   BranchProbability LatchExitProbability =
  939   const auto LatchProbabilityThreshold =
  943     BranchProbability ExitingBlockProbability =
lib/Transforms/Utils/CodeExtractor.cpp
 1361       BPI->setEdgeProbability(CodeReplacer, i, BranchProbability::getZero());
 1377     BranchProbability BP(Weight.Amount, BranchDist.Total);
lib/Transforms/Utils/MisExpect.cpp
  131       const llvm::BranchProbability LikelyThreshold(LikelyBranchWeight,
tools/llvm-exegesis/lib/SnippetRepetitor.cpp
   72       Entry.MBB->addSuccessor(Loop.MBB, BranchProbability::getOne());
   73       Loop.MBB->addSuccessor(Loop.MBB, BranchProbability::getOne());
   86       Loop.MBB->addSuccessor(Exit.MBB, BranchProbability::getZero());
unittests/Support/BlockFrequencyTest.cpp
   21   BranchProbability Prob(UINT32_MAX / 3, UINT32_MAX);
   32   BranchProbability Prob(UINT32_MAX, UINT32_MAX);
   43   BranchProbability Prob(3000000, 9000000);
   54   BranchProbability Prob(UINT32_MAX / 2, UINT32_MAX);
   67   BranchProbability Prob(P, P);
   78   BranchProbability Prob(UINT32_MAX, UINT32_MAX);
unittests/Support/BranchProbabilityTest.cpp
   16 void PrintTo(BranchProbability P, ::std::ostream *os) {
   22 typedef BranchProbability BP;
  338   const auto UnknownProb = BranchProbability::getUnknown();
  338   const auto UnknownProb = BranchProbability::getUnknown();
  340     SmallVector<BranchProbability, 2> Probs{{0, 1}, {0, 1}};
  341     BranchProbability::normalizeProbabilities(Probs.begin(), Probs.end());
  346     SmallVector<BranchProbability, 2> Probs{{0, 1}, {1, 1}};
  347     BranchProbability::normalizeProbabilities(Probs.begin(), Probs.end());
  352     SmallVector<BranchProbability, 2> Probs{{1, 100}, {1, 100}};
  353     BranchProbability::normalizeProbabilities(Probs.begin(), Probs.end());
  358     SmallVector<BranchProbability, 2> Probs{{1, 1}, {1, 1}};
  359     BranchProbability::normalizeProbabilities(Probs.begin(), Probs.end());
  364     SmallVector<BranchProbability, 3> Probs{{1, 1}, {1, 1}, {1, 1}};
  365     BranchProbability::normalizeProbabilities(Probs.begin(), Probs.end());
  374     SmallVector<BranchProbability, 2> Probs{{0, 1}, UnknownProb};
  375     BranchProbability::normalizeProbabilities(Probs.begin(), Probs.end());
  380     SmallVector<BranchProbability, 2> Probs{{1, 1}, UnknownProb};
  381     BranchProbability::normalizeProbabilities(Probs.begin(), Probs.end());
  386     SmallVector<BranchProbability, 2> Probs{{1, 2}, UnknownProb};
  387     BranchProbability::normalizeProbabilities(Probs.begin(), Probs.end());
  392     SmallVector<BranchProbability, 4> Probs{
  394     BranchProbability::normalizeProbabilities(Probs.begin(), Probs.end());
usr/include/c++/7.4.0/bits/algorithmfwd.h
  255     fill(_FIter, _FIter, const _Tp&);
  369     const _Tp&
  370     max(const _Tp&, const _Tp&);
  370     max(const _Tp&, const _Tp&);
  382     const _Tp&
  383     min(const _Tp&, const _Tp&);
  383     min(const _Tp&, const _Tp&);
usr/include/c++/7.4.0/bits/alloc_traits.h
  387       using allocator_type = allocator<_Tp>;
  389       using value_type = _Tp;
  392       using pointer = _Tp*;
  395       using const_pointer = const _Tp*;
  474 	construct(allocator_type& __a, _Up* __p, _Args&&... __args)
  474 	construct(allocator_type& __a, _Up* __p, _Args&&... __args)
  486 	destroy(allocator_type& __a, _Up* __p)
usr/include/c++/7.4.0/bits/allocator.h
  108     class allocator: public __allocator_base<_Tp>
  113       typedef _Tp*       pointer;
  114       typedef const _Tp* const_pointer;
  115       typedef _Tp&       reference;
  116       typedef const _Tp& const_reference;
  117       typedef _Tp        value_type;
  137 	allocator(const allocator<_Tp1>&) throw() { }
usr/include/c++/7.4.0/bits/cpp_type_traits.h
  329     : public __traitor<__is_integer<_Tp>, __is_floating<_Tp> >
  329     : public __traitor<__is_integer<_Tp>, __is_floating<_Tp> >
  337     : public __traitor<__is_arithmetic<_Tp>, __is_pointer<_Tp> >
  337     : public __traitor<__is_arithmetic<_Tp>, __is_pointer<_Tp> >
usr/include/c++/7.4.0/bits/move.h
   46     inline _GLIBCXX_CONSTEXPR _Tp*
   47     __addressof(_Tp& __r) _GLIBCXX_NOEXCEPT
   72     constexpr _Tp&&
   73     forward(typename std::remove_reference<_Tp>::type& __t) noexcept
   83     constexpr _Tp&&
   84     forward(typename std::remove_reference<_Tp>::type&& __t) noexcept
   98     move(_Tp&& __t) noexcept
  104     : public __and_<__not_<is_nothrow_move_constructible<_Tp>>,
  105                     is_copy_constructible<_Tp>>::type { };
  136     inline _GLIBCXX17_CONSTEXPR _Tp*
  137     addressof(_Tp& __r) noexcept
  143     const _Tp* addressof(const _Tp&&) = delete;
  143     const _Tp* addressof(const _Tp&&) = delete;
  184     typename enable_if<__and_<__not_<__is_tuple_like<_Tp>>,
  185 			      is_move_constructible<_Tp>,
  186 			      is_move_assignable<_Tp>>::value>::type
  187     swap(_Tp& __a, _Tp& __b)
  187     swap(_Tp& __a, _Tp& __b)
  198       _Tp __tmp = _GLIBCXX_MOVE(__a);
usr/include/c++/7.4.0/bits/stl_algo.h
 4397 	       _Predicate __pred, const _Tp& __new_value)
usr/include/c++/7.4.0/bits/stl_algobase.h
  680     __gnu_cxx::__enable_if<!__is_scalar<_Tp>::__value, void>::__type
  682  	     const _Tp& __value)
usr/include/c++/7.4.0/bits/stl_construct.h
   74     _Construct(_T1* __p, _Args&&... __args)
   74     _Construct(_T1* __p, _Args&&... __args)
   75     { ::new(static_cast<void*>(__p)) _T1(std::forward<_Args>(__args)...); }
   75     { ::new(static_cast<void*>(__p)) _T1(std::forward<_Args>(__args)...); }
  204 	     allocator<_Tp>&)
usr/include/c++/7.4.0/bits/stl_iterator.h
 1224     __make_move_if_noexcept_iterator(_Tp* __i)
usr/include/c++/7.4.0/bits/stl_iterator_base_types.h
  181       typedef _Tp                         value_type;
  183       typedef _Tp*                        pointer;
  184       typedef _Tp&                        reference;
  192       typedef _Tp                         value_type;
  194       typedef const _Tp*                  pointer;
  195       typedef const _Tp&                  reference;
usr/include/c++/7.4.0/bits/stl_pair.h
  101 		      is_constructible<_T2, const _U2&>>::value;
  101 		      is_constructible<_T2, const _U2&>>::value;
  108 		      is_convertible<const _U2&, _T2>>::value;
  108 		      is_convertible<const _U2&, _T2>>::value;
  115 		      is_constructible<_T2, _U2&&>>::value;
  115 		      is_constructible<_T2, _U2&&>>::value;
  122 		      is_convertible<_U2&&, _T2>>::value;
  122 		      is_convertible<_U2&&, _T2>>::value;
  129 				  is_convertible<_U2&&, _T2>>;
  129 				  is_convertible<_U2&&, _T2>>;
  134 		      is_constructible<_T2, _U2&&>,
  134 		      is_constructible<_T2, _U2&&>,
  143 				  is_convertible<const _U2&, _T2>>;
  143 				  is_convertible<const _U2&, _T2>>;
  148 		      is_constructible<_T2, const _U2&&>,
  148 		      is_constructible<_T2, const _U2&&>,
  209     : private __pair_base<_T1, _T2>
  212       typedef _T2 second_type;   /// @c second_type is the second bound type
  215       _T2 second;                /// @c second is a copy of the second object
  252       using _PCCP = _PCC<true, _T1, _T2>;
  260       constexpr pair(const _T1& __a, const _T2& __b)
  269       explicit constexpr pair(const _T1& __a, const _T2& __b)
  283 			    _T1, _T2>;
  311        constexpr pair(_U1&& __x, const _T2& __y)
  318        explicit constexpr pair(_U1&& __x, const _T2& __y)
  325        constexpr pair(const _T1& __x, _U2&& __y)
  341 	constexpr pair(_U1&& __x, _U2&& __y)
  380 		       is_copy_assignable<_T2>>::value,
  391 		       is_move_assignable<_T2>>::value,
  403 				is_assignable<_T2&, const _U2&>>::value,
  403 				is_assignable<_T2&, const _U2&>>::value,
  405 	operator=(const pair<_U1, _U2>& __p)
  414 				is_assignable<_T2&, _U2&&>>::value,
  414 				is_assignable<_T2&, _U2&&>>::value,
  416 	operator=(pair<_U1, _U2>&& __p)
usr/include/c++/7.4.0/bits/stl_uninitialized.h
  144 		      const _Tp& __x)
  182 		       const _Tp& __x)
  288 			   _ForwardIterator __result, allocator<_Tp>&)
usr/include/c++/7.4.0/bits/stl_vector.h
   77 	rebind<_Tp>::other _Tp_alloc_type;
  216     class vector : protected _Vector_base<_Tp, _Alloc>
  227       typedef _Vector_base<_Tp, _Alloc>			_Base;
  232       typedef _Tp					value_type;
  919       _Tp*
  923       const _Tp*
 1483 	_M_realloc_insert(iterator __position, _Args&&... __args);
usr/include/c++/7.4.0/ext/alloc_traits.h
  117       { typedef typename _Base_type::template rebind_alloc<_Tp> other; };
usr/include/c++/7.4.0/ext/new_allocator.h
   63       typedef _Tp*       pointer;
   64       typedef const _Tp* const_pointer;
   65       typedef _Tp&       reference;
   66       typedef const _Tp& const_reference;
   67       typedef _Tp        value_type;
  111 	return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp)));
  130       { return size_t(-1) / sizeof(_Tp); }
  135 	construct(_Up* __p, _Args&&... __args)
  135 	construct(_Up* __p, _Args&&... __args)
  136 	{ ::new((void *)__p) _Up(std::forward<_Args>(__args)...); }
  140 	destroy(_Up* __p) { __p->~_Up(); }
usr/include/c++/7.4.0/initializer_list
   50       typedef _E 		value_type;
   51       typedef const _E& 	reference;
   52       typedef const _E& 	const_reference;
   54       typedef const _E* 	iterator;
   55       typedef const _E* 	const_iterator;
usr/include/c++/7.4.0/tuple
   56     struct __is_empty_non_tuple : is_empty<_Tp> { };
  125       constexpr _Head_base(const _Head& __h)
  132         constexpr _Head_base(_UHead&& __h)
  133 	: _M_head_impl(std::forward<_UHead>(__h)) { }
  159       static constexpr _Head&
  162       static constexpr const _Head&
  165       _Head _M_head_impl;
  187       private _Head_base<_Idx, _Head>
  192       typedef _Head_base<_Idx, _Head> _Base;
  194       static constexpr _Head&
  197       static constexpr const _Head&
  210       constexpr _Tuple_impl(const _Head& __head, const _Tail&... __tail)
  216         constexpr _Tuple_impl(_UHead&& __head, _UTail&&... __tail)
  227 	_Base(std::forward<_Head>(_M_head(__in))) { }
  230         constexpr _Tuple_impl(const _Tuple_impl<_Idx, _UElements...>& __in)
  235         constexpr _Tuple_impl(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
  248 		    const _Head& __head, const _Tail&... __tail)
  304 	_M_head(*this) = std::forward<_Head>(_M_head(__in));
  313 	  _M_head(*this) = _Tuple_impl<_Idx, _UElements...>::_M_head(__in);
  314 	  _M_tail(*this) = _Tuple_impl<_Idx, _UElements...>::_M_tail(__in);
  473       return __and_<is_constructible<_Elements, const _UElements&>...>::value;
  473       return __and_<is_constructible<_Elements, const _UElements&>...>::value;
  479       return __and_<is_convertible<const _UElements&, _Elements>...>::value;
  479       return __and_<is_convertible<const _UElements&, _Elements>...>::value;
  485       return __and_<is_constructible<_Elements, _UElements&&>...>::value;
  485       return __and_<is_constructible<_Elements, _UElements&&>...>::value;
  491       return __and_<is_convertible<_UElements&&, _Elements>...>::value;
  491       return __and_<is_convertible<_UElements&&, _Elements>...>::value;
  907     class tuple<_T1, _T2> : public _Tuple_impl<0, _T1, _T2>
  909       typedef _Tuple_impl<0, _T1, _T2> _Inherited;
  939         _TC<is_same<_Dummy, void>::value, _T1, _T2>;
  947         constexpr tuple(const _T1& __a1, const _T2& __a2)
  956         explicit constexpr tuple(const _T1& __a1, const _T2& __a2)
  961       using _TMC = _TC<true, _T1, _T2>;
  971         constexpr tuple(_U1&& __a1, _U2&& __a2)
  995         constexpr tuple(const tuple<_U1, _U2>& __in)
 1013         constexpr tuple(tuple<_U1, _U2>&& __in)
 1078 	      const _T1& __a1, const _T2& __a2)
 1090 	      const _T1& __a1, const _T2& __a2)
 1225         operator=(const tuple<_U1, _U2>& __in)
 1233         operator=(tuple<_U1, _U2>&& __in)
 1288       typedef _Head type;
 1302     constexpr _Head&
 1303     __get_helper(_Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
 1304     { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }
 1307     constexpr const _Head&
 1308     __get_helper(const _Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
 1313     constexpr __tuple_element_t<__i, tuple<_Elements...>>&
 1313     constexpr __tuple_element_t<__i, tuple<_Elements...>>&
 1313     constexpr __tuple_element_t<__i, tuple<_Elements...>>&
 1314     get(tuple<_Elements...>& __t) noexcept
 1319     constexpr const __tuple_element_t<__i, tuple<_Elements...>>&
 1319     constexpr const __tuple_element_t<__i, tuple<_Elements...>>&
 1319     constexpr const __tuple_element_t<__i, tuple<_Elements...>>&
 1320     get(const tuple<_Elements...>& __t) noexcept
 1325     constexpr __tuple_element_t<__i, tuple<_Elements...>>&&
 1325     constexpr __tuple_element_t<__i, tuple<_Elements...>>&&
 1325     constexpr __tuple_element_t<__i, tuple<_Elements...>>&&
 1326     get(tuple<_Elements...>&& __t) noexcept
 1448     make_tuple(_Elements&&... __args)
 1588     constexpr tuple<_Elements&...>
 1589     tie(_Elements&... __args) noexcept
 1602     swap(tuple<_Elements...>& __x, tuple<_Elements...>& __y)
 1602     swap(tuple<_Elements...>& __x, tuple<_Elements...>& __y)
usr/include/c++/7.4.0/type_traits
  215     : public __is_void_helper<typename remove_cv<_Tp>::type>::type
  326     : public __is_integral_helper<typename remove_cv<_Tp>::type>::type
  354     : public __is_floating_point_helper<typename remove_cv<_Tp>::type>::type
  381     : public __is_pointer_helper<typename remove_cv<_Tp>::type>::type
  567     : public __is_null_pointer_helper<typename remove_cv<_Tp>::type>::type
  581     : public __or_<is_lvalue_reference<_Tp>,
  582                    is_rvalue_reference<_Tp>>::type
  588     : public __or_<is_integral<_Tp>, is_floating_point<_Tp>>::type
  588     : public __or_<is_integral<_Tp>, is_floating_point<_Tp>>::type
  601     : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
  601     : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
  602                           is_void<_Tp>>>::type
  611     : public __or_<is_arithmetic<_Tp>, is_enum<_Tp>, is_pointer<_Tp>,
  611     : public __or_<is_arithmetic<_Tp>, is_enum<_Tp>, is_pointer<_Tp>,
  611     : public __or_<is_arithmetic<_Tp>, is_enum<_Tp>, is_pointer<_Tp>,
  612                    is_member_pointer<_Tp>, is_null_pointer<_Tp>>::type
  612                    is_member_pointer<_Tp>, is_null_pointer<_Tp>>::type
  631     : public __is_member_pointer_helper<typename remove_cv<_Tp>::type>::type
  638     : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
  638     : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
  762     typename add_rvalue_reference<_Tp>::type declval() noexcept;
  777     : public __and_<is_array<_Tp>, __not_<extent<_Tp>>>
  777     : public __and_<is_array<_Tp>, __not_<extent<_Tp>>>
  798       typedef decltype(__test<_Tp>(0)) type;
  811                remove_all_extents<_Tp>::type>::type
  825     : public __is_destructible_safe<_Tp>::type
  889       typedef decltype(__test<_Tp>(0)) type;
  894     : public __and_<__not_<is_void<_Tp>>,
  895                     __is_default_constructible_impl<_Tp>>
  915     : public __is_default_constructible_atom<_Tp>::type
  921     : public __is_default_constructible_safe<_Tp>::type
  984       typedef decltype(__test<_Tp, _Arg>(0)) type;
  989     : public __and_<is_destructible<_Tp>,
  990                     __is_direct_constructible_impl<_Tp, _Arg>>
 1072 			 __is_direct_constructible_ref_cast<_Tp, _Arg>,
 1073 			 __is_direct_constructible_new_safe<_Tp, _Arg>
 1079     : public __is_direct_constructible_new<_Tp, _Arg>::type
 1119     : public __is_direct_constructible<_Tp, _Arg>
 1130     : public __is_constructible_impl<_Tp, _Args...>::type
 1142     : public is_constructible<_Tp, const _Tp&>
 1142     : public is_constructible<_Tp, const _Tp&>
 1148     : public __is_copy_constructible_impl<_Tp>
 1160     : public is_constructible<_Tp, _Tp&&>
 1160     : public is_constructible<_Tp, _Tp&&>
 1166     : public __is_move_constructible_impl<_Tp>
 1215     : public __and_<is_constructible<_Tp, _Args...>,
 1216 		    __is_nt_constructible_impl<_Tp, _Args...>>
 1246     : public is_nothrow_constructible<_Tp, _Tp&&>
 1246     : public is_nothrow_constructible<_Tp, _Tp&&>
 1252     : public __is_nothrow_move_constructible_impl<_Tp>
 1286     : public is_assignable<_Tp&, const _Tp&>
 1286     : public is_assignable<_Tp&, const _Tp&>
 1292     : public __is_copy_assignable_impl<_Tp>
 1304     : public is_assignable<_Tp&, _Tp&&>
 1304     : public is_assignable<_Tp&, _Tp&&>
 1310     : public __is_move_assignable_impl<_Tp>
 1352     : public is_nothrow_assignable<_Tp&, _Tp&&>
 1352     : public is_nothrow_assignable<_Tp&, _Tp&&>
 1358     : public __is_nt_move_assignable_impl<_Tp>
 1377     static void __helper(const _Tp&);
 1380     static true_type __test(const _Tp&,
 1381                             decltype(__helper<const _Tp&>({}))* = 0);
 1390     typedef decltype(__test(declval<_Tp>())) type;
 1395       : public __is_implicitly_default_constructible_impl<_Tp>::type
 1400       : public __and_<is_default_constructible<_Tp>,
 1401                       __is_implicitly_default_constructible_safe<_Tp>>
 1526 	static void __test_aux(_To1);
 1538       typedef decltype(__test<_From, _To>(0)) type;
 1545     : public __is_convertible_helper<_From, _To>::type
 1554     { typedef _Tp     type; };
 1558     { typedef _Tp     type; };
 1563     { typedef _Tp     type; };
 1574       remove_const<typename remove_volatile<_Tp>::type>::type     type;
 1629     { typedef _Tp   type; };
 1633     { typedef _Tp   type; };
 1659     { typedef _Tp&&   type; };
 1664     : public __add_rvalue_reference_helper<_Tp>
 1955     { typedef _Tp     type; };
 2104     { typedef typename remove_cv<_Up>::type __type; };
 2131       typedef _Tp __type;
 2574       typename remove_reference<_Tp>::type>::type>::type
 2579     typename enable_if<__and_<__not_<__is_tuple_like<_Tp>>,
 2580 			      is_move_constructible<_Tp>,
 2581 			      is_move_assignable<_Tp>>::value>::type
 2582     swap(_Tp&, _Tp&)
 2582     swap(_Tp&, _Tp&)
 2609           noexcept(swap(std::declval<_Tp&>(), std::declval<_Tp&>()))
 2609           noexcept(swap(std::declval<_Tp&>(), std::declval<_Tp&>()))
 2629       typedef decltype(__test<_Tp>(0)) type;
 2639     : public __is_nothrow_swappable_impl<_Tp>::type
utils/unittest/googletest/include/gtest/gtest-printers.h
  276   static ::std::string Format(const ToPrint& value) {
  351     const T1& value, const T2& /* other_operand */) {
  351     const T1& value, const T2& /* other_operand */) {
  352   return FormatForComparison<T1, T2>::Format(value);
  352   return FormatForComparison<T1, T2>::Format(value);
  366 void UniversalPrint(const T& value, ::std::ostream* os);
  455 void PrintTo(const T& value, ::std::ostream* os) {
  699   static void Print(const T& value, ::std::ostream* os) {
  784   static void Print(const T& value, ::std::ostream* os) {
  856   typedef T T1;
  983   internal::UniversalTersePrinter<T>::Print(value, &ss);
utils/unittest/googletest/include/gtest/gtest.h
 1377                                    const T1& lhs, const T2& rhs) {
 1377                                    const T1& lhs, const T2& rhs) {
 1389                             const T1& lhs,
 1390                             const T2& rhs) {
 1419                                  const T1& lhs,
 1420                                  const T2& rhs) {
utils/unittest/googletest/include/gtest/internal/gtest-internal.h
   94 ::std::string PrintToString(const T& value);