Subversion Repositories openrisc_me

; Options for the language- and target-independent parts of the compiler.

; Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010

; Free Software Foundation, Inc.

;

; 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

; .

; See the GCC internals manual (options.texi) for a description of this file's format.

; Please try to keep this file in ASCII collating order.

-help

Common

Display this information

-help=

Common Report Joined

--help= Display descriptions of a specific class of options.   is one or more of optimizers, target, warnings, undocumented, params

-target-help

Common

Alias for --help=target

;; The following four entries are to work around the gcc driver

;; program's insatiable desire to turn options starting with a

;; double dash (--) into options starting with a dash f (-f).

fhelp

Common Var(help_flag)

fhelp=

Common Joined

ftarget-help

Common

fversion

Common

-param

Common Separate

--param =       Set parameter  to value.  See below for a complete list of parameters

-version

Common

G

Common Joined Separate UInteger

-G      Put global and static data smaller than  bytes into a special section (on some targets)

O

Common JoinedOrMissing Optimization

-O      Set optimization level to 

Os

Common Optimization

Optimize for space rather than speed

W

Common RejectNegative Var(extra_warnings) Warning

This switch is deprecated; use -Wextra instead

Waggregate-return

Common Var(warn_aggregate_return) Warning

Warn about returning structures, unions or arrays

Warray-bounds

Common Var(warn_array_bounds) Warning

Warn if an array is accessed out of bounds

Wattributes

Common Var(warn_attributes) Init(1) Warning

Warn about inappropriate attribute usage

Wcast-align

Common Var(warn_cast_align) Warning

Warn about pointer casts which increase alignment

Wdeprecated-declarations

Common Var(warn_deprecated_decl) Init(1) Warning

Warn about uses of __attribute__((deprecated)) declarations

Wdisabled-optimization

Common Var(warn_disabled_optimization) Warning

Warn when an optimization pass is disabled

Werror

Common Var(warnings_are_errors)

Treat all warnings as errors

Werror=

Common Joined

Treat specified warning as error

Wextra

Common Var(extra_warnings) Warning

Print extra (possibly unwanted) warnings

Wfatal-errors

Common Var(flag_fatal_errors)

Exit on the first error occurred

Wframe-larger-than=

Common RejectNegative Joined UInteger

-Wframe-larger-than=    Warn if a function's stack frame requires more than  bytes

Winline

Common Var(warn_inline) Warning

Warn when an inlined function cannot be inlined

Wlarger-than-

Common RejectNegative Joined UInteger Warning Undocumented

Wlarger-than=

Common RejectNegative Joined UInteger Warning

-Wlarger-than=  Warn if an object is larger than  bytes

Wunsafe-loop-optimizations

Common Var(warn_unsafe_loop_optimizations) Warning

Warn if the loop cannot be optimized due to nontrivial assumptions.

Wmissing-noreturn

Common Var(warn_missing_noreturn) Warning

Warn about functions which might be candidates for __attribute__((noreturn))

Wmudflap

Common Var(warn_mudflap) Init(1) Warning

Warn about constructs not instrumented by -fmudflap

Woverflow

Common Var(warn_overflow) Init(1) Warning

Warn about overflow in arithmetic expressions

Wpacked

Common Var(warn_packed) Warning

Warn when the packed attribute has no effect on struct layout

Wpadded

Common Var(warn_padded) Warning

Warn when padding is required to align structure members

Wshadow

Common Var(warn_shadow) Warning

Warn when one local variable shadows another

Wstack-protector

Common Var(warn_stack_protect) Warning

Warn when not issuing stack smashing protection for some reason

Wstrict-aliasing

Common Warning

Warn about code which might break strict aliasing rules

Wstrict-aliasing=

Common Joined UInteger Var(warn_strict_aliasing) Init(-1) Warning

Warn about code which might break strict aliasing rules

Wstrict-overflow

Common Warning

Warn about optimizations that assume that signed overflow is undefined

Wstrict-overflow=

Common Joined UInteger Var(warn_strict_overflow) Init(-1) Warning

Warn about optimizations that assume that signed overflow is undefined

Wswitch

Common Var(warn_switch) Warning

Warn about enumerated switches, with no default, missing a case

Wswitch-default

Common Var(warn_switch_default) Warning

Warn about enumerated switches missing a \"default:\" statement

Wswitch-enum

Common Var(warn_switch_enum) Warning

Warn about all enumerated switches missing a specific case

Wsystem-headers

Common Var(warn_system_headers) Warning

