/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/data-streamer.h

Bug Summary

File:	build/gcc/data-streamer.h
Warning:	line 126, column 19 The result of the left shift is undefined because the right operand is negative

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-suse-linux -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name value-prof.cc -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model static -mframe-pointer=none -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/buildworker/marxinbox-gcc-clang-static-analyzer/objdir/gcc -resource-dir /usr/lib64/clang/15.0.7 -D IN_GCC -D HAVE_CONFIG_H -I . -I . -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/. -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../include -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libcpp/include -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libcody -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libdecnumber -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libdecnumber/bid -I ../libdecnumber -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libbacktrace -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/13/../../../../include/c++/13 -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/13/../../../../include/c++/13/x86_64-suse-linux -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/13/../../../../include/c++/13/backward -internal-isystem /usr/lib64/clang/15.0.7/include -internal-isystem /usr/local/include -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/13/../../../../x86_64-suse-linux/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-narrowing -Wwrite-strings -Wno-long-long -Wno-variadic-macros -Wno-overlength-strings -fdeprecated-macro -fdebug-compilation-dir=/buildworker/marxinbox-gcc-clang-static-analyzer/objdir/gcc -ferror-limit 19 -fno-rtti -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -analyzer-output=plist-html -analyzer-config silence-checkers=core.NullDereference -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /buildworker/marxinbox-gcc-clang-static-analyzer/objdir/clang-static-analyzer/2023-03-27-141847-20772-1/report-PBZeCw.plist -x c++ /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/value-prof.cc

/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/value-prof.cc

→

1/* Transformations based on profile information for values.
 Copyright (C) 2003-2023 Free Software Foundation, Inc.

4This file is part of GCC.

6GCC is free software; you can redistribute it and/or modify it under
7the terms of the GNU General Public License as published by the Free
8Software Foundation; either version 3, or (at your option) any later
9version.

11GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12WARRANTY; without even the implied warranty of MERCHANTABILITY or
13FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
14for more details.

16You should have received a copy of the GNU General Public License
17along with GCC; see the file COPYING3.  If not see
18<http://www.gnu.org/licenses/>.  */

20#include "config.h"
21#include "system.h"
22#include "coretypes.h"
23#include "backend.h"
24#include "rtl.h"
25#include "tree.h"
26#include "gimple.h"
27#include "cfghooks.h"
28#include "ssa.h"
29#include "cgraph.h"
30#include "coverage.h"
31#include "data-streamer.h"
32#include "diagnostic.h"
33#include "fold-const.h"
34#include "tree-nested.h"
35#include "calls.h"
36#include "expr.h"
37#include "value-prof.h"
38#include "tree-eh.h"
39#include "gimplify.h"
40#include "gimple-iterator.h"
41#include "tree-cfg.h"
42#include "gimple-pretty-print.h"
43#include "dumpfile.h"
44#include "builtins.h"

46/* In this file value profile based optimizations are placed.  Currently the
 following optimizations are implemented (for more detailed descriptions
 see comments at value_profile_transformations):

 1) Division/modulo specialization.  Provided that we can determine that the
    operands of the division have some special properties, we may use it to
    produce more effective code.

 2) Indirect/virtual call specialization. If we can determine most
    common function callee in indirect/virtual call. We can use this
    information to improve code effectiveness (especially info for
    the inliner).

 3) Speculative prefetching.  If we are able to determine that the difference
    between addresses accessed by a memory reference is usually constant, we
    may add the prefetch instructions.
    FIXME: This transformation was removed together with RTL based value
    profiling.


 Value profiling internals
 ==========================

 Every value profiling transformation starts with defining what values
 to profile.  There are different histogram types (see HIST_TYPE_* in
 value-prof.h) and each transformation can request one or more histogram
 types per GIMPLE statement.  The function gimple_find_values_to_profile()
 collects the values to profile in a vec, and adds the number of counters
 required for the different histogram types.

 For a -fprofile-generate run, the statements for which values should be
 recorded, are instrumented in instrument_values().  The instrumentation
 is done by helper functions that can be found in tree-profile.cc, where
 new types of histograms can be added if necessary.

 After a -fprofile-use, the value profiling data is read back in by
 compute_value_histograms() that translates the collected data to
 histograms and attaches them to the profiled statements via
 gimple_add_histogram_value().  Histograms are stored in a hash table
 that is attached to every intrumented function, see VALUE_HISTOGRAMS
 in function.h.
 
 The value-profile transformations driver is the function
 gimple_value_profile_transformations().  It traverses all statements in
 the to-be-transformed function, and looks for statements with one or
 more histograms attached to it.  If a statement has histograms, the
 transformation functions are called on the statement.

 Limitations / FIXME / TODO:
 * Only one histogram of each type can be associated with a statement.
 * Some value profile transformations are done in builtins.cc (?!)
 * Updating of histograms needs some TLC.
 * The value profiling code could be used to record analysis results
   from non-profiling (e.g. VRP).
 * Adding new profilers should be simplified, starting with a cleanup
   of what-happens-where and with making gimple_find_values_to_profile
   and gimple_value_profile_transformations table-driven, perhaps...
103*/

105static bool gimple_divmod_fixed_value_transform (gimple_stmt_iterator *);
106static bool gimple_mod_pow2_value_transform (gimple_stmt_iterator *);
107static bool gimple_mod_subtract_transform (gimple_stmt_iterator *);
108static bool gimple_stringops_transform (gimple_stmt_iterator *);
109static void dump_ic_profile (gimple_stmt_iterator *gsi);

111/* Allocate histogram value.  */

113histogram_value
114gimple_alloc_histogram_value (struct function *fun ATTRIBUTE_UNUSED__attribute__ ((__unused__)),
	      enum hist_type type, gimple *stmt, tree value)
116{
 histogram_value hist = (histogram_value) xcalloc (1, sizeof (*hist));
 hist->hvalue.value = value;
 hist->hvalue.stmt = stmt;
 hist->type = type;
 return hist;
122}

124/* Hash value for histogram.  */

126static hashval_t
127histogram_hash (const void *x)
128{
return htab_hash_pointer (((const_histogram_value)x)->hvalue.stmt);
130}

132/* Return nonzero if statement for histogram_value X is Y.  */

134static int
135histogram_eq (const void *x, const void *y)
136{
return ((const_histogram_value) x)->hvalue.stmt == (const gimple *) y;
138}

140/* Set histogram for STMT.  */

142static void
143set_histogram_value (struct function *fun, gimple *stmt, histogram_value hist)
144{
void **loc;
if (!hist && !VALUE_HISTOGRAMS (fun)(fun)->value_histograms)
  return;
if (!VALUE_HISTOGRAMS (fun)(fun)->value_histograms)
  VALUE_HISTOGRAMS (fun)(fun)->value_histograms = htab_create (1, histogram_hash,
		           histogram_eq, NULLnullptr);
loc = htab_find_slot_with_hash (VALUE_HISTOGRAMS (fun)(fun)->value_histograms, stmt,
                                htab_hash_pointer (stmt),
		  hist ? INSERT : NO_INSERT);
if (!hist)
  {
    if (loc)
htab_clear_slot (VALUE_HISTOGRAMS (fun)(fun)->value_histograms, loc);
    return;
  }
*loc = hist;
161}

163/* Get histogram list for STMT.  */

165histogram_value
166gimple_histogram_value (struct function *fun, gimple *stmt)
167{
if (!VALUE_HISTOGRAMS (fun)(fun)->value_histograms)
  return NULLnullptr;
return (histogram_value) htab_find_with_hash (VALUE_HISTOGRAMS (fun)(fun)->value_histograms, stmt,
				htab_hash_pointer (stmt));
172}

174/* Add histogram for STMT.  */

176void
177gimple_add_histogram_value (struct function *fun, gimple *stmt,
	    histogram_value hist)
179{
hist->hvalue.next = gimple_histogram_value (fun, stmt);
set_histogram_value (fun, stmt, hist);
hist->fun = fun;
183}

185/* Remove histogram HIST from STMT's histogram list.  */

187void
188gimple_remove_histogram_value (struct function *fun, gimple *stmt,
	       histogram_value hist)
190{
histogram_value hist2 = gimple_histogram_value (fun, stmt);
if (hist == hist2)
  {
    set_histogram_value (fun, stmt, hist->hvalue.next);
  }
else
  {
    while (hist2->hvalue.next != hist)
hist2 = hist2->hvalue.next;
    hist2->hvalue.next = hist->hvalue.next;
  }
free (hist->hvalue.counters);
if (flag_checkingglobal_options.x_flag_checking)
  memset (hist, 0xab, sizeof (*hist));
free (hist);
206}

208/* Lookup histogram of type TYPE in the STMT.  */

210histogram_value
211gimple_histogram_value_of_type (struct function *fun, gimple *stmt,
		enum hist_type type)
213{
histogram_value hist;
for (hist = gimple_histogram_value (fun, stmt); hist;
     hist = hist->hvalue.next)
  if (hist->type == type)
    return hist;
return NULLnullptr;
220}

222/* Dump information about HIST to DUMP_FILE.  */

224static void
225dump_histogram_value (FILE *dump_file, histogram_value hist)
226{
switch (hist->type)
  {
  case HIST_TYPE_INTERVAL:
    if (hist->hvalue.counters)
{
 fprintf (dump_file, "Interval counter range [%d,%d]: [",
   hist->hdata.intvl.int_start,
   (hist->hdata.intvl.int_start
    + hist->hdata.intvl.steps - 1));

 unsigned int i;
 for (i = 0; i < hist->hdata.intvl.steps; i++)
   {
     fprintf (dump_file, "%d:%" PRId64"l" "d",
       hist->hdata.intvl.int_start + i,
       (int64_t) hist->hvalue.counters[i]);
     if (i != hist->hdata.intvl.steps - 1)
fprintf (dump_file, ", ");
   }
 fprintf (dump_file, "] outside range: %" PRId64"l" "d" ".\n",
   (int64_t) hist->hvalue.counters[i]);
}
    break;

  case HIST_TYPE_POW2:
    if (hist->hvalue.counters)
fprintf (dump_file, "Pow2 counter pow2:%" PRId64"l" "d"
 " nonpow2:%" PRId64"l" "d" ".\n",
 (int64_t) hist->hvalue.counters[1],
 (int64_t) hist->hvalue.counters[0]);
    break;

  case HIST_TYPE_TOPN_VALUES:
  case HIST_TYPE_INDIR_CALL:
    if (hist->hvalue.counters)
{
 fprintf (dump_file,
   (hist->type == HIST_TYPE_TOPN_VALUES
    ? "Top N value counter" : "Indirect call counter"));
 if (hist->hvalue.counters)
   {
     unsigned count = hist->hvalue.counters[1];
     fprintf (dump_file, " all: %" PRId64"l" "d" ", %" PRId64"l" "d" " values: ",
       (int64_t) hist->hvalue.counters[0], (int64_t) count);
     for (unsigned i = 0; i < count; i++)
{
  fprintf (dump_file, "[%" PRId64"l" "d" ":%" PRId64"l" "d" "]",
	   (int64_t) hist->hvalue.counters[2 * i + 2],
	   (int64_t) hist->hvalue.counters[2 * i + 3]);
  if (i != count - 1)
    fprintf (dump_file, ", ");
}
     fprintf (dump_file, ".\n");
   }
}
    break;

  case HIST_TYPE_AVERAGE:
    if (hist->hvalue.counters)
fprintf (dump_file, "Average value sum:%" PRId64"l" "d"
 " times:%" PRId64"l" "d" ".\n",
 (int64_t) hist->hvalue.counters[0],
 (int64_t) hist->hvalue.counters[1]);
    break;

  case HIST_TYPE_IOR:
    if (hist->hvalue.counters)
fprintf (dump_file, "IOR value ior:%" PRId64"l" "d" ".\n",
 (int64_t) hist->hvalue.counters[0]);
    break;

  case HIST_TYPE_TIME_PROFILE:
    if (hist->hvalue.counters)
fprintf (dump_file, "Time profile time:%" PRId64"l" "d" ".\n",
 (int64_t) hist->hvalue.counters[0]);
    break;
  default:
    gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/value-prof.cc"
, 304, __FUNCTION__));
 }
