Collaboration diagram for bb_info:

Data Fields
insn_info_t	last_insn
bool	apply_wild_read
bitmap	gen
bitmap	kill
bitmap	in
bitmap	out
bitmap	regs_live
unsigned int	size
unsigned int	time
struct seginfo *	seginfo
int	computing
unsigned int	count_valid: 1
gcov_type	succ_count
gcov_type	pred_count

Detailed Description

@verbatim Function splitting pass

This file is part of GCC.

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

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

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

The purpose of this pass is to split function bodies to improve
   inlining.  I.e. for function of the form:

   func (...)
     {
       if (cheap_test)
         something_small
       else
         something_big
     }

   Produce:

   func.part (...)
     {
        something_big
     }

   func (...)
     {
       if (cheap_test)
         something_small
       else
         func.part (...);
     }

   When func becomes inlinable and when cheap_test is often true, inlining func,
   but not fund.part leads to performance improvement similar as inlining
   original func while the code size growth is smaller.

   The pass is organized in three stages:
   1) Collect local info about basic block into BB_INFO structure and
      compute function body estimated size and time.
   2) Via DFS walk find all possible basic blocks where we can split
      and chose best one.
   3) If split point is found, split at the specified BB by creating a clone
      and updating function to call it.  

   The decisions what functions to split are in execute_split_functions
   and consider_split.  

   There are several possible future improvements for this pass including:

   1) Splitting to break up large functions
   2) Splitting to reduce stack frame usage
   3) Allow split part of function to use values computed in the header part.
      The values needs to be passed to split function, perhaps via same
      interface as for nested functions or as argument.
   4) Support for simple rematerialization.  I.e. when split part use
      value computed in header from function parameter in very cheap way, we
      can just recompute it.
   5) Support splitting of nested functions.
   6) Support non-SSA arguments.  
   7) There is nothing preventing us from producing multiple parts of single function
      when needed or splitting also the parts.

Per basic block info.

@verbatim Calculate branch probabilities, and basic block execution counts.

Copyright (C) 1990-2013 Free Software Foundation, Inc. Contributed by James E. Wilson, UC Berkeley/Cygnus Support; based on some ideas from Dain Samples of UC Berkeley. Further mangling by Bob Manson, Cygnus Support.

This file is part of GCC.

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

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

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

Generate basic block profile instrumentation and auxiliary files.
   Profile generation is optimized, so that not all arcs in the basic
   block graph need instrumenting. First, the BB graph is closed with
   one entry (function start), and one exit (function exit).  Any
   ABNORMAL_EDGE cannot be instrumented (because there is no control
   path to place the code). We close the graph by inserting fake
   EDGE_FAKE edges to the EXIT_BLOCK, from the sources of abnormal
   edges that do not go to the exit_block. We ignore such abnormal
   edges.  Naturally these fake edges are never directly traversed,
   and so *cannot* be directly instrumented.  Some other graph
   massaging is done. To optimize the instrumentation we generate the
   BB minimal span tree, only edges that are not on the span tree
   (plus the entry point) need instrumenting. From that information
   all other edge counts can be deduced.  By construction all fake
   edges must be on the spanning tree. We also attempt to place
   EDGE_CRITICAL edges on the spanning tree.

   The auxiliary files generated are <dumpbase>.gcno (at compile time)
   and <dumpbase>.gcda (at run time).  The format is
   described in full in gcov-io.h.

??? Register allocation should use basic block execution counts to
   give preference to the most commonly executed blocks.

??? Should calculate branch probabilities before instrumenting code, since
   then we can use arc counts to help decide which arcs to instrument.

Field Documentation

bool bb_info::apply_wild_read

int bb_info::computing

Referenced by optimize_mode_switching().

unsigned int bb_info::count_valid

Referenced by compute_branch_probabilities().

bitmap bb_info::gen

Referenced by dse_confluence_0(), dse_step3(), dse_step3_exit_block_scan(), dse_step3_scan(), dse_step4(), and dse_transfer_function().

bitmap bb_info::in

Referenced by dse_confluence_n(), dse_step3(), dse_step4(), and dse_transfer_function().

bitmap bb_info::kill

Referenced by dse_step3_scan(), dse_step4(), and dse_transfer_function().

insn_info_t bb_info::last_insn

Referenced by add_non_frame_wild_read(), add_wild_read(), check_mem_read_rtx(), dse_step1(), dse_step3_scan(), dse_step5_nospill(), dse_step6(), find_insn_before_first_wild_read(), free_read_records(), record_store(), and scan_insn().

bitmap bb_info::out

Referenced by dse_confluence_0(), dse_confluence_n(), dse_step3(), dse_step4(), dse_step5_nospill(), and dse_transfer_function().

gcov_type bb_info::pred_count

Referenced by compute_branch_probabilities().

bitmap bb_info::regs_live

Referenced by check_mem_read_rtx(), dse_step1(), and scan_insn().

struct seginfo* bb_info::seginfo

Referenced by add_seginfo(), and optimize_mode_switching().

unsigned int bb_info::size

gcov_type bb_info::succ_count

Referenced by compute_branch_probabilities().

unsigned int bb_info::time

The documentation for this struct was generated from the following files:

Data Fields

Detailed Description

Field Documentation