Do not suppress warnings from system headers

Wtype-limits

Common Var(warn_type_limits) Init(-1) Warning

Warn if a comparison is always true or always false due to the limited range of the data type

Wuninitialized

Common Var(warn_uninitialized) Init(-1) Warning

Warn about uninitialized automatic variables

Wunreachable-code

Common

Does nothing. Preserved for backward compatibility.

Wunused

Common Var(warn_unused) Init(0) Warning

Enable all -Wunused- warnings

Wunused-function

Common Var(warn_unused_function) Init(-1) Warning

Warn when a function is unused

Wunused-label

Common Var(warn_unused_label) Init(-1) Warning

Warn when a label is unused

Wunused-parameter

Common Var(warn_unused_parameter) Init(-1) Warning

Warn when a function parameter is unused

Wunused-value

Common Var(warn_unused_value) Init(-1) Warning

Warn when an expression value is unused

Wunused-variable

Common Var(warn_unused_variable) Init(-1) Warning

Warn when a variable is unused

Wcoverage-mismatch

Common RejectNegative Var(warn_coverage_mismatch) Warning

Warn instead of error in case profiles in -fprofile-use do not match

aux-info

Common Separate

-aux-info       Emit declaration information into 

aux-info=

Common Joined

auxbase

Common Separate

auxbase-strip

Common Separate

d

Common Joined

-d      Enable dumps from specific passes of the compiler

dumpbase

Common Separate

-dumpbase       Set the file basename to be used for dumps

dumpdir

Common Separate

-dumpdir        Set the directory name to be used for dumps

; The version of the C++ ABI in use.  The following values are allowed:

;

; 0: The version of the ABI believed most conformant with the C++ ABI

;    specification.  This ABI may change as bugs are discovered and fixed.

;    Therefore, 0 will not necessarily indicate the same ABI in different

;    versions of G++.

;

; 1: The version of the ABI first used in G++ 3.2.

;

; 2: The version of the ABI first used in G++ 3.4 (and current default).

;

; 3: The version of the ABI that fixes the missing underscore

;    in template non-type arguments of pointer type.

;

; 4: The version of the ABI that introduces unambiguous mangling of

;    vector types.

;

; Additional positive integers will be assigned as new versions of

; the ABI become the default version of the ABI.

fabi-version=

Common Joined UInteger Var(flag_abi_version) Init(2)

falign-functions

Common Report Var(align_functions,0) Optimization UInteger

Align the start of functions

falign-functions=

Common RejectNegative Joined UInteger

falign-jumps

Common Report Var(align_jumps,0) Optimization UInteger

Align labels which are only reached by jumping

falign-jumps=

Common RejectNegative Joined UInteger

falign-labels

Common Report Var(align_labels,0) Optimization UInteger

Align all labels

falign-labels=

Common RejectNegative Joined UInteger

falign-loops

Common Report Var(align_loops) Optimization UInteger

Align the start of loops

falign-loops=

Common RejectNegative Joined UInteger

; This flag is only tested if alias checking is enabled.

; 0 if pointer arguments may alias each other.  True in C.

; 1 if pointer arguments may not alias each other but may alias

;   global variables.

; 2 if pointer arguments may not alias each other and may not

;   alias global variables.

; 3 if pointer arguments may not alias anything.  True in Fortran.

;   Set by the front end.

fargument-alias

Common Report Var(flag_argument_noalias,0) Optimization

Specify that arguments may alias each other and globals

fargument-noalias

Common Report Var(flag_argument_noalias,1) VarExists Optimization

Assume arguments may alias globals but not each other

fargument-noalias-global

Common Report Var(flag_argument_noalias,2) VarExists Optimization

Assume arguments alias neither each other nor globals

fargument-noalias-anything

Common Report Var(flag_argument_noalias,3) VarExists Optimization

Assume arguments alias no other storage

fasynchronous-unwind-tables

Common Report Var(flag_asynchronous_unwind_tables) Optimization

Generate unwind tables that are exact at each instruction boundary

fauto-inc-dec

Common Report Var(flag_auto_inc_dec) Init(1)

Generate auto-inc/dec instructions

; -fcheck-bounds causes gcc to generate array bounds checks.

; For C, C++ and ObjC: defaults off.

; For Java: defaults to on.

; For Fortran: defaults to off.

fbounds-check

Common Report Var(flag_bounds_check)

Generate code to check bounds before indexing arrays

fbranch-count-reg

Common Report Var(flag_branch_on_count_reg) Init(1) Optimization