306}

308/* Dump information about HIST to DUMP_FILE.  */

310void
311stream_out_histogram_value (struct output_block *ob, histogram_value hist)
312{
struct bitpack_d bp;
unsigned int i;

bp = bitpack_create (ob->main_stream);
bp_pack_enum (&bp, hist_type, HIST_TYPE_MAX, hist->type)bp_pack_int_in_range ((&bp), 0, (int)(HIST_TYPE_MAX) - 1,
 (int)(hist->type));
1
Calling 'bp_pack_int_in_range'→
16
←
Returning from 'bp_pack_int_in_range'→
bp_pack_value (&bp, hist->hvalue.next != NULLnullptr, 1);
17
←
Assuming the condition is false→
18
←
Calling 'bp_pack_value'→
streamer_write_bitpack (&bp);
switch (hist->type)
  {
  case HIST_TYPE_INTERVAL:
    streamer_write_hwi (ob, hist->hdata.intvl.int_start);
    streamer_write_uhwi (ob, hist->hdata.intvl.steps);
    break;
  default:
    break;
  }
for (i = 0; i < hist->n_counters; i++)
  {
    /* When user uses an unsigned type with a big value, constant converted
to gcov_type (a signed type) can be negative.  */
    gcov_type value = hist->hvalue.counters[i];
    streamer_write_gcov_count (ob, value);
  }
if (hist->hvalue.next)
  stream_out_histogram_value (ob, hist->hvalue.next);
338}

340/* Dump information about HIST to DUMP_FILE.  */

342void
343stream_in_histogram_value (class lto_input_block *ib, gimple *stmt)
344{
enum hist_type type;
unsigned int ncounters = 0;
struct bitpack_d bp;
unsigned int i;
histogram_value new_val;
bool next;
histogram_value *next_p = NULLnullptr;

do
  {
    bp = streamer_read_bitpack (ib);
    type = bp_unpack_enum (&bp, hist_type, HIST_TYPE_MAX)(enum hist_type)bp_unpack_int_in_range ((&bp), "hist_type"
, 0, (int)(HIST_TYPE_MAX) - 1);
    next = bp_unpack_value (&bp, 1);
    new_val = gimple_alloc_histogram_value (cfun(cfun + 0), type, stmt);
    switch (type)
{
case HIST_TYPE_INTERVAL:
 new_val->hdata.intvl.int_start = streamer_read_hwi (ib);
 new_val->hdata.intvl.steps = streamer_read_uhwi (ib);
 ncounters = new_val->hdata.intvl.steps + 2;
 break;

case HIST_TYPE_POW2:
case HIST_TYPE_AVERAGE:
 ncounters = 2;
 break;

case HIST_TYPE_TOPN_VALUES:
case HIST_TYPE_INDIR_CALL:
 break;

case HIST_TYPE_IOR:
      case HIST_TYPE_TIME_PROFILE:
 ncounters = 1;
 break;

default:
 gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/value-prof.cc"
, 382, __FUNCTION__));
}

    /* TOP N counters have variable number of counters.  */
    if (type == HIST_TYPE_INDIR_CALL || type == HIST_TYPE_TOPN_VALUES)
{
 gcov_type total = streamer_read_gcov_count (ib);
 gcov_type ncounters = streamer_read_gcov_count (ib);
 new_val->hvalue.counters = XNEWVAR (gcov_type,((gcov_type *) xmalloc ((sizeof (*new_val->hvalue.counters
) * (2 + 2 * ncounters))))
			      sizeof (*new_val->hvalue.counters)((gcov_type *) xmalloc ((sizeof (*new_val->hvalue.counters
) * (2 + 2 * ncounters))))
			      * (2 + 2 * ncounters))((gcov_type *) xmalloc ((sizeof (*new_val->hvalue.counters
) * (2 + 2 * ncounters))));
 new_val->hvalue.counters[0] = total;
 new_val->hvalue.counters[1] = ncounters;
 new_val->n_counters = 2 + 2 * ncounters;
 for (i = 0; i < 2 * ncounters; i++)
   new_val->hvalue.counters[2 + i] = streamer_read_gcov_count (ib);
}
    else
{
 new_val->hvalue.counters = XNEWVAR (gcov_type,((gcov_type *) xmalloc ((sizeof (*new_val->hvalue.counters
) * ncounters)))
			      sizeof (*new_val->hvalue.counters)((gcov_type *) xmalloc ((sizeof (*new_val->hvalue.counters
) * ncounters)))
			      * ncounters)((gcov_type *) xmalloc ((sizeof (*new_val->hvalue.counters
) * ncounters)));
 new_val->n_counters = ncounters;
 for (i = 0; i < ncounters; i++)
   new_val->hvalue.counters[i] = streamer_read_gcov_count (ib);
}

    if (!next_p)
gimple_add_histogram_value (cfun(cfun + 0), stmt, new_val);
    else
*next_p = new_val;
    next_p = &new_val->hvalue.next;
  }
while (next);
416}

418/* Dump all histograms attached to STMT to DUMP_FILE.  */

420void
421dump_histograms_for_stmt (struct function *fun, FILE *dump_file, gimple *stmt)
422{
histogram_value hist;
for (hist = gimple_histogram_value (fun, stmt); hist; hist = hist->hvalue.next)
  dump_histogram_value (dump_file, hist);
426}

428/* Remove all histograms associated with STMT.  */

430void
431gimple_remove_stmt_histograms (struct function *fun, gimple *stmt)
432{
histogram_value val;
while ((val = gimple_histogram_value (fun, stmt)) != NULLnullptr)
  gimple_remove_histogram_value (fun, stmt, val);
436}

438/* Duplicate all histograms associates with OSTMT to STMT.  */

440void
441gimple_duplicate_stmt_histograms (struct function *fun, gimple *stmt,
		  struct function *ofun, gimple *ostmt)
443{
histogram_value val;
for (val = gimple_histogram_value (ofun, ostmt); val != NULLnullptr; val = val->hvalue.next)
  {
    histogram_value new_val = gimple_alloc_histogram_value (fun, val->type);
    memcpy (new_val, val, sizeof (*val));
    new_val->hvalue.stmt = stmt;
    new_val->hvalue.counters = XNEWVAR (gcov_type, sizeof (*new_val->hvalue.counters) * new_val->n_counters)((gcov_type *) xmalloc ((sizeof (*new_val->hvalue.counters
) * new_val->n_counters)));
    memcpy (new_val->hvalue.counters, val->hvalue.counters, sizeof (*new_val->hvalue.counters) * new_val->n_counters);
    gimple_add_histogram_value (fun, stmt, new_val);
  }
454}

456/* Move all histograms associated with OSTMT to STMT.  */

458void
459gimple_move_stmt_histograms (struct function *fun, gimple *stmt, gimple *ostmt)
460{
histogram_value val = gimple_histogram_value (fun, ostmt);
if (val)
  {
    /* The following three statements can't be reordered,
       because histogram hashtab relies on stmt field value
for finding the exact slot. */
    set_histogram_value (fun, ostmt, NULLnullptr);
    for (; val != NULLnullptr; val = val->hvalue.next)
val->hvalue.stmt = stmt;
    set_histogram_value (fun, stmt, val);
  }
472}

474static bool error_found = false;

476/* Helper function for verify_histograms.  For each histogram reachable via htab
 walk verify that it was reached via statement walk.  */

479static int
480visit_hist (void **slot, void *data)
481{
hash_set<histogram_value> *visited = (hash_set<histogram_value> *) data;
histogram_value hist = *(histogram_value *) slot;

if (!visited->contains (hist)
    && hist->type != HIST_TYPE_TIME_PROFILE)
  {
    error ("dead histogram");
    dump_histogram_value (stderrstderr, hist);
    debug_gimple_stmt (hist->hvalue.stmt);
    error_found = true;
  }
return 1;
494}

496/* Verify sanity of the histograms.  */

498DEBUG_FUNCTION__attribute__ ((__used__)) void
499verify_histograms (void)
500{
basic_block bb;
gimple_stmt_iterator gsi;
histogram_value hist;

error_found = false;
hash_set<histogram_value> visited_hists;
FOR_EACH_BB_FN (bb, cfun)for (bb = ((cfun + 0))->cfg->x_entry_block_ptr->next_bb
; bb != ((cfun + 0))->cfg->x_exit_block_ptr; bb = bb->
next_bb)
  for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
    {
gimple *stmt = gsi_stmt (gsi);

for (hist = gimple_histogram_value (cfun(cfun + 0), stmt); hist;
    hist = hist->hvalue.next)
 {
   if (hist->hvalue.stmt != stmt)
     {
error ("histogram value statement does not correspond to "
       "the statement it is associated with");
debug_gimple_stmt (stmt);
dump_histogram_value (stderrstderr, hist);
error_found = true;
     }
          visited_hists.add (hist);
 }
    }
if (VALUE_HISTOGRAMS (cfun)((cfun + 0))->value_histograms)
  htab_traverse (VALUE_HISTOGRAMS (cfun)((cfun + 0))->value_histograms, visit_hist, &visited_hists);
if (error_found)
  internal_error ("%qs failed", __func__);
530}

532/* Helper function for verify_histograms.  For each histogram reachable via htab
 walk verify that it was reached via statement walk.  */

