<?xml version="1.0"?>
<!DOCTYPE flagsdescription
   SYSTEM "http://www.spec.org/dtd/cpuflags1.dtd"
>

  <flagsdescription>
  <!--
  <filename>flags</filename>
   -->
   <title>Fujitsu Siemens Computers SPEC CPU2006 Flag Description</title>

   <style>
      <![CDATA[
         body { background: white; }
      ]]>
   </style>
 
<!-- HEADERs -->

   <header>
      <![CDATA[
         <p>Compilers: Intel(R) C++ Compiler and Intel(R) Visual Fortran Compiler
            for applications running on Intel(R) 64, Version 10.1<br>
            Operating system: Windows Vista Ultimate, x64 Version<br>
            Last updated: 11-Dec-2007
         </p>
         <p>The text for many of the descriptions below was taken
            from the documentation of the Intel Compilers.
            This documentation is copyright &copy; 2007 Intel Corporation. All Rights Reserved.<br>
            The original documentation is distributed with the Intel compilers.
         </p>
         <hr />
      ]]>
   </header>

   <header class="optimization">
      <![CDATA[
         <p>HEADER for OPTIMIZATION</p>
      ]]>
   </header>
 
   <header class="portability">
      <![CDATA[
         <p>HEADER for PORTABILITY</p>
      ]]>
   </header>
 
   <header class="compiler">
      <![CDATA[
         <p>HEADER for COMPILER</p>
      ]]>
   </header>
 
   <header class="other">
      <![CDATA[
         <p>HEADER for OTHER</p>
      ]]>
   </header>
 
<!-- /HEADERs -->