Replace add, compare, branch with branch on count register

fbranch-probabilities

Common Report Var(flag_branch_probabilities) Optimization

Use profiling information for branch probabilities

fbranch-target-load-optimize

Common Report Var(flag_branch_target_load_optimize) Optimization

Perform branch target load optimization before prologue / epilogue threading

fbranch-target-load-optimize2

Common Report Var(flag_branch_target_load_optimize2) Optimization

Perform branch target load optimization after prologue / epilogue threading

fbtr-bb-exclusive

Common Report Var(flag_btr_bb_exclusive) Optimization

Restrict target load migration not to re-use registers in any basic block

fcall-saved-

Common Joined RejectNegative

-fcall-saved-   Mark  as being preserved across functions

fcall-used-

Common Joined RejectNegative

-fcall-used-    Mark  as being corrupted by function calls

; Nonzero for -fcaller-saves: allocate values in regs that need to

; be saved across function calls, if that produces overall better code.

; Optional now, so people can test it.

fcaller-saves

Common Report Var(flag_caller_saves) Optimization

Save registers around function calls

fcheck-data-deps

Common Report Var(flag_check_data_deps)

Compare the results of several data dependence analyzers.

fcommon

Common Report Var(flag_no_common,0) Optimization

Do not put uninitialized globals in the common section

fcompare-debug=

Common JoinedOrMissing RejectNegative Var(flag_compare_debug_opt)

-fcompare-debug[=]      Compile with and without e.g. -gtoggle, and compare the final-insns dump

fcompare-debug-second

Common RejectNegative Var(flag_compare_debug)

Run only the second compilation of -fcompare-debug

fconserve-stack

Common Var(flag_conserve_stack) Optimization

Do not perform optimizations increasing noticeably stack usage

fcprop-registers

Common Report Var(flag_cprop_registers) Optimization

Perform a register copy-propagation optimization pass

fcrossjumping

Common Report Var(flag_crossjumping) Optimization

Perform cross-jumping optimization

fcse-follow-jumps

Common Report Var(flag_cse_follow_jumps) Optimization

When running CSE, follow jumps to their targets

fcse-skip-blocks

Common

Does nothing.  Preserved for backward compatibility.

fcx-limited-range

Common Report Var(flag_cx_limited_range) Optimization

Omit range reduction step when performing complex division

fcx-fortran-rules

Common Report Var(flag_cx_fortran_rules) Optimization

Complex multiplication and division follow Fortran rules

fdata-sections

Common Report Var(flag_data_sections) Optimization

Place data items into their own section

fdbg-cnt-list

Common Report

List all available debugging counters with their limits and counts.

fdbg-cnt=

Common RejectNegative Joined

-fdbg-cnt=:[,:,...]     Set the debug counter limit.

fdebug-prefix-map=

Common Joined RejectNegative

Map one directory name to another in debug information

; Nonzero for -fdefer-pop: don't pop args after each function call

; instead save them up to pop many calls' args with one insns.

fdefer-pop

Common Report Var(flag_defer_pop) Optimization

Defer popping functions args from stack until later

fdelayed-branch

Common Report Var(flag_delayed_branch) Optimization

Attempt to fill delay slots of branch instructions

fdelete-null-pointer-checks

Common Report Var(flag_delete_null_pointer_checks) Init(1) Optimization

Delete useless null pointer checks

fdiagnostics-show-location=

Common Joined RejectNegative

-fdiagnostics-show-location=[once|every-line]   How often to emit source location at the beginning of line-wrapped diagnostics

fdiagnostics-show-option

Common

Amend appropriate diagnostic messages with the command line option that controls them

fdump-

Common Joined RejectNegative

-fdump- Dump various compiler internals to a file

fdump-final-insns=

Common RejectNegative Joined Var(flag_dump_final_insns)

-fdump-final-insns=filename     Dump to filename the insns at the end of translation

fdump-noaddr

Common Report Var(flag_dump_noaddr)

Suppress output of addresses in debugging dumps

fdump-unnumbered

Common Report Var(flag_dump_unnumbered) VarExists

Suppress output of instruction numbers, line number notes and addresses in debugging dumps

fdump-unnumbered-links

Common Report Var(flag_dump_unnumbered_links) VarExists

Suppress output of previous and next insn numbers in debugging dumps

fdwarf2-cfi-asm

Common Report Var(flag_dwarf2_cfi_asm) Init(HAVE_GAS_CFI_DIRECTIVE)