535static int
536free_hist (void **slot, void *data ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
537{
histogram_value hist = *(histogram_value *) slot;
free (hist->hvalue.counters);
free (hist);
return 1;
542}

544void
545free_histograms (struct function *fn)
546{
if (VALUE_HISTOGRAMS (fn)(fn)->value_histograms)
  {
    htab_traverse (VALUE_HISTOGRAMS (fn)(fn)->value_histograms, free_hist, NULLnullptr);
    htab_delete (VALUE_HISTOGRAMS (fn)(fn)->value_histograms);
    VALUE_HISTOGRAMS (fn)(fn)->value_histograms = NULLnullptr;
  }
553}

555/* The overall number of invocations of the counter should match
 execution count of basic block.  Report it as error rather than
 internal error as it might mean that user has misused the profile
 somehow.  */

560static bool
561check_counter (gimple *stmt, const char * name,
      gcov_type *count, gcov_type *all, profile_count bb_count_d)
563{
gcov_type bb_count = bb_count_d.ipa ().to_gcov_type ();
if (*all != bb_count || *count > *all)
  {
    dump_user_location_t locus;
    locus = ((stmt != NULLnullptr)
      ? dump_user_location_t (stmt)
      : dump_user_location_t::from_function_decl
   (current_function_decl));
    if (flag_profile_correctionglobal_options.x_flag_profile_correction)
      {
        if (dump_enabled_p ())
          dump_printf_loc (MSG_MISSED_OPTIMIZATION, locus,
                           "correcting inconsistent value profile: %s "
                           "profiler overall count (%d) does not match BB "
                           "count (%d)\n", name, (int)*all, (int)bb_count);
 *all = bb_count;
 if (*count > *all)
          *count = *all;
 return false;
}
    else
{
 error_at (locus.get_location_t (), "corrupted value profile: %s "
    "profile counter (%d out of %d) inconsistent with "
    "basic-block count (%d)",
    name,
    (int) *count,
    (int) *all,
    (int) bb_count);
 return true;
}
  }

return false;
598}

600/* GIMPLE based transformations. */

602bool
603gimple_value_profile_transformations (void)
604{
basic_block bb;
gimple_stmt_iterator gsi;
bool changed = false;

FOR_EACH_BB_FN (bb, cfun)for (bb = ((cfun + 0))->cfg->x_entry_block_ptr->next_bb
; bb != ((cfun + 0))->cfg->x_exit_block_ptr; bb = bb->
next_bb)
  {
    for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
{
 gimple *stmt = gsi_stmt (gsi);
 histogram_value th = gimple_histogram_value (cfun(cfun + 0), stmt);
 if (!th)
   continue;

 if (dump_file)
   {
     fprintf (dump_file, "Trying transformations on stmt ");
     print_gimple_stmt (dump_file, stmt, 0, TDF_SLIM);
     dump_histograms_for_stmt (cfun(cfun + 0), dump_file, stmt);
   }

 /* Transformations:  */
 /* The order of things in this conditional controls which
    transformation is used when more than one is applicable.  */
 /* It is expected that any code added by the transformations
    will be added before the current statement, and that the
    current statement remain valid (although possibly
    modified) upon return.  */
 if (gimple_mod_subtract_transform (&gsi)
     || gimple_divmod_fixed_value_transform (&gsi)
     || gimple_mod_pow2_value_transform (&gsi)
     || gimple_stringops_transform (&gsi))
   {
     stmt = gsi_stmt (gsi);
     changed = true;
     /* Original statement may no longer be in the same block. */
     if (bb != gimple_bb (stmt))
{
         bb = gimple_bb (stmt);
  gsi = gsi_for_stmt (stmt);
}
   }

 /* The function never thansforms a GIMPLE statement.  */
 if (dump_enabled_p ())
   dump_ic_profile (&gsi);
      }
  }

return changed;
654}

656/* Generate code for transformation 1 (with parent gimple assignment
 STMT and probability of taking the optimal path PROB, which is
 equivalent to COUNT/ALL within roundoff error).  This generates the
 result into a temp and returns the temp; it does not replace or
 alter the original STMT.  */

662static tree
663gimple_divmod_fixed_value (gassign *stmt, tree value, profile_probability prob,
	   gcov_type count, gcov_type all)
665{
gassign *stmt1, *stmt2;
gcond *stmt3;
tree tmp0, tmp1, tmp2;
gimple *bb1end, *bb2end, *bb3end;
basic_block bb, bb2, bb3, bb4;
tree optype, op1, op2;
edge e12, e13, e23, e24, e34;
gimple_stmt_iterator gsi;

gcc_assert (is_gimple_assign (stmt)((void)(!(is_gimple_assign (stmt) && (gimple_assign_rhs_code
 (stmt) == TRUNC_DIV_EXPR || gimple_assign_rhs_code (stmt) ==
 TRUNC_MOD_EXPR)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/value-prof.cc"
, 677, __FUNCTION__), 0 : 0))
     && (gimple_assign_rhs_code (stmt) == TRUNC_DIV_EXPR((void)(!(is_gimple_assign (stmt) && (gimple_assign_rhs_code
 (stmt) == TRUNC_DIV_EXPR || gimple_assign_rhs_code (stmt) ==
 TRUNC_MOD_EXPR)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/value-prof.cc"
, 677, __FUNCTION__), 0 : 0))
  || gimple_assign_rhs_code (stmt) == TRUNC_MOD_EXPR))((void)(!(is_gimple_assign (stmt) && (gimple_assign_rhs_code
 (stmt) == TRUNC_DIV_EXPR || gimple_assign_rhs_code (stmt) ==
 TRUNC_MOD_EXPR)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/value-prof.cc"
, 677, __FUNCTION__), 0 : 0));

optype = TREE_TYPE (gimple_assign_lhs (stmt))((contains_struct_check ((gimple_assign_lhs (stmt)), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/value-prof.cc"
, 679, __FUNCTION__))->typed.type);
op1 = gimple_assign_rhs1 (stmt);
op2 = gimple_assign_rhs2 (stmt);

bb = gimple_bb (stmt);
gsi = gsi_for_stmt (stmt);

tmp0 = make_temp_ssa_name (optype, NULLnullptr, "PROF");
tmp1 = make_temp_ssa_name (optype, NULLnullptr, "PROF");
stmt1 = gimple_build_assign (tmp0, fold_convert (optype, value)fold_convert_loc (((location_t) 0), optype, value));
stmt2 = gimple_build_assign (tmp1, op2);
stmt3 = gimple_build_cond (NE_EXPR, tmp1, tmp0, NULL_TREE(tree) nullptr, NULL_TREE(tree) nullptr);
gsi_insert_before (&gsi, stmt1, GSI_SAME_STMT);
gsi_insert_before (&gsi, stmt2, GSI_SAME_STMT);
gsi_insert_before (&gsi, stmt3, GSI_SAME_STMT);
bb1end = stmt3;

tmp2 = create_tmp_reg (optype, "PROF");
stmt1 = gimple_build_assign (tmp2, gimple_assign_rhs_code (stmt), op1, tmp0);
gsi_insert_before (&gsi, stmt1, GSI_SAME_STMT);
bb2end = stmt1;

stmt1 = gimple_build_assign (tmp2, gimple_assign_rhs_code (stmt), op1, op2);
gsi_insert_before (&gsi, stmt1, GSI_SAME_STMT);
bb3end = stmt1;

/* Fix CFG. */
/* Edge e23 connects bb2 to bb3, etc. */
e12 = split_block (bb, bb1end);
bb2 = e12->dest;
bb2->count = profile_count::from_gcov_type (count);
e23 = split_block (bb2, bb2end);
bb3 = e23->dest;
bb3->count = profile_count::from_gcov_type (all - count);
e34 = split_block (bb3, bb3end);
bb4 = e34->dest;
bb4->count = profile_count::from_gcov_type (all);

e12->flags &= ~EDGE_FALLTHRU;
e12->flags |= EDGE_FALSE_VALUE;
e12->probability = prob;

e13 = make_edge (bb, bb3, EDGE_TRUE_VALUE);
e13->probability = prob.invert ();

remove_edge (e23);

e24 = make_edge (bb2, bb4, EDGE_FALLTHRU);
e24->probability = profile_probability::always ();

e34->probability = profile_probability::always ();

return tmp2;
732}

734/* Return the n-th value count of TOPN_VALUE histogram.  If
 there's a value, return true and set VALUE and COUNT
 arguments.

 Counters have the following meaning.

 abs (counters[0]) is the number of executions
 for i in 0 ... TOPN-1
   counters[2 * i + 2] is target
   counters[2 * i + 3] is corresponding hitrate counter.

 Value of counters[0] negative when counter became
 full during merging and some values are lost.  */

748bool
749get_nth_most_common_value (gimple *stmt, const char *counter_type,
	   histogram_value hist, gcov_type *value,
	   gcov_type *count, gcov_type *all, unsigned n)
752{
unsigned counters = hist->hvalue.counters[1];
if (n >= counters)
  return false;

*count = 0;
*value = 0;

gcov_type read_all = abs_hwi (hist->hvalue.counters[0]);
gcov_type covered = 0;
for (unsigned i = 0; i < counters; ++i)
  covered += hist->hvalue.counters[2 * i + 3];

gcov_type v = hist->hvalue.counters[2 * n + 2];
gcov_type c = hist->hvalue.counters[2 * n + 3];

if (hist->hvalue.counters[0] < 0
    && flag_profile_reproducibleglobal_options.x_flag_profile_reproducible == PROFILE_REPRODUCIBILITY_PARALLEL_RUNS)
  {
    if (dump_file)
fprintf (dump_file, "Histogram value dropped in '%s' mode\n",
 "-fprofile-reproducible=parallel-runs");
    return false;
  }
else if (covered != read_all
  && flag_profile_reproducibleglobal_options.x_flag_profile_reproducible == PROFILE_REPRODUCIBILITY_MULTITHREADED)
  {
    if (dump_file)
fprintf (dump_file, "Histogram value dropped in '%s' mode\n",
 "-fprofile-reproducible=multithreaded");
    return false;
  }

/* Indirect calls can't be verified.  */
if (stmt
    && check_counter (stmt, counter_type, &c, &read_all,
	gimple_bb (stmt)->count))
  return false;

*all = read_all;

*value = v;
*count = c;
return true;
796}

798/* Do transform 1) on INSN if applicable.  */

800static bool
801gimple_divmod_fixed_value_transform (gimple_stmt_iterator *si)
802{
histogram_value histogram;
enum tree_code code;
gcov_type val, count, all;
tree result, value, tree_val;
profile_probability prob;
gassign *stmt;

stmt = dyn_cast <gassign *> (gsi_stmt (*si));
if (!stmt)
  return false;

if (!INTEGRAL_TYPE_P (TREE_TYPE (gimple_assign_lhs (stmt)))(((enum tree_code) (((contains_struct_check ((gimple_assign_lhs
 (stmt)), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/value-prof.cc"
, 814, __FUNCTION__))->typed.type))->base.code) == ENUMERAL_TYPE
 || ((enum tree_code) (((contains_struct_check ((gimple_assign_lhs
 (stmt)), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/value-prof.cc"
, 814, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
 || ((enum tree_code) (((contains_struct_check ((gimple_assign_lhs
 (stmt)), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/value-prof.cc"
, 814, __FUNCTION__))->typed.type))->base.code) == INTEGER_TYPE
))
  return false;

code = gimple_assign_rhs_code (stmt);

if (code != TRUNC_DIV_EXPR && code != TRUNC_MOD_EXPR)
  return false;

histogram = gimple_histogram_value_of_type (cfun(cfun + 0), stmt,
			      HIST_TYPE_TOPN_VALUES);
if (!histogram)
  return false;

if (!get_nth_most_common_value (stmt, "divmod", histogram, &val, &count,
		  &all))
  return false;

value = histogram->hvalue.value;
gimple_remove_histogram_value (cfun(cfun + 0), stmt, histogram);

/* We require that count is at least half of all.  */
if (simple_cst_equal (gimple_assign_rhs2 (stmt), value) != 1
    || 2 * count < all
    || optimize_bb_for_size_p (gimple_bb (stmt)))
  return false;

/* Compute probability of taking the optimal path.  */
if (all > 0)
  prob = profile_probability::probability_in_gcov_type (count, all);
else
  prob = profile_probability::never ();

if (sizeof (gcov_type) == sizeof (HOST_WIDE_INTlong))
  tree_val = build_int_cst (get_gcov_type (), val);
else
  {
    HOST_WIDE_INTlong a[2];
    a[0] = (unsigned HOST_WIDE_INTlong) val;
    a[1] = val >> (HOST_BITS_PER_WIDE_INT64 - 1) >> 1;

    tree_val = wide_int_to_tree (get_gcov_type (), wide_int::from_array (a, 2,
TYPE_PRECISION (get_gcov_type ())((tree_class_check ((get_gcov_type ()), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/value-prof.cc"
, 855, __FUNCTION__))->type_common.precision), false));
  }
result = gimple_divmod_fixed_value (stmt, tree_val, prob, count, all);

if (dump_enabled_p ())
  dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, stmt,
     "Transformation done: div/mod by constant %T\n", tree_val);

gimple_assign_set_rhs_from_tree (si, result);
update_stmt (gsi_stmt (*si));

return true;
867}

869/* Generate code for transformation 2 (with parent gimple assign STMT and
 probability of taking the optimal path PROB, which is equivalent to COUNT/ALL
 within roundoff error).  This generates the result into a temp and returns
 the temp; it does not replace or alter the original STMT.  */

874static tree
875gimple_mod_pow2 (gassign *stmt, profile_probability prob, gcov_type count, gcov_type all)
876{
gassign *stmt1, *stmt2, *stmt3;
gcond *stmt4;
tree tmp2, tmp3;
gimple *bb1end, *bb2end, *bb3end;
basic_block bb, bb2, bb3, bb4;
tree optype, op1, op2;
edge e12, e13, e23, e24, e34;
gimple_stmt_iterator gsi;
tree result;

gcc_assert (is_gimple_assign (stmt)((void)(!(is_gimple_assign (stmt) && gimple_assign_rhs_code
 (stmt) == TRUNC_MOD_EXPR) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/value-prof.cc"
, 888, __FUNCTION__), 0 : 0))
     && gimple_assign_rhs_code (stmt) == TRUNC_MOD_EXPR)((void)(!(is_gimple_assign (stmt) && gimple_assign_rhs_code
 (stmt) == TRUNC_MOD_EXPR) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/value-prof.cc"
, 888, __FUNCTION__), 0 : 0));

optype = TREE_TYPE (gimple_assign_lhs (stmt))((contains_struct_check ((gimple_assign_lhs (stmt)), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/value-prof.cc"
, 890, __FUNCTION__))->typed.type);
op1 = gimple_assign_rhs1 (stmt);
op2 = gimple_assign_rhs2 (stmt);

bb = gimple_bb (stmt);
gsi = gsi_for_stmt (stmt);

result = create_tmp_reg (optype, "PROF");
tmp2 = make_temp_ssa_name (optype, NULLnullptr, "PROF");
tmp3 = make_temp_ssa_name (optype, NULLnullptr, "PROF");
stmt2 = gimple_build_assign (tmp2, PLUS_EXPR, op2,
	       build_int_cst (optype, -1));
stmt3 = gimple_build_assign (tmp3, BIT_AND_EXPR, tmp2, op2);
stmt4 = gimple_build_cond (NE_EXPR, tmp3, build_int_cst (optype, 0),
	     NULL_TREE(tree) nullptr, NULL_TREE(tree) nullptr);
gsi_insert_before (&gsi, stmt2, GSI_SAME_STMT);
gsi_insert_before (&gsi, stmt3, GSI_SAME_STMT);
gsi_insert_before (&gsi, stmt4, GSI_SAME_STMT);
bb1end = stmt4;

/* tmp2 == op2-1 inherited from previous block.  */
stmt1 = gimple_build_assign (result, BIT_AND_EXPR, op1, tmp2);
gsi_insert_before (&gsi, stmt1, GSI_SAME_STMT);
bb2end = stmt1;

stmt1 = gimple_build_assign (result, gimple_assign_rhs_code (stmt),
	       op1, op2);
gsi_insert_before (&gsi, stmt1, GSI_SAME_STMT);
bb3end = stmt1;

/* Fix CFG. */
/* Edge e23 connects bb2 to bb3, etc. */
e12 = split_block (bb, bb1end);
bb2 = e12->dest;
bb2->count = profile_count::from_gcov_type (count);
e23 = split_block (bb2, bb2end);
bb3 = e23->dest;
bb3->count = profile_count::from_gcov_type (all - count);
e34 = split_block (bb3, bb3end);
bb4 = e34->dest;
bb4->count = profile_count::from_gcov_type (all);

e12->flags &= ~EDGE_FALLTHRU;
e12->flags |= EDGE_FALSE_VALUE;
e12->probability = prob;

e13 = make_edge (bb, bb3, EDGE_TRUE_VALUE);
e13->probability = prob.invert ();

remove_edge (e23);

e24 = make_edge (bb2, bb4, EDGE_FALLTHRU);
e24->probability = profile_probability::always ();

e34->probability = profile_probability::always ();

return result;
947}

949/* Do transform 2) on INSN if applicable.  */

951static bool
952gimple_mod_pow2_value_transform (gimple_stmt_iterator *si)
953{
histogram_value histogram;
enum tree_code code;
gcov_type count, wrong_values, all;
tree lhs_type, result, value;
profile_probability prob;
gassign *stmt;

stmt = dyn_cast <gassign *> (gsi_stmt (*si));
if (!stmt)
  return false;

lhs_type = TREE_TYPE (gimple_assign_lhs (stmt))((contains_struct_check ((gimple_assign_lhs (stmt)), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/value-prof.cc"
, 965, __FUNCTION__))->typed.type);
if (!INTEGRAL_TYPE_P (lhs_type)(((enum tree_code) (lhs_type)->base.code) == ENUMERAL_TYPE
 || ((enum tree_code) (lhs_type)->base.code) == BOOLEAN_TYPE
 || ((enum tree_code) (lhs_type)->base.code) == INTEGER_TYPE
))
  return false;

code = gimple_assign_rhs_code (stmt);

if (code != TRUNC_MOD_EXPR || !TYPE_UNSIGNED (lhs_type)((tree_class_check ((lhs_type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/value-prof.cc"
, 971, __FUNCTION__))->base.u.bits.unsigned_flag))
  return false;

histogram = gimple_histogram_value_of_type (cfun(cfun + 0), stmt, HIST_TYPE_POW2);
if (!histogram)
  return false;

value = histogram->hvalue.value;
wrong_values = histogram->hvalue.counters[0];
count = histogram->hvalue.counters[1];

gimple_remove_histogram_value (cfun(cfun + 0), stmt, histogram);

/* We require that we hit a power of 2 at least half of all evaluations.  */
if (simple_cst_equal (gimple_assign_rhs2 (stmt), value) != 1
    || count < wrong_values
    || optimize_bb_for_size_p (gimple_bb (stmt)))
  return false;

/* Compute probability of taking the optimal path.  */
all = count + wrong_values;

if (check_counter (stmt, "pow2", &count, &all, gimple_bb (stmt)->count))
  return false;

if (dump_enabled_p ())
  dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, stmt,
     "Transformation done: mod power of 2\n");

if (all > 0)
  prob = profile_probability::probability_in_gcov_type (count, all);
else
  prob = profile_probability::never ();

result = gimple_mod_pow2 (stmt, prob, count, all);

gimple_assign_set_rhs_from_tree (si, result);
update_stmt (gsi_stmt (*si));

return true;
1011}

1013/* Generate code for transformations 3 and 4 (with parent gimple assign STMT, and
 NCOUNTS the number of cases to support.  Currently only NCOUNTS==0 or 1 is
 supported and this is built into this interface.  The probabilities of taking
 the optimal paths are PROB1 and PROB2, which are equivalent to COUNT1/ALL and
 COUNT2/ALL respectively within roundoff error).  This generates the
 result into a temp and returns the temp; it does not replace or alter
 the original STMT.  */
1020/* FIXME: Generalize the interface to handle NCOUNTS > 1.  */

1022static tree
1023gimple_mod_subtract (gassign *stmt, profile_probability prob1,
     profile_probability prob2, int ncounts,
     gcov_type count1, gcov_type count2, gcov_type all)
1026{
gassign *stmt1;
gimple *stmt2;
gcond *stmt3;
tree tmp1;
gimple *bb1end, *bb2end = NULLnullptr, *bb3end;
basic_block bb, bb2, bb3, bb4;
tree optype, op1, op2;
edge e12, e23 = 0, e24, e34, e14;
gimple_stmt_iterator gsi;
tree result;

gcc_assert (is_gimple_assign (stmt)((void)(!(is_gimple_assign (stmt) && gimple_assign_rhs_code
 (stmt) == TRUNC_MOD_EXPR) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/value-prof.cc"
, 1039, __FUNCTION__), 0 : 0))
     && gimple_assign_rhs_code (stmt) == TRUNC_MOD_EXPR)((void)(!(is_gimple_assign (stmt) && gimple_assign_rhs_code
 (stmt) == TRUNC_MOD_EXPR) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/value-prof.cc"
, 1039, __FUNCTION__), 0 : 0));

optype = TREE_TYPE (gimple_assign_lhs (stmt))((contains_struct_check ((gimple_assign_lhs (stmt)), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/value-prof.cc"
, 1041, __FUNCTION__))->typed.type);
op1 = gimple_assign_rhs1 (stmt);
op2 = gimple_assign_rhs2 (stmt);

bb = gimple_bb (stmt);
gsi = gsi_for_stmt (stmt);

result = create_tmp_reg (optype, "PROF");
tmp1 = make_temp_ssa_name (optype, NULLnullptr, "PROF");
stmt1 = gimple_build_assign (result, op1);
stmt2 = gimple_build_assign (tmp1, op2);
stmt3 = gimple_build_cond (LT_EXPR, result, tmp1, NULL_TREE(tree) nullptr, NULL_TREE(tree) nullptr);
gsi_insert_before (&gsi, stmt1, GSI_SAME_STMT);
gsi_insert_before (&gsi, stmt2, GSI_SAME_STMT);
gsi_insert_before (&gsi, stmt3, GSI_SAME_STMT);
bb1end = stmt3;

if (ncounts)	/* Assumed to be 0 or 1 */
  {
    stmt1 = gimple_build_assign (result, MINUS_EXPR, result, tmp1);
    stmt2 = gimple_build_cond (LT_EXPR, result, tmp1, NULL_TREE(tree) nullptr, NULL_TREE(tree) nullptr);
    gsi_insert_before (&gsi, stmt1, GSI_SAME_STMT);
    gsi_insert_before (&gsi, stmt2, GSI_SAME_STMT);
    bb2end = stmt2;
  }

/* Fallback case. */
stmt1 = gimple_build_assign (result, gimple_assign_rhs_code (stmt),
	       result, tmp1);
gsi_insert_before (&gsi, stmt1, GSI_SAME_STMT);
bb3end = stmt1;

/* Fix CFG. */
/* Edge e23 connects bb2 to bb3, etc. */
/* However block 3 is optional; if it is not there, references
   to 3 really refer to block 2. */
e12 = split_block (bb, bb1end);
bb2 = e12->dest;
bb2->count = profile_count::from_gcov_type (all - count1);

if (ncounts)	/* Assumed to be 0 or 1.  */
  {
    e23 = split_block (bb2, bb2end);
    bb3 = e23->dest;
    bb3->count = profile_count::from_gcov_type (all - count1 - count2);
  }

e34 = split_block (ncounts ? bb3 : bb2, bb3end);
bb4 = e34->dest;
bb4->count = profile_count::from_gcov_type (all);

e12->flags &= ~EDGE_FALLTHRU;
e12->flags |= EDGE_FALSE_VALUE;
e12->probability = prob1.invert ();

e14 = make_edge (bb, bb4, EDGE_TRUE_VALUE);
e14->probability = prob1;

if (ncounts)  /* Assumed to be 0 or 1.  */
  {
    e23->flags &= ~EDGE_FALLTHRU;
    e23->flags |= EDGE_FALSE_VALUE;
    e23->probability = prob2.invert ();

    e24 = make_edge (bb2, bb4, EDGE_TRUE_VALUE);
    e24->probability = prob2;
  }

e34->probability = profile_probability::always ();

return result;
1112}

1114/* Do transforms 3) and 4) on the statement pointed-to by SI if applicable.  */

1116static bool
1117gimple_mod_subtract_transform (gimple_stmt_iterator *si)
1118{
histogram_value histogram;
enum tree_code code;
gcov_type count, wrong_values, all;
tree lhs_type, result;
profile_probability prob1, prob2;
unsigned int i, steps;
gcov_type count1, count2;
gassign *stmt;
stmt = dyn_cast <gassign *> (gsi_stmt (*si));
if (!stmt)
  return false;

lhs_type = TREE_TYPE (gimple_assign_lhs (stmt))((contains_struct_check ((gimple_assign_lhs (stmt)), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/value-prof.cc"
, 1131, __FUNCTION__))->typed.type);
if (!INTEGRAL_TYPE_P (lhs_type)(((enum tree_code) (lhs_type)->base.code) == ENUMERAL_TYPE
 || ((enum tree_code) (lhs_type)->base.code) == BOOLEAN_TYPE
 || ((enum tree_code) (lhs_type)->base.code) == INTEGER_TYPE
))
  return false;

code = gimple_assign_rhs_code (stmt);

if (code != TRUNC_MOD_EXPR || !TYPE_UNSIGNED (lhs_type)((tree_class_check ((lhs_type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/value-prof.cc"
, 1137, __FUNCTION__))->base.u.bits.unsigned_flag))
  return false;

histogram = gimple_histogram_value_of_type (cfun(cfun + 0), stmt, HIST_TYPE_INTERVAL);
if (!histogram)
  return false;

all = 0;
wrong_values = 0;
for (i = 0; i < histogram->hdata.intvl.steps; i++)
  all += histogram->hvalue.counters[i];

wrong_values += histogram->hvalue.counters[i];
wrong_values += histogram->hvalue.counters[i+1];
steps = histogram->hdata.intvl.steps;
all += wrong_values;
count1 = histogram->hvalue.counters[0];
count2 = histogram->hvalue.counters[1];

if (check_counter (stmt, "interval", &count1, &all, gimple_bb (stmt)->count))
  {
    gimple_remove_histogram_value (cfun(cfun + 0), stmt, histogram);
    return false;
  }

if (flag_profile_correctionglobal_options.x_flag_profile_correction && count1 + count2 > all)
    all = count1 + count2;

gcc_assert (count1 + count2 <= all)((void)(!(count1 + count2 <= all) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/value-prof.cc"
, 1165, __FUNCTION__), 0 : 0));

/* We require that we use just subtractions in at least 50% of all
   evaluations.  */
count = 0;
for (i = 0; i < histogram->hdata.intvl.steps; i++)
  {
    count += histogram->hvalue.counters[i];
    if (count * 2 >= all)
break;
  }
if (i == steps
    || optimize_bb_for_size_p (gimple_bb (stmt)))
  return false;

gimple_remove_histogram_value (cfun(cfun + 0), stmt, histogram);
if (dump_enabled_p ())
  dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, stmt,
     "Transformation done: mod subtract\n");

/* Compute probability of taking the optimal path(s).  */
if (all > 0)
  {
    prob1 = profile_probability::probability_in_gcov_type (count1, all);
    prob2 = profile_probability::probability_in_gcov_type (count2, all);
  }
else
  {
    prob1 = prob2 = profile_probability::never ();
  }

/* In practice, "steps" is always 2.  This interface reflects this,
   and will need to be changed if "steps" can change.  */
result = gimple_mod_subtract (stmt, prob1, prob2, i, count1, count2, all);

gimple_assign_set_rhs_from_tree (si, result);
update_stmt (gsi_stmt (*si));

return true;
1204}

