testsuite: remove SPE tests.
[official-gcc.git] / gcc / profile-count.h
blob014f597986d09bf07edf0152709e081ceb7b9da6
1 /* Profile counter container type.
2 Copyright (C) 2017-2020 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;
25 struct profile_count;
26 class sreal;
28 /* Quality of the profile count. Because gengtype does not support enums
29 inside of classes, this is in global namespace. */
30 enum profile_quality {
31 /* Uninitialized value. */
32 UNINITIALIZED_PROFILE,
34 /* Profile is based on static branch prediction heuristics and may
35 or may not match reality. It is local to function and cannot be compared
36 inter-procedurally. Never used by probabilities (they are always local).
38 GUESSED_LOCAL,
40 /* Profile was read by feedback and was 0, we used local heuristics to guess
41 better. This is the case of functions not run in profile feedback.
42 Never used by probabilities. */
43 GUESSED_GLOBAL0,
45 /* Same as GUESSED_GLOBAL0 but global count is adjusted 0. */
46 GUESSED_GLOBAL0_ADJUSTED,
48 /* Profile is based on static branch prediction heuristics. It may or may
49 not reflect the reality but it can be compared interprocedurally
50 (for example, we inlined function w/o profile feedback into function
51 with feedback and propagated from that).
52 Never used by probabilities. */
53 GUESSED,
55 /* Profile was determined by autofdo. */
56 AFDO,
58 /* Profile was originally based on feedback but it was adjusted
59 by code duplicating optimization. It may not precisely reflect the
60 particular code path. */
61 ADJUSTED,
63 /* Profile was read from profile feedback or determined by accurate static
64 method. */
65 PRECISE
68 extern const char *profile_quality_as_string (enum profile_quality);
69 extern bool parse_profile_quality (const char *value,
70 profile_quality *quality);
72 /* The base value for branch probability notes and edge probabilities. */
73 #define REG_BR_PROB_BASE 10000
75 #define RDIV(X,Y) (((X) + (Y) / 2) / (Y))
77 bool slow_safe_scale_64bit (uint64_t a, uint64_t b, uint64_t c, uint64_t *res);
79 /* Compute RES=(a*b + c/2)/c capping and return false if overflow happened. */
81 inline bool
82 safe_scale_64bit (uint64_t a, uint64_t b, uint64_t c, uint64_t *res)
84 #if (GCC_VERSION >= 5000)
85 uint64_t tmp;
86 if (!__builtin_mul_overflow (a, b, &tmp)
87 && !__builtin_add_overflow (tmp, c/2, &tmp))
89 *res = tmp / c;
90 return true;
92 if (c == 1)
94 *res = (uint64_t) -1;
95 return false;
97 #else
98 if (a < ((uint64_t)1 << 31)
99 && b < ((uint64_t)1 << 31)
100 && c < ((uint64_t)1 << 31))
102 *res = (a * b + (c / 2)) / c;
103 return true;
105 #endif
106 return slow_safe_scale_64bit (a, b, c, res);
109 /* Data type to hold probabilities. It implements fixed point arithmetics
110 with capping so probability is always in range [0,1] and scaling requiring
111 values greater than 1 needs to be represented otherwise.
113 In addition to actual value the quality of profile is tracked and propagated
114 through all operations. Special value UNINITIALIZED_PROFILE is used for probabilities
115 that has not been determined yet (for example because of
116 -fno-guess-branch-probability)
118 Typically probabilities are derived from profile feedback (via
119 probability_in_gcov_type), autoFDO or guessed statically and then propagated
120 thorough the compilation.
122 Named probabilities are available:
123 - never (0 probability)
124 - guessed_never
125 - very_unlikely (1/2000 probability)
126 - unlikely (1/5 probability)
127 - even (1/2 probability)
128 - likely (4/5 probability)
129 - very_likely (1999/2000 probability)
130 - guessed_always
131 - always
133 Named probabilities except for never/always are assumed to be statically
134 guessed and thus not necessarily accurate. The difference between never
135 and guessed_never is that the first one should be used only in case that
136 well behaving program will very likely not execute the "never" path.
137 For example if the path is going to abort () call or it exception handling.
139 Always and guessed_always probabilities are symmetric.
141 For legacy code we support conversion to/from REG_BR_PROB_BASE based fixpoint
142 integer arithmetics. Once the code is converted to branch probabilities,
143 these conversions will probably go away because they are lossy.
146 class GTY((user)) profile_probability
148 static const int n_bits = 29;
149 /* We can technically use ((uint32_t) 1 << (n_bits - 1)) - 2 but that
150 will lead to harder multiplication sequences. */
151 static const uint32_t max_probability = (uint32_t) 1 << (n_bits - 2);
152 static const uint32_t uninitialized_probability
153 = ((uint32_t) 1 << (n_bits - 1)) - 1;
155 uint32_t m_val : 29;
156 enum profile_quality m_quality : 3;
158 friend struct profile_count;
159 public:
160 profile_probability (): m_val (uninitialized_probability),
161 m_quality (GUESSED)
164 profile_probability (uint32_t val, profile_quality quality):
165 m_val (val), m_quality (quality)
168 /* Named probabilities. */
169 static profile_probability never ()
171 profile_probability ret;
172 ret.m_val = 0;
173 ret.m_quality = PRECISE;
174 return ret;
177 static profile_probability guessed_never ()
179 profile_probability ret;
180 ret.m_val = 0;
181 ret.m_quality = GUESSED;
182 return ret;
185 static profile_probability very_unlikely ()
187 /* Be consistent with PROB_VERY_UNLIKELY in predict.h. */
188 profile_probability r = guessed_always ().apply_scale (1, 2000);
189 r.m_val--;
190 return r;
193 static profile_probability unlikely ()
195 /* Be consistent with PROB_VERY_LIKELY in predict.h. */
196 profile_probability r = guessed_always ().apply_scale (1, 5);
197 r.m_val--;
198 return r;
201 static profile_probability even ()
203 return guessed_always ().apply_scale (1, 2);
206 static profile_probability very_likely ()
208 return always () - very_unlikely ();
211 static profile_probability likely ()
213 return always () - unlikely ();
216 static profile_probability guessed_always ()
218 profile_probability ret;
219 ret.m_val = max_probability;
220 ret.m_quality = GUESSED;
221 return ret;
224 static profile_probability always ()
226 profile_probability ret;
227 ret.m_val = max_probability;
228 ret.m_quality = PRECISE;
229 return ret;
232 /* Probabilities which has not been initialized. Either because
233 initialization did not happen yet or because profile is unknown. */
234 static profile_probability uninitialized ()
236 profile_probability c;
237 c.m_val = uninitialized_probability;
238 c.m_quality = GUESSED;
239 return c;
242 /* Return true if value has been initialized. */
243 bool initialized_p () const
245 return m_val != uninitialized_probability;
248 /* Return true if value can be trusted. */
249 bool reliable_p () const
251 return m_quality >= ADJUSTED;
254 /* Conversion from and to REG_BR_PROB_BASE integer fixpoint arithmetics.
255 this is mostly to support legacy code and should go away. */
256 static profile_probability from_reg_br_prob_base (int v)
258 profile_probability ret;
259 gcc_checking_assert (v >= 0 && v <= REG_BR_PROB_BASE);
260 ret.m_val = RDIV (v * (uint64_t) max_probability, REG_BR_PROB_BASE);
261 ret.m_quality = GUESSED;
262 return ret;
265 /* Return THIS with quality set to ADJUSTED. */
266 profile_probability adjusted () const
268 profile_probability ret = *this;
269 if (!initialized_p ())
270 return *this;
271 ret.m_quality = ADJUSTED;
272 return ret;
275 int to_reg_br_prob_base () const
277 gcc_checking_assert (initialized_p ());
278 return RDIV (m_val * (uint64_t) REG_BR_PROB_BASE, max_probability);
281 /* Conversion to and from RTL representation of profile probabilities. */
282 static profile_probability from_reg_br_prob_note (int v)
284 profile_probability ret;
285 ret.m_val = ((unsigned int)v) / 8;
286 ret.m_quality = (enum profile_quality)(v & 7);
287 return ret;
290 int to_reg_br_prob_note () const
292 gcc_checking_assert (initialized_p ());
293 int ret = m_val * 8 + m_quality;
294 gcc_checking_assert (from_reg_br_prob_note (ret) == *this);
295 return ret;
298 /* Return VAL1/VAL2. */
299 static profile_probability probability_in_gcov_type
300 (gcov_type val1, gcov_type val2)
302 profile_probability ret;
303 gcc_checking_assert (val1 >= 0 && val2 > 0);
304 if (val1 > val2)
305 ret.m_val = max_probability;
306 else
308 uint64_t tmp;
309 safe_scale_64bit (val1, max_probability, val2, &tmp);
310 gcc_checking_assert (tmp <= max_probability);
311 ret.m_val = tmp;
313 ret.m_quality = PRECISE;
314 return ret;
317 /* Basic operations. */
318 bool operator== (const profile_probability &other) const
320 return m_val == other.m_val && m_quality == other.m_quality;
323 profile_probability operator+ (const profile_probability &other) const
325 if (other == never ())
326 return *this;
327 if (*this == never ())
328 return other;
329 if (!initialized_p () || !other.initialized_p ())
330 return uninitialized ();
332 profile_probability ret;
333 ret.m_val = MIN ((uint32_t)(m_val + other.m_val), max_probability);
334 ret.m_quality = MIN (m_quality, other.m_quality);
335 return ret;
338 profile_probability &operator+= (const profile_probability &other)
340 if (other == never ())
341 return *this;
342 if (*this == never ())
344 *this = other;
345 return *this;
347 if (!initialized_p () || !other.initialized_p ())
348 return *this = uninitialized ();
349 else
351 m_val = MIN ((uint32_t)(m_val + other.m_val), max_probability);
352 m_quality = MIN (m_quality, other.m_quality);
354 return *this;
357 profile_probability operator- (const profile_probability &other) const
359 if (*this == never ()
360 || other == never ())
361 return *this;
362 if (!initialized_p () || !other.initialized_p ())
363 return uninitialized ();
364 profile_probability ret;
365 ret.m_val = m_val >= other.m_val ? m_val - other.m_val : 0;
366 ret.m_quality = MIN (m_quality, other.m_quality);
367 return ret;
370 profile_probability &operator-= (const profile_probability &other)
372 if (*this == never ()
373 || other == never ())
374 return *this;
375 if (!initialized_p () || !other.initialized_p ())
376 return *this = uninitialized ();
377 else
379 m_val = m_val >= other.m_val ? m_val - other.m_val : 0;
380 m_quality = MIN (m_quality, other.m_quality);
382 return *this;
385 profile_probability operator* (const profile_probability &other) const
387 if (*this == never ()
388 || other == never ())
389 return never ();
390 if (!initialized_p () || !other.initialized_p ())
391 return uninitialized ();
392 profile_probability ret;
393 ret.m_val = RDIV ((uint64_t)m_val * other.m_val, max_probability);
394 ret.m_quality = MIN (MIN (m_quality, other.m_quality), ADJUSTED);
395 return ret;
398 profile_probability &operator*= (const profile_probability &other)
400 if (*this == never ()
401 || other == never ())
402 return *this = never ();
403 if (!initialized_p () || !other.initialized_p ())
404 return *this = uninitialized ();
405 else
407 m_val = RDIV ((uint64_t)m_val * other.m_val, max_probability);
408 m_quality = MIN (MIN (m_quality, other.m_quality), ADJUSTED);
410 return *this;
413 profile_probability operator/ (const profile_probability &other) const
415 if (*this == never ())
416 return never ();
417 if (!initialized_p () || !other.initialized_p ())
418 return uninitialized ();
419 profile_probability ret;
420 /* If we get probability above 1, mark it as unreliable and return 1. */
421 if (m_val >= other.m_val)
423 ret.m_val = max_probability;
424 ret.m_quality = MIN (MIN (m_quality, other.m_quality),
425 GUESSED);
426 return ret;
428 else if (!m_val)
429 ret.m_val = 0;
430 else
432 gcc_checking_assert (other.m_val);
433 ret.m_val = MIN (RDIV ((uint64_t)m_val * max_probability,
434 other.m_val),
435 max_probability);
437 ret.m_quality = MIN (MIN (m_quality, other.m_quality), ADJUSTED);
438 return ret;
441 profile_probability &operator/= (const profile_probability &other)
443 if (*this == never ())
444 return *this = never ();
445 if (!initialized_p () || !other.initialized_p ())
446 return *this = uninitialized ();
447 else
449 /* If we get probability above 1, mark it as unreliable
450 and return 1. */
451 if (m_val > other.m_val)
453 m_val = max_probability;
454 m_quality = MIN (MIN (m_quality, other.m_quality),
455 GUESSED);
456 return *this;
458 else if (!m_val)
460 else
462 gcc_checking_assert (other.m_val);
463 m_val = MIN (RDIV ((uint64_t)m_val * max_probability,
464 other.m_val),
465 max_probability);
467 m_quality = MIN (MIN (m_quality, other.m_quality), ADJUSTED);
469 return *this;
472 /* Split *THIS (ORIG) probability into 2 probabilities, such that
473 the returned one (FIRST) is *THIS * CPROB and *THIS is
474 adjusted (SECOND) so that FIRST + FIRST.invert () * SECOND
475 == ORIG. This is useful e.g. when splitting a conditional
476 branch like:
477 if (cond)
478 goto lab; // ORIG probability
479 into
480 if (cond1)
481 goto lab; // FIRST = ORIG * CPROB probability
482 if (cond2)
483 goto lab; // SECOND probability
484 such that the overall probability of jumping to lab remains
485 the same. CPROB gives the relative probability between the
486 branches. */
487 profile_probability split (const profile_probability &cprob)
489 profile_probability ret = *this * cprob;
490 /* The following is equivalent to:
491 *this = cprob.invert () * *this / ret.invert ();
492 Avoid scaling when overall outcome is supposed to be always.
493 Without knowing that one is inverse of other, the result would be
494 conservative. */
495 if (!(*this == always ()))
496 *this = (*this - ret) / ret.invert ();
497 return ret;
500 gcov_type apply (gcov_type val) const
502 if (*this == uninitialized ())
503 return val / 2;
504 return RDIV (val * m_val, max_probability);
507 /* Return 1-*THIS. */
508 profile_probability invert () const
510 return always() - *this;
513 /* Return THIS with quality dropped to GUESSED. */
514 profile_probability guessed () const
516 profile_probability ret = *this;
517 ret.m_quality = GUESSED;
518 return ret;
521 /* Return THIS with quality dropped to AFDO. */
522 profile_probability afdo () const
524 profile_probability ret = *this;
525 ret.m_quality = AFDO;
526 return ret;
529 /* Return *THIS * NUM / DEN. */
530 profile_probability apply_scale (int64_t num, int64_t den) const
532 if (*this == never ())
533 return *this;
534 if (!initialized_p ())
535 return uninitialized ();
536 profile_probability ret;
537 uint64_t tmp;
538 safe_scale_64bit (m_val, num, den, &tmp);
539 ret.m_val = MIN (tmp, max_probability);
540 ret.m_quality = MIN (m_quality, ADJUSTED);
541 return ret;
544 /* Return true when the probability of edge is reliable.
546 The profile guessing code is good at predicting branch outcome (i.e.
547 taken/not taken), that is predicted right slightly over 75% of time.
548 It is however notoriously poor on predicting the probability itself.
549 In general the profile appear a lot flatter (with probabilities closer
550 to 50%) than the reality so it is bad idea to use it to drive optimization
551 such as those disabling dynamic branch prediction for well predictable
552 branches.
554 There are two exceptions - edges leading to noreturn edges and edges
555 predicted by number of iterations heuristics are predicted well. This macro
556 should be able to distinguish those, but at the moment it simply check for
557 noreturn heuristic that is only one giving probability over 99% or bellow
558 1%. In future we might want to propagate reliability information across the
559 CFG if we find this information useful on multiple places. */
560 bool probably_reliable_p () const
562 if (m_quality >= ADJUSTED)
563 return true;
564 if (!initialized_p ())
565 return false;
566 return m_val < max_probability / 100
567 || m_val > max_probability - max_probability / 100;
570 /* Return false if profile_probability is bogus. */
571 bool verify () const
573 gcc_checking_assert (m_quality != UNINITIALIZED_PROFILE);
574 if (m_val == uninitialized_probability)
575 return m_quality == GUESSED;
576 else if (m_quality < GUESSED)
577 return false;
578 return m_val <= max_probability;
581 /* Comparisons are three-state and conservative. False is returned if
582 the inequality cannot be decided. */
583 bool operator< (const profile_probability &other) const
585 return initialized_p () && other.initialized_p () && m_val < other.m_val;
588 bool operator> (const profile_probability &other) const
590 return initialized_p () && other.initialized_p () && m_val > other.m_val;
593 bool operator<= (const profile_probability &other) const
595 return initialized_p () && other.initialized_p () && m_val <= other.m_val;
598 bool operator>= (const profile_probability &other) const
600 return initialized_p () && other.initialized_p () && m_val >= other.m_val;
603 /* Get the value of the count. */
604 uint32_t value () const { return m_val; }
606 /* Get the quality of the count. */
607 enum profile_quality quality () const { return m_quality; }
609 /* Output THIS to F. */
610 void dump (FILE *f) const;
612 /* Print THIS to stderr. */
613 void debug () const;
615 /* Return true if THIS is known to differ significantly from OTHER. */
616 bool differs_from_p (profile_probability other) const;
618 /* Return if difference is greater than 50%. */
619 bool differs_lot_from_p (profile_probability other) const;
621 /* COUNT1 times event happens with *THIS probability, COUNT2 times OTHER
622 happens with COUNT2 probability. Return probability that either *THIS or
623 OTHER happens. */
624 profile_probability combine_with_count (profile_count count1,
625 profile_probability other,
626 profile_count count2) const;
628 /* Return probability as sreal. */
629 sreal to_sreal () const;
630 /* LTO streaming support. */
631 static profile_probability stream_in (class lto_input_block *);
632 void stream_out (struct output_block *);
633 void stream_out (struct lto_output_stream *);
636 /* Main data type to hold profile counters in GCC. Profile counts originate
637 either from profile feedback, static profile estimation or both. We do not
638 perform whole program profile propagation and thus profile estimation
639 counters are often local to function, while counters from profile feedback
640 (or special cases of profile estimation) can be used inter-procedurally.
642 There are 3 basic types
643 1) local counters which are result of intra-procedural static profile
644 estimation.
645 2) ipa counters which are result of profile feedback or special case
646 of static profile estimation (such as in function main).
647 3) counters which counts as 0 inter-procedurally (because given function
648 was never run in train feedback) but they hold local static profile
649 estimate.
651 Counters of type 1 and 3 cannot be mixed with counters of different type
652 within operation (because whole function should use one type of counter)
653 with exception that global zero mix in most operations where outcome is
654 well defined.
656 To take local counter and use it inter-procedurally use ipa member function
657 which strips information irrelevant at the inter-procedural level.
659 Counters are 61bit integers representing number of executions during the
660 train run or normalized frequency within the function.
662 As the profile is maintained during the compilation, many adjustments are
663 made. Not all transformations can be made precisely, most importantly
664 when code is being duplicated. It also may happen that part of CFG has
665 profile counts known while other do not - for example when LTO optimizing
666 partly profiled program or when profile was lost due to COMDAT merging.
668 For this reason profile_count tracks more information than
669 just unsigned integer and it is also ready for profile mismatches.
670 The API of this data type represent operations that are natural
671 on profile counts - sum, difference and operation with scales and
672 probabilities. All operations are safe by never getting negative counts
673 and they do end up in uninitialized scale if any of the parameters is
674 uninitialized.
676 All comparisons that are three state and handling of probabilities. Thus
677 a < b is not equal to !(a >= b).
679 The following pre-defined counts are available:
681 profile_count::zero () for code that is known to execute zero times at
682 runtime (this can be detected statically i.e. for paths leading to
683 abort ();
684 profile_count::one () for code that is known to execute once (such as
685 main () function
686 profile_count::uninitialized () for unknown execution count.
690 struct GTY(()) profile_count
692 public:
693 /* Use 62bit to hold basic block counters. Should be at least
694 64bit. Although a counter cannot be negative, we use a signed
695 type to hold various extra stages. */
697 static const int n_bits = 61;
698 static const uint64_t max_count = ((uint64_t) 1 << n_bits) - 2;
699 private:
700 static const uint64_t uninitialized_count = ((uint64_t) 1 << n_bits) - 1;
702 #if defined (__arm__) && (__GNUC__ >= 6 && __GNUC__ <= 8)
703 /* Work-around for PR88469. A bug in the gcc-6/7/8 PCS layout code
704 incorrectly detects the alignment of a structure where the only
705 64-bit aligned object is a bit-field. We force the alignment of
706 the entire field to mitigate this. */
707 #define UINT64_BIT_FIELD_ALIGN __attribute__ ((aligned(8)))
708 #else
709 #define UINT64_BIT_FIELD_ALIGN
710 #endif
711 uint64_t UINT64_BIT_FIELD_ALIGN m_val : n_bits;
712 #undef UINT64_BIT_FIELD_ALIGN
713 enum profile_quality m_quality : 3;
714 public:
716 /* Return true if both values can meaningfully appear in single function
717 body. We have either all counters in function local or global, otherwise
718 operations between them are not really defined well. */
719 bool compatible_p (const profile_count other) const
721 if (!initialized_p () || !other.initialized_p ())
722 return true;
723 if (*this == zero ()
724 || other == zero ())
725 return true;
726 /* Do not allow nonzero global profile together with local guesses
727 that are globally0. */
728 if (ipa ().nonzero_p ()
729 && !(other.ipa () == other))
730 return false;
731 if (other.ipa ().nonzero_p ()
732 && !(ipa () == *this))
733 return false;
735 return ipa_p () == other.ipa_p ();
738 /* Used for counters which are expected to be never executed. */
739 static profile_count zero ()
741 return from_gcov_type (0);
744 static profile_count adjusted_zero ()
746 profile_count c;
747 c.m_val = 0;
748 c.m_quality = ADJUSTED;
749 return c;
752 static profile_count guessed_zero ()
754 profile_count c;
755 c.m_val = 0;
756 c.m_quality = GUESSED;
757 return c;
760 static profile_count one ()
762 return from_gcov_type (1);
765 /* Value of counters which has not been initialized. Either because
766 initialization did not happen yet or because profile is unknown. */
767 static profile_count uninitialized ()
769 profile_count c;
770 c.m_val = uninitialized_count;
771 c.m_quality = GUESSED_LOCAL;
772 return c;
775 /* Conversion to gcov_type is lossy. */
776 gcov_type to_gcov_type () const
778 gcc_checking_assert (initialized_p ());
779 return m_val;
782 /* Return true if value has been initialized. */
783 bool initialized_p () const
785 return m_val != uninitialized_count;
788 /* Return true if value can be trusted. */
789 bool reliable_p () const
791 return m_quality >= ADJUSTED;
794 /* Return true if value can be operated inter-procedurally. */
795 bool ipa_p () const
797 return !initialized_p () || m_quality >= GUESSED_GLOBAL0;
800 /* Return true if quality of profile is precise. */
801 bool precise_p () const
803 return m_quality == PRECISE;
806 /* Get the value of the count. */
807 uint32_t value () const { return m_val; }
809 /* Get the quality of the count. */
810 enum profile_quality quality () const { return m_quality; }
812 /* When merging basic blocks, the two different profile counts are unified.
813 Return true if this can be done without losing info about profile.
814 The only case we care about here is when first BB contains something
815 that makes it terminate in a way not visible in CFG. */
816 bool ok_for_merging (profile_count other) const
818 if (m_quality < ADJUSTED
819 || other.m_quality < ADJUSTED)
820 return true;
821 return !(other < *this);
824 /* When merging two BBs with different counts, pick common count that looks
825 most representative. */
826 profile_count merge (profile_count other) const
828 if (*this == other || !other.initialized_p ()
829 || m_quality > other.m_quality)
830 return *this;
831 if (other.m_quality > m_quality
832 || other > *this)
833 return other;
834 return *this;
837 /* Basic operations. */
838 bool operator== (const profile_count &other) const
840 return m_val == other.m_val && m_quality == other.m_quality;
843 profile_count operator+ (const profile_count &other) const
845 if (other == zero ())
846 return *this;
847 if (*this == zero ())
848 return other;
849 if (!initialized_p () || !other.initialized_p ())
850 return uninitialized ();
852 profile_count ret;
853 gcc_checking_assert (compatible_p (other));
854 ret.m_val = m_val + other.m_val;
855 ret.m_quality = MIN (m_quality, other.m_quality);
856 return ret;
859 profile_count &operator+= (const profile_count &other)
861 if (other == zero ())
862 return *this;
863 if (*this == zero ())
865 *this = other;
866 return *this;
868 if (!initialized_p () || !other.initialized_p ())
869 return *this = uninitialized ();
870 else
872 gcc_checking_assert (compatible_p (other));
873 m_val += other.m_val;
874 m_quality = MIN (m_quality, other.m_quality);
876 return *this;
879 profile_count operator- (const profile_count &other) const
881 if (*this == zero () || other == zero ())
882 return *this;
883 if (!initialized_p () || !other.initialized_p ())
884 return uninitialized ();
885 gcc_checking_assert (compatible_p (other));
886 profile_count ret;
887 ret.m_val = m_val >= other.m_val ? m_val - other.m_val : 0;
888 ret.m_quality = MIN (m_quality, other.m_quality);
889 return ret;
892 profile_count &operator-= (const profile_count &other)
894 if (*this == zero () || other == zero ())
895 return *this;
896 if (!initialized_p () || !other.initialized_p ())
897 return *this = uninitialized ();
898 else
900 gcc_checking_assert (compatible_p (other));
901 m_val = m_val >= other.m_val ? m_val - other.m_val: 0;
902 m_quality = MIN (m_quality, other.m_quality);
904 return *this;
907 /* Return false if profile_count is bogus. */
908 bool verify () const
910 gcc_checking_assert (m_quality != UNINITIALIZED_PROFILE);
911 return m_val != uninitialized_count || m_quality == GUESSED_LOCAL;
914 /* Comparisons are three-state and conservative. False is returned if
915 the inequality cannot be decided. */
916 bool operator< (const profile_count &other) const
918 if (!initialized_p () || !other.initialized_p ())
919 return false;
920 if (*this == zero ())
921 return !(other == zero ());
922 if (other == zero ())
923 return false;
924 gcc_checking_assert (compatible_p (other));
925 return m_val < other.m_val;
928 bool operator> (const profile_count &other) const
930 if (!initialized_p () || !other.initialized_p ())
931 return false;
932 if (*this == zero ())
933 return false;
934 if (other == zero ())
935 return !(*this == zero ());
936 gcc_checking_assert (compatible_p (other));
937 return initialized_p () && other.initialized_p () && m_val > other.m_val;
940 bool operator< (const gcov_type other) const
942 gcc_checking_assert (ipa_p ());
943 gcc_checking_assert (other >= 0);
944 return ipa ().initialized_p () && ipa ().m_val < (uint64_t) other;
947 bool operator> (const gcov_type other) const
949 gcc_checking_assert (ipa_p ());
950 gcc_checking_assert (other >= 0);
951 return ipa ().initialized_p () && ipa ().m_val > (uint64_t) other;
954 bool operator<= (const profile_count &other) const
956 if (!initialized_p () || !other.initialized_p ())
957 return false;
958 if (*this == zero ())
959 return true;
960 if (other == zero ())
961 return (*this == zero ());
962 gcc_checking_assert (compatible_p (other));
963 return m_val <= other.m_val;
966 bool operator>= (const profile_count &other) const
968 if (!initialized_p () || !other.initialized_p ())
969 return false;
970 if (other == zero ())
971 return true;
972 if (*this == zero ())
973 return (other == zero ());
974 gcc_checking_assert (compatible_p (other));
975 return m_val >= other.m_val;
978 bool operator<= (const gcov_type other) const
980 gcc_checking_assert (ipa_p ());
981 gcc_checking_assert (other >= 0);
982 return ipa ().initialized_p () && ipa ().m_val <= (uint64_t) other;
985 bool operator>= (const gcov_type other) const
987 gcc_checking_assert (ipa_p ());
988 gcc_checking_assert (other >= 0);
989 return ipa ().initialized_p () && ipa ().m_val >= (uint64_t) other;
992 /* Return true when value is not zero and can be used for scaling.
993 This is different from *this > 0 because that requires counter to
994 be IPA. */
995 bool nonzero_p () const
997 return initialized_p () && m_val != 0;
1000 /* Make counter forcibly nonzero. */
1001 profile_count force_nonzero () const
1003 if (!initialized_p ())
1004 return *this;
1005 profile_count ret = *this;
1006 if (ret.m_val == 0)
1008 ret.m_val = 1;
1009 ret.m_quality = MIN (m_quality, ADJUSTED);
1011 return ret;
1014 profile_count max (profile_count other) const
1016 profile_count val = *this;
1018 /* Always prefer nonzero IPA counts over local counts. */
1019 if (ipa ().nonzero_p () || other.ipa ().nonzero_p ())
1021 val = ipa ();
1022 other = other.ipa ();
1024 if (!initialized_p ())
1025 return other;
1026 if (!other.initialized_p ())
1027 return *this;
1028 if (*this == zero ())
1029 return other;
1030 if (other == zero ())
1031 return *this;
1032 gcc_checking_assert (compatible_p (other));
1033 if (val.m_val < other.m_val || (m_val == other.m_val
1034 && val.m_quality < other.m_quality))
1035 return other;
1036 return *this;
1039 /* PROB is a probability in scale 0...REG_BR_PROB_BASE. Scale counter
1040 accordingly. */
1041 profile_count apply_probability (int prob) const
1043 gcc_checking_assert (prob >= 0 && prob <= REG_BR_PROB_BASE);
1044 if (m_val == 0)
1045 return *this;
1046 if (!initialized_p ())
1047 return uninitialized ();
1048 profile_count ret;
1049 ret.m_val = RDIV (m_val * prob, REG_BR_PROB_BASE);
1050 ret.m_quality = MIN (m_quality, ADJUSTED);
1051 return ret;
1054 /* Scale counter according to PROB. */
1055 profile_count apply_probability (profile_probability prob) const
1057 if (*this == zero ())
1058 return *this;
1059 if (prob == profile_probability::never ())
1060 return zero ();
1061 if (!initialized_p ())
1062 return uninitialized ();
1063 profile_count ret;
1064 uint64_t tmp;
1065 safe_scale_64bit (m_val, prob.m_val, profile_probability::max_probability,
1066 &tmp);
1067 ret.m_val = tmp;
1068 ret.m_quality = MIN (m_quality, prob.m_quality);
1069 return ret;
1072 /* Return *THIS * NUM / DEN. */
1073 profile_count apply_scale (int64_t num, int64_t den) const
1075 if (m_val == 0)
1076 return *this;
1077 if (!initialized_p ())
1078 return uninitialized ();
1079 profile_count ret;
1080 uint64_t tmp;
1082 gcc_checking_assert (num >= 0 && den > 0);
1083 safe_scale_64bit (m_val, num, den, &tmp);
1084 ret.m_val = MIN (tmp, max_count);
1085 ret.m_quality = MIN (m_quality, ADJUSTED);
1086 return ret;
1089 profile_count apply_scale (profile_count num, profile_count den) const
1091 if (*this == zero ())
1092 return *this;
1093 if (num == zero ())
1094 return num;
1095 if (!initialized_p () || !num.initialized_p () || !den.initialized_p ())
1096 return uninitialized ();
1097 if (num == den)
1098 return *this;
1099 gcc_checking_assert (den.m_val);
1101 profile_count ret;
1102 uint64_t val;
1103 safe_scale_64bit (m_val, num.m_val, den.m_val, &val);
1104 ret.m_val = MIN (val, max_count);
1105 ret.m_quality = MIN (MIN (MIN (m_quality, ADJUSTED),
1106 num.m_quality), den.m_quality);
1107 /* Be sure that ret is not local if num is global.
1108 Also ensure that ret is not global0 when num is global. */
1109 if (num.ipa_p ())
1110 ret.m_quality = MAX (ret.m_quality,
1111 num == num.ipa () ? GUESSED : num.m_quality);
1112 return ret;
1115 /* Return THIS with quality dropped to GUESSED_LOCAL. */
1116 profile_count guessed_local () const
1118 profile_count ret = *this;
1119 if (!initialized_p ())
1120 return *this;
1121 ret.m_quality = GUESSED_LOCAL;
1122 return ret;
1125 /* We know that profile is globally 0 but keep local profile if present. */
1126 profile_count global0 () const
1128 profile_count ret = *this;
1129 if (!initialized_p ())
1130 return *this;
1131 ret.m_quality = GUESSED_GLOBAL0;
1132 return ret;
1135 /* We know that profile is globally adjusted 0 but keep local profile
1136 if present. */
1137 profile_count global0adjusted () const
1139 profile_count ret = *this;
1140 if (!initialized_p ())
1141 return *this;
1142 ret.m_quality = GUESSED_GLOBAL0_ADJUSTED;
1143 return ret;
1146 /* Return THIS with quality dropped to GUESSED. */
1147 profile_count guessed () const
1149 profile_count ret = *this;
1150 ret.m_quality = MIN (ret.m_quality, GUESSED);
1151 return ret;
1154 /* Return variant of profile count which is always safe to compare
1155 across functions. */
1156 profile_count ipa () const
1158 if (m_quality > GUESSED_GLOBAL0_ADJUSTED)
1159 return *this;
1160 if (m_quality == GUESSED_GLOBAL0)
1161 return zero ();
1162 if (m_quality == GUESSED_GLOBAL0_ADJUSTED)
1163 return adjusted_zero ();
1164 return uninitialized ();
1167 /* Return THIS with quality dropped to AFDO. */
1168 profile_count afdo () const
1170 profile_count ret = *this;
1171 ret.m_quality = AFDO;
1172 return ret;
1175 /* Return probability of event with counter THIS within event with counter
1176 OVERALL. */
1177 profile_probability probability_in (const profile_count overall) const
1179 if (*this == zero ()
1180 && !(overall == zero ()))
1181 return profile_probability::never ();
1182 if (!initialized_p () || !overall.initialized_p ()
1183 || !overall.m_val)
1184 return profile_probability::uninitialized ();
1185 if (*this == overall && m_quality == PRECISE)
1186 return profile_probability::always ();
1187 profile_probability ret;
1188 gcc_checking_assert (compatible_p (overall));
1190 if (overall.m_val < m_val)
1192 ret.m_val = profile_probability::max_probability;
1193 ret.m_quality = GUESSED;
1194 return ret;
1196 else
1197 ret.m_val = RDIV (m_val * profile_probability::max_probability,
1198 overall.m_val);
1199 ret.m_quality = MIN (MAX (MIN (m_quality, overall.m_quality),
1200 GUESSED), ADJUSTED);
1201 return ret;
1204 int to_frequency (struct function *fun) const;
1205 int to_cgraph_frequency (profile_count entry_bb_count) const;
1206 sreal to_sreal_scale (profile_count in, bool *known = NULL) const;
1208 /* Output THIS to F. */
1209 void dump (FILE *f) const;
1211 /* Print THIS to stderr. */
1212 void debug () const;
1214 /* Return true if THIS is known to differ significantly from OTHER. */
1215 bool differs_from_p (profile_count other) const;
1217 /* We want to scale profile across function boundary from NUM to DEN.
1218 Take care of the side case when NUM and DEN are zeros of incompatible
1219 kinds. */
1220 static void adjust_for_ipa_scaling (profile_count *num, profile_count *den);
1222 /* THIS is a count of bb which is known to be executed IPA times.
1223 Combine this information into bb counter. This means returning IPA
1224 if it is nonzero, not changing anything if IPA is uninitialized
1225 and if IPA is zero, turning THIS into corresponding local profile with
1226 global0. */
1227 profile_count combine_with_ipa_count (profile_count ipa);
1229 /* Same as combine_with_ipa_count but inside function with count IPA2. */
1230 profile_count combine_with_ipa_count_within
1231 (profile_count ipa, profile_count ipa2);
1233 /* The profiling runtime uses gcov_type, which is usually 64bit integer.
1234 Conversions back and forth are used to read the coverage and get it
1235 into internal representation. */
1236 static profile_count from_gcov_type (gcov_type v,
1237 profile_quality quality = PRECISE);
1239 /* LTO streaming support. */
1240 static profile_count stream_in (class lto_input_block *);
1241 void stream_out (struct output_block *);
1242 void stream_out (struct lto_output_stream *);
1244 #endif