Enable CFI tables via GAS assembler directives.

fearly-inlining

Common Report Var(flag_early_inlining) Init(1) Optimization

Perform early inlining

feliminate-dwarf2-dups

Common Report Var(flag_eliminate_dwarf2_dups)

Perform DWARF2 duplicate elimination

fipa-sra

Common Report Var(flag_ipa_sra) Init(0) Optimization

Perform interprocedural reduction of aggregates

feliminate-unused-debug-symbols

Common Report Var(flag_debug_only_used_symbols)

Perform unused type elimination in debug info

feliminate-unused-debug-types

Common Report Var(flag_eliminate_unused_debug_types) Init(1)

Perform unused type elimination in debug info

femit-class-debug-always

Common Report Var(flag_emit_class_debug_always) Init(0)

Do not suppress C++ class debug information.

fenable-icf-debug

Common Report Var(flag_enable_icf_debug)

Generate debug information to support Identical Code Folding (ICF)

fexceptions

Common Report Var(flag_exceptions) Optimization

Enable exception handling

fexpensive-optimizations

Common Report Var(flag_expensive_optimizations) Optimization

Perform a number of minor, expensive optimizations

fexcess-precision=

Common Joined RejectNegative

-fexcess-precision=[fast|standard]      Specify handling of excess floating-point precision

ffast-math

Common

ffinite-math-only

Common Report Var(flag_finite_math_only) Optimization

Assume no NaNs or infinities are generated

ffixed-

Common Joined RejectNegative

-ffixed-        Mark  as being unavailable to the compiler

ffloat-store

Common Report Var(flag_float_store) Optimization

Don't allocate floats and doubles in extended-precision registers

fforce-addr

Common

Does nothing.  Preserved for backward compatibility.

fforward-propagate

Common Report Var(flag_forward_propagate) Optimization

Perform a forward propagation pass on RTL

; Nonzero means don't put addresses of constant functions in registers.

; Used for compiling the Unix kernel, where strange substitutions are

; done on the assembly output.

ffunction-cse

Common Report Var(flag_no_function_cse,0)

Allow function addresses to be held in registers

ffunction-sections

Common Report Var(flag_function_sections)

Place each function into its own section

fgcse

Common Report Var(flag_gcse) Optimization

Perform global common subexpression elimination

fgcse-lm

Common Report Var(flag_gcse_lm) Init(1) Optimization

Perform enhanced load motion during global common subexpression elimination

fgcse-sm

Common Report Var(flag_gcse_sm) Init(0) Optimization

Perform store motion after global common subexpression elimination

fgcse-las

Common Report Var(flag_gcse_las) Init(0) Optimization

Perform redundant load after store elimination in global common subexpression

elimination

fgcse-after-reload

Common Report Var(flag_gcse_after_reload) Optimization

Perform global common subexpression elimination after register allocation

has finished

; This option is not documented yet as its semantics will change.

fgraphite

Common Report Var(flag_graphite)

Enable in and out of Graphite representation

fgraphite-identity

Common Report Var(flag_graphite_identity) Optimization

Enable Graphite Identity transformation

floop-parallelize-all

Common Report Var(flag_loop_parallelize_all) Optimization

Mark all loops as parallel

floop-strip-mine

Common Report Var(flag_loop_strip_mine) Optimization

Enable Loop Strip Mining transformation

floop-interchange

Common Report Var(flag_loop_interchange) Optimization

Enable Loop Interchange transformation

floop-block

Common Report Var(flag_loop_block) Optimization

Enable Loop Blocking transformation

fguess-branch-probability

Common Report Var(flag_guess_branch_prob) Optimization

Enable guessing of branch probabilities

; Nonzero means ignore `#ident' directives.  0 means handle them.

; Generate position-independent code for executables if possible

; On SVR4 targets, it also controls whether or not to emit a

; string identifying the compiler.

fident

Common Report Var(flag_no_ident,0)

Process #ident directives

fif-conversion

Common Report Var(flag_if_conversion) Optimization

Perform conversion of conditional jumps to branchless equivalents

fif-conversion2

Common Report Var(flag_if_conversion2) Optimization

Perform conversion of conditional jumps to conditional execution

; -finhibit-size-directive inhibits output of .size for ELF.

; This is used only for compiling crtstuff.c,

; and it may be extended to other effects

; needed for crtstuff.c on other systems.

finhibit-size-directive

Common Report Var(flag_inhibit_size_directive)

Do not generate .size directives

findirect-inlining

Common Report Var(flag_indirect_inlining)

Perform indirect inlining

; Nonzero means that functions declared `inline' will be treated