1206typedef int_hash <unsigned int, 0, UINT_MAX(2147483647 *2U +1U)> profile_id_hash;

1208static hash_map<profile_id_hash, cgraph_node *> *cgraph_node_map = 0;

1210/* Returns true if node graph is initialized. This
 is used to test if profile_id has been created
 for cgraph_nodes.  */

1214bool
1215coverage_node_map_initialized_p (void)
1216{
return cgraph_node_map != 0;
1218}

1220/* Initialize map from PROFILE_ID to CGRAPH_NODE.
 When LOCAL is true, the PROFILE_IDs are computed.  when it is false we assume
 that the PROFILE_IDs was already assigned.  */

1224void
1225init_node_map (bool local)
1226{
struct cgraph_node *n;
cgraph_node_map = new hash_map<profile_id_hash, cgraph_node *>;

FOR_EACH_DEFINED_FUNCTION (n)for ((n) = symtab->first_defined_function (); (n); (n) = symtab
->next_defined_function ((n)))
  if (n->has_gimple_body_p () || n->thunk)
    {
cgraph_node **val;
dump_user_location_t loc
 = dump_user_location_t::from_function_decl (n->decl);
if (local)
 {
   n->profile_id = coverage_compute_profile_id (n);
   while ((val = cgraph_node_map->get (n->profile_id))
   || !n->profile_id)
     {
if (dump_enabled_p ())
  dump_printf_loc (MSG_MISSED_OPTIMIZATION, loc,
		   "Local profile-id %i conflict"
		   " with nodes %s %s\n",
		   n->profile_id,
		   n->dump_name (),
		   (*val)->dump_name ());
n->profile_id = (n->profile_id + 1) & 0x7fffffff;
     }
 }
else if (!n->profile_id)
 {
   if (dump_enabled_p ())
     dump_printf_loc (MSG_MISSED_OPTIMIZATION, loc,
	       "Node %s has no profile-id"
	       " (profile feedback missing?)\n",
	       n->dump_name ());
   continue;
 }
else if ((val = cgraph_node_map->get (n->profile_id)))
 {
   if (dump_enabled_p ())
     dump_printf_loc (MSG_MISSED_OPTIMIZATION, loc,
	       "Node %s has IP profile-id %i conflict. "
	       "Giving up.\n",
	       n->dump_name (), n->profile_id);
   *val = NULLnullptr;
   continue;
 }
cgraph_node_map->put (n->profile_id, n);
    }
1273}