<!-- OPTIMIZATION -->
	
   <flag name="F-Qprof_gen" class="optimization" regexp="[-/]Qprof_gen">
      <example>-Qprof_gen</example>
      <![CDATA[
         <P>This option instruments a program for profiling
            as first step in Profile Guided Optimization.
         </P>
         <P>Profile Guided Optimization (PGO) consists of 3 phases:<br>
            Phase 1: Compile and generate instrumented code in preparation
            to gather profiling information (compiler flag -Qprof_gen).<br>
            Phase 2: Execute the instrumented code and gather profiling information.<br>
            Phase 3: Recompile the code and use the profiling information
            for improved optimization (compiler flag -Qprof_use).
         </P>
         <P>The option<i> -Qprof_gen </i>instruments a program
            for profiling to get the execution count of each basic block.
            It also creates a new static profile information file (.spi).
            This flag is used in phase 1 of the Profile Guided Optimizer (PGO)
            to instruct the compiler to produce code in your object files
            in preparation for instrumented execution.
         </P>
         <P>The instrumented code<br>
            <UL>
            <LI>Gathers information regarding execution paths.
            <LI>Gathers information regarding data values. 
            <LI>Does not use hardware performance counters.
            </LI>
            </UL>
         </P>
      ]]>
   </flag>
	
   <flag name="F-Qprof_use" class="optimization" regexp="[-/]Qprof_use">
      <example>-Qprof_use</example>
      <![CDATA[
         <P>This option enables the use of profiling information during optimization
            as final step in Profile Guided Optimization.
         </P>
         <P>Profile Guided Optimization (PGO) consists of 3 phases:<br>
            Phase 1: Compile and generate instrumented code in preparation
            to gather profiling information (compiler flag -Qprof_gen).<br>
            Phase 2: Execute the instrumented code and gather profiling information.<br>
            Phase 3: Recompile the code and use the profiling information
            for improved optimization (compiler flag -Qprof_use).
         </P>
         <P>The option <i>-Qprof_use</i> instructs the compiler to use the profiling 
            information from phase 2 of PGO in order to produce a profile-optimized 
            executable (phase 3 of PGO).
         </p>
         <p>
            It also enables function splitting (option -Qfnsplit)
            and function grouping during optimization.
         </P>
         <P>Note that there is no way to turn off function grouping
            if you enable it using this option.
         </P>
         <P>The recompilation with <i>-Qprof_use</i><br>
            <UL>
            <LI>Uses information regarding execution paths. 
            <LI>Uses information regarding data values. 
            <LI>Does not use hardware performance counters. 
            <LI>Uses techniques (like function grouping) which are not available without PGO.
            </LI>
            </UL>
         </p>
      ]]>
      <include flag="F-Qfnsplit"/>
   </flag>

   <flag name="f-fast" class="optimization">
      <example>-fast</example>
      <![CDATA[
         <p>Maximizes speed across the entire program.</p>
         <p>In Windows, it sets the following options:<br>
            -O3 -Qipo -Qprec-div- -QxT
         </p>
         <p>Note that programs compiled with the -QxT option
            will detect non-compatible processors and generate
            an error message during execution.<br>
            The -QxT option that is set by the -fast option
            cannot be overridden by other command line options.
            If you specify -fast and a differnt processor-specific option,
            such as -QxN, the compiler will issue a warning that explains
            the -QxT option cannot be overridden.
         </p>
      ]]>
      <include flag="F-O3"/>
      <include flag="F-Qprec-div-"/>
      <include flag="F-QxT"/>
      <include flag="F-Qipo"/>
   </flag>
	
   <flag name="F-O3" class="optimization" regexp="[-/]O3">
      <example>-O3</example>
      <![CDATA[
         <p>Optimizes for speed. Enables high-level optimization. This level does
         not guarantee higher performance. Using this option may increase the
         compilation time. Impact on performance is application dependent, some
         applications may not see a performance improvement.</p>
         <p>The optimizations include:</p>
         <ul>
            <li>All optimizations done with -O2</li>
            <li>loop unrolling, including instruction scheduling</li>
            <li>code replication to eliminate branches</li>
            <li>padding the size of certain power-of-two arrays to allow more efficient cache use.</li>
            <li>When used with -Qax or -Qx, it causes the compiler to perform
                more aggressive data dependency analysis than for -O2.</li>
         </ul>
      ]]>
      <include flag="F-O2"/>
   </flag>

   <flag name="F-Qprec-div-" class="optimization" regexp="[-/]Qprec-div-?">
      <example>-Qprec-div-</example>
      <![CDATA[
         <p>-Qprec-div improves precision of floating-point divides.
         It has a slight impact on speed.
         -Qprec-div- disables this option.</p>
         <p>With some optimizations, -QxN and -QxB,
         the compiler may change floating-point division computations
         into multiplication by the reciprocal of the denominator.
         For example, A/B is computed as A * (1/B) to improve the speed
         of the computation.</p>
         <p>However, sometimes the value produced by this transformation
         is not as accurate as full IEEE division.
         When it is important to have fully precise IEEE division,
         use this option to disable the floating-point
         division-to-multiplication optimization.
         The result is more accurate, with some loss of performance.</p>
         <p>If you specify -Qprec-div-, it enables optimizations
         that give slightly less precise results than full IEEE division.</p>
         <p>Default is -Qprec-div</p>
      ]]>
   </flag>
	
   <flag name="F-QxT" class="optimization" regexp="[-/]QxT">
      <example>-QxT</example>
      <![CDATA[
         <p>-Qx<i>processor</i>&nbsp;&nbsp;&nbsp; This option directs the compiler
            to generate specialized and optimized code for the Intel processor
            that executes your program.
            It lets you target your program to run on a specific Intel processor.
         </p>
         <p><i>processor</i>&nbsp;&nbsp;&nbsp; Is the processor
            for which you want to target your program.<br>
            Here: T&nbsp;&nbsp;&nbsp; Code is optimized
            generating SSSE3, SSE3, SSE2, and SSE instructions for Intel processors.
            Code can be optimized for the Intel Core 2 Duo processor family.
            The resulting code may contain unconditional use of features
            that are not supported on other processors.<br>
            This option also enables new optimizations in addition to Intel
            processor-specific optimizations including advanced data layout and code
            restructuring optimizations to improve memory accesses for Intel processors.
         </p>
         <p>Programs compiled with -QxT will display a fatal run-time error
            if they are executed on unsupported processors.
         </p>
      ]]>
   </flag>
	
   <flag name="F-Qipo" class="optimization" regexp="[-/]Qipo(5|)">
      <example>-Qipo</example>
      <![CDATA[
         <p>-Qipo[<i>n</i>]</p>
         <p>This option enables interprocedural optimizations between files.
            This is also called multifile interprocedural optimization (multifile IPO)
            or Whole Program Optimization (WPO).
         </p>
         <p>When you specify this option, the compiler performs inline function expansion
            for calls to functions defined in separate files.
         </p>
         <p>You cannot specify the names for the object files that are created.
         </p>
         <p><i>n</i>&nbsp;&nbsp;&nbsp; Is an optional integer that specifies
            the number of object files the compiler should create.
            The integer must be greater than or equal to 0.<br>
            If you do not specify <i>n</i>, the default is 0.
         </p>
         <p>If <i>n</i> is 0, the compiler decides whether to create one or more object files
            based on an estimate of the size of the application.
            It generates one object file for small applications,
            and two or more object files for large applications.
         </p>
         <p>If <i>n</i> is greater than 0, the compiler generates <i>n</i> object files,
            unless <i>n</i> exceeds the number of source files (<i>m</i>),
            in which case the compiler generates only <i>m</i> object files.
         </p>
      ]]>
   </flag>

   <flag name="F-O2" class="optimization" regexp="[-/]O2">
      <example>-O2</example>
      <![CDATA[
         <p>Optimizes for speed.
         <br>The -O2 option includes the following options:</p>
         <ul>
            <li>-Og</li>
            <li>-Oi-</li>
            <li>-Os</li>
            <li>-Oy</li>
            <li>-Ob2</li>
            <li>-GF</li>
            <li>-Gs</li>
            <li>-Gy</li>
            <li>-Qftz</li>
         </ul>
         <p>This options defaults to ON.</p>
         <p>This option also enables:</p>
         <ul>
            <li>inlining of intrinsics</li>
            <li>Intra-file interprocedural optimizations including:</li>
            <ul>
               <li>inlining</li>
               <li>constant propagation</li>
               <li>forward substitution</li>
               <li>routine attribute propagation</li>
               <li>variable address-taken analysis</li>
               <li>dead static function elimination</li>
               <li>removal of unreferenced variables.</li>
            </ul>
            <li>The following performance optimizations:</li>
            <ul>
               <li>copy propogation.</li>
               <li>dead-code elimination</li>
               <li>global register allocation</li>
               <li>global instruction scheduling and control speculation</li>
               <li>loop unrolliing</li>
               <li>optimized code selection</li>
               <li>partial redundancy elimination</li>
               <li>strength reduction/induction variable simplification</li>
               <li>variable renaming</li>
               <li>exception handling optimizations</li>
               <li>tail recursions</li>
               <li>peephole optimizations</li>
               <li>structure assignment lowering and optimization</li>
               <li>dead store elimination</li>
            </ul>
         </ul>
      ]]>
      <include flag="F-Og"/>
      <include flag="F-Oi"/>
      <include flag="F-Os"/>
      <include flag="F-Oy"/>
      <include flag="F-Obn"/>
      <include flag="F-GF"/>
      <include flag="F-Gs"/>
      <include flag="F-Gy"/>
      <include flag="F-Qftz"/>
   </flag>
	
   <flag name="F-Qip" class="optimization" regexp="[-/]Qip">
      <example>-Qip</example>
      <![CDATA[
         <p>Enables single-file interprocedural optimizations within a file.</p>
      ]]>
   </flag>

   <flag name="F-Qparallel" class="optimization" regexp="[-/]Qparallel">
      <example>-Qparallel</example>
      <![CDATA[
         <p>This option tells the auto-parallelizer to generate multithreaded code
            for loops that can be safely executed in parallel.
         </p>
         <p>To use this option, you must also specify -O2 or -O3.
         </p>
      ]]>
   </flag>

   <flag name="f-Qvec-guard-write" class="optimization" regexp="-Qvec-guard-write\b">
      Enables cache/bandwidth optimization for stores
      under conditionals (within vector loops).
      This option tells the compiler to perform a conditional check
      in a vectorized loop. This checking avoids unnecessary stores
      and may improve performance by conserving bandwidth.
   </flag>

   <flag name="f-Qpar-runtime-control" class="optimization"
         regexp="-Qpar-runtime-control\b">
      Enable compiler to generate runtime control code
      for effective automatic parallelization.
      
      This option generates code to perform run-time checks
      for loops that have symbolic loop bounds. 
      If the granularity of a loop is greater than the parallelization threshold,
      the loop will be executed in parallel. If you do not specify this option,
      the compiler may not parallelize loops with symbolic loop bounds
      if the compile-time granularity estimation of a loop can not ensure 
      it is beneficial to parallelize the loop.
   </flag>

   <flag name="f-Qansi-alias" class="optimization" regexp="-Qansi-alias\b">
      Enable/disable(DEFAULT) use of ANSI aliasing rules in
      optimizations; user asserts that the program adheres to
      these rules. 
   </flag>

   <flag name="F-Qfnsplit" class="optimization">
      <example>-Qfnsplit</example>
      <![CDATA[
         <p>Enables function splitting.</p>
         <p>This option enables function splitting if -Qprof-use is also specified.
         Otherwise, this option has no effect.</p>
         <p>It is enabled automatically if you specify -Qprof-use. If you do not specify
         one of those options, the default is -Qfnsplit-, which disables
         function splitting but leaves function grouping enabled.</p>
         <p>To disable function splitting when you use -Qprof-use, specify -Qfnsplit-.</p> 
      ]]>
   </flag>

   <flag name="f-Qopt-ra-region-strategy-routine" class="optimization"
         regexp="-Qopt-ra-region-strategy\=(routine|block|trace|loop|default)\b">
   <![CDATA[
      <P>Select the method that the register allocator uses to partition
      each routine into regions
      <ul>
      <li>routine - one region per routine</li>
      <li>block - one region per block</li>
      <li>trace - one region per trace</li> 
      <li>loop - one region per loop</li>
      <li>default - compiler selects best option</li>
      </ul></P>
   ]]>
   </flag>

   <flag name="f-Qopt-multi-version-aggressive" class="optimization"
         regexp="-Qopt-multi-version-aggressive\b">
      Multi-versioning is used for generating different versions of the loop based on
      run time dependence testing, alignment and checking for short/long trip counts.
      If this option is turned on, it will trigger more versioning at the expense
      of creating more overhead to check for pointer aliasing and scalar replacement.
   </flag>

   <flag name="f-Qopt-streaming-stores-always" class="optimization"
         regexp="-Qopt-streaming-stores:(always|auto|never)\b">
   <![CDATA[
      <p>Specifies whether streaming stores are generated:
      <ul>
      <li>always - enables generation of streaming stores under the assumption
          that the application is memory bound</li>
      <li>auto   - compiler decides when streaming stores are used (DEFAULT)</li>
      <li>never  - disables generation of streaming stores</li>
      </ul></p>
   ]]>
   </flag>
	
   <flag name="F-Og" class="optimization" regexp="[-/]Og">
      <example>-Og</example>
      <![CDATA[
         <p>Enables global optimizations.</p>
      ]]>
   </flag>
	
	<flag name="F-Oi" class="optimization" regexp="[-/]Oi-?">
		<example>-Oi</example>
		<![CDATA[
			<p>Enables/disables inline expansion of intrinsic functions.</p>
			<p>Default enabled</p>
		]]>
	</flag>
	
	<flag name="F-Os" class="optimization" regexp="[-/]Os">
		<example>-Os</example>
		<![CDATA[
			<p>This option enables most speed optimizations, but disables some that increase
			code size for a small speed benefit.</p>
			<p>Default enabled</p>
		]]>
	</flag>
	
	<flag name="F-Oy" class="optimization" regexp="[-/]Oy-?">
		<example>-Oy</example>
		<![CDATA[
			<p>Enables [disables] the use of the EBP register in optimizations.
			When you disable with <i>-Oy-</i>, the EBP register is used as frame pointer.
			-Oy has the effect of reducing the number of general-purpose registers by 1,
			and can produce slightly less efficient code.</p>
			<p>Default enabled</p>
		]]>
	</flag>
	
	<flag name="F-Obn" class="optimization" regexp="[-/]Ob(0|1|2|3)">
		<example>-Ob&lt;n&gt;</example>
		<![CDATA[
			<p><b><i>n</i> = 0</b>
			<br>Disables inlining of user-defined functions.
			However, statement functions are always inlined</p>
			<p><b><i>n</i> = 1</b>
			<br>Enables inlining of functions declared with the __inline keyword.
			Also enables inlining according to the C++ language</p>
			<p><b><i>n</i> = 2</b>
			<br>Enables inlining of any function.
			However, the compiler decides which functions are inlined.
			This option enables interprocedural optimizations and has the same
			effect as specifying option <i>Qip</i>.</p>
			<p>Default enabled with <i>n</i> = 2</p>
		]]>
	</flag>

	<flag name="F-GF" class="optimization" regexp="[-/]GF">
		<example>-GF</example>
		<![CDATA[
			<p>This option enables read-only string-pooling optimization.</p>
		]]>
	</flag>
	
	<flag name="F-Gs" class="optimization" regexp="[-/]Gs&lt;n&gt;?">
		<example>-Gs</example>
		<![CDATA[
			<p>Disables stack-checking for routines with n or more bytes of local
			variables and compiler temporaries.</p>
			<p>Default enabled with <i>n</i> = 4096.</p>
		]]>
	</flag>
	
	<flag name="F-Oa" class="optimization" regexp="[-/]Oa-?">
		<example>-Oa</example>
		<![CDATA[
			<p>Assume [not assume] no aliasing</p>
			<p>Default disabled</p>
		]]>
	</flag>
	
	<flag name="F-Ot" class="optimization" regexp="[-/]Ot">
		<example>-Ot</example>
		<![CDATA[
			<p>Enables all speed optimizations.</p>
			<p>Overrides -Os</p>
		]]>
	</flag>
	
	<flag name="F-Ow" class="optimization" regexp="[-/]Ow-?">
		<example>-Ow</example>
		<![CDATA[
			<p>Assume[not assume] no cross function aliasing.</p>
		]]>
	</flag>
	
	<flag name="F-Gf" class="optimization" regexp="[-/]Gf">
		<example>-Gf</example>
		<![CDATA[
			<p>Enables string-pooling optimization.</p>
		]]>
	</flag>
	
	<flag name="F-Gy" class="optimization" regexp="[-/]Gy">
		<example>-Gy</example>
		<![CDATA[
			<p>Packages functions to enable linker optimization.</p>
			<p>Default enabled</p>
		]]>
	</flag>
	
	<flag name="F-Qax" class="optimization" regexp="[-/]Qax[KWNPB]">
		<example>-QaxP</example>
		<![CDATA[
			<p>Generates specialized code for processor specific codes K, W, N, P while also generating generic IA-32 code.</p>
			<ul>
				<li><b>K</b> = Intel Pentium III and compatible Intel processors</li>
				<li><b>W</b> = Intel Pentium 4 and compatible Intel processors</li>
				<li><b>N</b> = Intel Pentium 4 and compatible Intel processors.
							These options also enable advanced data layout and code restructuring
							optimizations to improve memory accesses for Intel processors.</li>
				<li><b>P</b> = Intel Pentium 4 processor with Streaming SIMD 3 (SSE3) support.
							These option also enable advanced data layout and code restructuring optimizations
							to improve memory accesses for Intel processors.</li>
			</ul>
		]]>
	</flag>
	
	<flag name="F-Qrcd" class="optimization" regexp="[-/]Qrcd">
		<example>-Qrcd</example>
		<![CDATA[
			<p>Enables[disables] fast conversions of floating-point to integer conversions.
			This option does not guarantee that any particular rounding mode will be used.</p>
		]]>
	</flag>
	
	<flag name="F-Qansi_alias" class="optimization" regexp="[-/]Qansi_alias-?">
		<example>-Qansi_alias</example>
		<![CDATA[
			<p><b>for C and C++</b><br />
			<ul>
				Qansi_alias directs the compiler to assume the following:
			    <li>Arrays are not accessed out of bounds.</li>
			    <li>Pointers are not cast to non-pointer types, and vice-versa.</li>
			    <li>References to objects of two different scalar types cannot alias.
			    For example, an object of type int cannot alias with an object of type float,
			    or an object of type float cannot alias with an object of type double.</li>
			</ul>
			</p>
			<p>If your program satisfies the above conditions, setting the -Qansi_alias
			flag will help the compiler better optimize the program. However, if your
			program does not satisfy one of the above conditions, the -Qansi_alias
			flag may lead the compiler to generate incorrect code.</p>
			<p><b>for Fortran</b><br />
			Enables (default) or disables the compiler to assume that the program adheres to the ANSI Fortran type aliasablility rules.
			For example, an object of type real cannot be accessed as an integer.
			You should see the ANSI Standard for the complete set of rules.</p>
			
		]]>
	</flag>
	
	<flag name="F-Qfp_port" class="optimization" regexp="[-/]Qfp_port">
		<example>-Qfp_port</example>
		<![CDATA[
			<p>round fp results at assignments & casts (some speed impact)</p>
		]]>
	</flag>

	<flag name="F-Qftz" class="optimization" regexp="[-/]Qftz">
		<example>-Qftz</example>
		<![CDATA[
			<p>This option flushes denormal results to zero when the application
                           is in the gradual underflow mode. It may improve performance
                           if the denormal values are not critical to your application's behavior.
                        </p>
                        <p>This option only has an effect when the main program is being compiled.
                           It sets the ftz mode for the process.
                        </p>
		]]>
	</flag>
	
   <flag name="F-Qprefetch" class="optimization" regexp="[-/]Qprefetch">
      <example>-Qprefetch</example>
      <![CDATA[
         <p>This option enables prefetch insertion optimization.
         The goal of prefetching is to reduce cache misses
         by providing hints to the processor about when data
         should be loaded into the cache.</p>
         <p>Default is -Qprefetch- which disables this kind of optimization.</p>
      ]]>
   </flag>

   <flag name="f-unroll_n" class="optimization" regexp="-Qunroll\d+\b">
      <![CDATA[
         <p>-Qunroll<i>n</i> tells the compiler the maximum number
         of times to unroll loops.<br>
         If <i>n</i> is not specified, the optimizer determines
         how many times loops can be unrolled.<br>
         If <i>n</i> is 0, loop unrolling is disabled.</p>
      ]]>
   </flag>

   <flag name="f-Qunroll-aggressive" class="optimization" regexp="-Qunroll-aggressive\b">
      Enables more aggressive unrolling heuristics
   </flag>

   <flag name="f-Qauto" class="optimization" regexp="-Qauto">
   <![CDATA[
      <p>This option places local variables, except those declared as SAVE, to the run-time stack. 
      It is as if the variables were declared with the AUTOMATIC attribute. </p>

      <p> It does not affect variables that have the SAVE attribute or ALLOCATABLE attribute, 
      or variables that appear in an EQUIVALENCE statement or in a common block. </p>

      <p>This option may provide a performance gain for your program, but if your program depends on 
      variables having the same value as the last time the routine was invoked, your program may not 
      function properly. </p>

      <p> If you want to cause variables to be placed in static memory, specify /Qsave (Windows). <p>
   ]]> 
   </flag>
	
	<flag name="F-Zp" class="optimization" regexp="[-/]Zp[1248]}">
		<example>-Zp</example>
		<![CDATA[
			<p>Specifies the strictest alignment constraint for structure and union types as 1, 2. 4. 8 or 16 bytes</p>
			<p>Default is 16.</p>
			<p>Problem: 16 is also possible. How to write regexp?</p>
		]]>
	</flag>
	
	<flag name="F-arch:SSE" class="optimization" regexp="[-/]arch:SSE">
		<example>-arch:SSE</example>
		<![CDATA[
			<p>Enables the compiler to use SSE instructions.</p>
		]]>
	</flag>
	
	<flag name="F-arch:SSE2" class="optimization" regexp="[-/]arch:SSE2">
		<example>-arch:SSE2</example>
		<![CDATA[
			<p>Enables the compiler to use SSE2 instructions.</p>
		]]>
	</flag>
	
	<flag name="F-Qpc64" class="optimization" regexp="[-/]Qpc64">
		<example>-Qpc64</example>
		<![CDATA[
			<p>Enables floating-point significand precision control.
			The value is used to round the significand to the correct number of bits.
			The value must be either 32, 64 or 80.</p>
			<p>Default enabled</p>
		]]>
	</flag>
	
	<flag name="F-Ox" class="optimization" regexp="[-/]Ox">
		<example>-Ox</example>
		<![CDATA[
			<p>Same as the -O2 option: enables -Gs, and -Ob1, -Og, -Oy, and -Ot.</p>
		]]>
		<include flag="F-Gs" />
		<include flag="F-Obn" />
		<include flag="F-Og" />
		<include flag="F-Oy" />
		<include flag="F-Ot" />
	</flag>
	
	<flag name="F-auto" class="optimization" regexp="[-/]auto">
		<example>-auto</example>
		<![CDATA[
			<p>Determines whether local variables are put on the run-time stack.</p>
		]]>
	</flag>
	
	<flag name="F-Qscalar_rep" class="optimization" regexp="[-/]Qscalar[-_]rep-?">
		<example>-Qscalar_rep-</example>
		<![CDATA[
			<p>Enables[disables] scalar replacement performed during loop transformations.
			<br />(requires /O3).</p>
		]]>
	</flag>

   <flag name="F-Qcxx-features" class="optimization" regexp="[-/]Qcxx[-_]features">
      <example>-Qcxx-features</example>
      <![CDATA[
         <p>This option enables standard C++ features without disabling Microsoft
         features within the bounds of what is provided in the Microsoft headers and
         libraries.</p>
         <p>This option has the same effect as specifying -GX -GR.</p>
         <p>-GX Enables C++ exception handling.<br>
         -GR Enables C++ Run Time Type Information (RTTI).</p>
      ]]>
   </flag>

   <flag name="F-Fstacksize" class="optimization" regexp="-F\d+">
      <example>-F10000</example>
      <![CDATA[
         <p>Specifies the stack reserve amount for the program.</p>
         <p>-F&lt;n&gt;<br>
         &lt;n&gt; is the stack reserve amount.
         It can be specified as a decimal integer or by using a C-style convention
         for constants (for example, -F0x1000).<br>
         Default: The stack size default is chosen by the operating system.</p>
      ]]>
   </flag>

   <flag name="F-linkMultiple" class="optimization" regexp="-link -FORCE:MULTIPLE">
      <example>-link -FORCE:MULTIPLE</example>
      <![CDATA[
         <p>Force Linking even if multiple entry names are found.</p>
      ]]>
   </flag>

   <flag name="F-shlW32M.lib" class="optimization" regexp="shlW32M.lib">
      <example>shlw32m.lib</example>
      <![CDATA[
         <p>Link with MicroQuill SmartHeap Library.<br>
         Available from
         <a href="http://www.microquill.com/">http://www.microquill.com/</a></p>
      ]]>
   </flag>

   <flag name="F-shlW64M.lib" class="optimization" regexp="shlW64M.lib">
      <example>shlw64m.lib</example>
      <![CDATA[
         <p>Link with MicroQuill SmartHeap Library (64-bit version).<br>
         Available from
         <a href="http://www.microquill.com/">http://www.microquill.com/</a></p>
      ]]>
   </flag>

   <flag name="f-libguide40.lib" class="optimization" regexp="libguide40.lib\b">
      <![CDATA[       
         <p>The use of -Qparallel to generate auto-parallelized code
         requires support libraries that are dynamically linked by default.
         Specifying libguide40.lib on the link line, statically links in libguide40.lib
         to allow auto-parallelized binaries to work on systems which do not have the 
         dynamic version of this library installed.</p>
      ]]> 
   </flag>
	