; as `static'.  Prevents generation of zillions of copies of unused

; static inline functions; instead, `inlines' are written out

; only when actually used.  Used in conjunction with -g.  Also

; does the right thing with #pragma interface.

finline

Common Report Var(flag_no_inline,0) Init(0)

Pay attention to the \"inline\" keyword

finline-small-functions

Common Report Var(flag_inline_small_functions) Optimization

Integrate simple functions into their callers when code size is known to not growth

finline-functions

Common Report Var(flag_inline_functions) Optimization

Integrate simple functions into their callers

finline-functions-called-once

Common Report Var(flag_inline_functions_called_once) Init(1) Optimization

Integrate functions called once into their callers

finline-limit-

Common RejectNegative Joined UInteger

finline-limit=

Common RejectNegative Joined UInteger

-finline-limit= Limit the size of inlined functions to 

finstrument-functions

Common Report Var(flag_instrument_function_entry_exit)

Instrument function entry and exit with profiling calls

finstrument-functions-exclude-function-list=

Common RejectNegative Joined

-finstrument-functions-exclude-function-list=name,...  Do not instrument listed functions

finstrument-functions-exclude-file-list=

Common RejectNegative Joined

-finstrument-functions-exclude-file-list=filename,...  Do not instrument functions listed in files

fipa-cp

Common Report Var(flag_ipa_cp) Optimization

Perform Interprocedural constant propagation

fipa-cp-clone

Common Report Var(flag_ipa_cp_clone) Optimization

Perform cloning to make Interprocedural constant propagation stronger

fipa-pure-const

Common Report Var(flag_ipa_pure_const) Init(0) Optimization

Discover pure and const functions

fipa-pta

Common Report Var(flag_ipa_pta) Init(0) Optimization

Perform interprocedural points-to analysis

fipa-reference

Common Report Var(flag_ipa_reference) Init(0) Optimization

Discover readonly and non addressable static variables

fipa-type-escape

Common Report Var(flag_ipa_type_escape) Init(0) Optimization

Type based escape and alias analysis

fipa-matrix-reorg

Common Report Var(flag_ipa_matrix_reorg) Optimization

Perform matrix layout flattening and transposing based

on profiling information.

fipa-struct-reorg

Common Report Var(flag_ipa_struct_reorg)

Perform structure layout optimizations based

on profiling information.

fira-algorithm=

Common Joined RejectNegative

-fira-algorithm=[CB|priority] Set the used IRA algorithm

fira-region=

Common Joined RejectNegative

-fira-region=[one|all|mixed] Set regions for IRA

fira-coalesce

Common Report Var(flag_ira_coalesce) Init(0)

Do optimistic coalescing.

fira-loop-pressure

Common Report Var(flag_ira_loop_pressure)

Use IRA based register pressure calculation

in RTL loop optimizations.

fira-share-save-slots

Common Report Var(flag_ira_share_save_slots) Init(1)

Share slots for saving different hard registers.

fira-share-spill-slots

Common Report Var(flag_ira_share_spill_slots) Init(1)

Share stack slots for spilled pseudo-registers.

fira-verbose=

Common RejectNegative Joined UInteger

-fira-verbose=  Control IRA's level of diagnostic messages.

fivopts

Common Report Var(flag_ivopts) Init(1) Optimization

Optimize induction variables on trees

fjump-tables

Common Var(flag_jump_tables) Init(1) Optimization

Use jump tables for sufficiently large switch statements

fkeep-inline-functions

Common Report Var(flag_keep_inline_functions)

Generate code for functions even if they are fully inlined

fkeep-static-consts

Common Report Var(flag_keep_static_consts) Init(1)

Emit static const variables even if they are not used

fleading-underscore

Common Report Var(flag_leading_underscore) Init(-1)

Give external symbols a leading underscore

floop-optimize

Common

Does nothing.  Preserved for backward compatibility.

flto

Common Var(flag_lto)

Enable link-time optimization.

; The initial value of -1 comes from Z_DEFAULT_COMPRESSION in zlib.h.

flto-compression-level=

Common Joined UInteger Var(flag_lto_compression_level) Init(-1)

-flto-compression-level=        Use zlib compression level  for IL

flto-report

Common Report Var(flag_lto_report) Init(0) Optimization

Report various link-time optimization statistics

fmath-errno

Common Report Var(flag_errno_math) Init(1) Optimization