1275/* Delete the CGRAPH_NODE_MAP.  */

1277void
1278del_node_map (void)
1279{
delete cgraph_node_map;
1281}

1283/* Return cgraph node for function with pid */

1285struct cgraph_node*
1286find_func_by_profile_id (int profile_id)
1287{
cgraph_node **val = cgraph_node_map->get (profile_id);
if (val)
  return *val;
else
  return NULLnullptr;
1293}

1295/* Do transformation

if (actual_callee_address == address_of_most_common_function/method)
  do direct call
else
  old call
*/

1303gcall *
1304gimple_ic (gcall *icall_stmt, struct cgraph_node *direct_call,
  profile_probability prob)
1306{
gcall *dcall_stmt;
gassign *load_stmt;
gcond *cond_stmt;
tree tmp0, tmp1, tmp;
basic_block cond_bb, dcall_bb, icall_bb, join_bb = NULLnullptr;
edge e_cd, e_ci, e_di, e_dj = NULLnullptr, e_ij;
gimple_stmt_iterator gsi;
int lp_nr, dflags;
edge e_eh, e;
edge_iterator ei;

cond_bb = gimple_bb (icall_stmt);
gsi = gsi_for_stmt (icall_stmt);

tmp0 = make_temp_ssa_name (ptr_type_nodeglobal_trees[TI_PTR_TYPE], NULLnullptr, "PROF");
tmp1 = make_temp_ssa_name (ptr_type_nodeglobal_trees[TI_PTR_TYPE], NULLnullptr, "PROF");
tmp = unshare_expr (gimple_call_fn (icall_stmt));
load_stmt = gimple_build_assign (tmp0, tmp);
gsi_insert_before (&gsi, load_stmt, GSI_SAME_STMT);

tmp = fold_convert (ptr_type_node, build_addr (direct_call->decl))fold_convert_loc (((location_t) 0), global_trees[TI_PTR_TYPE]
, build_addr (direct_call->decl));
load_stmt = gimple_build_assign (tmp1, tmp);
gsi_insert_before (&gsi, load_stmt, GSI_SAME_STMT);

cond_stmt = gimple_build_cond (EQ_EXPR, tmp1, tmp0, NULL_TREE(tree) nullptr, NULL_TREE(tree) nullptr);
gsi_insert_before (&gsi, cond_stmt, GSI_SAME_STMT);

if (TREE_CODE (gimple_vdef (icall_stmt))((enum tree_code) (gimple_vdef (icall_stmt))->base.code) == SSA_NAME)
  {
    unlink_stmt_vdef (icall_stmt);
    release_ssa_name (gimple_vdef (icall_stmt));
  }
gimple_set_vdef (icall_stmt, NULL_TREE(tree) nullptr);
gimple_set_vuse (icall_stmt, NULL_TREE(tree) nullptr);
update_stmt (icall_stmt);
dcall_stmt = as_a <gcall *> (gimple_copy (icall_stmt));
gimple_call_set_fndecl (dcall_stmt, direct_call->decl);
dflags = flags_from_decl_or_type (direct_call->decl);
if ((dflags & ECF_NORETURN(1 << 3)) != 0
    && should_remove_lhs_p (gimple_call_lhs (dcall_stmt)))
  gimple_call_set_lhs (dcall_stmt, NULL_TREE(tree) nullptr);
gsi_insert_before (&gsi, dcall_stmt, GSI_SAME_STMT);

/* Fix CFG. */
/* Edge e_cd connects cond_bb to dcall_bb, etc; note the first letters. */
e_cd = split_block (cond_bb, cond_stmt);
dcall_bb = e_cd->dest;
dcall_bb->count = cond_bb->count.apply_probability (prob);

e_di = split_block (dcall_bb, dcall_stmt);
icall_bb = e_di->dest;
icall_bb->count = cond_bb->count - dcall_bb->count;

/* Do not disturb existing EH edges from the indirect call.  */
if (!stmt_ends_bb_p (icall_stmt))
  e_ij = split_block (icall_bb, icall_stmt);
else
  {
    e_ij = find_fallthru_edge (icall_bb->succs);
    /* The indirect call might be noreturn.  */
    if (e_ij != NULLnullptr)
{
 e_ij->probability = profile_probability::always ();
 e_ij = single_pred_edge (split_edge (e_ij));
}
  }
if (e_ij != NULLnullptr)
  {
    join_bb = e_ij->dest;
    join_bb->count = cond_bb->count;
  }

e_cd->flags = (e_cd->flags & ~EDGE_FALLTHRU) | EDGE_TRUE_VALUE;
e_cd->probability = prob;

e_ci = make_edge (cond_bb, icall_bb, EDGE_FALSE_VALUE);
e_ci->probability = prob.invert ();

remove_edge (e_di);

if (e_ij != NULLnullptr)
  {
    if ((dflags & ECF_NORETURN(1 << 3)) == 0)
{
 e_dj = make_edge (dcall_bb, join_bb, EDGE_FALLTHRU);
 e_dj->probability = profile_probability::always ();
}
    e_ij->probability = profile_probability::always ();
  }

/* Insert PHI node for the call result if necessary.  */
if (gimple_call_lhs (icall_stmt)
    && TREE_CODE (gimple_call_lhs (icall_stmt))((enum tree_code) (gimple_call_lhs (icall_stmt))->base.code
) == SSA_NAME
    && (dflags & ECF_NORETURN(1 << 3)) == 0)
  {
    tree result = gimple_call_lhs (icall_stmt);
    gphi *phi = create_phi_node (result, join_bb);
    gimple_call_set_lhs (icall_stmt,
	   duplicate_ssa_name (result, icall_stmt));
    add_phi_arg (phi, gimple_call_lhs (icall_stmt), e_ij, UNKNOWN_LOCATION((location_t) 0));
    gimple_call_set_lhs (dcall_stmt,
	   duplicate_ssa_name (result, dcall_stmt));
    add_phi_arg (phi, gimple_call_lhs (dcall_stmt), e_dj, UNKNOWN_LOCATION((location_t) 0));
  }

/* Build an EH edge for the direct call if necessary.  */
lp_nr = lookup_stmt_eh_lp (icall_stmt);
if (lp_nr > 0 && stmt_could_throw_p (cfun(cfun + 0), dcall_stmt))
  {
    add_stmt_to_eh_lp (dcall_stmt, lp_nr);
  }

FOR_EACH_EDGE (e_eh, ei, icall_bb->succs)for ((ei) = ei_start_1 (&((icall_bb->succs))); ei_cond
 ((ei), &(e_eh)); ei_next (&(ei)))
  if (e_eh->flags & (EDGE_EH | EDGE_ABNORMAL))
    {
e = make_edge (dcall_bb, e_eh->dest, e_eh->flags);
e->probability = e_eh->probability;
for (gphi_iterator psi = gsi_start_phis (e_eh->dest);
    !gsi_end_p (psi); gsi_next (&psi))
 {
   gphi *phi = psi.phi ();
   SET_USE (PHI_ARG_DEF_PTR_FROM_EDGE (phi, e),set_ssa_use_from_ptr (gimple_phi_arg_imm_use_ptr (((phi)), ((
e)->dest_idx)), gimple_phi_arg_def (((phi)), ((e_eh)->dest_idx
)))
     PHI_ARG_DEF_FROM_EDGE (phi, e_eh))set_ssa_use_from_ptr (gimple_phi_arg_imm_use_ptr (((phi)), ((
e)->dest_idx)), gimple_phi_arg_def (((phi)), ((e_eh)->dest_idx
)));
 }
     }
if (!stmt_could_throw_p (cfun(cfun + 0), dcall_stmt))
  gimple_purge_dead_eh_edges (dcall_bb);
return dcall_stmt;
1435}

1437/* Dump info about indirect call profile.  */

1439static void
1440dump_ic_profile (gimple_stmt_iterator *gsi)
1441{
gcall *stmt;
histogram_value histogram;
gcov_type val, count, all;
struct cgraph_node *direct_call;

stmt = dyn_cast <gcall *> (gsi_stmt (*gsi));
if (!stmt)
  return;

if (gimple_call_fndecl (stmt) != NULL_TREE(tree) nullptr)
  return;

if (gimple_call_internal_p (stmt))
  return;

histogram = gimple_histogram_value_of_type (cfun(cfun + 0), stmt, HIST_TYPE_INDIR_CALL);
if (!histogram)
  return;

count = 0;
all = histogram->hvalue.counters[0];

for (unsigned j = 0; j < GCOV_TOPN_MAXIMUM_TRACKED_VALUES32; j++)
  {
    if (!get_nth_most_common_value (NULLnullptr, "indirect call", histogram, &val,
		      &count, &all, j))
return;
    if (!count)
continue;

    direct_call = find_func_by_profile_id ((int) val);

    if (direct_call == NULLnullptr)
dump_printf_loc (
 MSG_MISSED_OPTIMIZATION, stmt,
 "Indirect call -> direct call from other "
 "module %T=> %i (will resolve by ipa-profile only with LTO)\n",
 gimple_call_fn (stmt), (int) val);
    else
dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, stmt,
	 "Indirect call -> direct call "
	 "%T => %T (will resolve by ipa-profile)\n",
	 gimple_call_fn (stmt), direct_call->decl);
    dump_printf_loc (MSG_NOTE, stmt,
       "hist->count %" PRId64"l" "d" " hist->all %" PRId64"l" "d" "\n",
       count, all);
  }