<!-- /OPTIMIZATION -->

<!-- PORTABILITY -->

   <flag name="F-TP" class="portability" regexp="[/-]TP">
      <example>-TP</example>
      <![CDATA[
         <p>-TP tells the compiler to process all source or unrecognized file types
         as C++ source files.<br>
         Default: The compiler assumes that files with the extension .c or .C
         are C source files.
         To handle them as C++ source files, the compiler flag -TP is needed.</p>
      ]]>
   </flag>

   <flag name="F-DSPEC_CPU_NO_NEED_VA_COPY" class="portability" regexp="-DSPEC_CPU_NO_NEED_VA_COPY">
      <example>-DSPEC_CPU_NO_NEED_VA_COPY</example>
      <![CDATA[
         Deselect the use of the special macro to copy va_list
         (variable argument list).<br>
         Without -DSPEC_CPU_NO_NEED_VA_COPY, a Runtime Error (unhandled win32 exception)
         occurs in 400.perlbench.
      ]]>
   </flag>

   <flag name="F-Qlowercase" class="portability">
      <example>-Qlowercase</example>
      <![CDATA[
         <p>-Qlowercase causes the compiler to ignore case differences in identifiers
         and to convert external names to lowercase.<br>
         It is needed to specify the naming convention for mixing C and Fortran codes.</p>
      ]]>
   </flag>
	
   <flag name="F-assume:underscore" class="portability" regexp="[/-]assume:underscore">
      <example>-assume:underscore</example>
      <![CDATA[
         <p><b>-assume:[no]underscore</b><br>
         Determines whether the compiler appends an underscore character
         to external user-defined names.<br>
         -assume:underscore is needed to specify the naming convention
         for mixing C and Fortran codes.</p>
      ]]>
   </flag>

   <flag name="F-D_Complex" class="portability" regexp="-D_Complex=">
      <example>-D_Complex=</example>
      <![CDATA[
         Unset a buggy Macro in the current version of Microsoft Visual Studio 2005.
      ]]>
   </flag>

   <flag name="F-Qoption_no_wchar_t_keyword" class="portability" regexp="-Qoption,cpp,--no_wchar_t_keyword">
      <example>-Qoption,cpp,--no_wchar_t_keyword</example>
      <![CDATA[
         <p>-Qoption,<i>string</i>,<i>options</i>&nbsp;&nbsp;&nbsp; This option
            passes options to a specified tool.
         </p>
         <p><i>string</i>&nbsp;&nbsp;&nbsp; Is the name of the tool.<br>
            Here: cpp indicates the C++ preprocessor.
         </p>
         <p><i>options</i>&nbsp;&nbsp;&nbsp; Are one or more comma-separated,
            valid options for the designated tool.<br>
            Here: --no_wchar_t_keyword is passed to C++ preprocessor to provide
            the information that there is no wchar_t keyword.
         </p>
         <p>This flag must be used with Microsoft Visual Studio 2005.<br>
            It avoids syntax errors coming from the use of wchar_t in 483.xalancbmk.
         </p>
      ]]>
   </flag>

