1 /* Profile counter container type.
2 Copyright (C) 2017 Free Software Foundation, Inc.
3 Contributed by Jan Hubicka
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 3, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
21 #ifndef GCC_PROFILE_COUNT_H
22 #define GCC_PROFILE_COUNT_H
26 /* Quality of the profile count. Because gengtype does not support enums
27 inside of classes, this is in global namespace. */
28 enum profile_quality
{
29 /* Profile is based on static branch prediction heuristics and may
30 or may not match reality. It is local to function and can not be compared
31 inter-procedurally. Never used by probabilities (they are always local).
33 profile_guessed_local
= 0,
34 /* Profile was read by feedback and was 0, we used local heuristics to guess
35 better. This is the case of functions not run in profile fedback.
36 Never used by probabilities. */
37 profile_guessed_global0
= 1,
39 /* Same as profile_guessed_global0 but global count is adjusted 0. */
40 profile_guessed_global0adjusted
= 2,
42 /* Profile is based on static branch prediction heuristics. It may or may
43 not reflect the reality but it can be compared interprocedurally
44 (for example, we inlined function w/o profile feedback into function
45 with feedback and propagated from that).
46 Never used by probablities. */
48 /* Profile was determined by autofdo. */
50 /* Profile was originally based on feedback but it was adjusted
51 by code duplicating optimization. It may not precisely reflect the
52 particular code path. */
54 /* Profile was read from profile feedback or determined by accurate static
59 /* The base value for branch probability notes and edge probabilities. */
60 #define REG_BR_PROB_BASE 10000
62 #define RDIV(X,Y) (((X) + (Y) / 2) / (Y))
64 bool slow_safe_scale_64bit (uint64_t a
, uint64_t b
, uint64_t c
, uint64_t *res
);
66 /* Compute RES=(a*b + c/2)/c capping and return false if overflow happened. */
69 safe_scale_64bit (uint64_t a
, uint64_t b
, uint64_t c
, uint64_t *res
)
71 #if (GCC_VERSION >= 5000)
73 if (!__builtin_mul_overflow (a
, b
, &tmp
)
74 && !__builtin_add_overflow (tmp
, c
/2, &tmp
))
85 if (a
< ((uint64_t)1 << 31)
86 && b
< ((uint64_t)1 << 31)
87 && c
< ((uint64_t)1 << 31))
89 *res
= (a
* b
+ (c
/ 2)) / c
;
93 return slow_safe_scale_64bit (a
, b
, c
, res
);
96 /* Data type to hold probabilities. It implements fixed point arithmetics
97 with capping so probability is always in range [0,1] and scaling requiring
98 values greater than 1 needs to be represented otherwise.
100 In addition to actual value the quality of profile is tracked and propagated
101 through all operations. Special value UNINITIALIZED is used for probabilities
102 that has not been determined yet (for example bacause of
103 -fno-guess-branch-probability)
105 Typically probabilities are derived from profile feedback (via
106 probability_in_gcov_type), autoFDO or guessed statically and then propagated
107 thorough the compilation.
109 Named probabilities are available:
110 - never (0 probability)
112 - very_unlikely (1/2000 probability)
113 - unlikely (1/5 probablity)
114 - even (1/2 probability)
115 - likely (4/5 probability)
116 - very_likely (1999/2000 probability)
120 Named probabilities except for never/always are assumed to be statically
121 guessed and thus not necessarily accurate. The difference between never
122 and guessed_never is that the first one should be used only in case that
123 well behaving program will very likely not execute the "never" path.
124 For example if the path is going to abort () call or it exception handling.
126 Always and guessed_always probabilities are symmetric.
128 For legacy code we support conversion to/from REG_BR_PROB_BASE based fixpoint
129 integer arithmetics. Once the code is converted to branch probabilities,
130 these conversions will probably go away because they are lossy.
133 class GTY((user
)) profile_probability
135 static const int n_bits
= 29;
136 /* We can technically use ((uint32_t) 1 << (n_bits - 1)) - 2 but that
137 will lead to harder multiplication sequences. */
138 static const uint32_t max_probability
= (uint32_t) 1 << (n_bits
- 2);
139 static const uint32_t uninitialized_probability
140 = ((uint32_t) 1 << (n_bits
- 1)) - 1;
143 enum profile_quality m_quality
: 3;
145 friend class profile_count
;
148 /* Named probabilities. */
149 static profile_probability
never ()
151 profile_probability ret
;
153 ret
.m_quality
= profile_precise
;
156 static profile_probability
guessed_never ()
158 profile_probability ret
;
160 ret
.m_quality
= profile_guessed
;
163 static profile_probability
very_unlikely ()
165 /* Be consistent with PROB_VERY_UNLIKELY in predict.h. */
166 profile_probability r
167 = profile_probability::always ().apply_scale (1, 2000);
171 static profile_probability
unlikely ()
173 /* Be consistent with PROB_VERY_LIKELY in predict.h. */
174 profile_probability r
175 = profile_probability::always ().apply_scale (1, 5);
179 static profile_probability
even ()
181 return profile_probability::always ().apply_scale (1, 2);
183 static profile_probability
very_likely ()
185 return profile_probability::always () - very_unlikely ();
187 static profile_probability
likely ()
189 return profile_probability::always () - unlikely ();
191 static profile_probability
guessed_always ()
193 profile_probability ret
;
194 ret
.m_val
= max_probability
;
195 ret
.m_quality
= profile_guessed
;
198 static profile_probability
always ()
200 profile_probability ret
;
201 ret
.m_val
= max_probability
;
202 ret
.m_quality
= profile_precise
;
205 /* Probabilities which has not been initialized. Either because
206 initialization did not happen yet or because profile is unknown. */
207 static profile_probability
uninitialized ()
209 profile_probability c
;
210 c
.m_val
= uninitialized_probability
;
211 c
.m_quality
= profile_guessed
;
216 /* Return true if value has been initialized. */
217 bool initialized_p () const
219 return m_val
!= uninitialized_probability
;
221 /* Return true if value can be trusted. */
222 bool reliable_p () const
224 return m_quality
>= profile_adjusted
;
227 /* Conversion from and to REG_BR_PROB_BASE integer fixpoint arithmetics.
228 this is mostly to support legacy code and should go away. */
229 static profile_probability
from_reg_br_prob_base (int v
)
231 profile_probability ret
;
232 gcc_checking_assert (v
>= 0 && v
<= REG_BR_PROB_BASE
);
233 ret
.m_val
= RDIV (v
* (uint64_t) max_probability
, REG_BR_PROB_BASE
);
234 ret
.m_quality
= profile_guessed
;
237 int to_reg_br_prob_base () const
239 gcc_checking_assert (initialized_p ());
240 return RDIV (m_val
* (uint64_t) REG_BR_PROB_BASE
, max_probability
);
243 /* Conversion to and from RTL representation of profile probabilities. */
244 static profile_probability
from_reg_br_prob_note (int v
)
246 profile_probability ret
;
247 ret
.m_val
= ((unsigned int)v
) / 8;
248 ret
.m_quality
= (enum profile_quality
)(v
& 7);
251 int to_reg_br_prob_note () const
253 gcc_checking_assert (initialized_p ());
254 int ret
= m_val
* 8 + m_quality
;
255 gcc_checking_assert (profile_probability::from_reg_br_prob_note (ret
)
260 /* Return VAL1/VAL2. */
261 static profile_probability probability_in_gcov_type
262 (gcov_type val1
, gcov_type val2
)
264 profile_probability ret
;
265 gcc_checking_assert (val1
>= 0 && val2
> 0);
267 ret
.m_val
= max_probability
;
271 safe_scale_64bit (val1
, max_probability
, val2
, &tmp
);
272 gcc_checking_assert (tmp
<= max_probability
);
275 ret
.m_quality
= profile_precise
;
279 /* Basic operations. */
280 bool operator== (const profile_probability
&other
) const
282 return m_val
== other
.m_val
&& m_quality
== other
.m_quality
;
284 profile_probability
operator+ (const profile_probability
&other
) const
286 if (other
== profile_probability::never ())
288 if (*this == profile_probability::never ())
290 if (!initialized_p () || !other
.initialized_p ())
291 return profile_probability::uninitialized ();
293 profile_probability ret
;
294 ret
.m_val
= MIN ((uint32_t)(m_val
+ other
.m_val
), max_probability
);
295 ret
.m_quality
= MIN (m_quality
, other
.m_quality
);
298 profile_probability
&operator+= (const profile_probability
&other
)
300 if (other
== profile_probability::never ())
302 if (*this == profile_probability::never ())
307 if (!initialized_p () || !other
.initialized_p ())
308 return *this = profile_probability::uninitialized ();
311 m_val
= MIN ((uint32_t)(m_val
+ other
.m_val
), max_probability
);
312 m_quality
= MIN (m_quality
, other
.m_quality
);
316 profile_probability
operator- (const profile_probability
&other
) const
318 if (*this == profile_probability::never ()
319 || other
== profile_probability::never ())
321 if (!initialized_p () || !other
.initialized_p ())
322 return profile_probability::uninitialized ();
323 profile_probability ret
;
324 ret
.m_val
= m_val
>= other
.m_val
? m_val
- other
.m_val
: 0;
325 ret
.m_quality
= MIN (m_quality
, other
.m_quality
);
328 profile_probability
&operator-= (const profile_probability
&other
)
330 if (*this == profile_probability::never ()
331 || other
== profile_probability::never ())
333 if (!initialized_p () || !other
.initialized_p ())
334 return *this = profile_probability::uninitialized ();
337 m_val
= m_val
>= other
.m_val
? m_val
- other
.m_val
: 0;
338 m_quality
= MIN (m_quality
, other
.m_quality
);
342 profile_probability
operator* (const profile_probability
&other
) const
344 if (*this == profile_probability::never ()
345 || other
== profile_probability::never ())
346 return profile_probability::never ();
347 if (!initialized_p () || !other
.initialized_p ())
348 return profile_probability::uninitialized ();
349 profile_probability ret
;
350 ret
.m_val
= RDIV ((uint64_t)m_val
* other
.m_val
, max_probability
);
351 ret
.m_quality
= MIN (m_quality
, other
.m_quality
);
354 profile_probability
&operator*= (const profile_probability
&other
)
356 if (*this == profile_probability::never ()
357 || other
== profile_probability::never ())
358 return *this = profile_probability::never ();
359 if (!initialized_p () || !other
.initialized_p ())
360 return *this = profile_probability::uninitialized ();
363 m_val
= RDIV ((uint64_t)m_val
* other
.m_val
, max_probability
);
364 m_quality
= MIN (m_quality
, other
.m_quality
);
368 profile_probability
operator/ (const profile_probability
&other
) const
370 if (*this == profile_probability::never ())
371 return profile_probability::never ();
372 if (!initialized_p () || !other
.initialized_p ())
373 return profile_probability::uninitialized ();
374 profile_probability ret
;
375 if (m_val
>= other
.m_val
)
376 ret
.m_val
= max_probability
;
381 gcc_checking_assert (other
.m_val
);
382 ret
.m_val
= MIN (RDIV ((uint64_t)m_val
* max_probability
,
386 ret
.m_quality
= MIN (m_quality
, other
.m_quality
);
389 profile_probability
&operator/= (const profile_probability
&other
)
391 if (*this == profile_probability::never ())
392 return *this = profile_probability::never ();
393 if (!initialized_p () || !other
.initialized_p ())
394 return *this = profile_probability::uninitialized ();
397 if (m_val
> other
.m_val
)
398 m_val
= max_probability
;
403 gcc_checking_assert (other
.m_val
);
404 m_val
= MIN (RDIV ((uint64_t)m_val
* max_probability
,
408 m_quality
= MIN (m_quality
, other
.m_quality
);
413 gcov_type
apply (gcov_type val
) const
415 if (*this == profile_probability::uninitialized ())
417 return RDIV (val
* m_val
, max_probability
);
420 /* Return 1-*THIS. */
421 profile_probability
invert () const
423 return profile_probability::always() - *this;
426 /* Return THIS with quality dropped to GUESSED. */
427 profile_probability
guessed () const
429 profile_probability ret
= *this;
430 ret
.m_quality
= profile_guessed
;
434 /* Return THIS with quality dropped to AFDO. */
435 profile_probability
afdo () const
437 profile_probability ret
= *this;
438 ret
.m_quality
= profile_afdo
;
442 profile_probability
combine_with_freq (int freq1
, profile_probability other
,
445 profile_probability ret
;
447 if (*this == profile_probability::uninitialized ()
448 || other
== profile_probability::uninitialized ())
449 return profile_probability::uninitialized ();
451 gcc_checking_assert (freq1
>= 0 && freq2
>= 0);
452 if (!freq1
&& !freq2
)
454 ret
.m_val
= (m_val
+ other
.m_val
) / 2;
457 ret
.m_val
= RDIV (m_val
* (uint64_t) freq1
458 + other
.m_val
* (uint64_t) freq2
, freq1
+ freq2
);
459 ret
.m_quality
= MIN (m_quality
, other
.m_quality
);
463 /* Return *THIS * NUM / DEN. */
464 profile_probability
apply_scale (int64_t num
, int64_t den
) const
466 if (*this == profile_probability::never ())
468 if (!initialized_p ())
469 return profile_probability::uninitialized ();
470 profile_probability ret
;
472 safe_scale_64bit (m_val
, num
, den
, &tmp
);
473 ret
.m_val
= MIN (tmp
, max_probability
);
474 ret
.m_quality
= MIN (m_quality
, profile_adjusted
);
478 /* Return true when the probability of edge is reliable.
480 The profile guessing code is good at predicting branch outcome (ie.
481 taken/not taken), that is predicted right slightly over 75% of time.
482 It is however notoriously poor on predicting the probability itself.
483 In general the profile appear a lot flatter (with probabilities closer
484 to 50%) than the reality so it is bad idea to use it to drive optimization
485 such as those disabling dynamic branch prediction for well predictable
488 There are two exceptions - edges leading to noreturn edges and edges
489 predicted by number of iterations heuristics are predicted well. This macro
490 should be able to distinguish those, but at the moment it simply check for
491 noreturn heuristic that is only one giving probability over 99% or bellow
492 1%. In future we might want to propagate reliability information across the
493 CFG if we find this information useful on multiple places. */
495 bool probably_reliable_p () const
497 if (m_quality
>= profile_adjusted
)
499 if (!initialized_p ())
501 return m_val
< max_probability
/ 100
502 || m_val
> max_probability
- max_probability
/ 100;
505 /* Return false if profile_probability is bogus. */
508 if (m_val
== uninitialized_probability
)
509 return m_quality
== profile_guessed
;
510 else if (m_quality
< profile_guessed
)
512 return m_val
<= max_probability
;
515 /* Comparsions are three-state and conservative. False is returned if
516 the inequality can not be decided. */
517 bool operator< (const profile_probability
&other
) const
519 return initialized_p () && other
.initialized_p () && m_val
< other
.m_val
;
521 bool operator> (const profile_probability
&other
) const
523 return initialized_p () && other
.initialized_p () && m_val
> other
.m_val
;
526 bool operator<= (const profile_probability
&other
) const
528 return initialized_p () && other
.initialized_p () && m_val
<= other
.m_val
;
530 bool operator>= (const profile_probability
&other
) const
532 return initialized_p () && other
.initialized_p () && m_val
>= other
.m_val
;
535 /* Output THIS to F. */
536 void dump (FILE *f
) const;
538 /* Print THIS to stderr. */
541 /* Return true if THIS is known to differ significantly from OTHER. */
542 bool differs_from_p (profile_probability other
) const;
543 /* Return if difference is greater than 50%. */
544 bool differs_lot_from_p (profile_probability other
) const;
546 /* LTO streaming support. */
547 static profile_probability
stream_in (struct lto_input_block
*);
548 void stream_out (struct output_block
*);
549 void stream_out (struct lto_output_stream
*);
552 /* Main data type to hold profile counters in GCC. Profile counts originate
553 either from profile feedback, static profile estimation or both. We do not
554 perform whole program profile propagation and thus profile estimation
555 counters are often local to function, while counters from profile feedback
556 (or special cases of profile estimation) can be used inter-procedurally.
558 There are 3 basic types
559 1) local counters which are result of intra-procedural static profile
561 2) ipa counters which are result of profile feedback or special case
562 of static profile estimation (such as in function main).
563 3) counters which counts as 0 inter-procedurally (beause given function
564 was never run in train feedback) but they hold local static profile
567 Counters of type 1 and 3 can not be mixed with counters of different type
568 within operation (because whole function should use one type of counter)
569 with exception that global zero mix in most operations where outcome is
572 To take local counter and use it inter-procedurally use ipa member function
573 which strips information irelevant at the inter-procedural level.
575 Counters are 61bit integers representing number of executions during the
576 train run or normalized frequency within the function.
578 As the profile is maintained during the compilation, many adjustments are
579 made. Not all transformations can be made precisely, most importantly
580 when code is being duplicated. It also may happen that part of CFG has
581 profile counts known while other do not - for example when LTO optimizing
582 partly profiled program or when profile was lost due to COMDAT merging.
584 For this reason profile_count tracks more information than
585 just unsigned integer and it is also ready for profile mismatches.
586 The API of this data type represent operations that are natural
587 on profile counts - sum, difference and operation with scales and
588 probabilities. All operations are safe by never getting negative counts
589 and they do end up in uninitialized scale if any of the parameters is
592 All comparsions that are three state and handling of probabilities. Thus
593 a < b is not equal to !(a >= b).
595 The following pre-defined counts are available:
597 profile_count::zero () for code that is known to execute zero times at
598 runtime (this can be detected statically i.e. for paths leading to
600 profile_count::one () for code that is known to execute once (such as
602 profile_count::uninitialized () for unknown execution count.
608 class GTY(()) profile_count
611 /* Use 62bit to hold basic block counters. Should be at least
612 64bit. Although a counter cannot be negative, we use a signed
613 type to hold various extra stages. */
615 static const int n_bits
= 61;
617 static const uint64_t max_count
= ((uint64_t) 1 << n_bits
) - 2;
618 static const uint64_t uninitialized_count
= ((uint64_t) 1 << n_bits
) - 1;
620 uint64_t m_val
: n_bits
;
621 enum profile_quality m_quality
: 3;
623 /* Return true if both values can meaningfully appear in single function
624 body. We have either all counters in function local or global, otherwise
625 operations between them are not really defined well. */
626 bool compatible_p (const profile_count other
) const
628 if (!initialized_p () || !other
.initialized_p ())
630 if (*this == profile_count::zero ()
631 || other
== profile_count::zero ())
633 return ipa_p () == other
.ipa_p ();
637 /* Used for counters which are expected to be never executed. */
638 static profile_count
zero ()
640 return from_gcov_type (0);
642 static profile_count
adjusted_zero ()
646 c
.m_quality
= profile_adjusted
;
649 static profile_count
guessed_zero ()
653 c
.m_quality
= profile_guessed
;
656 static profile_count
one ()
658 return from_gcov_type (1);
660 /* Value of counters which has not been initialized. Either because
661 initialization did not happen yet or because profile is unknown. */
662 static profile_count
uninitialized ()
665 c
.m_val
= uninitialized_count
;
666 c
.m_quality
= profile_guessed_local
;
670 /* Conversion to gcov_type is lossy. */
671 gcov_type
to_gcov_type () const
673 gcc_checking_assert (initialized_p ());
677 /* Return true if value has been initialized. */
678 bool initialized_p () const
680 return m_val
!= uninitialized_count
;
682 /* Return true if value can be trusted. */
683 bool reliable_p () const
685 return m_quality
>= profile_adjusted
;
687 /* Return true if vlaue can be operated inter-procedurally. */
690 return !initialized_p () || m_quality
>= profile_guessed_global0
;
693 /* When merging basic blocks, the two different profile counts are unified.
694 Return true if this can be done without losing info about profile.
695 The only case we care about here is when first BB contains something
696 that makes it terminate in a way not visible in CFG. */
697 bool ok_for_merging (profile_count other
) const
699 if (m_quality
< profile_adjusted
700 || other
.m_quality
< profile_adjusted
)
702 return !(other
< *this);
705 /* When merging two BBs with different counts, pick common count that looks
706 most representative. */
707 profile_count
merge (profile_count other
) const
709 if (*this == other
|| !other
.initialized_p ()
710 || m_quality
> other
.m_quality
)
712 if (other
.m_quality
> m_quality
718 /* Basic operations. */
719 bool operator== (const profile_count
&other
) const
721 return m_val
== other
.m_val
&& m_quality
== other
.m_quality
;
723 profile_count
operator+ (const profile_count
&other
) const
725 if (other
== profile_count::zero ())
727 if (*this == profile_count::zero ())
729 if (!initialized_p () || !other
.initialized_p ())
730 return profile_count::uninitialized ();
733 gcc_checking_assert (compatible_p (other
));
734 ret
.m_val
= m_val
+ other
.m_val
;
735 ret
.m_quality
= MIN (m_quality
, other
.m_quality
);
738 profile_count
&operator+= (const profile_count
&other
)
740 if (other
== profile_count::zero ())
742 if (*this == profile_count::zero ())
747 if (!initialized_p () || !other
.initialized_p ())
748 return *this = profile_count::uninitialized ();
751 gcc_checking_assert (compatible_p (other
));
752 m_val
+= other
.m_val
;
753 m_quality
= MIN (m_quality
, other
.m_quality
);
757 profile_count
operator- (const profile_count
&other
) const
759 if (*this == profile_count::zero () || other
== profile_count::zero ())
761 if (!initialized_p () || !other
.initialized_p ())
762 return profile_count::uninitialized ();
763 gcc_checking_assert (compatible_p (other
));
765 ret
.m_val
= m_val
>= other
.m_val
? m_val
- other
.m_val
: 0;
766 ret
.m_quality
= MIN (m_quality
, other
.m_quality
);
769 profile_count
&operator-= (const profile_count
&other
)
771 if (*this == profile_count::zero () || other
== profile_count::zero ())
773 if (!initialized_p () || !other
.initialized_p ())
774 return *this = profile_count::uninitialized ();
777 gcc_checking_assert (compatible_p (other
));
778 m_val
= m_val
>= other
.m_val
? m_val
- other
.m_val
: 0;
779 m_quality
= MIN (m_quality
, other
.m_quality
);
784 /* Return false if profile_count is bogus. */
787 return m_val
!= uninitialized_count
|| m_quality
== profile_guessed_local
;
790 /* Comparsions are three-state and conservative. False is returned if
791 the inequality can not be decided. */
792 bool operator< (const profile_count
&other
) const
794 if (!initialized_p () || !other
.initialized_p ())
796 if (*this == profile_count::zero ())
797 return !(other
== profile_count::zero ());
798 if (other
== profile_count::zero ())
800 gcc_checking_assert (compatible_p (other
));
801 return m_val
< other
.m_val
;
803 bool operator> (const profile_count
&other
) const
805 if (!initialized_p () || !other
.initialized_p ())
807 if (*this == profile_count::zero ())
809 if (other
== profile_count::zero ())
810 return !(*this == profile_count::zero ());
811 gcc_checking_assert (compatible_p (other
));
812 return initialized_p () && other
.initialized_p () && m_val
> other
.m_val
;
814 bool operator< (const gcov_type other
) const
816 gcc_checking_assert (ipa_p ());
817 gcc_checking_assert (other
>= 0);
818 return initialized_p () && m_val
< (uint64_t) other
;
820 bool operator> (const gcov_type other
) const
822 gcc_checking_assert (ipa_p ());
823 gcc_checking_assert (other
>= 0);
824 return initialized_p () && m_val
> (uint64_t) other
;
827 bool operator<= (const profile_count
&other
) const
829 if (!initialized_p () || !other
.initialized_p ())
831 if (*this == profile_count::zero ())
833 if (other
== profile_count::zero ())
834 return (*this == profile_count::zero ());
835 gcc_checking_assert (compatible_p (other
));
836 return m_val
<= other
.m_val
;
838 bool operator>= (const profile_count
&other
) const
840 if (!initialized_p () || !other
.initialized_p ())
842 if (other
== profile_count::zero ())
844 if (*this == profile_count::zero ())
845 return !(other
== profile_count::zero ());
846 gcc_checking_assert (compatible_p (other
));
847 return m_val
>= other
.m_val
;
849 bool operator<= (const gcov_type other
) const
851 gcc_checking_assert (ipa_p ());
852 gcc_checking_assert (other
>= 0);
853 return initialized_p () && m_val
<= (uint64_t) other
;
855 bool operator>= (const gcov_type other
) const
857 gcc_checking_assert (ipa_p ());
858 gcc_checking_assert (other
>= 0);
859 return initialized_p () && m_val
>= (uint64_t) other
;
861 /* Return true when value is not zero and can be used for scaling.
862 This is different from *this > 0 because that requires counter to
864 bool nonzero_p () const
866 return initialized_p () && m_val
!= 0;
869 /* Make counter forcingly nonzero. */
870 profile_count
force_nonzero () const
872 if (!initialized_p ())
874 profile_count ret
= *this;
880 profile_count
max (profile_count other
) const
882 if (!initialized_p ())
884 if (!other
.initialized_p ())
886 if (*this == profile_count::zero ())
888 if (other
== profile_count::zero ())
890 gcc_checking_assert (compatible_p (other
));
891 if (m_val
< other
.m_val
|| (m_val
== other
.m_val
892 && m_quality
< other
.m_quality
))
897 /* PROB is a probability in scale 0...REG_BR_PROB_BASE. Scale counter
899 profile_count
apply_probability (int prob
) const
901 gcc_checking_assert (prob
>= 0 && prob
<= REG_BR_PROB_BASE
);
904 if (!initialized_p ())
905 return profile_count::uninitialized ();
907 ret
.m_val
= RDIV (m_val
* prob
, REG_BR_PROB_BASE
);
908 ret
.m_quality
= MIN (m_quality
, profile_adjusted
);
912 /* Scale counter according to PROB. */
913 profile_count
apply_probability (profile_probability prob
) const
915 if (*this == profile_count::zero ())
917 if (prob
== profile_probability::never ())
918 return profile_count::zero ();
919 if (!initialized_p ())
920 return profile_count::uninitialized ();
923 safe_scale_64bit (m_val
, prob
.m_val
, profile_probability::max_probability
,
926 ret
.m_quality
= MIN (m_quality
, prob
.m_quality
);
929 /* Return *THIS * NUM / DEN. */
930 profile_count
apply_scale (int64_t num
, int64_t den
) const
934 if (!initialized_p ())
935 return profile_count::uninitialized ();
939 gcc_checking_assert (num
>= 0 && den
> 0);
940 safe_scale_64bit (m_val
, num
, den
, &tmp
);
941 ret
.m_val
= MIN (tmp
, max_count
);
942 ret
.m_quality
= MIN (m_quality
, profile_adjusted
);
945 profile_count
apply_scale (profile_count num
, profile_count den
) const
947 if (*this == profile_count::zero ())
949 if (num
== profile_count::zero ())
951 if (!initialized_p () || !num
.initialized_p () || !den
.initialized_p ())
952 return profile_count::uninitialized ();
955 gcc_checking_assert (den
.m_val
);
959 safe_scale_64bit (m_val
, num
.m_val
, den
.m_val
, &val
);
960 ret
.m_val
= MIN (val
, max_count
);
961 ret
.m_quality
= MIN (MIN (MIN (m_quality
, profile_adjusted
),
962 num
.m_quality
), den
.m_quality
);
963 if (num
.ipa_p () && !ret
.ipa_p ())
964 ret
.m_quality
= MIN (num
.m_quality
, profile_guessed
);
968 /* Return THIS with quality dropped to GUESSED_LOCAL. */
969 profile_count
guessed_local () const
971 profile_count ret
= *this;
972 if (!initialized_p ())
974 ret
.m_quality
= profile_guessed_local
;
978 /* We know that profile is globally 0 but keep local profile if present. */
979 profile_count
global0 () const
981 profile_count ret
= *this;
982 if (!initialized_p ())
984 ret
.m_quality
= profile_guessed_global0
;
988 /* We know that profile is globally adjusted 0 but keep local profile
990 profile_count
global0adjusted () const
992 profile_count ret
= *this;
993 if (!initialized_p ())
995 ret
.m_quality
= profile_guessed_global0adjusted
;
999 /* Return THIS with quality dropped to GUESSED. */
1000 profile_count
guessed () const
1002 profile_count ret
= *this;
1003 ret
.m_quality
= MIN (ret
.m_quality
, profile_guessed
);
1007 /* Return variant of profile counte which is always safe to compare
1008 acorss functions. */
1009 profile_count
ipa () const
1011 if (m_quality
> profile_guessed_global0adjusted
)
1013 if (m_quality
== profile_guessed_global0
)
1014 return profile_count::zero ();
1015 if (m_quality
== profile_guessed_global0adjusted
)
1016 return profile_count::adjusted_zero ();
1017 return profile_count::uninitialized ();
1020 /* Return THIS with quality dropped to AFDO. */
1021 profile_count
afdo () const
1023 profile_count ret
= *this;
1024 ret
.m_quality
= profile_afdo
;
1028 /* Return probability of event with counter THIS within event with counter
1030 profile_probability
probability_in (const profile_count overall
) const
1032 if (*this == profile_count::zero ())
1033 return profile_probability::never ();
1034 if (!initialized_p () || !overall
.initialized_p ()
1036 return profile_probability::uninitialized ();
1037 profile_probability ret
;
1038 gcc_checking_assert (compatible_p (overall
));
1040 if (overall
.m_val
< m_val
)
1041 ret
.m_val
= profile_probability::max_probability
;
1043 ret
.m_val
= RDIV (m_val
* profile_probability::max_probability
,
1045 ret
.m_quality
= MAX (MIN (m_quality
, overall
.m_quality
), profile_guessed
);
1049 int to_frequency (struct function
*fun
) const;
1050 int to_cgraph_frequency (profile_count entry_bb_count
) const;
1051 sreal
to_sreal_scale (profile_count in
, bool *known
= NULL
) const;
1053 /* Output THIS to F. */
1054 void dump (FILE *f
) const;
1056 /* Print THIS to stderr. */
1057 void debug () const;
1059 /* Return true if THIS is known to differ significantly from OTHER. */
1060 bool differs_from_p (profile_count other
) const;
1062 /* We want to scale profile across function boundary from NUM to DEN.
1063 Take care of the side case when NUM and DEN are zeros of incompatible
1065 static void adjust_for_ipa_scaling (profile_count
*num
, profile_count
*den
);
1067 /* THIS is a count of bb which is known to be executed IPA times.
1068 Combine this information into bb counter. This means returning IPA
1069 if it is nonzero, not changing anything if IPA is uninitialized
1070 and if IPA is zero, turning THIS into corresponding local profile with
1072 profile_count
combine_with_ipa_count (profile_count ipa
);
1074 /* The profiling runtime uses gcov_type, which is usually 64bit integer.
1075 Conversions back and forth are used to read the coverage and get it
1076 into internal representation. */
1077 static profile_count
from_gcov_type (gcov_type v
);
1079 /* LTO streaming support. */
1080 static profile_count
stream_in (struct lto_input_block
*);
1081 void stream_out (struct output_block
*);
1082 void stream_out (struct lto_output_stream
*);