1489}

1491/* Return true if the stringop CALL shall be profiled.  SIZE_ARG be
 set to the argument index for the size of the string operation.  */

1494static bool
1495interesting_stringop_to_profile_p (gcall *call, int *size_arg)
1496{
enum built_in_function fcode;

fcode = DECL_FUNCTION_CODE (gimple_call_fndecl (call));
switch (fcode)
  {
   case BUILT_IN_MEMCPY:
   case BUILT_IN_MEMPCPY:
   case BUILT_IN_MEMMOVE:
     *size_arg = 2;
     return validate_gimple_arglist (call, POINTER_TYPE, POINTER_TYPE,
		       INTEGER_TYPE, VOID_TYPE);
   case BUILT_IN_MEMSET:
     *size_arg = 2;
     return validate_gimple_arglist (call, POINTER_TYPE, INTEGER_TYPE,
		      INTEGER_TYPE, VOID_TYPE);
   case BUILT_IN_BZERO:
     *size_arg = 1;
     return validate_gimple_arglist (call, POINTER_TYPE, INTEGER_TYPE,
		       VOID_TYPE);
   default:
     return false;
  }
1519}

1521/* Convert stringop (..., vcall_size)
 into
 if (vcall_size == icall_size)
   stringop (..., icall_size);
 else
   stringop (..., vcall_size);
 assuming we'll propagate a true constant into ICALL_SIZE later.  */

1529static void
1530gimple_stringop_fixed_value (gcall *vcall_stmt, tree icall_size, profile_probability prob,
	     gcov_type count, gcov_type all)
1532{
gassign *tmp_stmt;
gcond *cond_stmt;
gcall *icall_stmt;
tree tmp0, tmp1, vcall_size, optype;
basic_block cond_bb, icall_bb, vcall_bb, join_bb;
edge e_ci, e_cv, e_iv, e_ij, e_vj;
gimple_stmt_iterator gsi;
int size_arg;

if (!interesting_stringop_to_profile_p (vcall_stmt, &size_arg))
  gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/value-prof.cc"
, 1543, __FUNCTION__));

cond_bb = gimple_bb (vcall_stmt);
gsi = gsi_for_stmt (vcall_stmt);

vcall_size = gimple_call_arg (vcall_stmt, size_arg);
optype = TREE_TYPE (vcall_size)((contains_struct_check ((vcall_size), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/value-prof.cc"
, 1549, __FUNCTION__))->typed.type);

tmp0 = make_temp_ssa_name (optype, NULLnullptr, "PROF");
tmp1 = make_temp_ssa_name (optype, NULLnullptr, "PROF");
tmp_stmt = gimple_build_assign (tmp0, fold_convert (optype, icall_size)fold_convert_loc (((location_t) 0), optype, icall_size));
gsi_insert_before (&gsi, tmp_stmt, GSI_SAME_STMT);

tmp_stmt = gimple_build_assign (tmp1, vcall_size);
gsi_insert_before (&gsi, tmp_stmt, GSI_SAME_STMT);

cond_stmt = gimple_build_cond (EQ_EXPR, tmp1, tmp0, NULL_TREE(tree) nullptr, NULL_TREE(tree) nullptr);
gsi_insert_before (&gsi, cond_stmt, GSI_SAME_STMT);

if (TREE_CODE (gimple_vdef (vcall_stmt))((enum tree_code) (gimple_vdef (vcall_stmt))->base.code) == SSA_NAME)
  {
    unlink_stmt_vdef (vcall_stmt);
    release_ssa_name (gimple_vdef (vcall_stmt));
  }
gimple_set_vdef (vcall_stmt, NULLnullptr);
gimple_set_vuse (vcall_stmt, NULLnullptr);
update_stmt (vcall_stmt);
icall_stmt = as_a <gcall *> (gimple_copy (vcall_stmt));
gimple_call_set_arg (icall_stmt, size_arg,
       fold_convert (optype, icall_size)fold_convert_loc (((location_t) 0), optype, icall_size));
gsi_insert_before (&gsi, icall_stmt, GSI_SAME_STMT);

/* Fix CFG. */
/* Edge e_ci connects cond_bb to icall_bb, etc. */
e_ci = split_block (cond_bb, cond_stmt);
icall_bb = e_ci->dest;
icall_bb->count = profile_count::from_gcov_type (count);

e_iv = split_block (icall_bb, icall_stmt);
vcall_bb = e_iv->dest;
vcall_bb->count = profile_count::from_gcov_type (all - count);

e_vj = split_block (vcall_bb, vcall_stmt);
join_bb = e_vj->dest;
join_bb->count = profile_count::from_gcov_type (all);

e_ci->flags = (e_ci->flags & ~EDGE_FALLTHRU) | EDGE_TRUE_VALUE;
e_ci->probability = prob;

e_cv = make_edge (cond_bb, vcall_bb, EDGE_FALSE_VALUE);
e_cv->probability = prob.invert ();

remove_edge (e_iv);

e_ij = make_edge (icall_bb, join_bb, EDGE_FALLTHRU);
e_ij->probability = profile_probability::always ();

e_vj->probability = profile_probability::always ();

/* Insert PHI node for the call result if necessary.  */
if (gimple_call_lhs (vcall_stmt)
    && TREE_CODE (gimple_call_lhs (vcall_stmt))((enum tree_code) (gimple_call_lhs (vcall_stmt))->base.code
) == SSA_NAME)
  {
    tree result = gimple_call_lhs (vcall_stmt);
    gphi *phi = create_phi_node (result, join_bb);
    gimple_call_set_lhs (vcall_stmt,
	   duplicate_ssa_name (result, vcall_stmt));
    add_phi_arg (phi, gimple_call_lhs (vcall_stmt), e_vj, UNKNOWN_LOCATION((location_t) 0));
    gimple_call_set_lhs (icall_stmt,
	   duplicate_ssa_name (result, icall_stmt));
    add_phi_arg (phi, gimple_call_lhs (icall_stmt), e_ij, UNKNOWN_LOCATION((location_t) 0));
  }

/* Because these are all string op builtins, they're all nothrow.  */
gcc_assert (!stmt_could_throw_p (cfun, vcall_stmt))((void)(!(!stmt_could_throw_p ((cfun + 0), vcall_stmt)) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/value-prof.cc"
, 1617, __FUNCTION__), 0 : 0));
gcc_assert (!stmt_could_throw_p (cfun, icall_stmt))((void)(!(!stmt_could_throw_p ((cfun + 0), icall_stmt)) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/value-prof.cc"
, 1618, __FUNCTION__), 0 : 0));
1619}

1621/* Find values inside STMT for that we want to measure histograms for
 division/modulo optimization.  */

1624static bool
1625gimple_stringops_transform (gimple_stmt_iterator *gsi)
1626{
gcall *stmt;
tree blck_size;
enum built_in_function fcode;
histogram_value histogram;
gcov_type count, all, val;
tree dest, src;
unsigned int dest_align, src_align;
profile_probability prob;
tree tree_val;
int size_arg;

stmt = dyn_cast <gcall *> (gsi_stmt (*gsi));
if (!stmt)
  return false;

if (!gimple_call_builtin_p (gsi_stmt (*gsi), BUILT_IN_NORMAL))
  return false;

if (!interesting_stringop_to_profile_p (stmt, &size_arg))
  return false;

blck_size = gimple_call_arg (stmt, size_arg);
if (TREE_CODE (blck_size)((enum tree_code) (blck_size)->base.code) == INTEGER_CST)
  return false;

histogram = gimple_histogram_value_of_type (cfun(cfun + 0), stmt,
			      HIST_TYPE_TOPN_VALUES);
if (!histogram)
  return false;

if (!get_nth_most_common_value (stmt, "stringops", histogram, &val, &count,
		  &all))
  return false;

gimple_remove_histogram_value (cfun(cfun + 0), stmt, histogram);

/* We require that count is at least half of all.  */
if (2 * count < all || optimize_bb_for_size_p (gimple_bb (stmt)))
  return false;
if (check_counter (stmt, "value", &count, &all, gimple_bb (stmt)->count))
  return false;
if (all > 0)
  prob = profile_probability::probability_in_gcov_type (count, all);
else
  prob = profile_probability::never ();

dest = gimple_call_arg (stmt, 0);
dest_align = get_pointer_alignment (dest);
fcode = DECL_FUNCTION_CODE (gimple_call_fndecl (stmt));
switch (fcode)
  {
  case BUILT_IN_MEMCPY:
  case BUILT_IN_MEMPCPY:
  case BUILT_IN_MEMMOVE:
    src = gimple_call_arg (stmt, 1);
    src_align = get_pointer_alignment (src);
    if (!can_move_by_pieces (val, MIN (dest_align, src_align)((dest_align) < (src_align) ? (dest_align) : (src_align))))
return false;
    break;
  case BUILT_IN_MEMSET:
    if (!can_store_by_pieces (val, builtin_memset_read_str,
		gimple_call_arg (stmt, 1),
		dest_align, true))
return false;
    break;
  case BUILT_IN_BZERO:
    if (!can_store_by_pieces (val, builtin_memset_read_str,
		integer_zero_nodeglobal_trees[TI_INTEGER_ZERO],
		dest_align, true))
return false;
    break;
  default:
    gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/value-prof.cc"
, 1699, __FUNCTION__));
  }

if (sizeof (gcov_type) == sizeof (HOST_WIDE_INTlong))
  tree_val = build_int_cst (get_gcov_type (), val);
else
  {
    HOST_WIDE_INTlong a[2];
    a[0] = (unsigned HOST_WIDE_INTlong) val;
    a[1] = val >> (HOST_BITS_PER_WIDE_INT64 - 1) >> 1;

    tree_val = wide_int_to_tree (get_gcov_type (), wide_int::from_array (a, 2,
TYPE_PRECISION (get_gcov_type ())((tree_class_check ((get_gcov_type ()), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/value-prof.cc"
, 1711, __FUNCTION__))->type_common.precision), false));
  }

if (dump_enabled_p ())
  dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, stmt,
     "Transformation done: single value %i stringop for %s\n",
     (int)val, built_in_names[(int)fcode]);

gimple_stringop_fixed_value (stmt, tree_val, prob, count, all);

return true;
1722}

1724void
1725stringop_block_profile (gimple *stmt, unsigned int *expected_align,
	HOST_WIDE_INTlong *expected_size)
1727{
histogram_value histogram;
histogram = gimple_histogram_value_of_type (cfun(cfun + 0), stmt, HIST_TYPE_AVERAGE);

if (!histogram)
  *expected_size = -1;
else if (!histogram->hvalue.counters[1])
  {
    *expected_size = -1;
    gimple_remove_histogram_value (cfun(cfun + 0), stmt, histogram);
  }
else
  {
    gcov_type size;
    size = ((histogram->hvalue.counters[0]
     + histogram->hvalue.counters[1] / 2)
      / histogram->hvalue.counters[1]);
    /* Even if we can hold bigger value in SIZE, INT_MAX
is safe "infinity" for code generation strategies.  */
    if (size > INT_MAX2147483647)
size = INT_MAX2147483647;
    *expected_size = size;
    gimple_remove_histogram_value (cfun(cfun + 0), stmt, histogram);
  }

histogram = gimple_histogram_value_of_type (cfun(cfun + 0), stmt, HIST_TYPE_IOR);

if (!histogram)
  *expected_align = 0;
else if (!histogram->hvalue.counters[0])
  {
    gimple_remove_histogram_value (cfun(cfun + 0), stmt, histogram);
    *expected_align = 0;
  }
else
  {
    gcov_type count;
    unsigned int alignment;

    count = histogram->hvalue.counters[0];
    alignment = 1;
    while (!(count & alignment)
    && (alignment <= UINT_MAX(2147483647 *2U +1U) / 2 / BITS_PER_UNIT(8)))
alignment <<= 1;
    *expected_align = alignment * BITS_PER_UNIT(8);
    gimple_remove_histogram_value (cfun(cfun + 0), stmt, histogram);
  }
1774}

