[Compbench-devel] CompBenchmarks++/libcompbenchmarks/share/KB/gxx/3.1.x Makefile.am, NONE, 1.1 arch.xml, NONE, 1.1 description.xml, NONE, 1.1 profile.xml, NONE, 1.1

[Frederic T. <xf...@us...>]

Update of /cvsroot/compbench/CompBenchmarks++/libcompbenchmarks/share/KB/gxx/3.1.x
In directory sc8-pr-cvs4.sourceforge.net:/tmp/cvs-serv13841/gxx/3.1.x

Added Files:
	Makefile.am arch.xml description.xml profile.xml 
Log Message:
GCC 3.1.x KB added.

--- NEW FILE: description.xml ---
<?xml version="1.0" ?>

<!-- 
    $Id: description.xml,v 1.1 2007/04/17 19:25:52 xfred Exp $

    This is free software.
    For details, see the GNU Public License in the COPYING file, or
    Look http://www.fsf.org
-->

<!-- Options for 'gxx' 3.1 and above (includes gcc and g++) -->

<options>

 <include file="gxx/3.0.x/description.xml"/>
 <include file="gxx/3.1.x/profile.xml"/>
 <include file="gxx/3.1.x/arch.xml"/>

 <option id="optimize-sibling-calls">
  <value>-foptimize-sibling-calls</value>
  <short-description>Optimize sibling and tail recursive calls</short-description>
  <editor-description>
   Optimize sibling and tail recursive calls
  </editor-description>
  <logic/>
 </option>

 <option id="prefetch-loop-arrays">
  <value>-fprefetch-loop-arrays</value>
  <short-description>Generate instructions to prefetch memory</short-description>
  <editor-description>
   If supported by the target machine, generate instructions to
   prefetch memory to improve the performance of loops that access
   large arrays.
  </editor-description>
  <logic>
   <logic-option-implied-by id="O2"/>
   <logic-option-implied-by id="O3"/>
  </logic>
 </option>

 <option id="rerun-loop-opt">
  <value>-frerun-loop-opt</value>
  <short-description>Run the loop optimizer twice</short-description>
  <editor-description>
   Run the loop optimizer twice.
  </editor-description>
  <logic>
   <logic-option-implied-by id="O2"/>
   <logic-option-implied-by id="O3"/>
  </logic>
 </option>

 <option id="gcse-lm">
  <value>-fgcse-lm</value>
  <short-description>Global CSE move loads killed by self-storing</short-description>
  <editor-description>
   When -fgcse-lm is enabled, global common subexpression elimination
   will attempt to move loads which are only killed by stores into
   themselves.  This allows a loop containing a load/store sequence to
   be changed to a load outside the loop, and a copy/store within the
   loop.
  </editor-description>
  <logic>
   <logic-option-implied-by id="O2"/>
   <logic-option-implied-by id="O3"/>
  </logic>
 </option>

 <option id="gcse-sm">
  <value>-fgcse-sm</value>
  <short-description>Global CSE tries a motion pass</short-description>
  <editor-description>
   When -fgcse-sm is enabled, A store motion pass is run after global
   common subexpression elimination.  This pass will attempt to move
   stores out of loops.  When used in conjunction with -fgcse-lm,
   loops containing a load/store sequence can be changed to a load
   before the loop and a store after the loop.
  </editor-description>
  <logic>
   <logic-option-implied-by id="O2"/>
   <logic-option-implied-by id="O3"/>
  </logic>
 </option>

 <option id="ssa-ccp">
  <value>-fssa-ccp</value>
  <short-description>Perform Sparse Conditional Constant Propagation</short-description>
  <editor-description>
   Perform Sparse Conditional Constant Propagation in SSA form.
   Requires -fssa.  Like -fssa, this is an experimental feature.
  </editor-description>
  <logic>
   <logic-option-implied-by id="O2"/>
   <logic-option-implied-by id="O3"/>
   <logic-option-requires id="ssa"/>
  </logic>
 </option>


 <option id="ssa-dce">
  <value>fssa-dce</value>
  <short-description>Agressive dead code elimination</short-description>
  <editor-description>
   Perform aggressive dead-code elimination in SSA form.  Requires
   -fssa.  Like -fssa, this is an experimental feature.
  </editor-description>
  <logic>
   <logic-option-implied-by id="O2"/>
   <logic-option-implied-by id="O3"/>
   <logic-option-requires id="ssa"/>
  </logic>
 </option>

