neulab/tldr huggingface dataset:
max-inline-insns-single Several parameters control the tree inliner used in gcc.  This number sets the maximum number of instructions (counted in GCC's internal representation) in a single function that the tree inliner will consider for inlining.  This only affects functions declared inline and methods implemented in a class declaration (C++).  The default value is 450.
max-inline-insns-auto When you use -finline-functions (included in -O3), a lot of functions that would otherwise not be considered for inlining by the compiler will be investigated.  To those functions, a different (more restrictive) limit compared to functions declared inline can be applied.  The default value is 90.
large-function-insns The limit specifying really large functions.  For functions larger than this limit after inlining inlining is constrained by --param large-function-growth.  This parameter is useful primarily to avoid extreme compilation time caused by non-linear algorithms used by the backend.  This parameter is ignored when -funit-at-a-time is not used.  The default value is 2700.
large-function-growth Specifies maximal growth of large function caused by inlining in percents.  This parameter is ignored when -funit-at-a-time is not used.  The default value is 100 which limits large function growth to 2.0 times the original size.
large-unit-insns The limit specifying large translation unit.  Growth caused by inlining of units larger than this limit is limited by --param inline-unit-growth.  For small units this might be too tight (consider unit consisting of function A that is inline and B that just calls A three time.  If B is small relative to A, the growth of unit is 300\% and yet such inlining is very sane.  For very large units consisting of small inlininable functions however the overall unit growth limit is needed to avoid exponential explosion of code size.  Thus for smaller units, the size is increased to --param large-unit-insns before applying --param inline-unit-growth.  The default is 10000
inline-unit-growth Specifies maximal overall growth of the compilation unit caused by inlining.  This parameter is ignored when -funit-at-a-time is not used.  The default value is 50 which limits unit growth to 1.5 times the original size.
max-inline-insns-recursive max-inline-insns-recursive-auto Specifies maximum number of instructions out-of-line copy of self recursive inline function can grow into by performing recursive inlining.
For functions declared inline --param max-inline-insns-recursive is taken into account.  For function not declared inline, recursive inlining happens only when -finline-functions (included in -O3) is enabled and --param max-inline-insns-recursive-auto is used.  The default value is 450.
max-inline-recursive-depth max-inline-recursive-depth-auto Specifies maximum recursion depth used by the recursive inlining.
For functions declared inline --param max-inline-recursive-depth is taken into account.  For function not declared inline, recursive inlining happens only when -finline-functions (included in -O3) is enabled and --param max-inline-recursive-depth-auto is used.  The default value is 450.
When profile feedback is available (see -fprofile-generate) the actual recursion depth can be guessed from probability that function will recurse via given call expression.  This parameter limits inlining only to call expression whose probability exceeds given threshold (in percents).  The default value is 10.
inline-call-cost Specify cost of call instruction relative to simple arithmetics operations (having cost of 1).  Increasing this cost disqualifies inlining of non-leaf functions and at the same time increases size of leaf function that is believed to reduce function size by being inlined.  In effect it increases amount of inlining for code having large abstraction penalty (many functions that just pass the arguments to other functions) and decrease inlining for code with low abstraction penalty.  The default value is 16.
max-unrolled-insns The maximum number of instructions that a loop should have if that loop is unrolled, and if the loop is unrolled, it determines how many times the loop code is unrolled.
max-average-unrolled-insns The maximum number of instructions biased by probabilities of their execution that a loop should have if that loop is unrolled, and if the loop is unrolled, it determines how many times the loop code is unrolled.
max-peeled-insns The maximum number of instructions that a loop should have if that loop is peeled, and if the loop is peeled, it determines how many times the loop code is peeled.
iv-consider-all-candidates-bound Bound on number of candidates for induction variables below that all candidates are considered for each use in induction variable optimizations.  Only the most relevant candidates are considered if there are more candidates, to avoid quadratic time complexity.
iv-always-prune-cand-set-bound If number of candidates in the set is smaller than this value, we always try to remove unnecessary ivs from the set during its optimization when a new iv is added to the set.
vect-max-version-checks The maximum number of runtime checks that can be performed when doing loop versioning in the vectorizer.  See option ftree-vect- loop-version for more information.
max-iterations-to-track The maximum number of iterations of a loop the brute force algorithm for analysis of # of iterations of the loop tries to evaluate.
hot-bb-count-fraction Select fraction of the maximal count of repetitions of basic block in program given basic block needs to have to be considered hot.
hot-bb-frequency-fraction Select fraction of the maximal frequency of executions of basic block in function given basic block needs to have to be considered hot
max-predicted-iterations The maximum number of loop iterations we predict statically. This is useful in cases where function contain single loop with known bound and other loop with unknown.  We predict the known number of iterations correctly, while the unknown number of iterations average to roughly 10.  This means that the loop without bounds would appear artificially cold relative to the other one.
The tracer-dynamic-coverage-feedback is used only when profile feedback is available.  The real profiles (as opposed to statically estimated ones) are much less balanced allowing the threshold to be larger value.
tracer-max-code-growth Stop tail duplication once code growth has reached given percentage.  This is rather hokey argument, as most of the duplicates will be eliminated later in cross jumping, so it may be set to much higher values than is the desired code growth.
tracer-min-branch-ratio tracer-min-branch-ratio-feedback Stop forward growth if the best edge do have probability lower than this threshold.
Similarly to tracer-dynamic-coverage two values are present, one for compilation for profile feedback and one for compilation without.  The value for compilation with profile feedback needs to be more conservative (higher) in order to make tracer effective.
max-cse-path-length Maximum number of basic blocks on path that cse considers.  The default is 10.
max-cse-insns The maximum instructions CSE process before flushing. The default is 1000.
global-var-threshold Counts the number of function calls (n) and the number of call- clobbered variables (v).  If nxv is larger than this limit, a single artificial variable will be created to represent all the call-clobbered variables at function call sites.  This artificial variable will then be made to alias every call-clobbered variable.  (done as "int * size_t" on the host machine; beware overflow).
max-aliased-vops Maximum number of virtual operands allowed to represent aliases before triggering the alias grouping heuristic.  Alias grouping reduces compile times and memory consumption needed for aliasing at the expense of precision loss in alias information.
The default is the smaller of RAM/8, RLIMIT_RSS, or a limit which tries to ensure that RLIMIT_DATA or RLIMIT_AS are not exceeded, but with a lower bound of 4096 (four megabytes) and an upper bound of 131072 (128 megabytes).  If GCC is not able to calculate RAM on a particular platform, the lower bound is used.  Setting this parameter very large effectively disables garbage collection.  Setting this parameter and ggc-min-expand to zero causes a full collection to occur at every opportunity.
max-reload-search-insns The maximum number of instruction reload should look backward for equivalent register.  Increasing values mean more aggressive optimization, making the compile time increase with probably slightly better performance.  The default value is 100.
max-cselib-memory-locations The maximum number of memory locations cselib should take into account.  Increasing values mean more aggressive optimization, making the compile time increase with probably slightly better performance.  The default value is 500.
max-flow-memory-locations Similar as max-cselib-memory-locations but for dataflow liveness. The default value is 100.
reorder-blocks-duplicate reorder-blocks-duplicate-feedback Used by basic block reordering pass to decide whether to use unconditional branch or duplicate the code on its destination. Code is duplicated when its estimated size is smaller than this value multiplied by the estimated size of unconditional jump in the hot spots of the program.
The reorder-block-duplicate-feedback is used only when profile feedback is available and may be set to higher values than reorder-block-duplicate since information about the hot spots is more accurate.
max-sched-ready-insns The maximum number of instructions ready to be issued the scheduler should consider at any given time during the first scheduling pass.  Increasing values mean more thorough searches, making the compilation time increase with probably little benefit.  The default value is 100.
max-sched-region-blocks The maximum number of blocks in a region to be considered for interblock scheduling.  The default value is 10.
max-sched-region-insns The maximum number of insns in a region to be considered for interblock scheduling.  The default value is 100.
min-spec-prob The minimum probability (in percents) of reaching a source block for interblock speculative scheduling.  The default value is 40.
max-sched-extend-regions-iters The maximum number of iterations through CFG to extend regions. 0 - disable region extension, N - do at most N iterations.  The default value is 0.
max-sched-insn-conflict-delay The maximum conflict delay for an insn to be considered for speculative motion.  The default value is 3.
sched-spec-prob-cutoff The minimal probability of speculation success (in percents), so that speculative insn will be scheduled.  The default value is 40.
max-last-value-rtl The maximum size measured as number of RTLs that can be recorded in an expression in combiner for a pseudo register as last known value of that register.  The default is 10000.
integer-share-limit Small integer constants can use a shared data structure, reducing the compiler's memory usage and increasing its speed.  This sets the maximum value of a shared integer constant's.  The default value is 256.
min-virtual-mappings Specifies the minimum number of virtual mappings in the incremental SSA updater that should be registered to trigger the virtual mappings heuristic defined by virtual-mappings-ratio. The default value is 100.
virtual-mappings-ratio If the number of virtual mappings is virtual-mappings-ratio bigger than the number of virtual symbols to be updated, then the incremental SSA updater switches to a full update for those symbols.  The default ratio is 3.
ssp-buffer-size The minimum size of buffers (i.e. arrays) that will receive stack smashing protection when -fstack-protection is used.
max-fields-for-field-sensitive Maximum number of fields in a structure we will treat in a field sensitive manner during pointer analysis.
-Xpreprocessor option Pass option as an option to the preprocessor.  You can use this to supply system-specific preprocessor options which GCC does not know how to recognize.
-D name=definition The contents of definition are tokenized and processed as if they appeared during translation phase three in a #define directive.  In particular, the definition will be truncated by embedded newline characters.
If you wish to define a function-like macro on the command line, write its argument list with surrounding parentheses before the equals sign (if any).  Parentheses are meaningful to most shells, so you will need to quote the option.  With sh and csh, -D'name(args...)=definition' works.
-I dir Add the directory dir to the list of directories to be searched for header files.  Directories named by -I are searched before the standard system include directories.  If the directory dir is a standard system include directory, the option is ignored to ensure that the default search order for system directories and the special treatment of system headers are not defeated .
-o file Write output to file.  This is the same as specifying file as the second non-option argument to cpp.  gcc has a different interpretation of a second non-option argument, so you must use -o to specify the output file.
-Wall Turns on all optional warnings which are desirable for normal code. At present this is -Wcomment, -Wtrigraphs, -Wmultichar and a warning about integer promotion causing a change of sign in "#if" expressions.  Note that many of the preprocessor's warnings are on by default and have no options to control them.
-Wcomment -Wcomments Warn whenever a comment-start sequence /* appears in a /* comment, or whenever a backslash-newline appears in a // comment.  (Both forms have the same effect.)
-Wtrigraphs Most trigraphs in comments cannot affect the meaning of the program. However, a trigraph that would form an escaped newline (??/ at the end of a line) can, by changing where the comment begins or ends. Therefore, only trigraphs that would form escaped newlines produce warnings inside a comment.
-Wtraditional Warn about certain constructs that behave differently in traditional and ISO C.  Also warn about ISO C constructs that have no traditional C equivalent, and problematic constructs which should be avoided.
-Wimport Warn the first time #import is used.
-Wundef Warn whenever an identifier which is not a macro is encountered in an #if directive, outside of defined.  Such identifiers are replaced with zero.
-Wunused-macros Warn about macros defined in the main file that are unused.  A macro is used if it is expanded or tested for existence at least once.  The preprocessor will also warn if the macro has not been used at the time it is redefined or undefined.
Note: If a macro is actually used, but only used in skipped conditional blocks, then CPP will report it as unused.  To avoid the warning in such a case, you might improve the scope of the macro's definition by, for example, moving it into the first skipped block. Alternatively, you could provide a dummy use with something like:
-Wendif-labels Warn whenever an #else or an #endif are followed by text.  This usually happens in code of the form
The second and third "FOO" should be in comments, but often are not in older programs.  This warning is on by default.
-Werror Make all warnings into hard errors.  Source code which triggers warnings will be rejected.
-Wsystem-headers Issue warnings for code in system headers.  These are normally unhelpful in finding bugs in your own code, therefore suppressed.  If you are responsible for the system library, you may want to see them.
-w  Suppress all warnings, including those which GNU CPP issues by default.
-pedantic Issue all the mandatory diagnostics listed in the C standard.  Some of them are left out by default, since they trigger frequently on harmless code.
-pedantic-errors Issue all the mandatory diagnostics, and make all mandatory diagnostics into errors.  This includes mandatory diagnostics that GCC issues without -pedantic but treats as warnings.
-M  Instead of outputting the result of preprocessing, output a rule suitable for make describing the dependencies of the main source file.  The preprocessor outputs one make rule containing the object file name for that source file, a colon, and the names of all the included files, including those coming from -include or -imacros command line options.
Unless specified explicitly (with -MT or -MQ), the object file name consists of the basename of the source file with any suffix replaced with object file suffix.  If there are many included files then the rule is split into several lines using \-newline.  The rule has no commands.
This option does not suppress the preprocessor's debug output, such as -dM.  To avoid mixing such debug output with the dependency rules you should explicitly specify the dependency output file with -MF, or use an environment variable like DEPENDENCIES_OUTPUT.  Debug output will still be sent to the regular output stream as normal.
This implies that the choice of angle brackets or double quotes in an #include directive does not in itself determine whether that header will appear in -MM dependency output.  This is a slight change in semantics from GCC versions 3.0 and earlier.
-MF file When used with -M or -MM, specifies a file to write the dependencies to.  If no -MF switch is given the preprocessor sends the rules to the same place it would have sent preprocessed output.
-dependency-file Like -MF. (APPLE ONLY)
-MT target Change the target of the rule emitted by dependency generation.  By default CPP takes the name of the main input file, including any path, deletes any file suffix such as .c, and appends the platform's usual object suffix.  The result is the target.
An -MT option will set the target to be exactly the string you specify.  If you want multiple targets, you can specify them as a single argument to -MT, or use multiple -MT options.
-MD -MD is equivalent to -M -MF file, except that -E is not implied.  The driver determines file based on whether an -o option is given.  If it is, the driver uses its argument but with a suffix of .d, otherwise it take the basename of the input file and applies a .d suffix.
Since -E is not implied, -MD can be used to generate a dependency output file as a side-effect of the compilation process.
-fpch-deps When using precompiled headers, this flag will cause the dependency- output flags to also list the files from the precompiled header's dependencies.  If not specified only the precompiled header would be listed and not the files that were used to create it because those files are not consulted when a precompiled header is used.
-fpch-preprocess This option allows use of a precompiled header together with -E.  It inserts a special "#pragma", "#pragma GCC pch_preprocess "<filename>"" in the output to mark the place where the precompiled header was found, and its filename.  When -fpreprocessed is in use, GCC recognizes this "#pragma" and loads the PCH.
-x c -x c++ -x objective-c -x objective-c++ -x assembler-with-cpp Specify the source language: C, C++, Objective-C, Objective-C++, or assembly.  This has nothing to do with standards conformance or extensions; it merely selects which base syntax to expect.  If you give none of these options, cpp will deduce the language from the extension of the source file: .c, .cc, .m, .mm, or .S.  Some other common extensions for C++ and assembly are also recognized.  If cpp does not recognize the extension, it will treat the file as C; this is the most generic mode.
Note: Previous versions of cpp accepted a -lang option which selected both the language and the standards conformance level.  This option has been removed, because it conflicts with the -l option.
-std=standard -ansi Specify the standard to which the code should conform.  Currently CPP knows about C and C++ standards; others may be added in the future.
standard may be one of:
"iso9899:1990" "c89" The ISO C standard from 1990.  c89 is the customary shorthand for this version of the standard.
The -ansi option is equivalent to -std=c89.
"iso9899:199409" The 1990 C standard, as amended in 1994.
"iso9899:1999" "c99" "iso9899:199x" "c9x" The revised ISO C standard, published in December 1999.  Before publication, this was known as C9X.
"gnu89" The 1990 C standard plus GNU extensions.  This is the default.
"gnu99" "gnu9x" The 1999 C standard plus GNU extensions.
"c++98" The 1998 ISO C++ standard plus amendments.
"gnu++98" The same as -std=c++98 plus GNU extensions.  This is the default for C++ code.
-I- Split the include path.  Any directories specified with -I options before -I- are searched only for headers requested with "#include "file""; they are not searched for "#include <file>".  If additional directories are specified with -I options after the -I-, those directories are searched for all #include directives.
In addition, -I- inhibits the use of the directory of the current file directory as the first search directory for "#include "file"". This option has been deprecated.
-nostdinc Do not search the standard system directories for header files.  Only the directories you have specified with -I options (and the directory of the current file, if appropriate) are searched.
-idirafter dir Search dir for header files, but do it after all directories specified with -I and the standard system directories have been exhausted.  dir is treated as a system include directory.
-isysroot dir This option is like the --sysroot option, but applies only to header files, except for Apple's version of GCC, where it applies to both header files and libraries and effectively replaces the --sysroot option.  See the --sysroot option for more information.
-isystem dir Search dir for header files, after all directories specified by -I but before the standard system directories.  Mark it as a system directory, so that it gets the same special treatment as is applied to the standard system directories.
-iquote dir Search dir only for header files requested with "#include "file""; they are not searched for "#include <file>", before all directories specified by -I and before the standard system directories.
-fextended-identifiers Accept universal character names in identifiers.  This option is experimental; in a future version of GCC, it will be enabled by default for C99 and C++.
-finput-charset=charset Set the input character set, used for translation from the character set of the input file to the source character set used by GCC.  If the locale does not specify, or GCC cannot get this information from the locale, the default is UTF-8.  This can be overridden by either the locale or this command line option.  Currently the command line option takes precedence if there's a conflict.  charset can be any encoding supported by the system's "iconv" library routine.
-fworking-directory Enable generation of linemarkers in the preprocessor output that will let the compiler know the current working directory at the time of preprocessing.  When this option is enabled, the preprocessor will emit, after the initial linemarker, a second linemarker with the current working directory followed by two slashes.  GCC will use this directory, when it's present in the preprocessed input, as the directory emitted as the current working directory in some debugging information formats.  This option is implicitly enabled if debugging information is enabled, but this can be inhibited with the negated form -fno-working-directory.  If the -P flag is present in the command line, this option has no effect, since no "#line" directives are emitted whatsoever.
-dCHARS CHARS is a sequence of one or more of the following characters, and must not be preceded by a space.  Other characters are interpreted by the compiler proper, or reserved for future versions of GCC, and so are silently ignored.  If you specify characters whose behavior conflicts, the result is undefined.
M   Instead of the normal output, generate a list of #define directives for all the macros defined during the execution of the preprocessor, including predefined macros.  This gives you a way of finding out what is predefined in your version of the preprocessor.  Assuming you have no file foo.h, the command
will show all the predefined macros.
D   Like M except in two respects: it does not include the predefined macros, and it outputs both the #define directives and the result of preprocessing.  Both kinds of output go to the standard output file.
N   Like D, but emit only the macro names, not their expansions.
I   Output #include directives in addition to the result of preprocessing.
In addition to the side-effects of the -C option, the -CC option causes all C++-style comments inside a macro to be converted to C-style comments.  This is to prevent later use of that macro from inadvertently commenting out the remainder of the source line.
-traditional-cpp Try to imitate the behavior of old-fashioned C preprocessors, as opposed to ISO C preprocessors.
-trigraphs Process trigraph sequences.  These are three-character sequences, all starting with ??, that are defined by ISO C to stand for single characters.  For example, ??/ stands for \, so '??/n' is a character constant for a newline.  By default, GCC ignores trigraphs, but in standard-conforming modes it converts them.  See the -std and -ansi options.
--help --target-help Print text describing all the command line options instead of preprocessing anything.
-v  Verbose mode.  Print out GNU CPP's version number at the beginning of execution, and report the final form of the include path.
-version --version Print out GNU CPP's version number.  With one dash, proceed to preprocess as normal.  With two dashes, exit immediately.
-Xassembler option Pass option as an option to the assembler.  You can use this to supply system-specific assembler options which GCC does not know how to recognize.
In addition to the options listed below, Apple's GCC also accepts and passes nearly all of the options defined by the linker ld and by the library tool libtool.  Common options include -framework, -dynamic, -bundle, -flat_namespace, and so forth.  See the ld and libtool man pages for further details.
The linker searches a standard list of directories for the library, which is actually a file named liblibrary.a.  The linker then uses this file as if it had been specified precisely by name.
The directories searched include several standard system directories plus any that you specify with -L.
Normally the files found this way are library files---archive files whose members are object files.  The linker handles an archive file by scanning through it for members which define symbols that have so far been referenced but not defined.  But if the file that is found is an ordinary object file, it is linked in the usual fashion.  The only difference between using an -l option and specifying a file name is that -l surrounds library with lib and .a and searches several directories.
-nostartfiles Do not use the standard system startup files when linking.  The standard system libraries are used normally, unless -nostdlib or -nodefaultlibs is used.
-nodefaultlibs Do not use the standard system libraries when linking.  Only the libraries you specify will be passed to the linker.  The standard startup files are used normally, unless -nostartfiles is used.  The compiler may generate calls to "memcmp", "memset", "memcpy" and "memmove".  These entries are usually resolved by entries in libc. These entry points should be supplied through some other mechanism when this option is specified.
-nostdlib Do not use the standard system startup files or libraries when linking.  No startup files and only the libraries you specify will be passed to the linker.  The compiler may generate calls to "memcmp", "memset", "memcpy" and "memmove".  These entries are usually resolved by entries in libc.  These entry points should be supplied through some other mechanism when this option is specified.
One of the standard libraries bypassed by -nostdlib and -nodefaultlibs is libgcc.a, a library of internal subroutines that GCC uses to overcome shortcomings of particular machines, or special needs for some languages.
In most cases, you need libgcc.a even when you want to avoid other standard libraries.  In other words, when you specify -nostdlib or -nodefaultlibs you should usually specify -lgcc as well.  This ensures that you have no unresolved references to internal GCC library subroutines.  (For example, __main, used to ensure C++ constructors will be called.)
-pie Produce a position independent executable on targets which support it.  For predictable results, you must also specify the same set of options that were used to generate code (-fpie, -fPIE, or model suboptions) when you specify this option.
-static On systems that support dynamic linking, this prevents linking with the shared libraries.  On other systems, this option has no effect.
This option will not work on Mac OS X unless all libraries (including libgcc.a) have also been compiled with -static.  Since neither a static version of libSystem.dylib nor crt0.o are provided, this option is not useful to most people.
-shared Produce a shared object which can then be linked with other objects to form an executable.  Not all systems support this option.  For predictable results, you must also specify the same set of options that were used to generate code (-fpic, -fPIC, or model suboptions) when you specify this option.[1]
This option is not supported on Mac OS X.
-shared-libgcc -static-libgcc On systems that provide libgcc as a shared library, these options force the use of either the shared or static version respectively. If no shared version of libgcc was built when the compiler was configured, these options have no effect.
Therefore, the G++ and GCJ drivers automatically add -shared-libgcc whenever you build a shared library or a main executable, because C++ and Java programs typically use exceptions, so this is the right thing to do.
If, instead, you use the GCC driver to create shared libraries, you may find that they will not always be linked with the shared libgcc. If GCC finds, at its configuration time, that you have a non-GNU linker or a GNU linker that does not support option --eh-frame-hdr, it will link the shared version of libgcc into shared libraries by default.  Otherwise, it will take advantage of the linker and optimize away the linking with the shared version of libgcc, linking with the static version of libgcc by default.  This allows exceptions to propagate through such shared libraries, without incurring relocation costs at library load time.
However, if a library or main executable is supposed to throw or catch exceptions, you must link it using the G++ or GCJ driver, as appropriate for the languages used in the program, or using the option -shared-libgcc, such that it is linked with the shared libgcc.
-Xlinker option Pass option as an option to the linker.  You can use this to supply system-specific linker options which GCC does not know how to recognize.
If you want to pass an option that takes an argument, you must use -Xlinker twice, once for the option and once for the argument.  For example, to pass -assert definitions, you must write -Xlinker -assert -Xlinker definitions.  It does not work to write -Xlinker "-assert definitions", because this passes the entire string as a single argument, which is not what the linker expects.
-Wl,option Pass option as an option to the linker.  If option contains commas, it is split into multiple options at the commas.
-Idir Add the directory dir to the head of the list of directories to be searched for header files.  This can be used to override a system header file, substituting your own version, since these directories are searched before the system header file directories.  However, you should not use this option to add directories that contain vendor- supplied system header files (use -isystem for that).  If you use more than one -I option, the directories are scanned in left-to-right order; the standard system directories come after.
If a standard system include directory, or a directory specified with -isystem, is also specified with -I, the -I option will be ignored. The directory will still be searched but as a system directory at its normal position in the system include chain.  This is to ensure that GCC's procedure to fix buggy system headers and the ordering for the include_next directive are not inadvertently changed.  If you really need to change the search order for system directories, use the -nostdinc and/or -isystem options.
The option -iwithsysroot (APPLE ONLY), if specified with an absolute path, will prepend the system root directory (if applicable) to the path and add it to the beginning of the system search paths.  If specified with a relative path, -iwithsysroot will behave identically to -isystem.
-iquotedir Add the directory dir to the head of the list of directories to be searched for header files only for the case of #include "file"; they are not searched for #include <file>, otherwise just like -I.
The compiler driver program runs one or more of the subprograms cpp, cc1, as and ld.  It tries prefix as a prefix for each program it tries to run, both with and without machine/version/.
For each subprogram to be run, the compiler driver first tries the -B prefix, if any.  If that name is not found, or if -B was not specified, the driver tries two standard prefixes, which are /usr/lib/gcc/ and /usr/local/lib/gcc/.  If neither of those results in a file name that is found, the unmodified program name is searched for using the directories specified in your PATH environment variable.
The compiler will check to see if the path provided by the -B refers to a directory, and if necessary it will add a directory separator character at the end of the path.
-B prefixes that effectively specify directory names also apply to libraries in the linker, because the compiler translates these options into -L options for the linker.  They also apply to includes files in the preprocessor, because the compiler translates these options into -isystem options for the preprocessor.  In this case, the compiler appends include to the prefix.
The run-time support file libgcc.a can also be searched for using the -B prefix, if needed.  If it is not found there, the two standard prefixes above are tried, and that is all.  The file is left out of the link if it is not found by those means.
As a special kludge, if the path provided by -B is [dir/]stageN/, where N is a number in the range 0 to 9, then it will be replaced by [dir/]include.  This is to help with boot-strapping the compiler.
-specs=file Process file after the compiler reads in the standard specs file, in order to override the defaults that the gcc driver program uses when determining what switches to pass to cc1, cc1plus, as, ld, etc.  More than one -specs=file can be specified on the command line, and they are processed in order, from left to right.
--sysroot=dir Use dir as the logical root directory for headers and libraries.  For example, if the compiler would normally search for headers in /usr/include and libraries in /usr/lib, it will instead search dir/usr/include and dir/usr/lib.
With Apple's version of GCC, this option is effectively replaced by -isysroot, which you should use instead of --sysroot.  For other (non-Apple) versions of GCC, if you use both this option and the -isysroot option, then the --sysroot option will apply to libraries, but the -isysroot option will apply to header files.
The GNU linker (beginning with version 2.16) has the necessary support for this option.  If your linker does not support this option, the header file aspect of --sysroot will still work, but the library aspect will not.
-I- This option has been deprecated.  Please use -iquote instead for -I directories before the -I- and remove the -I-.  Any directories you specify with -I options before the -I- option are searched only for the case of #include "file"; they are not searched for #include <file>.
If additional directories are specified with -I options after the -I-, these directories are searched for all #include directives. (Ordinarily all -I directories are used this way.)
In addition, the -I- option inhibits the use of the current directory (where the current input file came from) as the first search directory for #include "file".  There is no way to override this effect of -I-.  With -I. you can specify searching the directory which was current when the compiler was invoked.  That is not exactly the same as what the preprocessor does by default, but it is often satisfactory.
-I- does not inhibit the use of the standard system directories for header files.  Thus, -I- and -nostdinc are independent.
Specifying Target Machine and Compiler Version The usual way to run GCC is to run the executable called gcc, or <machine>-gcc when cross-compiling, or <machine>-gcc-<version> to run a version other than the one that was installed last.  Sometimes this is inconvenient, so GCC provides options that will switch to another cross- compiler or version.
-b machine The argument machine specifies the target machine for compilation.
The value to use for machine is the same as was specified as the machine type when configuring GCC as a cross-compiler.  For example, if a cross-compiler was configured with configure arm-elf, meaning to compile for an arm processor with elf binaries, then you would specify -b arm-elf to run that cross compiler.  Because there are other options beginning with -b, the configuration must contain a hyphen.
-V version The argument version specifies which version of GCC to run.  This is useful when multiple versions are installed.  For example, version might be 4.0, meaning to run GCC version 4.0.
The -V and -b options work by running the <machine>-gcc-<version> executable, so there's no real reason to use them if you can just run that directly.
Hardware Models and Configurations Earlier we discussed the standard option -b which chooses among different installed compilers for completely different target machines, such as VAX vs. 68000 vs. 80386.
In addition, each of these target machine types can have its own special options, starting with -m, to choose among various hardware models or configurations---for example, 68010 vs 68020, floating coprocessor or none.  A single installed version of the compiler can compile for any model or configuration, according to the options specified.
Some configurations of the compiler also support additional special options, usually for compatibility with other compilers on the same platform.
These -m options are defined for Advanced RISC Machines (ARM) architectures:
-mapcs-frame Generate a stack frame that is compliant with the ARM Procedure Call Standard for all functions, even if this is not strictly necessary for correct execution of the code.  Specifying -fomit-frame-pointer with this option will cause the stack frames not to be generated for leaf functions.  The default is -mno-apcs-frame.
-mapcs This is a synonym for -mapcs-frame.
-mapcs-stack-check Generate code to check the amount of stack space available upon entry to every function (that actually uses some stack space).  If there is insufficient space available then either the function __rt_stkovf_split_small or __rt_stkovf_split_big will be called, depending upon the amount of stack space required.  The run time system is required to provide these functions.  The default is -mno-apcs-stack-check, since this produces smaller code.
-mapcs-float Pass floating point arguments using the float point registers.  This is one of the variants of the APCS.  This option is recommended if the target hardware has a floating point unit or if a lot of floating point arithmetic is going to be performed by the code.  The default is -mno-apcs-float, since integer only code is slightly increased in size if -mapcs-float is used.
-mapcs-reentrant Generate reentrant, position independent code.  The default is -mno-apcs-reentrant.
-mthumb-interwork Generate code which supports calling between the ARM and Thumb instruction sets.  Without this option the two instruction sets cannot be reliably used inside one program.  The default is -mno-thumb-interwork, since slightly larger code is generated when -mthumb-interwork is specified.
-mno-sched-prolog Prevent the reordering of instructions in the function prolog, or the merging of those instruction with the instructions in the function's body.  This means that all functions will start with a recognizable set of instructions (or in fact one of a choice from a small set of different function prologues), and this information can be used to locate the start if functions inside an executable piece of code. The default is -msched-prolog.
-mhard-float Generate output containing floating point instructions.  This is the default.
-msoft-float Generate output containing library calls for floating point. Warning: the requisite libraries are not available for all ARM targets.  Normally the facilities of the machine's usual C compiler are used, but this cannot be done directly in cross-compilation.  You must make your own arrangements to provide suitable library functions for cross-compilation.
-mfloat-abi=name Specifies which ABI to use for floating point values.  Permissible values are: soft, softfp and hard.
soft and hard are equivalent to -msoft-float and -mhard-float respectively.  softfp allows the generation of floating point instructions, but still uses the soft-float calling conventions.
-mwords-little-endian This option only applies when generating code for big-endian processors.  Generate code for a little-endian word order but a big- endian byte order.  That is, a byte order of the form 32107654. Note: this option should only be used if you require compatibility with code for big-endian ARM processors generated by versions of the compiler prior to 2.8.
-mcpu=name This specifies the name of the target ARM processor.  GCC uses this name to determine what kind of instructions it can emit when generating assembly code.  Permissible names are: arm2, arm250, arm3, arm6, arm60, arm600, arm610, arm620, arm7, arm7m, arm7d, arm7dm, arm7di, arm7dmi, arm70, arm700, arm700i, arm710, arm710c, arm7100, arm7500, arm7500fe, arm7tdmi, arm7tdmi-s, arm8, strongarm, strongarm110, strongarm1100, arm8, arm810, arm9, arm9e, arm920, arm920t, arm922t, arm946e-s, arm966e-s, arm968e-s, arm926ej-s, arm940t, arm9tdmi, arm10tdmi, arm1020t, arm1026ej-s, arm10e, arm1020e, arm1022e, arm1136j-s, arm1136jf-s, mpcore, mpcorenovfp, arm1176jz-s, arm1176jzf-s, xscale, iwmmxt, ep9312.
-mtune=name This option is very similar to the -mcpu= option, except that instead of specifying the actual target processor type, and hence restricting which instructions can be used, it specifies that GCC should tune the performance of the code as if the target were of the type specified in this option, but still choosing the instructions that it will generate based on the cpu specified by a -mcpu= option.  For some ARM implementations better performance can be obtained by using this option.
-march=name This specifies the name of the target ARM architecture.  GCC uses this name to determine what kind of instructions it can emit when generating assembly code.  This option can be used in conjunction with or instead of the -mcpu= option.  Permissible names are: armv2, armv2a, armv3, armv3m, armv4, armv4t, armv5, armv5t, armv5te, armv6, armv6j, iwmmxt, ep9312.
-mfpu=name -mfpe=number -mfp=number This specifies what floating point hardware (or hardware emulation) is available on the target.  Permissible names are: fpa, fpe2, fpe3, maverick, vfp.  -mfp and -mfpe are synonyms for -mfpu=fpenumber, for compatibility with older versions of GCC.
If -msoft-float is specified this specifies the format of floating point values.
-mstructure-size-boundary=n The size of all structures and unions will be rounded up to a multiple of the number of bits set by this option.  Permissible values are 8, 32 and 64.  The default value varies for different toolchains.  For the COFF targeted toolchain the default value is 8. A value of 64 is only allowed if the underlying ABI supports it.
Specifying the larger number can produce faster, more efficient code, but can also increase the size of the program.  Different values are potentially incompatible.  Code compiled with one value cannot necessarily expect to work with code or libraries compiled with another value, if they exchange information using structures or unions.
-mabort-on-noreturn Generate a call to the function "abort" at the end of a "noreturn" function.  It will be executed if the function tries to return.
-mlong-calls -mno-long-calls Tells the compiler to perform function calls by first loading the address of the function into a register and then performing a subroutine call on this register.  This switch is needed if the target function will lie outside of the 64 megabyte addressing range of the offset based version of subroutine call instruction.
Even if this switch is enabled, not all function calls will be turned into long calls.  The heuristic is that static functions, functions which have the short-call attribute, functions that are inside the scope of a #pragma no_long_calls directive and functions whose definitions have already been compiled within the current compilation unit, will not be turned into long calls.  The exception to this rule is that weak function definitions, functions with the long-call attribute or the section attribute, and functions that are within the scope of a #pragma long_calls directive, will always be turned into long calls.
This feature is not enabled by default.  Specifying -mno-long-calls will restore the default behavior, as will placing the function calls within the scope of a #pragma long_calls_off directive.  Note these switches have no effect on how the compiler generates code to handle function calls via function pointers.
-mnop-fun-dllimport Disable support for the "dllimport" attribute.
-msingle-pic-base Treat the register used for PIC addressing as read-only, rather than loading it in the prologue for each function.  The run-time system is responsible for initializing this register with an appropriate value before execution begins.
-mpic-register=reg Specify the register to be used for PIC addressing.  The default is R10 unless stack-checking is enabled, when R9 is used.
-mcirrus-fix-invalid-insns Insert NOPs into the instruction stream to in order to work around problems with invalid Maverick instruction combinations.  This option is only valid if the -mcpu=ep9312 option has been used to enable generation of instructions for the Cirrus Maverick floating point co- processor.  This option is not enabled by default, since the problem is only present in older Maverick implementations.  The default can be re-enabled by use of the -mno-cirrus-fix-invalid-insns switch.
-mthumb Generate code for the 16-bit Thumb instruction set.  For ARMv7, the default is to use the THUMB2 instruction set. For all other architectures, the default is to use the 32-bit ARM instruction set. The ARM instruction set may be explicitly selected via -mno-thumb or -marm.
-mcallee-super-interworking Gives all externally visible functions in the file being compiled an ARM instruction set header which switches to Thumb mode before executing the rest of the function.  This allows these functions to be called from non-interworking code.
-mcaller-super-interworking Allows calls via function pointers (including virtual functions) to execute correctly regardless of whether the target code has been compiled for interworking or not.  There is a small overhead in the cost of executing a function pointer if this option is enabled.
-mms-bitfields Set the default structure layout to be compatible with the Microsoft compiler standard. This is equivalent to adding an "ms_struct" attribute to each structure and union tag definition. The default is mno-ms-bitfields.
FSF GCC on Darwin does not create "universal" object files; it will create an object file for the single architecture that it was built to target.  Apple's GCC on Darwin does create "universal" files if multiple -arch options are used; it does so by running the compiler or linker multiple times and joining the results together with lipo.
The subtype of the file created (like ppc7400 or ppc970 or i686) is determined by the flags that specify the ISA that GCC is targetting, like -mcpu or -march.  The -force_cpusubtype_ALL option can be used to override this.