1776
1777/* Find values inside STMT for that we want to measure histograms for
 division/modulo optimization.  */

1780static void
1781gimple_divmod_values_to_profile (gimple *stmt, histogram_values *values)
1782{
tree lhs, divisor, op0, type;
histogram_value hist;

if (gimple_code (stmt) != GIMPLE_ASSIGN)
  return;

lhs = gimple_assign_lhs (stmt);
type = TREE_TYPE (lhs)((contains_struct_check ((lhs), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/value-prof.cc"
, 1790, __FUNCTION__))->typed.type);
if (!INTEGRAL_TYPE_P (type)(((enum tree_code) (type)->base.code) == ENUMERAL_TYPE || (
(enum tree_code) (type)->base.code) == BOOLEAN_TYPE || ((enum
 tree_code) (type)->base.code) == INTEGER_TYPE))
  return;

switch (gimple_assign_rhs_code (stmt))
  {
  case TRUNC_DIV_EXPR:
  case TRUNC_MOD_EXPR:
    divisor = gimple_assign_rhs2 (stmt);
    op0 = gimple_assign_rhs1 (stmt);

    if (TREE_CODE (divisor)((enum tree_code) (divisor)->base.code) == SSA_NAME)
/* Check for the case where the divisor is the same value most
  of the time.  */
values->safe_push (gimple_alloc_histogram_value (cfun(cfun + 0),
					 HIST_TYPE_TOPN_VALUES,
					 stmt, divisor));

    /* For mod, check whether it is not often a noop (or replaceable by
a few subtractions).  */
    if (gimple_assign_rhs_code (stmt) == TRUNC_MOD_EXPR
 && TYPE_UNSIGNED (type)((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/value-prof.cc"
, 1811, __FUNCTION__))->base.u.bits.unsigned_flag)
 && TREE_CODE (divisor)((enum tree_code) (divisor)->base.code) == SSA_NAME)
{
        tree val;
        /* Check for a special case where the divisor is power of 2.  */
 values->safe_push (gimple_alloc_histogram_value (cfun(cfun + 0),
					   HIST_TYPE_POW2,
					   stmt, divisor));
 val = build2 (TRUNC_DIV_EXPR, type, op0, divisor);
 hist = gimple_alloc_histogram_value (cfun(cfun + 0), HIST_TYPE_INTERVAL,
			       stmt, val);
 hist->hdata.intvl.int_start = 0;
 hist->hdata.intvl.steps = 2;
 values->safe_push (hist);
}
    return;

  default:
    return;
  }
1831}

1833/* Find calls inside STMT for that we want to measure histograms for
 indirect/virtual call optimization. */

1836static void
1837gimple_indirect_call_to_profile (gimple *stmt, histogram_values *values)
1838{
tree callee;

if (gimple_code (stmt) != GIMPLE_CALL
    || gimple_call_internal_p (stmt)
    || gimple_call_fndecl (stmt) != NULL_TREE(tree) nullptr)
  return;

callee = gimple_call_fn (stmt);
histogram_value v = gimple_alloc_histogram_value (cfun(cfun + 0), HIST_TYPE_INDIR_CALL,
				    stmt, callee);
values->safe_push (v);

return;
1852}

1854/* Find values inside STMT for that we want to measure histograms for
 string operations.  */

1857static void
1858gimple_stringops_values_to_profile (gimple *gs, histogram_values *values)
1859{
gcall *stmt;
tree blck_size;
tree dest;
int size_arg;

stmt = dyn_cast <gcall *> (gs);
if (!stmt)
  return;

if (!gimple_call_builtin_p (gs, BUILT_IN_NORMAL))
  return;

if (!interesting_stringop_to_profile_p (stmt, &size_arg))
  return;

dest = gimple_call_arg (stmt, 0);
blck_size = gimple_call_arg (stmt, size_arg);

if (TREE_CODE (blck_size)((enum tree_code) (blck_size)->base.code) != INTEGER_CST)
  {
    values->safe_push (gimple_alloc_histogram_value (cfun(cfun + 0),
				       HIST_TYPE_TOPN_VALUES,
				       stmt, blck_size));
    values->safe_push (gimple_alloc_histogram_value (cfun(cfun + 0), HIST_TYPE_AVERAGE,
				       stmt, blck_size));
  }

if (TREE_CODE (blck_size)((enum tree_code) (blck_size)->base.code) != INTEGER_CST)
  values->safe_push (gimple_alloc_histogram_value (cfun(cfun + 0), HIST_TYPE_IOR,
				     stmt, dest));
1890}

1892/* Find values inside STMT for that we want to measure histograms and adds
 them to list VALUES.  */

1895static void
1896gimple_values_to_profile (gimple *stmt, histogram_values *values)
1897{
gimple_divmod_values_to_profile (stmt, values);
gimple_stringops_values_to_profile (stmt, values);
gimple_indirect_call_to_profile (stmt, values);
1901}

1903void
1904gimple_find_values_to_profile (histogram_values *values)
1905{
basic_block bb;
gimple_stmt_iterator gsi;
unsigned i;
histogram_value hist = NULLnullptr;
values->create (0);

FOR_EACH_BB_FN (bb, cfun)for (bb = ((cfun + 0))->cfg->x_entry_block_ptr->next_bb
; bb != ((cfun + 0))->cfg->x_exit_block_ptr; bb = bb->
next_bb)
  for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
    gimple_values_to_profile (gsi_stmt (gsi), values);

values->safe_push (gimple_alloc_histogram_value (cfun(cfun + 0),
				   HIST_TYPE_TIME_PROFILE));

FOR_EACH_VEC_ELT (*values, i, hist)for (i = 0; (*values).iterate ((i), &(hist)); ++(i))
  {
    switch (hist->type)
      {
case HIST_TYPE_INTERVAL:
 hist->n_counters = hist->hdata.intvl.steps + 2;
 break;

case HIST_TYPE_POW2:
 hist->n_counters = 2;
 break;

case HIST_TYPE_TOPN_VALUES:
case HIST_TYPE_INDIR_CALL:
 hist->n_counters = GCOV_TOPN_MEM_COUNTERS3;
 break;

      case HIST_TYPE_TIME_PROFILE:
        hist->n_counters = 1;
        break;

case HIST_TYPE_AVERAGE:
 hist->n_counters = 2;
 break;

case HIST_TYPE_IOR:
 hist->n_counters = 1;
 break;

default:
 gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/value-prof.cc"
, 1949, __FUNCTION__));
}
    if (dump_file && hist->hvalue.stmt != NULLnullptr)
      {
 fprintf (dump_file, "Stmt ");
        print_gimple_stmt (dump_file, hist->hvalue.stmt, 0, TDF_SLIM);
 dump_histogram_value (dump_file, hist);
      }
  }
1958}

←

/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/data-streamer.h

