* cgraphclones.c (cgraph_edge::clone): Rename gcov_count to prof_count.
[official-gcc.git] / gcc / profile-count.h
blob2ffa33f639c6ad6be9d1285f010b79c349000bb3
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
10 version.
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
15 for more details.
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
24 struct function;
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. */
47 profile_guessed = 3,
48 /* Profile was determined by autofdo. */
49 profile_afdo = 4,
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. */
53 profile_adjusted = 5,
54 /* Profile was read from profile feedback or determined by accurate static
55 method. */
56 profile_precise = 7
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. */
68 inline bool
69 safe_scale_64bit (uint64_t a, uint64_t b, uint64_t c, uint64_t *res)
71 #if (GCC_VERSION >= 5000)
72 uint64_t tmp;
73 if (!__builtin_mul_overflow (a, b, &tmp)
74 && !__builtin_add_overflow (tmp, c/2, &tmp))
76 *res = tmp / c;
77 return true;
79 if (c == 1)
81 *res = (uint64_t) -1;
82 return false;
84 #else
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;
90 return true;
92 #endif
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)
111 - guessed_never
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)
117 - guessed_always
118 - always
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;
142 uint32_t m_val : 29;
143 enum profile_quality m_quality : 3;
145 friend class profile_count;
146 public:
148 /* Named probabilities. */
149 static profile_probability never ()
151 profile_probability ret;
152 ret.m_val = 0;
153 ret.m_quality = profile_precise;
154 return ret;
156 static profile_probability guessed_never ()
158 profile_probability ret;
159 ret.m_val = 0;
160 ret.m_quality = profile_guessed;
161 return ret;
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);
168 r.m_val--;
169 return r;
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);
176 r.m_val--;
177 return r;
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;
196 return ret;
198 static profile_probability always ()
200 profile_probability ret;
201 ret.m_val = max_probability;
202 ret.m_quality = profile_precise;
203 return ret;
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;
212 return c;
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;
235 return ret;
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);
249 return ret;
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)
256 == *this);
257 return 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);
266 if (val1 > val2)
267 ret.m_val = max_probability;
268 else
270 uint64_t tmp;
271 safe_scale_64bit (val1, max_probability, val2, &tmp);
272 gcc_checking_assert (tmp <= max_probability);
273 ret.m_val = tmp;
275 ret.m_quality = profile_precise;
276 return ret;
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 ())
287 return *this;
288 if (*this == profile_probability::never ())
289 return other;
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);
296 return ret;
298 profile_probability &operator+= (const profile_probability &other)
300 if (other == profile_probability::never ())
301 return *this;
302 if (*this == profile_probability::never ())
304 *this = other;
305 return *this;
307 if (!initialized_p () || !other.initialized_p ())
308 return *this = profile_probability::uninitialized ();
309 else
311 m_val = MIN ((uint32_t)(m_val + other.m_val), max_probability);
312 m_quality = MIN (m_quality, other.m_quality);
314 return *this;
316 profile_probability operator- (const profile_probability &other) const
318 if (*this == profile_probability::never ()
319 || other == profile_probability::never ())
320 return *this;
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);
326 return ret;
328 profile_probability &operator-= (const profile_probability &other)
330 if (*this == profile_probability::never ()
331 || other == profile_probability::never ())
332 return *this;
333 if (!initialized_p () || !other.initialized_p ())
334 return *this = profile_probability::uninitialized ();
335 else
337 m_val = m_val >= other.m_val ? m_val - other.m_val : 0;
338 m_quality = MIN (m_quality, other.m_quality);
340 return *this;
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);
352 return ret;
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 ();
361 else
363 m_val = RDIV ((uint64_t)m_val * other.m_val, max_probability);
364 m_quality = MIN (m_quality, other.m_quality);
366 return *this;
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;
377 else if (!m_val)
378 ret.m_val = 0;
379 else
381 gcc_checking_assert (other.m_val);
382 ret.m_val = MIN (RDIV ((uint64_t)m_val * max_probability,
383 other.m_val),
384 max_probability);
386 ret.m_quality = MIN (m_quality, other.m_quality);
387 return ret;
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 ();
395 else
397 if (m_val > other.m_val)
398 m_val = max_probability;
399 else if (!m_val)
401 else
403 gcc_checking_assert (other.m_val);
404 m_val = MIN (RDIV ((uint64_t)m_val * max_probability,
405 other.m_val),
406 max_probability);
408 m_quality = MIN (m_quality, other.m_quality);
410 return *this;
413 gcov_type apply (gcov_type val) const
415 if (*this == profile_probability::uninitialized ())
416 return val / 2;
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;
431 return ret;
434 /* Return THIS with quality dropped to AFDO. */
435 profile_probability afdo () const
437 profile_probability ret = *this;
438 ret.m_quality = profile_afdo;
439 return ret;
442 profile_probability combine_with_freq (int freq1, profile_probability other,
443 int freq2) const
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;
456 else
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);
460 return ret;
463 /* Return *THIS * NUM / DEN. */
464 profile_probability apply_scale (int64_t num, int64_t den) const
466 if (*this == profile_probability::never ())
467 return *this;
468 if (!initialized_p ())
469 return profile_probability::uninitialized ();
470 profile_probability ret;
471 uint64_t tmp;
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);
475 return ret;
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
486 branches.
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)
498 return true;
499 if (!initialized_p ())
500 return false;
501 return m_val < max_probability / 100
502 || m_val > max_probability - max_probability / 100;
505 /* Return false if profile_probability is bogus. */
506 bool verify () const
508 if (m_val == uninitialized_probability)
509 return m_quality == profile_guessed;
510 else if (m_quality < profile_guessed)
511 return false;
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. */
539 void debug () const;
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
560 estimation.
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
565 estimate.
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
570 well defined.
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
590 uninitialized.
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
599 abort ();
600 profile_count::one () for code that is known to execute once (such as
601 main () function
602 profile_count::uninitialized () for unknown execution count.
606 class sreal;
608 class GTY(()) profile_count
610 public:
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;
616 private:
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 ())
629 return true;
630 if (*this == profile_count::zero ()
631 || other == profile_count::zero ())
632 return true;
633 return ipa_p () == other.ipa_p ();
635 public:
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 ()
644 profile_count c;
645 c.m_val = 0;
646 c.m_quality = profile_adjusted;
647 return c;
649 static profile_count guessed_zero ()
651 profile_count c;
652 c.m_val = 0;
653 c.m_quality = profile_guessed;
654 return c;
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 ()
664 profile_count c;
665 c.m_val = uninitialized_count;
666 c.m_quality = profile_guessed_local;
667 return c;
670 /* The profiling runtime uses gcov_type, which is usually 64bit integer.
671 Conversions back and forth are used to read the coverage and get it
672 into internal representation. */
673 static profile_count from_gcov_type (gcov_type v)
675 profile_count ret;
676 gcc_checking_assert (v >= 0 && (uint64_t) v <= max_count);
677 ret.m_val = v;
678 ret.m_quality = profile_precise;
679 return ret;
682 /* Conversion to gcov_type is lossy. */
683 gcov_type to_gcov_type () const
685 gcc_checking_assert (initialized_p ());
686 return m_val;
689 /* Return true if value has been initialized. */
690 bool initialized_p () const
692 return m_val != uninitialized_count;
694 /* Return true if value can be trusted. */
695 bool reliable_p () const
697 return m_quality >= profile_adjusted;
699 /* Return true if vlaue can be operated inter-procedurally. */
700 bool ipa_p () const
702 return !initialized_p () || m_quality >= profile_guessed_global0;
705 /* When merging basic blocks, the two different profile counts are unified.
706 Return true if this can be done without losing info about profile.
707 The only case we care about here is when first BB contains something
708 that makes it terminate in a way not visible in CFG. */
709 bool ok_for_merging (profile_count other) const
711 if (m_quality < profile_adjusted
712 || other.m_quality < profile_adjusted)
713 return true;
714 return !(other < *this);
717 /* When merging two BBs with different counts, pick common count that looks
718 most representative. */
719 profile_count merge (profile_count other) const
721 if (*this == other || !other.initialized_p ()
722 || m_quality > other.m_quality)
723 return *this;
724 if (other.m_quality > m_quality
725 || other > *this)
726 return other;
727 return *this;
730 /* Basic operations. */
731 bool operator== (const profile_count &other) const
733 return m_val == other.m_val && m_quality == other.m_quality;
735 profile_count operator+ (const profile_count &other) const
737 if (other == profile_count::zero ())
738 return *this;
739 if (*this == profile_count::zero ())
740 return other;
741 if (!initialized_p () || !other.initialized_p ())
742 return profile_count::uninitialized ();
744 profile_count ret;
745 gcc_checking_assert (compatible_p (other));
746 ret.m_val = m_val + other.m_val;
747 ret.m_quality = MIN (m_quality, other.m_quality);
748 return ret;
750 profile_count &operator+= (const profile_count &other)
752 if (other == profile_count::zero ())
753 return *this;
754 if (*this == profile_count::zero ())
756 *this = other;
757 return *this;
759 if (!initialized_p () || !other.initialized_p ())
760 return *this = profile_count::uninitialized ();
761 else
763 gcc_checking_assert (compatible_p (other));
764 m_val += other.m_val;
765 m_quality = MIN (m_quality, other.m_quality);
767 return *this;
769 profile_count operator- (const profile_count &other) const
771 if (*this == profile_count::zero () || other == profile_count::zero ())
772 return *this;
773 if (!initialized_p () || !other.initialized_p ())
774 return profile_count::uninitialized ();
775 gcc_checking_assert (compatible_p (other));
776 profile_count ret;
777 ret.m_val = m_val >= other.m_val ? m_val - other.m_val : 0;
778 ret.m_quality = MIN (m_quality, other.m_quality);
779 return ret;
781 profile_count &operator-= (const profile_count &other)
783 if (*this == profile_count::zero () || other == profile_count::zero ())
784 return *this;
785 if (!initialized_p () || !other.initialized_p ())
786 return *this = profile_count::uninitialized ();
787 else
789 gcc_checking_assert (compatible_p (other));
790 m_val = m_val >= other.m_val ? m_val - other.m_val: 0;
791 m_quality = MIN (m_quality, other.m_quality);
793 return *this;
796 /* Return false if profile_count is bogus. */
797 bool verify () const
799 return m_val != uninitialized_count || m_quality == profile_guessed_local;
802 /* Comparsions are three-state and conservative. False is returned if
803 the inequality can not be decided. */
804 bool operator< (const profile_count &other) const
806 if (!initialized_p () || !other.initialized_p ())
807 return false;
808 if (*this == profile_count::zero ())
809 return !(other == profile_count::zero ());
810 if (other == profile_count::zero ())
811 return false;
812 gcc_checking_assert (compatible_p (other));
813 return m_val < other.m_val;
815 bool operator> (const profile_count &other) const
817 if (!initialized_p () || !other.initialized_p ())
818 return false;
819 if (*this == profile_count::zero ())
820 return false;
821 if (other == profile_count::zero ())
822 return !(*this == profile_count::zero ());
823 gcc_checking_assert (compatible_p (other));
824 return initialized_p () && other.initialized_p () && m_val > other.m_val;
826 bool operator< (const gcov_type other) const
828 gcc_checking_assert (ipa_p ());
829 gcc_checking_assert (other >= 0);
830 return initialized_p () && m_val < (uint64_t) other;
832 bool operator> (const gcov_type other) const
834 gcc_checking_assert (ipa_p ());
835 gcc_checking_assert (other >= 0);
836 return initialized_p () && m_val > (uint64_t) other;
839 bool operator<= (const profile_count &other) const
841 if (!initialized_p () || !other.initialized_p ())
842 return false;
843 if (*this == profile_count::zero ())
844 return true;
845 if (other == profile_count::zero ())
846 return (*this == profile_count::zero ());
847 gcc_checking_assert (compatible_p (other));
848 return m_val <= other.m_val;
850 bool operator>= (const profile_count &other) const
852 if (!initialized_p () || !other.initialized_p ())
853 return false;
854 if (other == profile_count::zero ())
855 return true;
856 if (*this == profile_count::zero ())
857 return !(other == profile_count::zero ());
858 gcc_checking_assert (compatible_p (other));
859 return m_val >= other.m_val;
861 bool operator<= (const gcov_type other) const
863 gcc_checking_assert (ipa_p ());
864 gcc_checking_assert (other >= 0);
865 return initialized_p () && m_val <= (uint64_t) other;
867 bool operator>= (const gcov_type other) const
869 gcc_checking_assert (ipa_p ());
870 gcc_checking_assert (other >= 0);
871 return initialized_p () && m_val >= (uint64_t) other;
873 /* Return true when value is not zero and can be used for scaling.
874 This is different from *this > 0 because that requires counter to
875 be IPA. */
876 bool nonzero_p () const
878 return initialized_p () && m_val != 0;
881 /* Make counter forcingly nonzero. */
882 profile_count force_nonzero () const
884 if (!initialized_p ())
885 return *this;
886 profile_count ret = *this;
887 if (ret.m_val == 0)
888 ret.m_val = 1;
889 return ret;
892 profile_count max (profile_count other) const
894 if (!initialized_p ())
895 return other;
896 if (!other.initialized_p ())
897 return *this;
898 if (*this == profile_count::zero ())
899 return other;
900 if (other == profile_count::zero ())
901 return *this;
902 gcc_checking_assert (compatible_p (other));
903 if (m_val < other.m_val || (m_val == other.m_val
904 && m_quality < other.m_quality))
905 return other;
906 return *this;
909 /* PROB is a probability in scale 0...REG_BR_PROB_BASE. Scale counter
910 accordingly. */
911 profile_count apply_probability (int prob) const
913 gcc_checking_assert (prob >= 0 && prob <= REG_BR_PROB_BASE);
914 if (m_val == 0)
915 return *this;
916 if (!initialized_p ())
917 return profile_count::uninitialized ();
918 profile_count ret;
919 ret.m_val = RDIV (m_val * prob, REG_BR_PROB_BASE);
920 ret.m_quality = MIN (m_quality, profile_adjusted);
921 return ret;
924 /* Scale counter according to PROB. */
925 profile_count apply_probability (profile_probability prob) const
927 if (*this == profile_count::zero ())
928 return *this;
929 if (prob == profile_probability::never ())
930 return profile_count::zero ();
931 if (!initialized_p ())
932 return profile_count::uninitialized ();
933 profile_count ret;
934 uint64_t tmp;
935 safe_scale_64bit (m_val, prob.m_val, profile_probability::max_probability,
936 &tmp);
937 ret.m_val = tmp;
938 ret.m_quality = MIN (m_quality, prob.m_quality);
939 return ret;
941 /* Return *THIS * NUM / DEN. */
942 profile_count apply_scale (int64_t num, int64_t den) const
944 if (m_val == 0)
945 return *this;
946 if (!initialized_p ())
947 return profile_count::uninitialized ();
948 profile_count ret;
949 uint64_t tmp;
951 gcc_checking_assert (num >= 0 && den > 0);
952 safe_scale_64bit (m_val, num, den, &tmp);
953 ret.m_val = MIN (tmp, max_count);
954 ret.m_quality = MIN (m_quality, profile_adjusted);
955 return ret;
957 profile_count apply_scale (profile_count num, profile_count den) const
959 if (*this == profile_count::zero ())
960 return *this;
961 if (num == profile_count::zero ())
962 return num;
963 if (!initialized_p () || !num.initialized_p () || !den.initialized_p ())
964 return profile_count::uninitialized ();
965 if (num == den)
966 return *this;
967 gcc_checking_assert (den.m_val);
969 profile_count ret;
970 uint64_t val;
971 safe_scale_64bit (m_val, num.m_val, den.m_val, &val);
972 ret.m_val = MIN (val, max_count);
973 ret.m_quality = MIN (MIN (MIN (m_quality, profile_adjusted),
974 num.m_quality), den.m_quality);
975 if (num.ipa_p () && !ret.ipa_p ())
976 ret.m_quality = MIN (num.m_quality, profile_guessed);
977 return ret;
980 /* Return THIS with quality dropped to GUESSED_LOCAL. */
981 profile_count guessed_local () const
983 profile_count ret = *this;
984 if (!initialized_p ())
985 return *this;
986 ret.m_quality = profile_guessed_local;
987 return ret;
990 /* We know that profile is globally 0 but keep local profile if present. */
991 profile_count global0 () const
993 profile_count ret = *this;
994 if (!initialized_p ())
995 return *this;
996 ret.m_quality = profile_guessed_global0;
997 return ret;
1000 /* We know that profile is globally adjusted 0 but keep local profile
1001 if present. */
1002 profile_count global0adjusted () const
1004 profile_count ret = *this;
1005 if (!initialized_p ())
1006 return *this;
1007 ret.m_quality = profile_guessed_global0adjusted;
1008 return ret;
1011 /* Return THIS with quality dropped to GUESSED. */
1012 profile_count guessed () const
1014 profile_count ret = *this;
1015 ret.m_quality = MIN (ret.m_quality, profile_guessed);
1016 return ret;
1019 /* Return variant of profile counte which is always safe to compare
1020 acorss functions. */
1021 profile_count ipa () const
1023 if (m_quality > profile_guessed_global0adjusted)
1024 return *this;
1025 if (m_quality == profile_guessed_global0)
1026 return profile_count::zero ();
1027 if (m_quality == profile_guessed_global0adjusted)
1028 return profile_count::adjusted_zero ();
1029 return profile_count::uninitialized ();
1032 /* Return THIS with quality dropped to AFDO. */
1033 profile_count afdo () const
1035 profile_count ret = *this;
1036 ret.m_quality = profile_afdo;
1037 return ret;
1040 /* Return probability of event with counter THIS within event with counter
1041 OVERALL. */
1042 profile_probability probability_in (const profile_count overall) const
1044 if (*this == profile_count::zero ())
1045 return profile_probability::never ();
1046 if (!initialized_p () || !overall.initialized_p ()
1047 || !overall.m_val)
1048 return profile_probability::uninitialized ();
1049 profile_probability ret;
1050 gcc_checking_assert (compatible_p (overall));
1052 if (overall.m_val < m_val)
1053 ret.m_val = profile_probability::max_probability;
1054 else
1055 ret.m_val = RDIV (m_val * profile_probability::max_probability,
1056 overall.m_val);
1057 ret.m_quality = MAX (MIN (m_quality, overall.m_quality), profile_guessed);
1058 return ret;
1061 int to_frequency (struct function *fun) const;
1062 int to_cgraph_frequency (profile_count entry_bb_count) const;
1063 sreal to_sreal_scale (profile_count in, bool *known = NULL) const;
1065 /* Output THIS to F. */
1066 void dump (FILE *f) const;
1068 /* Print THIS to stderr. */
1069 void debug () const;
1071 /* Return true if THIS is known to differ significantly from OTHER. */
1072 bool differs_from_p (profile_count other) const;
1074 /* We want to scale profile across function boundary from NUM to DEN.
1075 Take care of the side case when NUM and DEN are zeros of incompatible
1076 kinds. */
1077 static void adjust_for_ipa_scaling (profile_count *num, profile_count *den);
1079 /* THIS is a count of bb which is known to be executed IPA times.
1080 Combine this information into bb counter. This means returning IPA
1081 if it is nonzero, not changing anything if IPA is uninitialized
1082 and if IPA is zero, turning THIS into corresponding local profile with
1083 global0. */
1084 profile_count combine_with_ipa_count (profile_count ipa);
1086 /* LTO streaming support. */
1087 static profile_count stream_in (struct lto_input_block *);
1088 void stream_out (struct output_block *);
1089 void stream_out (struct lto_output_stream *);
1091 #endif