</options>
--- NEW FILE: Makefile.am ---
# -----------------------------------------------------------------------------
# $Id: Makefile.am,v 1.1 2007/04/17 19:25:52 xfred Exp $
# $Source: /cvsroot/compbench/CompBenchmarks++/libcompbenchmarks/share/KB/gxx/3.1.x/Makefile.am,v $
#
# This is free software.
# For details, see the GNU Public License in the COPYING file, or
# Look http://www.fsf.org
# -----------------------------------------------------------------------------

data_DATA	=	description.xml arch.xml profile.xml

datarootdir=@datarootdir@/compbenchmarks/@VERSION@/KB/gxx/3.1.x

EXTRA_DIST = $(data_DATA)
--- NEW FILE: profile.xml ---
<?xml version="1.0" ?>

<!-- 
    $Id: profile.xml,v 1.1 2007/04/17 19:25:52 xfred Exp $

    This is free software.
    For details, see the GNU Public License in the COPYING file, or
    Look http://www.fsf.org
-->

<options>

 <option id="profile-generate">
  <value>-fprofile-arcs</value>
  <compilation type="first-pass"/>
  <short-description>Instrument arcs during compilation</short-description>
  <editor-description>
   Instrument arcs during compilation to generate coverage data or for
   profile-directed block ordering.  During execution the program
   records how many times each branch is executed and how many times
   it is taken.  When the compiled program exits it saves this data to
   a file called sourcename.da for each source file.

   For profile-directed block ordering, compile the program with
   -fprofile-arcs plus optimization and code generation options, generate
   the arc profile information by running the program on a
   selected workload, and then compile the program again with the same
   optimization and code generation options plus -fbranch-probabilities.

   The other use of -fprofile-arcs is for use with "gcov", when it is
   used with the -ftest-coverage option.  GCC supports two methods of
   determining code coverage: the options that support "gcov", and
   options -a and -ax, which write information to text files.  The
   options that support "gcov" do not need to instrument every arc in
   the program, so a program compiled with them runs faster than a
   program compiled with -a, which adds instrumentation code to every
   basic block in the program.  The tradeoff: since "gcov" does not
   have execution counts for all branches, it must start with the execution
   counts for the instrumented branches, and then iterate over
   the program flow graph until the entire graph has been solved.
   Hence, "gcov" runs a little more slowly than a program which uses
   information from -a and -ax.

   With -fprofile-arcs, for each function of your program GCC creates
   a program flow graph, then finds a spanning tree for the graph.
   Only arcs that are not on the spanning tree have to be instrumented:
   the compiler adds code to count the number of times that
   these arcs are executed.  When an arc is the only exit or only
   entrance to a block, the instrumentation code can be added to the
   block; otherwise, a new basic block must be created to hold the
   instrumentation code.

   This option makes it possible to estimate branch probabilities and
   to calculate basic block execution counts.  In general, basic block
   execution counts as provided by -a do not give enough information
   to estimate all branch probabilities.
  </editor-description>
  <logic/>
 </option>

 <option id="profile-use">
  <value>-fbranch-probabilities</value>
  <compilation type="second-pass" first-pass="profile-generate"/>
  <short-description>Optimizations based on path guessing</short-description>
  <editor-description>
   After running a program compiled with -fprofile-arcs, you can compile
   it a second time using -fbranch-probabilities, to improve
   optimizations based on the number of times each branch was taken.
   When the program compiled with -fprofile-arcs exits it saves arc
   execution counts to a file called sourcename.da for each source
   file  The information in this data file is very dependent on the
   structure of the generated code, so you must use the same source
   code and the same optimization options for both compilations.

   With -fbranch-probabilities, GCC puts a REG_EXEC_COUNT note on the
   first instruction of each basic block, and a REG_BR_PROB note on
   each JUMP_INSN and CALL_INSN.  These can be used to improve
   optimization.  Currently, they are only used in one place: in reorg.c,
   instead of guessing which path a branch is mostly to take, the
   REG_BR_PROB values are used to exactly determine which path is
   taken more often.
  </editor-description>
  <logic/>
 </option>

</options>
--- NEW FILE: arch.xml ---
<?xml version="1.0" ?>

<!-- 
    $Id: arch.xml,v 1.1 2007/04/17 19:25:52 xfred Exp $

    This is free software.
    For details, see the GNU Public License in the COPYING file, or
    Look http://www.fsf.org