1/* Generic streaming support for various data types.
2 
3   Copyright (C) 2011-2023 Free Software Foundation, Inc.
4   Contributed by Diego Novillo <dnovillo@google.com>
5 
6This file is part of GCC.
7 
8GCC is free software; you can redistribute it and/or modify it under
9the terms of the GNU General Public License as published by the Free
10Software Foundation; either version 3, or (at your option) any later
11version.
12 
13GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14WARRANTY; without even the implied warranty of MERCHANTABILITY or
15FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
16for more details.
17 
18You should have received a copy of the GNU General Public License
19along with GCC; see the file COPYING3.  If not see
20<http://www.gnu.org/licenses/>.  */
21 
22#ifndef GCC_DATA_STREAMER_H
23#define GCC_DATA_STREAMER_H
24 
25#include "lto-streamer.h"
26 
27/* Data structures used to pack values and bitflags into a vector of
28   words.  Used to stream values of a fixed number of bits in a space
29   efficient way.  */
30static unsigned const BITS_PER_BITPACK_WORD = HOST_BITS_PER_WIDE_INT64;
31 
32typedef unsigned HOST_WIDE_INTlong bitpack_word_t;
33 
34struct bitpack_d
35{
36  /* The position of the first unused or unconsumed bit in the word.  */
37  unsigned pos;
38 
39  /* The current word we are (un)packing.  */
40  bitpack_word_t word;
41 
42  /* The lto_output_stream or the lto_input_block we are streaming to/from.  */
43  void *stream;
44};
45 
46/* In data-streamer.cc  */
47void bp_pack_var_len_unsigned (struct bitpack_d *, unsigned HOST_WIDE_INTlong);
48void bp_pack_var_len_int (struct bitpack_d *, HOST_WIDE_INTlong);
49unsigned HOST_WIDE_INTlong bp_unpack_var_len_unsigned (struct bitpack_d *);
50HOST_WIDE_INTlong bp_unpack_var_len_int (struct bitpack_d *);
51 
52/* In data-streamer-out.cc  */
53void streamer_write_zero (struct output_block *);
54void streamer_write_uhwi (struct output_block *, unsigned HOST_WIDE_INTlong);
55void streamer_write_hwi (struct output_block *, HOST_WIDE_INTlong);
56void streamer_write_poly_uint64 (struct output_block *, poly_uint64);
57void streamer_write_poly_int64 (struct output_block *, poly_int64);
58void streamer_write_gcov_count (struct output_block *, gcov_type);
59void streamer_write_string (struct output_block *, struct lto_output_stream *,
60			    const char *, bool);
61void streamer_write_string_with_length (struct output_block *,
62					struct lto_output_stream *,
63					const char *, unsigned int, bool);
64void bp_pack_string_with_length (struct output_block *, struct bitpack_d *,
65				 const char *, unsigned int, bool);
66void bp_pack_string (struct output_block *, struct bitpack_d *,
67		     const char *, bool);
68void streamer_write_uhwi_stream (struct lto_output_stream *,
69				 unsigned HOST_WIDE_INTlong);
70void streamer_write_hwi_stream (struct lto_output_stream *, HOST_WIDE_INTlong);
71void streamer_write_gcov_count_stream (struct lto_output_stream *, gcov_type);
72void streamer_write_data_stream (struct lto_output_stream *, const void *,
73				 size_t);
74void streamer_write_wide_int (struct output_block *, const wide_int &);
75void streamer_write_widest_int (struct output_block *, const widest_int &);
76 
77/* In data-streamer-in.cc  */
78const char *streamer_read_string (class data_in *, class lto_input_block *);
79const char *streamer_read_indexed_string (class data_in *,
80					  class lto_input_block *,
81					  unsigned int *);
82const char *bp_unpack_indexed_string (class data_in *, struct bitpack_d *,
83				      unsigned int *);
84const char *bp_unpack_string (class data_in *, struct bitpack_d *);
85unsigned HOST_WIDE_INTlong streamer_read_uhwi (class lto_input_block *);
86HOST_WIDE_INTlong streamer_read_hwi (class lto_input_block *);
87poly_uint64 streamer_read_poly_uint64 (class lto_input_block *);
88poly_int64 streamer_read_poly_int64 (class lto_input_block *);
89gcov_type streamer_read_gcov_count (class lto_input_block *);
90wide_int streamer_read_wide_int (class lto_input_block *);
91widest_int streamer_read_widest_int (class lto_input_block *);
92 
93/* Returns a new bit-packing context for bit-packing into S.  */
94inline struct bitpack_d
95bitpack_create (struct lto_output_stream *s)
96{
97  struct bitpack_d bp;
98  bp.pos = 0;
99  bp.word = 0;
100  bp.stream = (void *)s;
101  return bp;
102}
103 
104/* Pack the NBITS bit sized value VAL into the bit-packing context BP.  */
105inline void
106bp_pack_value (struct bitpack_d *bp, bitpack_word_t val, unsigned nbits)
107{
108  bitpack_word_t word = bp->word;
109  int pos = bp->pos;
19
←
'pos' initialized here→
110 
111  /* Verify that VAL fits in the NBITS.  */
112  gcc_checking_assert (nbits == BITS_PER_BITPACK_WORD((void)(!(nbits == BITS_PER_BITPACK_WORD || !(val & ~(((bitpack_word_t
)1<<nbits)-1))) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/data-streamer.h"
, 113, __FUNCTION__), 0 : 0))
8
←
Assuming 'nbits' is not equal to 'BITS_PER_BITPACK_WORD'→
9
←
Assuming the condition is true→
10
←
'?' condition is false→
20
←
'?' condition is false→
113		       || !(val & ~(((bitpack_word_t)1<<nbits)-1)))((void)(!(nbits == BITS_PER_BITPACK_WORD || !(val & ~(((bitpack_word_t
)1<<nbits)-1))) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/data-streamer.h"
, 113, __FUNCTION__), 0 : 0));
114 
115  /* If val does not fit into the current bitpack word switch to the
116     next one.  */
117  if (pos + nbits > BITS_PER_BITPACK_WORD)
11
←
Assuming the condition is true→
12
←
Taking true branch→
21
←
Assuming the condition is false→
22
←
Taking false branch→
118    {
119      streamer_write_uhwi_stream ((struct lto_output_stream *) bp->stream,
120				  word);
121      word = val;
122      pos = nbits;
13
←
The value of 'nbits' is assigned to 'pos'→
123    }
124  else
125    {
126      word |= val << pos;
23
←
The result of the left shift is undefined because the right operand is negative
127      pos += nbits;
128    }
129  bp->word = word;
130  bp->pos = pos;
14
←
The value of 'pos' is assigned to 'bp.pos'→
131}
132 
133/* Pack VAL into the bit-packing context BP, using NBITS for each
134   coefficient.  */
135inline void
136bp_pack_poly_value (struct bitpack_d *bp,
137		    const poly_int<NUM_POLY_INT_COEFFS1, bitpack_word_t> &val,
138		    unsigned nbits)
139{
140  for (int i = 0; i < NUM_POLY_INT_COEFFS1; ++i)
141    bp_pack_value (bp, val.coeffs[i], nbits);
142}
143 
144/* Finishes bit-packing of BP.  */
145inline void
146streamer_write_bitpack (struct bitpack_d *bp)
147{
148  streamer_write_uhwi_stream ((struct lto_output_stream *) bp->stream,
149			      bp->word);
150  bp->word = 0;
151  bp->pos = 0;
152}
153 
154/* Returns a new bit-packing context for bit-unpacking from IB.  */
155inline struct bitpack_d
156streamer_read_bitpack (class lto_input_block *ib)
157{
158  struct bitpack_d bp;
159  bp.word = streamer_read_uhwi (ib);
160  bp.pos = 0;
161  bp.stream = (void *)ib;
162  return bp;
163}
164 
165/* Unpacks NBITS bits from the bit-packing context BP and returns them.  */
166inline bitpack_word_t
167bp_unpack_value (struct bitpack_d *bp, unsigned nbits)
168{
169  bitpack_word_t mask, val;
170  int pos = bp->pos;
171 
172  mask = (nbits == BITS_PER_BITPACK_WORD
173	  ? (bitpack_word_t) -1
174	  : ((bitpack_word_t) 1 << nbits) - 1);
175 
176  /* If there are not continuous nbits in the current bitpack word
177     switch to the next one.  */
178  if (pos + nbits > BITS_PER_BITPACK_WORD)
179    {
180      bp->word = val 
181	= streamer_read_uhwi ((class lto_input_block *)bp->stream);
182      bp->pos = nbits;
183      return val & mask;
184    }
185  val = bp->word;
186  val >>= pos;
187  bp->pos = pos + nbits;
188 
189  return val & mask;
190}
191 
192/* Unpacks a polynomial value from the bit-packing context BP in which each
193   coefficient has NBITS bits.  */
194inline poly_int<NUM_POLY_INT_COEFFS1, bitpack_word_t>
195bp_unpack_poly_value (struct bitpack_d *bp, unsigned nbits)
196{
197  poly_int_pod<NUM_POLY_INT_COEFFS1, bitpack_word_t> x;
198  for (int i = 0; i < NUM_POLY_INT_COEFFS1; ++i)
199    x.coeffs[i] = bp_unpack_value (bp, nbits);
200  return x;
201}
202 
203 
204/* Write a character to the output block.  */
205 
206inline void
207streamer_write_char_stream (struct lto_output_stream *obs, char c)
208{
209  /* No space left.  */
210  if (obs->left_in_block == 0)
211    lto_append_block (obs);
212 
213  /* Write the actual character.  */
214  char *current_pointer = obs->current_pointer;
215  *(current_pointer++) = c;
216  obs->current_pointer = current_pointer;
217  obs->total_size++;
218  obs->left_in_block--;
219}
220 
221 
222/* Read byte from the input block.  */
223 
224inline unsigned char
225streamer_read_uchar (class lto_input_block *ib)
226{
227  if (ib->p >= ib->len)
228    lto_section_overrun (ib);
229  return (ib->data[ib->p++]);
230}
231 
232/* Output VAL into OBS and verify it is in range MIN...MAX that is supposed
233   to be compile time constant.
234   Be host independent, limit range to 31bits.  */
235 
236inline void
237streamer_write_hwi_in_range (struct lto_output_stream *obs,
238				  HOST_WIDE_INTlong min,
239				  HOST_WIDE_INTlong max,
240				  HOST_WIDE_INTlong val)
241{
242  HOST_WIDE_INTlong range = max - min;
243 
244  gcc_checking_assert (val >= min && val <= max && range > 0((void)(!(val >= min && val <= max && range
 > 0 && range < 0x7fffffff) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/data-streamer.h"
, 245, __FUNCTION__), 0 : 0))
245		       && range < 0x7fffffff)((void)(!(val >= min && val <= max && range
 > 0 && range < 0x7fffffff) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/data-streamer.h"
, 245, __FUNCTION__), 0 : 0));
246 
247  val -= min;
248  streamer_write_uhwi_stream (obs, (unsigned HOST_WIDE_INTlong) val);
249}
250 
251/* Input VAL into OBS and verify it is in range MIN...MAX that is supposed
252   to be compile time constant.  PURPOSE is used for error reporting.  */
253 
254inline HOST_WIDE_INTlong
255streamer_read_hwi_in_range (class lto_input_block *ib,
256				 const char *purpose,
257				 HOST_WIDE_INTlong min,
258				 HOST_WIDE_INTlong max)
259{
260  HOST_WIDE_INTlong range = max - min;
261  unsigned HOST_WIDE_INTlong uval = streamer_read_uhwi (ib);
262 
263  gcc_checking_assert (range > 0 && range < 0x7fffffff)((void)(!(range > 0 && range < 0x7fffffff) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/data-streamer.h"
, 263, __FUNCTION__), 0 : 0));
264 
265  HOST_WIDE_INTlong val = (HOST_WIDE_INTlong) (uval + (unsigned HOST_WIDE_INTlong) min);
266  if (val < min || val > max)
267    lto_value_range_error (purpose, val, min, max);
268  return val;
269}
270 
271/* Output VAL into BP and verify it is in range MIN...MAX that is supposed
272   to be compile time constant.
273   Be host independent, limit range to 31bits.  */
274 
275inline void
276bp_pack_int_in_range (struct bitpack_d *bp,
277		      HOST_WIDE_INTlong min,
278		      HOST_WIDE_INTlong max,
279		      HOST_WIDE_INTlong val)
280{
281  HOST_WIDE_INTlong range = max - min;
282  int nbits = floor_log2 (range) + 1;
2
←
'nbits' initialized here→
283 
284  gcc_checking_assert (val >= min && val <= max && range > 0((void)(!(val >= min && val <= max && range
 > 0 && range < 0x7fffffff) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/data-streamer.h"
, 285, __FUNCTION__), 0 : 0))
3
←
Assuming 'val' is >= 'min'→
4
←
Assuming 'val' is <= 'max'→
5
←
'?' condition is false→
285		       && range < 0x7fffffff)((void)(!(val >= min && val <= max && range
 > 0 && range < 0x7fffffff) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/data-streamer.h"
, 285, __FUNCTION__), 0 : 0));
286 
287  val -= min;
288  bp_pack_value (bp, val, nbits);
6
←
Passing value via 3rd parameter 'nbits'→
7
←
Calling 'bp_pack_value'→
15
←
Returning from 'bp_pack_value'→
289}
290 
291/* Input VAL into BP and verify it is in range MIN...MAX that is supposed
292   to be compile time constant.  PURPOSE is used for error reporting.  */
293 
294inline HOST_WIDE_INTlong
295bp_unpack_int_in_range (struct bitpack_d *bp,
296		        const char *purpose,
297		        HOST_WIDE_INTlong min,
298		        HOST_WIDE_INTlong max)
299{
300  HOST_WIDE_INTlong range = max - min;
301  int nbits = floor_log2 (range) + 1;
302  HOST_WIDE_INTlong val = bp_unpack_value (bp, nbits);
303 
304  gcc_checking_assert (range > 0 && range < 0x7fffffff)((void)(!(range > 0 && range < 0x7fffffff) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/data-streamer.h"
, 304, __FUNCTION__), 0 : 0));
305 
306  if (val < min || val > max)
307    lto_value_range_error (purpose, val, min, max);
308  return val;
309}
310 
311/* Output VAL of type "enum enum_name" into OBS.
312   Assume range 0...ENUM_LAST - 1.  */
313#define streamer_write_enum(obs,enum_name,enum_last,val)streamer_write_hwi_in_range ((obs), 0, (int)(enum_last) - 1, (
int)(val)) \
314  streamer_write_hwi_in_range ((obs), 0, (int)(enum_last) - 1, (int)(val))
315 
316/* Input enum of type "enum enum_name" from IB.
317   Assume range 0...ENUM_LAST - 1.  */
318#define streamer_read_enum(ib,enum_name,enum_last)(enum enum_name)streamer_read_hwi_in_range ((ib), "enum_name"
, 0, (int)(enum_last) - 1) \
319  (enum enum_name)streamer_read_hwi_in_range ((ib), #enum_name, 0, \
320					      (int)(enum_last) - 1)
321 
322/* Output VAL of type "enum enum_name" into BP.
323   Assume range 0...ENUM_LAST - 1.  */
324#define bp_pack_enum(bp,enum_name,enum_last,val)bp_pack_int_in_range ((bp), 0, (int)(enum_last) - 1, (int)(val
)) \
325  bp_pack_int_in_range ((bp), 0, (int)(enum_last) - 1, (int)(val))
326 
327/* Input enum of type "enum enum_name" from BP.
328   Assume range 0...ENUM_LAST - 1.  */
329#define bp_unpack_enum(bp,enum_name,enum_last)(enum enum_name)bp_unpack_int_in_range ((bp), "enum_name", 0,
 (int)(enum_last) - 1) \
330  (enum enum_name)bp_unpack_int_in_range ((bp), #enum_name, 0, \
331					(int)(enum_last) - 1)
332 
333/* Output the start of a record with TAG to output block OB.  */
334 
335inline void
336streamer_write_record_start (struct output_block *ob, enum LTO_tags tag)
337{
338  streamer_write_enum (ob->main_stream, LTO_tags, LTO_NUM_TAGS, tag)streamer_write_hwi_in_range ((ob->main_stream), 0, (int)(LTO_NUM_TAGS
) - 1, (int)(tag));
339}
340 
341/* Return the next tag in the input block IB.  */
342 
343inline enum LTO_tags
344streamer_read_record_start (class lto_input_block *ib)
345{
346  return streamer_read_enum (ib, LTO_tags, LTO_NUM_TAGS)(enum LTO_tags)streamer_read_hwi_in_range ((ib), "LTO_tags", 0
, (int)(LTO_NUM_TAGS) - 1);
347}
348 
349#endif  /* GCC_DATA_STREAMER_H  */