[Compbench-devel] CompBenchmarks++/libcompbenchmarks/share/KB/gxx/2.95.x arch.xml, NONE, 1.1 cse.xml, NONE, 1.1 description.xml, NONE, 1.1 inline.xml, NONE, 1.1 loops.xml, NONE, 1.1 mainopt.xml, NONE, 1.1 Makefile.am, NONE, 1.1 options.xml, NONE, 1.1

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

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

Added Files:
	arch.xml cse.xml description.xml inline.xml loops.xml 
	mainopt.xml Makefile.am options.xml 
Log Message:
Moved from ..

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

<!--
     $Id: options.xml,v 1.1 2007/03/20 20:33:16 xfred Exp $

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

<cel>
 <cel-include>
  <cel-str>common/common.xml</cel-str>
  <cel-str>gxx/2.95.x/mainopt.xml</cel-str>
  <cel-str>gxx/2.95.x/cse.xml</cel-str>
  <cel-str>gxx/2.95.x/inline.xml</cel-str>
  <cel-str>gxx/2.95.x/loops.xml</cel-str>
  <cel-str>gxx/2.95.x/arch.xml</cel-str>
 </cel-include>

 <!-- Utility functions -->

 <!-- Returns 1 if the compiler on the stack is gcc or g++ -->
 <cel-function-def>
  <cel-str>kb-gxx-option-gxx-compiler</cel-str>
  
  <cel-var-set>
   <cel-str>compiler-id</cel-str>
   <cel-stack-pop/>
  </cel-var-set>

  <cel-var-set>
   <cel-str>return</cel-str>
   <cel-str>1</cel-str>
  </cel-var-set>

  <cel-cond-if>
   <cel-logic-not>
    <cel-logic-or>
     <cel-cmp-eq>
      <cel-var-get>
       <cel-str>compiler-id</cel-str>
      </cel-var-get>
      <cel-str>g++</cel-str>
     </cel-cmp-eq>
     <cel-cmp-eq>
      <cel-var-get>
       <cel-str>compiler-id</cel-str>
      </cel-var-get>
      <cel-str>gcc</cel-str>
     </cel-cmp-eq>
    </cel-logic-or>
   </cel-logic-not>
   <cel-var-set>
    <cel-str>return</cel-str>
    <cel-str>g++ or gcc needed</cel-str>
   </cel-var-set>
  </cel-cond-if>

  <cel-var-get>
    <cel-str>return</cel-str>
  </cel-var-get>
 </cel-function-def>

 <!-- Returns 1 if the compiler version and the compiler-id on the stack -->
 <!-- match a gcc/g++ 2.95.0 or above -->
 <cel-function-def>
  <cel-str>kb-gxx-option-gcc2.95-is-compatible</cel-str>

  <cel-var-set>
   <cel-str>compiler-version</cel-str>
   <cel-stack-pop/>
  </cel-var-set>
  
  <cel-var-set>
   <cel-str>compiler-id</cel-str>
   <cel-stack-pop/>
  </cel-var-set>

  <cel-var-set>
   <cel-str>return</cel-str>
   <cel-block>
    <cel-stack-push>
     <cel-var-get>
      <cel-str>compiler-id</cel-str>
     </cel-var-get>
    </cel-stack-push>
    <cel-function-call>
     <cel-str>kb-gxx-option-gxx-compiler</cel-str>
    </cel-function-call>
   </cel-block>
  </cel-var-set>

  <cel-cond-if>
   <cel-cmp-eq>
    <cel-var-get>
     <cel-str>return</cel-str>
    </cel-var-get>
    <cel-str>1</cel-str>
   </cel-cmp-eq>
   <cel-var-set>
    <cel-str>return</cel-str>
    <cel-block>
     <cel-stack-push>
      <cel-version>2.95.0</cel-version>
     </cel-stack-push>
     <cel-stack-push>
      <cel-var-get>
       <cel-str>compiler-version</cel-str>
      </cel-var-get>
     </cel-stack-push>
     <cel-function-call>
      <cel-str>kb-common-option-version-is-compatible</cel-str>
     </cel-function-call>
    </cel-block>
   </cel-var-set>
  </cel-cond-if>

  <cel-var-get>
    <cel-str>return</cel-str>
  </cel-var-get>
 </cel-function-def>    

 <!-- caller-saves -->
 <cel-function-def>
  <cel-str>kb-gxx-option-caller-saves-is-compatible</cel-str>

  <cel-function-call>
   <cel-str>kb-gxx-option-gcc2.95-is-compatible</cel-str>
  </cel-function-call>
 </cel-function-def>

 <!-- delayed-branch -->
 <cel-function-def>
  <cel-str>kb-gxx-option-delayed-branch-is-compatible</cel-str>

  <cel-var-set>
   <cel-str>return</cel-str>
   <cel-function-call>
    <cel-str>kb-gxx-option-gcc2.95-is-compatible</cel-str>
   </cel-function-call>
  </cel-var-set>

  <cel-cond-if>
   <cel-cmp-eq>
    <cel-var-get>
     <cel-str>return</cel-str>
    </cel-var-get>
    <cel-str>1</cel-str>
   </cel-cmp-eq>
   <cel-cond-if>
    <cel-logic-or>
     <cel-cmp-eq>
      <cel-var-get>
       <cel-str>kb-option-mainoptimization</cel-str>
      </cel-var-get>
      <cel-str>-O2</cel-str>
     </cel-cmp-eq>
     <cel-cmp-eq>
      <cel-var-get>
       <cel-str>kb-option-mainoptimization</cel-str>
      </cel-var-get>
      <cel-str>-O3</cel-str>
     </cel-cmp-eq>
    </cel-logic-or>
    <cel-var-set>
     <cel-str>return</cel-str>
     <cel-str>option implied by -O2 and -O3</cel-str>
    </cel-var-set>
   </cel-cond-if>
  </cel-cond-if>
  <cel-var-get>
   <cel-str>return</cel-str>
  </cel-var-get>
 </cel-function-def>

 <!-- expensive-optimizations -->
 <cel-function-def>
  <cel-str>kb-gxx-option-expensive-optimizations-is-compatible</cel-str>

  <cel-var-set>
   <cel-str>return</cel-str>
   <cel-function-call>
    <cel-str>kb-gxx-option-gcc2.95-is-compatible</cel-str>
   </cel-function-call>
  </cel-var-set>

  <cel-cond-if>
   <cel-cmp-eq>
    <cel-var-get>
     <cel-str>return</cel-str>
    </cel-var-get>
    <cel-str>1</cel-str>
   </cel-cmp-eq>
   <cel-cond-if>
    <cel-logic-or>
     <cel-cmp-eq>
      <cel-var-get>
       <cel-str>kb-option-mainoptimization</cel-str>
      </cel-var-get>
      <cel-str>-O2</cel-str>
     </cel-cmp-eq>
     <cel-cmp-eq>
      <cel-var-get>
       <cel-str>kb-option-mainoptimization</cel-str>
      </cel-var-get>
      <cel-str>-O3</cel-str>
     </cel-cmp-eq>
    </cel-logic-or>
    <cel-var-set>
     <cel-str>return</cel-str>
     <cel-str>option implied by -O2 and -O3</cel-str>
    </cel-var-set>
   </cel-cond-if>
  </cel-cond-if>
  <cel-var-get>
   <cel-str>return</cel-str>
  </cel-var-get>
 </cel-function-def>

 <!-- float-store -->
 <cel-function-def>
  <cel-str>kb-gxx-option-float-store-is-compatible</cel-str>

  <cel-var-set>
   <cel-str>return</cel-str>
   <cel-function-call>
    <cel-str>kb-gxx-option-gcc2.95-is-compatible</cel-str>
   </cel-function-call>
  </cel-var-set>

  <cel-cond-if>
   <cel-cmp-eq>
    <cel-var-get>
     <cel-str>return</cel-str>
    </cel-var-get>
    <cel-str>1</cel-str>
   </cel-cmp-eq>
   <cel-cond-if>
    <cel-logic-or>
     <cel-cmp-eq>
      <cel-var-get>
       <cel-str>kb-option-mainoptimization</cel-str>
      </cel-var-get>
      <cel-str>-O2</cel-str>
     </cel-cmp-eq>
     <cel-cmp-eq>
      <cel-var-get>
       <cel-str>kb-option-mainoptimization</cel-str>
      </cel-var-get>
      <cel-str>-O3</cel-str>
     </cel-cmp-eq>
    </cel-logic-or>
    <cel-var-set>
     <cel-str>return</cel-str>
     <cel-str>option implied by -O2 and -O3</cel-str>
    </cel-var-set>
   </cel-cond-if>
  </cel-cond-if>
  <cel-var-get>
   <cel-str>return</cel-str>
  </cel-var-get>
 </cel-function-def>


 <!-- force-addr -->
 <cel-function-def>
  <cel-str>kb-gxx-option-force-addr-is-compatible</cel-str>

  <cel-var-set>
   <cel-str>return</cel-str>
   <cel-function-call>
    <cel-str>kb-gxx-option-gcc2.95-is-compatible</cel-str>
   </cel-function-call>
  </cel-var-set>

  <cel-cond-if>
   <cel-cmp-eq>
    <cel-var-get>
     <cel-str>return</cel-str>
    </cel-var-get>
    <cel-str>1</cel-str>
   </cel-cmp-eq>
   <cel-cond-if>
    <cel-logic-or>
     <cel-cmp-eq>
      <cel-var-get>
       <cel-str>kb-option-mainoptimization</cel-str>
      </cel-var-get>
      <cel-str>-O2</cel-str>
     </cel-cmp-eq>
     <cel-cmp-eq>
      <cel-var-get>
       <cel-str>kb-option-mainoptimization</cel-str>
      </cel-var-get>
      <cel-str>-O3</cel-str>
     </cel-cmp-eq>
    </cel-logic-or>
    <cel-var-set>
     <cel-str>return</cel-str>
     <cel-str>option implied by -O2 and -O3</cel-str>
    </cel-var-set>
   </cel-cond-if>
  </cel-cond-if>
  <cel-var-get>
   <cel-str>return</cel-str>
  </cel-var-get>
 </cel-function-def>

 <!-- force-mem -->
 <cel-function-def>
  <cel-str>kb-gxx-option-force-mem-is-compatible</cel-str>

  <cel-var-set>
   <cel-str>return</cel-str>
   <cel-function-call>
    <cel-str>kb-gxx-option-gcc2.95-is-compatible</cel-str>
   </cel-function-call>
  </cel-var-set>

  <cel-cond-if>
   <cel-cmp-eq>
    <cel-var-get>
     <cel-str>return</cel-str>
    </cel-var-get>
    <cel-str>1</cel-str>
   </cel-cmp-eq>
   <cel-cond-if>
    <cel-logic-or>
     <cel-cmp-eq>
      <cel-var-get>
       <cel-str>kb-option-mainoptimization</cel-str>
      </cel-var-get>
      <cel-str>-O2</cel-str>
     </cel-cmp-eq>
     <cel-cmp-eq>
      <cel-var-get>
       <cel-str>kb-option-mainoptimization</cel-str>
      </cel-var-get>
      <cel-str>-O3</cel-str>
     </cel-cmp-eq>
    </cel-logic-or>
    <cel-var-set>
     <cel-str>return</cel-str>
     <cel-str>option implied by -O2 and -O3</cel-str>
    </cel-var-set>
   </cel-cond-if>
  </cel-cond-if>
  <cel-var-get>
   <cel-str>return</cel-str>
  </cel-var-get>
 </cel-function-def>

 <!-- fast-math -->
 <cel-function-def>
  <cel-str>kb-gxx-option-fast-math-is-compatible</cel-str>

  <cel-function-call>
   <cel-str>kb-gxx-option-gcc2.95-is-compatible</cel-str>
  </cel-function-call>
 </cel-function-def>

 <!-- Not integrated (seem useless for optimizations measurement : -->
 <!-- no-defer-pop, no-peephole -->

 <!-- omit-frame-pointer -->
 <cel-function-def>
  <cel-str>kb-gxx-option-omit-frame-pointer-is-compatible</cel-str>

  <cel-function-call>
   <cel-str>kb-gxx-option-gcc2.95-is-compatible</cel-str>
  </cel-function-call>
 </cel-function-def>

 <!-- schedule-insns -->
 <cel-function-def>
  <cel-str>kb-gxx-option-schedule-insns-is-compatible</cel-str>

  <cel-var-set>
   <cel-str>return</cel-str>
   <cel-function-call>
    <cel-str>kb-gxx-option-gcc2.95-is-compatible</cel-str>
   </cel-function-call>
  </cel-var-set>

  <cel-cond-if>
   <cel-cmp-eq>
    <cel-var-get>
     <cel-str>return</cel-str>
    </cel-var-get>
    <cel-str>1</cel-str>
   </cel-cmp-eq>
   <cel-cond-if>
    <cel-logic-or>
     <cel-cmp-eq>
      <cel-var-get>
       <cel-str>kb-option-mainoptimization</cel-str>
      </cel-var-get>
      <cel-str>-O2</cel-str>
     </cel-cmp-eq>
     <cel-cmp-eq>
      <cel-var-get>
       <cel-str>kb-option-mainoptimization</cel-str>
      </cel-var-get>
      <cel-str>-O3</cel-str>
     </cel-cmp-eq>
    </cel-logic-or>
    <cel-var-set>
     <cel-str>return</cel-str>
     <cel-str>option implied by -O2 and -O3</cel-str>
    </cel-var-set>
   </cel-cond-if>
  </cel-cond-if>
  <cel-var-get>
   <cel-str>return</cel-str>
  </cel-var-get>
 </cel-function-def>

 <!-- schedule-insns2 -->
 <cel-function-def>
  <cel-str>kb-gxx-option-schedule-insns2-is-compatible</cel-str>

  <cel-var-set>
   <cel-str>return</cel-str>
   <cel-function-call>
    <cel-str>kb-gxx-option-gcc2.95-is-compatible</cel-str>
   </cel-function-call>
  </cel-var-set>

  <cel-cond-if>
   <cel-cmp-eq>
    <cel-var-get>
     <cel-str>return</cel-str>
    </cel-var-get>
    <cel-str>1</cel-str>
   </cel-cmp-eq>
   <cel-cond-if>
    <cel-logic-or>
     <cel-cmp-eq>
      <cel-var-get>
       <cel-str>kb-option-mainoptimization</cel-str>
      </cel-var-get>
      <cel-str>-O2</cel-str>
     </cel-cmp-eq>
     <cel-cmp-eq>
      <cel-var-get>
       <cel-str>kb-option-mainoptimization</cel-str>
      </cel-var-get>
      <cel-str>-O3</cel-str>
     </cel-cmp-eq>
    </cel-logic-or>
    <cel-var-set>
     <cel-str>return</cel-str>
     <cel-str>option implied by -O2 and -O3</cel-str>
    </cel-var-set>
   </cel-cond-if>
  </cel-cond-if>
  <cel-var-get>
   <cel-str>return</cel-str>
  </cel-var-get>
 </cel-function-def>

</cel>

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

<!-- 
    $Id: inline.xml,v 1.1 2007/03/20 20:33:16 xfred Exp $

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

<!-- inlining related options for gxx -->
<!-- included by gxx/options.xml -->

<cel>
 <!-- inline-functions -->
 <cel-function-def>
  <cel-str>kb-gxx-option-inline-functions-is-compatible</cel-str>

  <cel-var-set>
   <cel-str>return</cel-str>
   <cel-function-call>
    <cel-str>kb-gxx-option-gcc2.95-is-compatible</cel-str>
   </cel-function-call>
  </cel-var-set>

  <cel-cond-if>
   <cel-cmp-eq>
    <cel-var-get>
     <cel-str>return</cel-str>
    </cel-var-get>
    <cel-str>1</cel-str>
   </cel-cmp-eq>
   <cel-cond-if>
    <cel-cmp-eq>
     <cel-var-get>
      <cel-str>kb-option-mainoptimization</cel-str>
     </cel-var-get>
     <cel-str>-O3</cel-str>
    </cel-cmp-eq>
    <cel-var-set>
     <cel-str>return</cel-str>
     <cel-str>option implied by -O3</cel-str>
    </cel-var-set>
   </cel-cond-if>
  </cel-cond-if>
  <cel-var-get>
   <cel-str>return</cel-str>
  </cel-var-get>
 </cel-function-def>

 <!-- Not integrated (seem useless for optimizations measurement : -->
 <!-- keep-inline-functions -->
 <!-- no-default-inline -->
</cel>
--- NEW FILE: arch.xml ---
<?xml version="1.0" ?>

<!-- 
    $Id: arch.xml,v 1.1 2007/03/20 20:33:14 xfred Exp $

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

<!-- Architecture related options for gxx -->
<!-- included by gxx/options.xml -->

<!-- !!! Should check real platform architecture in matches -->

<cel>

 <!-- m486 -->
 <cel-function-def>
  <cel-str>kb-gxx-option-m486-is-compatible</cel-str>
  <cel-var-set>
   <cel-str>result</cel-str>
   <cel-function-call>
    <cel-str>kb-gxx-option-gcc2.95-is-compatible</cel-str>
   </cel-function-call>
  </cel-var-set>

  <cel-cond-if>
   <cel-cmp-eq>
    <cel-var-get>
     <cel-str>result</cel-str>
    </cel-var-get>
    <cel-str>1</cel-str>
   </cel-cmp-eq>
   <cel-block>
    <cel-stack-push>
     <cel-str>kb-option-cpu</cel-str>
    </cel-stack-push>
    <cel-stack-push>
     <cel-str>-m486</cel-str>
    </cel-stack-push>
    <cel-var-set>
     <cel-str>result</cel-str>
     <cel-function-call>
      <cel-str>kb-common-option-apply</cel-str>
     </cel-function-call>
    </cel-var-set> 
   </cel-block>   
  </cel-cond-if>
  <cel-var-get>
   <cel-str>result</cel-str>
  </cel-var-get>
 </cel-function-def>
 
 <!-- no-fp-ret-in-387 -->
 <cel-function-def>
  <cel-str>kb-gxx-option-no-fp-ret-in-387-is-compatible</cel-str>

  <cel-function-call>
   <cel-str>kb-gxx-option-gcc2.95-is-compatible</cel-str>
  </cel-function-call>
 </cel-function-def>

 <!-- Not integrated (seem useless for optimizations measurement) : -->
 <!-- -msoft-float -->

</cel>

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

<!-- 
    $Id: description.xml,v 1.1 2007/03/20 20:33:16 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' (includes gcc and g++) -->

<!-- cel-interface is gxx/options.xml by default and should
     be evaluated -->
<!-- globaly; that's the default since all compilers'll have their -->
<!-- own descriptions -->

<options>

 <option id="O0">
  <value>-O0</value>
  <short-description>Globally disable compiler optimization</short-description>
  <editor-description>
   Do not optimize. This is the default
  </editor-description>
 </option>

 <option id="Os">
  <value>-Os</value>
  <short-description>Globally optimize for size</short-description>
  <editor-description>
   Optimize for size.  -Os enables all -O2 optimizations that do not typically
   increase code size.  It also performs further optimizations designed to
   reduce code size.

   -Os disables the following optimization flags: -falign-functions
   -falign-jumps  -falign-loops -falign-labels  -freorder-blocks
   -fprefetch-loop-arrays

   If you use multiple -O options, with or without level numbers, the last
   such option is the one that is effective.
  </editor-description>
 </option>

 <option id="O1">
  <value>-O1</value>
  <short-description>Global optimization, level 1</short-description>
  <editor-description>
   Optimize.  Optimizing compilation takes somewhat more time,  and
   a lot more memory for a large function.

   Without  `-O', the compiler's goal is to reduce the cost of
   compilation and to make debugging  produce  the  expected  results.
   Statements  are  independent:  if  you  stop  the program with a
   breakpoint between statements, you can then assign a  new  value
   to  any  variable  or  change  the  program counter to any other
   statement in the function and get exactly the results you  would
   expect from the source code.

   Without  `-O', only variables declared register are allocated in
   registers.  The resulting compiled code is a little  worse  than
   produced by PCC without `-O'.

   With  `-O', the compiler tries to reduce code size and execution
   time.

   When you specify `-O',  the  two  options  `-fthread-jumps'  and
   `-fdefer-pop' are turned on.  On machines that have delay slots,
   the `-fdelayed-branch' option is turned on.  For those  machines
   that  can  support  debugging  even without a frame pointer, the
   `-fomit-frame-pointer' option is turned on.   On  some  machines
   other flags may also be turned on.
  </editor-description>
 </option>
  
 <option id="O2">
  <value>-O2</value>
  <short-description>Global optimization, level 2</short-description>
  <editor-description>
   Optimize even more than -O1. Nearly all supported optimizations that
   do not involve a space-speed tradeoff are performed.  Loop unrolling
   and function inlining are not done, for example. As compared to -O, this
   option increases both compilation time and the performance of the
   generated code.
  </editor-description>
 </option>

 <option id="O3">
  <value>-O3</value>
  <short-description>Global optimization, level 3</short-description>
  <editor-description>
   Optimize  yet  more.  This turns on everything -O2 does, along with also
   turning on -finline-functions.
  </editor-description>
 </option>

 <option id="caller-save">  
  <value>-fcaller-saves</value>
  <short-description>Try allocating registers that'll be cloberred by function calls</short-description>
  <editor-description>
   Enable  values  to  be allocated in registers that will be
   clobbered by function calls, by emitting extra instructions to  save
   and restore the registers around such calls.  Such allocation is
   done only when it seems to result in better code than would otherwise
   be produced.

   This  option  is enabled by default on certain machines, usually
   those which have no call-preserved registers to use instead.
  </editor-description>
 </option>

 <option id="cse-follow-jumps">
  <value>-fcse-follow-jumps</value>
  <short-description>Always scan through jump instructions in common subexpression elimination</short-description>
  <editor-description>
   In common subexpression elimination, scan through jump  instructions
   when  the  target of the jump is not reached by any other
   path.  For example, when CSE encounters an if statement with  an else
   clause, CSE will follow the jump when the condition tested
   is false.
  </editor-description>
 </option>

 <option id="cse-skip-blocks">
  <value>-fcse-skip-blocks</value>
  <short-description>Always scan through conditionnal jump instructions in common subexpression elimination</short-description>
  <editor-description>
   This is similar to `-fcse-follow-jumps', but causes CSE to  follow
   jumps  which  conditionally skip over blocks.  When CSE encounters
   a  simple  if   statement   with   no   else   clause,
   `-fcse-skip-blocks'  causes  CSE  to  follow the jump around the
   body of the if.
  </editor-description>
 </option>

 <option id="delayed-branch">
  <value>-fdelayed-branch</value>
  <short-description>Attempt to reorder instructions to increase slot utilisation</short-description>
  <editor-description>
   If supported for the target machine, attempt to reorder instructions
   to  exploit  instruction  slots  available  after  delayed
   branch instructions.
  </editor-description>
 </option>

 <option id="expensive-optimizations">
  <value>-fexpensive-optimizations</value>
  <short-description>Perform a number of minor optimizations</short-description>
  <editor-description>
   Perform a number of minor optimizations that are relatively expensive.
  </editor-description>
 </option>


 <option id="fast-math">
  <value>-ffast-math</value>
  <short-description>Violate ANSI or IEEE rules/specifications for optimizing code</short-description>
  <editor-description>
   This option allows GCC to violate some ANSI or IEEE rules/specifications
   in the interest of optimizing code for speed.  For example, it allows
   the compiler to assume arguments  to  the  sqrt
   function are non-negative numbers.

   This  option  should never be turned on by any `-O' option since
   it can result in incorrect output for programs which  depend  on
   an exact implementation of IEEE or ANSI rules/specifications for
   math functions.
  </editor-description>
 </option>

 <option id="float-store">
  <value>-ffloat-store</value>
  <short-description>Do not store floating point variables in registers</short-description>
  <editor-description>
    Do  not  store floating point variables in registers.  This prevents
    undesirable excess precision on machines such as the 68000
    where  the floating registers (of the 68881) keep more precision
    than a double is supposed to have.

    For most programs, the excess precision does only  good,  but  a
    few  programs  rely  on  the precise definition of IEEE floating
    point.  Use `-ffloat-store' for such programs.
  </editor-description>
 </option>

 <option id="force-addr">
  <value>-fforce-addr</value>
  <short-description>Force memory address constants to be copied in registers</short-description>
  <editor-description>
   Force memory address constants to be copied into  registers  before
   doing  arithmetic  on  them.  This may produce better code
   just as `-fforce-mem' may.  I am interested in hearing about the
   difference this makes.
  </editor-description>
 </option>

 <option id="force-mem">
  <value>-fforce-mem</value>
  <short-description>Force memory operands to be copied into registers</short-description>
  <editor-description>
   Force  memory  operands to be copied into registers before doing
   arithmetic on them.  This may produce better code by making  all
   memory  references  potential  common subexpressions.  When they
   are not common subexpressions,  instruction  combination  should
   eliminate  the separate register-load.  I am interested in hearing
   about the difference this makes.
  </editor-description>
 </option>

 <option id="inline-functions">
  <value>-finline-functions</value>
  <short-description>Integrate all simple functions into their callers</short-description>
  <editor-description>
   Integrate all simple functions into their callers.  The compiler
   heuristically decides which functions are simple  enough  to  be
   worth integrating in this way.

   If  all  calls to a given function are integrated, and the function
   is declared static, then GCC normally does not  output  the
   function as assembler code in its own right.
  </editor-description>
 </option>

 <option id="omit-frame-pointer">
  <value>-fomit-frame-pointer</value>
  <short-description>Remove frame pointer from register when useless</short-description>
  <editor-description>
   Don't  keep  the  frame pointer in a register for functions that
   don't need one.  This avoids the instructions to  save,  set  up
   and  restore  frame  pointers;  it  also makes an extra register
   available in many functions.  It also makes debugging impossible
   on most machines.

   On  some machines, such as the Vax, this flag has no effect, because
   the standard calling sequence  automatically  handles  the
   frame  pointer and nothing is saved by pretending it doesn't exist.
   The machine-description macro FRAME_POINTER_REQUIRED  controls
   whether a target machine supports this flag.
  </editor-description>
 </option>

<option id="rerun-cse-after-loop">
  <value>-frerun-cse-after-loop</value>
  <short-description>Re-run CSE after loop optimizations</short-description>
  <editor-description>
   Re-run common subexpression elimination after loop optimizations
   has been performed.
  </editor-description>
 </option>

 <option id="schedule-insns">
  <value>-fschedule-insns</value>
  <short-description>Attempt to reorder instructions to eliminate stalls</short-description>
  <editor-description>
   If supported for the target machine, attempt to reorder instructions
   to eliminate execution stalls due to required  data  being
   unavailable.   This helps machines that have slow floating point
   or memory load instructions by allowing other instructions to be
   issued  until  the result of the load or floating point instruction
   is required.
  </editor-description>
 </option>

 <option id="schedule-insns2">
  <value>-fschedule-insns2</value>
  <short-description>Attempt to reorder instructions to eliminate stalls (also watch for registers)</short-description>
  <editor-description>
   Similar to `-fschedule-insns', but requests an  additional  pass
   of  instruction  scheduling  after  register allocation has been
   done.  This is especially useful on machines with  a  relatively
   small  number  of  registers  and where memory load instructions
   take more than one cycle.
  </editor-description>
 </option>

 <option id="strength-reduce">
  <value>-fstrength-reduce</value>
  <short-description>Loop optimizations</short-description>
  <editor-description>
   Perform  the optimizations of loop strength reduction and
   elimination of iteration variables.
  </editor-description>
 </option>

 <option id="thread-jumps">
  <value>-fthread-jumps</value>
  <short-description>Jump shortcuts' detection</short-description>
  <editor-description>
   Perform optimizations where we check to see if a  jump  branches
   to  a location where another comparison subsumed by the first is
   found.  If so, the first branch is redirected to either the
   destination  of  the second branch or a point immediately following
   it, depending on whether the condition is known to  be  true  or
   false.
  </editor-description>
 </option>


 <option id="unroll-all-loops">
  <value>-funroll-all-loops</value>
  <short-description>Global loop unrolling optimization</short-description>
  <editor-description>
   Perform  the  optimization  of loop unrolling.  This is done for
   all loops.  This usually makes programs run more slowly.
  </editor-description>
 </option>


 <option id="unroll-loops">
  <value>-funroll-loops</value>
  <short-description>Loop unrolling optimizations</short-description>
  <editor-description>
   Perform  the  optimization of loop unrolling.  This is only done
   for loops whose number of iterations can be determined  at  com-
   pile time or run time.
  </editor-description>
 </option>

 <option id="m486">
  <value>-m486</value>
  <short-description>Generate i486 optimized code</short-description>
  <editor-description>
   Control whether or not code is optimized for a 486 instead of an
   386.  Code generated for a 486 will run on a 386 and vice versa.
  </editor-description>
 </option>


 <option id="no-fp-ret-in-387">
  <value>-fno-fp-ret-in-387</value>
  <short-description>Do not use FPU to return values</short-description>
  <editor-description>
   Do not use the FPU registers for return values of functions.

   The  usual  calling  convention  has  functions return values of
   types float and double in an FPU register, even if there  is  no
   FPU.   The  idea  is that the operating system should emulate an
   FPU.

   The option `-mno-fp-ret-in-387' causes such  values  to  be
   returned in ordinary CPU registers instead.
  </editor-description>
 </option>

 <!--
 <option id="">
  <value></value>
  <short-description></short-description>
  <editor-description>
  </editor-description>
 </option>
 -->

</options>
--- NEW FILE: Makefile.am ---
# -----------------------------------------------------------------------------
# $Id: Makefile.am,v 1.1 2007/03/20 20:33:16 xfred Exp $
# $Source: /cvsroot/compbench/CompBenchmarks++/libcompbenchmarks/share/KB/gxx/2.95.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	=	options.xml \
			mainopt.xml \
			arch.xml cse.xml \
			inline.xml loops.xml


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

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

<!-- 
    $Id: loops.xml,v 1.1 2007/03/20 20:33:16 xfred Exp $

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

<!-- Loop related options for gxx -->
<!-- included by gxx/options.xml -->

<cel>
  <!-- strength-reduce -->
 <cel-function-def>
  <cel-str>kb-gxx-option-strength-reduce-is-compatible</cel-str>

  <cel-var-set>
   <cel-str>return</cel-str>
   <cel-function-call>
    <cel-str>kb-gxx-option-gcc2.95-is-compatible</cel-str>
   </cel-function-call>
  </cel-var-set>

  <cel-cond-if>
   <cel-cmp-eq>
    <cel-var-get>
     <cel-str>return</cel-str>
    </cel-var-get>
    <cel-str>1</cel-str>
   </cel-cmp-eq>
   <cel-cond-if>
    <cel-logic-or>
     <cel-cmp-eq>
      <cel-var-get>
       <cel-str>kb-option-mainoptimization</cel-str>
      </cel-var-get>
      <cel-str>-O2</cel-str>
     </cel-cmp-eq>
     <cel-cmp-eq>
      <cel-var-get>
       <cel-str>kb-option-mainoptimization</cel-str>
      </cel-var-get>
      <cel-str>-O3</cel-str>
     </cel-cmp-eq>
    </cel-logic-or>
    <cel-var-set>
     <cel-str>return</cel-str>
     <cel-str>option implied by -O2 and -O3</cel-str>
    </cel-var-set>
   </cel-cond-if>
  </cel-cond-if>
  <cel-var-get>
   <cel-str>return</cel-str>
  </cel-var-get>
 </cel-function-def>

 <!-- thread-jumps -->
 <cel-function-def>
  <cel-str>kb-gxx-option-thread-jumps-is-compatible</cel-str>

  <cel-var-set>
   <cel-str>return</cel-str>
   <cel-function-call>
    <cel-str>kb-gxx-option-gcc2.95-is-compatible</cel-str>
   </cel-function-call>
  </cel-var-set>

  <cel-cond-if>
   <cel-cmp-eq>
    <cel-var-get>
     <cel-str>return</cel-str>
    </cel-var-get>
    <cel-str>1</cel-str>
   </cel-cmp-eq>
   <cel-cond-if>
    <cel-logic-or>
     <cel-cmp-eq>
      <cel-var-get>
       <cel-str>kb-option-mainoptimization</cel-str>
      </cel-var-get>
      <cel-str>-O2</cel-str>
     </cel-cmp-eq>
     <cel-cmp-eq>
      <cel-var-get>
       <cel-str>kb-option-mainoptimization</cel-str>
      </cel-var-get>
      <cel-str>-O3</cel-str>
     </cel-cmp-eq>
    </cel-logic-or>
    <cel-var-set>
     <cel-str>return</cel-str>
     <cel-str>option implied by -O2 and -O3</cel-str>
    </cel-var-set>
   </cel-cond-if>
  </cel-cond-if>
  <cel-var-get>
   <cel-str>return</cel-str>
  </cel-var-get>
 </cel-function-def> 

 <!-- unroll-all-loops -->
 <cel-function-def>
  <cel-str>kb-gxx-option-unroll-all-loops-is-compatible</cel-str>

  <cel-function-call>
   <cel-str>kb-gxx-option-gcc2.95-is-compatible</cel-str>
  </cel-function-call>
 </cel-function-def>

 <!-- unroll-loops -->
 <cel-function-def>
  <cel-str>kb-gxx-option-unroll-loops-is-compatible</cel-str>

  <cel-function-call>
   <cel-str>kb-gxx-option-gcc2.95-is-compatible</cel-str>
  </cel-function-call>
 </cel-function-def>

</cel>
--- NEW FILE: mainopt.xml ---
<?xml version="1.0" ?>

<!-- 
    $Id: mainopt.xml,v 1.1 2007/03/20 20:33:16 xfred Exp $

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

<!-- 'Main optimization' options for gxx -->
<!-- included by gxx/options.xml -->

<cel>
 <!-- Option related functions -->

 <!-- O0 -->
 <cel-function-def>
  <cel-str>kb-gxx-option-O0-is-compatible</cel-str>
  <cel-var-set>
   <cel-str>result</cel-str>
   <cel-function-call>
    <cel-str>kb-gxx-option-gcc2.95-is-compatible</cel-str>
   </cel-function-call>
  </cel-var-set>

  <cel-cond-if>
   <cel-cmp-eq>
    <cel-var-get>
     <cel-str>result</cel-str>
    </cel-var-get>
    <cel-str>1</cel-str>
   </cel-cmp-eq>
   <cel-block>
    <cel-stack-push>
     <cel-str>kb-option-mainoptimization</cel-str>
    </cel-stack-push>
    <cel-stack-push>
     <cel-str>-O0</cel-str>
    </cel-stack-push>
    <cel-var-set>
     <cel-str>result</cel-str>
     <cel-function-call>
      <cel-str>kb-common-option-apply</cel-str>
     </cel-function-call>
    </cel-var-set> 
   </cel-block>   
  </cel-cond-if>
  <cel-var-get>
   <cel-str>result</cel-str>
  </cel-var-get>
 </cel-function-def>

 <!-- Os -->
 <cel-function-def>
  <cel-str>kb-gxx-option-Os-is-compatible</cel-str>

  <cel-var-set>
   <cel-str>result</cel-str>
   <cel-function-call>
    <cel-str>kb-gxx-option-gcc2.95-is-compatible</cel-str>
   </cel-function-call>
  </cel-var-set>

  <cel-cond-if>
   <cel-cmp-eq>
    <cel-var-get>
     <cel-str>result</cel-str>
    </cel-var-get>
    <cel-str>1</cel-str>
   </cel-cmp-eq>
   <cel-block>
    <cel-stack-push>
     <cel-str>kb-option-mainoptimization</cel-str>
    </cel-stack-push>
    <cel-stack-push>
     <cel-str>-Os</cel-str>
    </cel-stack-push>
    <cel-var-set>
     <cel-str>result</cel-str>
     <cel-function-call>
      <cel-str>kb-common-option-apply</cel-str>
     </cel-function-call>
    </cel-var-set> 
   </cel-block>   
  </cel-cond-if>
  <cel-var-get>
   <cel-str>result</cel-str>
  </cel-var-get>
 </cel-function-def>


 <!-- O1 -->
 <cel-function-def>
  <cel-str>kb-gxx-option-O1-is-compatible</cel-str>

  <cel-var-set>
   <cel-str>result</cel-str>
   <cel-function-call>
    <cel-str>kb-gxx-option-gcc2.95-is-compatible</cel-str>
   </cel-function-call>
  </cel-var-set>

  <cel-cond-if>
   <cel-cmp-eq>
    <cel-var-get>
     <cel-str>result</cel-str>
    </cel-var-get>
    <cel-str>1</cel-str>
   </cel-cmp-eq>
   <cel-block>
    <cel-stack-push>
     <cel-str>kb-option-mainoptimization</cel-str>
    </cel-stack-push>
    <cel-stack-push>
     <cel-str>-O1</cel-str>
    </cel-stack-push>
    <cel-var-set>
     <cel-str>result</cel-str>
     <cel-function-call>
      <cel-str>kb-common-option-apply</cel-str>
     </cel-function-call>
    </cel-var-set> 
   </cel-block>   
  </cel-cond-if>
  <cel-var-get>
   <cel-str>result</cel-str>
  </cel-var-get>  
 </cel-function-def>

 <!-- O2 -->
 <cel-function-def>
  <cel-str>kb-gxx-option-O2-is-compatible</cel-str>

  <cel-var-set>
   <cel-str>result</cel-str>
   <cel-function-call>
    <cel-str>kb-gxx-option-gcc2.95-is-compatible</cel-str>
   </cel-function-call>
  </cel-var-set>

  <cel-cond-if>
   <cel-cmp-eq>
    <cel-var-get>
     <cel-str>result</cel-str>
    </cel-var-get>
    <cel-str>1</cel-str>
   </cel-cmp-eq>
   <cel-block>
    <cel-stack-push>
     <cel-str>kb-option-mainoptimization</cel-str>
    </cel-stack-push>
    <cel-stack-push>
     <cel-str>-O2</cel-str>
    </cel-stack-push>
    <cel-var-set>
     <cel-str>result</cel-str>
     <cel-function-call>
      <cel-str>kb-common-option-apply</cel-str>
     </cel-function-call>
    </cel-var-set> 
   </cel-block>   
  </cel-cond-if>
  <cel-var-get>
   <cel-str>result</cel-str>
  </cel-var-get>  
 </cel-function-def>

 <!-- O3 -->
 <cel-function-def>
  <cel-str>kb-gxx-option-O3-is-compatible</cel-str>

  <cel-var-set>
   <cel-str>result</cel-str>
   <cel-function-call>
    <cel-str>kb-gxx-option-gcc2.95-is-compatible</cel-str>
   </cel-function-call>
  </cel-var-set>

  <cel-cond-if>
   <cel-cmp-eq>
    <cel-var-get>
     <cel-str>result</cel-str>
    </cel-var-get>
    <cel-str>1</cel-str>
   </cel-cmp-eq>
   <cel-block>
    <cel-stack-push>
     <cel-str>kb-option-mainoptimization</cel-str>
    </cel-stack-push>
    <cel-stack-push>
     <cel-str>-O3</cel-str>
    </cel-stack-push>
    <cel-var-set>
     <cel-str>result</cel-str>
     <cel-function-call>
      <cel-str>kb-common-option-apply</cel-str>
     </cel-function-call>
    </cel-var-set> 
   </cel-block>   
  </cel-cond-if>
  <cel-var-get>
   <cel-str>result</cel-str>
  </cel-var-get>  
 </cel-function-def>

</cel>
--- NEW FILE: cse.xml ---
<?xml version="1.0" ?>

<!-- 
    $Id: cse.xml,v 1.1 2007/03/20 20:33:14 xfred Exp $

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

<!-- CSE (common subexpression elimination) related options for gxx -->
<!-- included by gxx/options.xml -->

<cel>
 <!-- cse-follow-jumps -->
 <cel-function-def>
  <cel-str>kb-gxx-option-cse-follow-jumps-is-compatible</cel-str>

  <cel-var-set>
   <cel-str>return</cel-str>
   <cel-function-call>
    <cel-str>kb-gxx-option-gcc2.95-is-compatible</cel-str>
   </cel-function-call>
  </cel-var-set>

  <cel-cond-if>
   <cel-cmp-eq>
    <cel-var-get>
     <cel-str>return</cel-str>
    </cel-var-get>
    <cel-str>1</cel-str>
   </cel-cmp-eq>
   <cel-cond-if>
    <cel-logic-or>
     <cel-cmp-eq>
      <cel-var-get>
       <cel-str>kb-option-mainoptimization</cel-str>
      </cel-var-get>
      <cel-str>-O2</cel-str>
     </cel-cmp-eq>
     <cel-cmp-eq>
      <cel-var-get>
       <cel-str>kb-option-mainoptimization</cel-str>
      </cel-var-get>
      <cel-str>-O3</cel-str>
     </cel-cmp-eq>
    </cel-logic-or>
    <cel-var-set>
     <cel-str>return</cel-str>
     <cel-str>option implied by -O2 and -O3</cel-str>
    </cel-var-set>
   </cel-cond-if>
  </cel-cond-if>
  <cel-var-get>
   <cel-str>return</cel-str>
  </cel-var-get>
 </cel-function-def>


 <!-- cse-skip-blocks -->
 <cel-function-def>
  <cel-str>kb-gxx-option-cse-skip-blocks-is-compatible</cel-str>

  <cel-var-set>
   <cel-str>return</cel-str>
   <cel-function-call>
    <cel-str>kb-gxx-option-gcc2.95-is-compatible</cel-str>
   </cel-function-call>
  </cel-var-set>

  <cel-cond-if>
   <cel-cmp-eq>
    <cel-var-get>
     <cel-str>return</cel-str>
    </cel-var-get>
    <cel-str>1</cel-str>
   </cel-cmp-eq>
   <cel-cond-if>
    <cel-logic-or>
     <cel-cmp-eq>
      <cel-var-get>
       <cel-str>kb-option-mainoptimization</cel-str>
      </cel-var-get>
      <cel-str>-O2</cel-str>
     </cel-cmp-eq>
     <cel-cmp-eq>
      <cel-var-get>
       <cel-str>kb-option-mainoptimization</cel-str>
      </cel-var-get>
      <cel-str>-O3</cel-str>
     </cel-cmp-eq>
    </cel-logic-or>
    <cel-var-set>
     <cel-str>return</cel-str>
     <cel-str>option implied by -O2 and -O3</cel-str>
    </cel-var-set>
   </cel-cond-if>
  </cel-cond-if>
  <cel-var-get>
   <cel-str>return</cel-str>
  </cel-var-get>
 </cel-function-def>

 <!-- rerun-cse-after-loop -->
 <cel-function-def>
  <cel-str>kb-gxx-option-rerun-cse-after-loop-is-compatible</cel-str>

  <cel-var-set>
   <cel-str>return</cel-str>
   <cel-function-call>
    <cel-str>kb-gxx-option-gcc2.95-is-compatible</cel-str>
   </cel-function-call>
  </cel-var-set>

  <cel-cond-if>
   <cel-cmp-eq>
    <cel-var-get>
     <cel-str>return</cel-str>
    </cel-var-get>
    <cel-str>1</cel-str>
   </cel-cmp-eq>
   <cel-cond-if>
    <cel-logic-or>
     <cel-cmp-eq>
      <cel-var-get>
       <cel-str>kb-option-mainoptimization</cel-str>
      </cel-var-get>
      <cel-str>-O2</cel-str>
     </cel-cmp-eq>
     <cel-cmp-eq>
      <cel-var-get>
       <cel-str>kb-option-mainoptimization</cel-str>
      </cel-var-get>
      <cel-str>-O3</cel-str>
     </cel-cmp-eq>
    </cel-logic-or>
    <cel-var-set>
     <cel-str>return</cel-str>
     <cel-str>option implied by -O2 and -O3</cel-str>
    </cel-var-set>
   </cel-cond-if>
  </cel-cond-if>
  <cel-var-get>
   <cel-str>return</cel-str>
  </cel-var-get>
 </cel-function-def>
</cel>