Set errno after built-in math functions

fmem-report

Common Report Var(mem_report)

Report on permanent memory allocation

; This will attempt to merge constant section constants, if 1 only

; string constants and constants from constant pool, if 2 also constant

; variables.

fmerge-all-constants

Common Report Var(flag_merge_constants,2) Init(1) Optimization

Attempt to merge identical constants and constant variables

fmerge-constants

Common Report Var(flag_merge_constants,1) VarExists Optimization

Attempt to merge identical constants across compilation units

fmerge-debug-strings

Common Report Var(flag_merge_debug_strings) Init(1)

Attempt to merge identical debug strings across compilation units

fmessage-length=

Common RejectNegative Joined UInteger

-fmessage-length=       Limit diagnostics to  characters per line.  0 suppresses line-wrapping

fmodulo-sched

Common Report Var(flag_modulo_sched) Optimization

Perform SMS based modulo scheduling before the first scheduling pass

fmodulo-sched-allow-regmoves

Common Report Var(flag_modulo_sched_allow_regmoves)

Perform SMS based modulo scheduling with register moves allowed

fmove-loop-invariants

Common Report Var(flag_move_loop_invariants) Init(1) Optimization

Move loop invariant computations out of loops

fmudflap

Common RejectNegative Report Var(flag_mudflap)

Add mudflap bounds-checking instrumentation for single-threaded program

fmudflapth

Common RejectNegative Report VarExists Var(flag_mudflap,2)

Add mudflap bounds-checking instrumentation for multi-threaded program

fmudflapir

Common RejectNegative Report Var(flag_mudflap_ignore_reads)

Ignore read operations when inserting mudflap instrumentation

fdce

Common Var(flag_dce) Init(1) Optimization

Use the RTL dead code elimination pass

fdse

Common Var(flag_dse) Init(1) Optimization

Use the RTL dead store elimination pass

freschedule-modulo-scheduled-loops

Common Report Var(flag_resched_modulo_sched) Optimization

Enable/Disable the traditional scheduling in loops that already passed modulo scheduling

fnon-call-exceptions

Common Report Var(flag_non_call_exceptions) Optimization

Support synchronous non-call exceptions

fomit-frame-pointer

Common Report Var(flag_omit_frame_pointer) Optimization

When possible do not generate stack frames

foptimize-register-move

Common Report Var(flag_regmove) Optimization

Do the full register move optimization pass

foptimize-sibling-calls

Common Report Var(flag_optimize_sibling_calls) Optimization

Optimize sibling and tail recursive calls

fpre-ipa-mem-report

Common Report Var(pre_ipa_mem_report)

Report on memory allocation before interprocedural optimization

fpost-ipa-mem-report

Common Report Var(post_ipa_mem_report)

Report on memory allocation before interprocedural optimization

fpack-struct

Common Report Var(flag_pack_struct) Optimization

Pack structure members together without holes

fpack-struct=

Common RejectNegative Joined UInteger Optimization

-fpack-struct=  Set initial maximum structure member alignment

fpcc-struct-return

Common Report Var(flag_pcc_struct_return,1) VarExists

Return small aggregates in memory, not registers

fpeel-loops

Common Report Var(flag_peel_loops) Optimization

Perform loop peeling

fpeephole

Common Report Var(flag_no_peephole,0) Optimization

Enable machine specific peephole optimizations

fpeephole2

Common Report Var(flag_peephole2) Optimization

Enable an RTL peephole pass before sched2

fPIC

Common Report Var(flag_pic,2)

Generate position-independent code if possible (large mode)

fPIE

Common Report Var(flag_pie,2)

Generate position-independent code for executables if possible (large mode)

fpic

Common Report Var(flag_pic,1) VarExists

Generate position-independent code if possible (small mode)

fpie

Common Report Var(flag_pie,1) VarExists

Generate position-independent code for executables if possible (small mode)

fplugin=

Common Joined RejectNegative

Specify a plugin to load

fplugin-arg-

Common Joined RejectNegative

-fplugin-arg--[=]       Specify argument = for plugin 

fpredictive-commoning

Common Report Var(flag_predictive_commoning) Optimization

Run predictive commoning optimization.

fprefetch-loop-arrays

Common Report Var(flag_prefetch_loop_arrays) Optimization

Generate prefetch instructions, if available, for arrays in loops

fprofile

Common Report Var(profile_flag)

Enable basic program profiling code

fprofile-arcs

Common Report Var(profile_arc_flag)

Insert arc-based program profiling code