<!-- /PORTABILITY -->

<!-- COMPILER -->

   <flag name="Ficl" class="compiler" regexp="icl">
      <example>icl</example>
      <![CDATA[
         <p> Invoke Intel C/C++ compiler.<br>
         Also used to invoke linker for C/C++ programs.</p>
      ]]>
   </flag>

   <flag name="Fifort" class="compiler" regexp="ifort">
      <example>icl</example>
      <![CDATA[
         <p> Invoke Intel Fortran compiler.<br>
         Also used to invoke linker for Fortran programs
         and C/Fortran mixtures.</p>
      ]]>
   </flag>

   <flag name="F-Qc99" class="compiler" regexp="[/-]Qc99-?">
      <example>-Qc99</example>
      <![CDATA[
         <p>This option enables/disables C99 support for C programs.</p>
      ]]>
   </flag>

   <flag name="F-Qvc71" class="compiler" regexp="[/-]Qvc7.1">
      <example>-Qvc7.1</example>
      <![CDATA[
         Specifies compatibilty with Microsoft Visual Studio .NET 2003.
      ]]>
   </flag>

   <flag name="F-Qvc8" class="compiler">
      <example>-Qvc8</example>
      <![CDATA[
         Specifies compatibilty with Microsoft Visual Studio 2005.
      ]]>
   </flag>

<!-- /COMPILER -->

<!-- OTHER -->

<!-- currently there are no flags in the class "other" -->

<!-- /OTHER -->

</flagsdescription>