-->

<options>

 <option id="fpmath-387">
  <value>-mfpmath=387</value>
  <short-description>Use standard 387 floating point coprocessor</short-description>
  <editor-description>
   generate floating point arithmetics for selected unit unit.  the
   choices for unit are:

   387 Use the standard 387 floating point coprocessor present majority
   of chips and emulated otherwise.  Code compiled with this
   option will run almost everywhere.  The temporary results are
   computed in 80bit precesion instead of precision specified by
   the type resulting in slightly different results compared to
   most of other chips. See -ffloat-store for more detailed
   description.

   This is the default choice for i386 compiler.

   sse Use scalar floating point instructions present in the SSE
   instruction set.  This instruction set is supported by Pentium3
   and newer chips, in the AMD line by Athlon-4, Athlon-xp and
   Athlon-mp chips.  The earlier version of SSE instruction set
   supports only single precision arithmetics, thus the double and
   extended precision arithmetics is still done using 387.  Later
   version, present only in Pentium4 and the future AMD x86-64
   chips supports double precision arithmetics too.

   For i387 you need to use -march=cpu-type, -msse or -msse2
   switches to enable SSE extensions and make this option effective.
   For x86-64 compiler, these extensions are enabled by
   default.

   The resulting code should be considerably faster in majority of
   cases and avoid the numerical instability problems of 387 code,
   but may break some existing code that expects temporaries to be
   80bit.

   This is the default choice for x86-64 compiler.

   sse,387
   Attempt to utilize both instruction sets at once.  This
   effectivly double the amount of available registers and on chips
   with separate execution units for 387 and SSE the execution
   resources too.  Use this option with care, as it is still
   experimental, because gcc register allocator does not model
   separate functional units well resulting in instable
   performance.
  </editor-description>
  <logic>
   <logic-option-exclusive on="kb-option-cpu"/>
  </logic>
 </option>

 <option id="fpmath-sse">
  <value>-mfpmath=sse</value>
  <short-description>Use SSE floating point instruction set</short-description>
  <editor-description copy-id="fpmath-387">
  <logic>
   <logic-option-exclusive on="kb-option-cpu"/>
  </logic>
 </option>

 <option id="fpmath-sse-387">
  <value>-mfpmath=sse</value>
  <short-description>Use SSE floating point instruction set with 387 coprocessor</short-description>
  <editor-description copy-id="fpmath-387">
  <logic>
   <logic-option-exclusive on="kb-option-cpu"/>
  </logic>
 </option>

 <option id="no-double-alignment">
  <value>-mno-align-double</value>
  <short-description>Disable two word boundary aligments on long types</short-description>
  <editor-description>
   Control whether GCC aligns "double", "long double", and "long long"
   variables on a two word boundary or a one word boundary.  Aligning
   "double" variables on a two word boundary will produce code that
   runs somewhat faster on a Pentium at the expense of more memory.
  </editor-description>
  <logic>
   <logic-option-exclusive on="alignment-disabled" value="0"/>
   <logic-option-exclusive on="double-alignment"/>
  </logic>
 </option>

 <option id="double-alignment">
  <value>-malign-double</value>
  <short-description>Enable two word boundary aligments on long types</short-description>
  <editor-description copy-id="no-double-alignment"/>
  <logic>
   <logic-option-exclusive on="alignment-disabled" value="0"/>
   <logic-option-exclusive on="double-alignment"/>
  </logic>
 </option>

 <option id="mmmx">
  <value>-mmmx</value>
  <short-description>Enable MMX instruction set</short-description>
  <editor-description>
    These switches enable or disable the use of built-in functions that
    allow direct access to the MMX, SSE and 3Dnow extensions of the
    instruction set.
  </editor-description>
  <logic/>
 </option>

 <option id="msse">
  <value>-msse</value>
  <short-description>Enable SSE instruction set</short-description>
  <editor-description copy-id="mmmx"/>
  <logic/>
 </option>

 <option id="msse2">
  <value>-msse2</value>
  <short-description>Enable SSE2 instruction set</short-description>
  <editor-description copy-id="mmmx"/>
  <logic/>
 </option>

 <option id="m3dnow">
  <value>-m3dnow</value>
  <short-description>Enable 3Dnow! instruction set</short-description>
  <editor-description copy-id="mmmx"/>
  <logic/>
 </option>

</options>