1/* Profile counter container type.
2 Copyright (C) 2017 Free Software Foundation, Inc.
3 Contributed by Jan Hubicka
4
5This file is part of GCC.
6
7GCC is free software; you can redistribute it and/or modify it under
8the terms of the GNU General Public License as published by the Free
9Software Foundation; either version 3, or (at your option) any later
10version.
11
12GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13WARRANTY; without even the implied warranty of MERCHANTABILITY or
14FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15for more details.
16
17You should have received a copy of the GNU General Public License
18along with GCC; see the file COPYING3. If not see
19<http://www.gnu.org/licenses/>. */
20
21#include "config.h"
22#include "system.h"
23#include "coretypes.h"
24#include "profile-count.h"
25#include "options.h"
26#include "tree.h"
27#include "basic-block.h"
28#include "cfg.h"
29#include "function.h"
30#include "gimple.h"
31#include "data-streamer.h"
32#include "cgraph.h"
33#include "wide-int.h"
34#include "sreal.h"
35
36/* Dump THIS to F. */
37
38void
39profile_count::dump (FILE *f) const
40{
41 if (!initialized_p ())
42 fprintf (f, "uninitialized");
43 else
44 {
45 fprintf (f, "%" PRId64, m_val);
46 if (m_quality == profile_guessed_local)
47 fprintf (f, " (estimated locally)");
48 else if (m_quality == profile_guessed_global0)
49 fprintf (f, " (estimated locally, globally 0)");
50 else if (m_quality == profile_guessed_global0adjusted)
51 fprintf (f, " (estimated locally, globally 0 adjusted)");
52 else if (m_quality == profile_adjusted)
53 fprintf (f, " (adjusted)");
54 else if (m_quality == profile_afdo)
55 fprintf (f, " (auto FDO)");
56 else if (m_quality == profile_guessed)
57 fprintf (f, " (guessed)");
58 }
59}
60
61/* Dump THIS to stderr. */
62
63void
64profile_count::debug () const
65{
66 dump (stderr);
67 fprintf (stderr, "\n");
68}
69
70/* Return true if THIS differs from OTHER; tolerate small diferences. */
71
72bool
73profile_count::differs_from_p (profile_count other) const
74{
75 gcc_checking_assert (compatible_p (other));
76 if (!initialized_p () || !other.initialized_p ())
77 return false;
78 if ((uint64_t)m_val - (uint64_t)other.m_val < 100
79 || (uint64_t)other.m_val - (uint64_t)m_val < 100)
80 return false;
81 if (!other.m_val)
82 return true;
83 int64_t ratio = (int64_t)m_val * 100 / other.m_val;
84 return ratio < 99 || ratio > 101;
85}
86
87/* Stream THIS from IB. */
88
89profile_count
90profile_count::stream_in (struct lto_input_block *ib)
91{
92 profile_count ret;
93 ret.m_val = streamer_read_gcov_count (ib);
94 ret.m_quality = (profile_quality) streamer_read_uhwi (ib);
95 return ret;
96}
97
98/* Stream THIS to OB. */
99
100void
101profile_count::stream_out (struct output_block *ob)
102{
103 streamer_write_gcov_count (ob, m_val);
104 streamer_write_uhwi (ob, m_quality);
105}
106
107/* Stream THIS to OB. */
108
109void
110profile_count::stream_out (struct lto_output_stream *ob)
111{
112 streamer_write_gcov_count_stream (ob, m_val);
113 streamer_write_uhwi_stream (ob, m_quality);
114}
115
116/* Dump THIS to F. */
117
118void
119profile_probability::dump (FILE *f) const
120{
121 if (!initialized_p ())
122 fprintf (f, "uninitialized");
123 else
124 {
125 /* Make difference between 0.00 as a roundoff error and actual 0.
126 Similarly for 1. */
127 if (m_val == 0)
128 fprintf (f, "never");
129 else if (m_val == max_probability)
130 fprintf (f, "always");
131 else
132 fprintf (f, "%3.1f%%", (double)m_val * 100 / max_probability);
133 if (m_quality == profile_adjusted)
134 fprintf (f, " (adjusted)");
135 else if (m_quality == profile_afdo)
136 fprintf (f, " (auto FDO)");
137 else if (m_quality == profile_guessed)
138 fprintf (f, " (guessed)");
139 }
140}
141
142/* Dump THIS to stderr. */
143
144void
145profile_probability::debug () const
146{
147 dump (stderr);
148 fprintf (stderr, "\n");
149}
150
151/* Return true if THIS differs from OTHER; tolerate small diferences. */
152
153bool
154profile_probability::differs_from_p (profile_probability other) const
155{
156 if (!initialized_p () || !other.initialized_p ())
157 return false;
158 if ((uint64_t)m_val - (uint64_t)other.m_val < max_probability / 1000
159 || (uint64_t)other.m_val - (uint64_t)max_probability < 1000)
160 return false;
161 if (!other.m_val)
162 return true;
163 int64_t ratio = (int64_t)m_val * 100 / other.m_val;
164 return ratio < 99 || ratio > 101;
165}
166
167/* Return true if THIS differs significantly from OTHER. */
168
169bool
170profile_probability::differs_lot_from_p (profile_probability other) const
171{
172 if (!initialized_p () || !other.initialized_p ())
173 return false;
174 uint32_t d = m_val > other.m_val ? m_val - other.m_val : other.m_val - m_val;
175 return d > max_probability / 2;
176}
177
178/* Stream THIS from IB. */
179
180profile_probability
181profile_probability::stream_in (struct lto_input_block *ib)
182{
183 profile_probability ret;
184 ret.m_val = streamer_read_uhwi (ib);
185 ret.m_quality = (profile_quality) streamer_read_uhwi (ib);
186 return ret;
187}
188
189/* Stream THIS to OB. */
190
191void
192profile_probability::stream_out (struct output_block *ob)
193{
194 streamer_write_uhwi (ob, m_val);
195 streamer_write_uhwi (ob, m_quality);
196}
197
198/* Stream THIS to OB. */
199
200void
201profile_probability::stream_out (struct lto_output_stream *ob)
202{
203 streamer_write_uhwi_stream (ob, m_val);
204 streamer_write_uhwi_stream (ob, m_quality);
205}
206
207/* Compute RES=(a*b + c/2)/c capping and return false if overflow happened. */
208
209bool
210slow_safe_scale_64bit (uint64_t a, uint64_t b, uint64_t c, uint64_t *res)
211{
212 FIXED_WIDE_INT (128) tmp = a;
213 bool overflow;
214 tmp = wi::udiv_floor (wi::umul (tmp, b, &overflow) + (c / 2), c);
215 gcc_checking_assert (!overflow);
216 if (wi::fits_uhwi_p (tmp))
217 {
218 *res = tmp.to_uhwi ();
219 return true;
220 }
221 *res = (uint64_t) -1;
222 return false;
223}
224
225/* Return count as frequency within FUN scaled in range 0 to REG_FREQ_MAX
226 Used for legacy code and should not be used anymore. */
227
228int
229profile_count::to_frequency (struct function *fun) const
230{
231 if (!initialized_p ())
232 return BB_FREQ_MAX;
233 if (*this == profile_count::zero ())
234 return 0;
235 gcc_assert (REG_BR_PROB_BASE == BB_FREQ_MAX
236 && fun->cfg->count_max.initialized_p ());
237 profile_probability prob = probability_in (fun->cfg->count_max);
238 if (!prob.initialized_p ())
239 return REG_BR_PROB_BASE;
240 return prob.to_reg_br_prob_base ();
241}
242
243/* Return count as frequency within FUN scaled in range 0 to CGRAPH_FREQ_MAX
244 where CGRAPH_FREQ_BASE means that count equals to entry block count.
245 Used for legacy code and should not be used anymore. */
246
247int
248profile_count::to_cgraph_frequency (profile_count entry_bb_count) const
249{
250 if (!initialized_p () || !entry_bb_count.initialized_p ())
251 return CGRAPH_FREQ_BASE;
252 if (*this == profile_count::zero ())
253 return 0;
254 gcc_checking_assert (entry_bb_count.initialized_p ());
255 uint64_t scale;
256 if (!safe_scale_64bit (!entry_bb_count.m_val ? m_val + 1 : m_val,
257 CGRAPH_FREQ_BASE, MAX (1, entry_bb_count.m_val), &scale))
258 return CGRAPH_FREQ_MAX;
259 return MIN (scale, CGRAPH_FREQ_MAX);
260}
261
262/* Return THIS/IN as sreal value. */
263
264sreal
265profile_count::to_sreal_scale (profile_count in, bool *known) const
266{
267 if (!initialized_p () || !in.initialized_p ())
268 {
269 if (known)
270 *known = false;
271 return 1;
272 }
273 if (known)
274 *known = true;
275 if (*this == profile_count::zero ())
276 return 0;
277
278 if (!in.m_val)
279 {
280 if (!m_val)
281 return 1;
282 return m_val * 4;
283 }
284 return (sreal)m_val / (sreal)in.m_val;
285}
286
287/* We want to scale profile across function boundary from NUM to DEN.
288 Take care of the side case when DEN is zeros. We still want to behave
289 sanely here which means
290 - scale to profile_count::zero () if NUM is profile_count::zero
291 - do not affect anything if NUM == DEN
292 - preserve counter value but adjust quality in other cases. */
293
294void
295profile_count::adjust_for_ipa_scaling (profile_count *num,
296 profile_count *den)
297{
298 /* Scaling is no-op if NUM and DEN are the same. */
299 if (*num == *den)
300 return;
301 /* Scaling to zero is always zero. */
302 if (*num == profile_count::zero ())
303 return;
304 /* If den is non-zero we are safe. */
305 if (den->force_nonzero () == *den)
306 return;
307 /* Force both to non-zero so we do not push profiles to 0 when
308 both num == 0 and den == 0. */
309 *den = den->force_nonzero ();
310 *num = num->force_nonzero ();
311}
312
313/* THIS is a count of bb which is known to be executed IPA times.
314 Combine this information into bb counter. This means returning IPA
315 if it is nonzero, not changing anything if IPA is uninitialized
316 and if IPA is zero, turning THIS into corresponding local profile with
317 global0. */
318profile_count
319profile_count::combine_with_ipa_count (profile_count ipa)
320{
321 ipa = ipa.ipa ();
322 if (ipa.nonzero_p ())
323 return ipa;
324 if (!ipa.initialized_p ())
325 return *this;
326 if (ipa == profile_count::zero ())
327 return this->global0 ();
328 return this->global0adjusted ();
329}
330
331/* The profiling runtime uses gcov_type, which is usually 64bit integer.
332 Conversions back and forth are used to read the coverage and get it
333 into internal representation. */
334profile_count
335profile_count::from_gcov_type (gcov_type v)
336 {
337 profile_count ret;
338 gcc_checking_assert (v >= 0);
339 if (dump_file && v >= (gcov_type)max_count)
340 fprintf (dump_file,
341 "Capping gcov count %" PRId64 " to max_count %" PRId64 "\n",
342 (int64_t) v, (int64_t) max_count);
343 ret.m_val = MIN (v, (gcov_type)max_count);
344 ret.m_quality = profile_precise;
345 return ret;
346 }
347
348