g++

Language Independent
`-fmessage-length=n`
`-fdiagnostics-show-location=[once\|every-line]`
C Language Options -ansi -std=standard -aux-info filename
-faltivec^ -fasm-blocks  -fno-asm -fno-builtin -fno-builtin-function -fhosted -ffreestanding -fms-extensions -trigraphs -no-integrated-cpp -traditional -traditional-cpp -fallow-single-precision -fcond-mismatch -fconstant-cfstrings^ -fnon-lvalue-assign  -fno-nested-functions -fpch-preprocess^ -fsigned-bitfields -fsigned-char -fpascal-strings^ -wno-#warnings^ -wextra-tokens  -wnewline-eof^ -wno-altivec-long-deprecated^ -funsigned-bitfields -funsigned-char -fwritable-strings

You can request many specific warnings with options beginning -W, for example -Wimplicit to request warnings on implicit declarations. these warning options have a negative form beginning -Wno- to turn off warnings; for example, -Wno-implicit. Here is liskted only the not the default form.

Options Controlling the Preprocessor

-E only preprocess

-D name Predefine name as a macro, with definition 1.

-D name=definition

Definition is tokenized and processed as if were a #define directive, Definition will be truncated by embedded newlines <
When invoking the preprocessor from a shell use shell's quoting to protect characters such as spaces that have a meaning in the shell syntax.

To define a function-like macro on the command line, write its argument list with surrounding parentheses before the equals sign . Use quotes to supress shell function .
For example with sh and csh, -D'name(args...)=definition'

-U name Undefine name, either built in or provided with a -D option. -D and -U are processed in the order they are given .
All -imacros file and -include file are processed after -D and -U

-undef Do not predefine any system-specific macros. The standard predefined macros remain defined.

-I dir Add the directory dir to the list of directories to be searched for includes . 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. as specifying file as the second non-option argument to cpp.

-Wall Turns on all optional warnings which are desirable for normal code. comment, trigraphs, multichar and a warning about integer promotion causing a change of

-Wcomment[s] a comment-start (/* appears within a /* , or
a backslash- newline appears in a // comment.(i.e. a line ends in a \)

-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. Built-in macros, macros defined on the command line, and macros defined in include files are not warned about. 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: #if defined the_macro_causing_the_warning #endif

-Wendif-labels

Warn whenever an #else or an #endif are followed by text. This usually happens in code of the form

                   #if FOO
                   ...
                   #else FOO
                   ...
                   #endif FOO

The second and third "FOO" should be in comments
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.

-W Suppress all warnings,

-pedantic Issue mandatory diagnostics listed in the C standard. Some are left out by default,

-pedantic-errors make mandatory diagnostics into errors.

Make related options

-M

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.

does not suppress the preprocessor's debug output, such as -dM. To avoid mixing such debug output with the dependency rules 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

-M implies -E, and suppresses warnings with an implicit -w.

-MM

Like -M but do not mention header files that are found in system header directories, nor header files that are included, directly or indirectly, from such a header.

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. @anchor{dashMF}

-MF file with -M or -MM, 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. When used with the driver options -MD or -MMD, -MF overrides the default dependency output file.

-dependency-file Like -MF. 

-MG with an option such as , -MG assumes missing header files are generated files and adds them to the dependency list without raising an error. The dependency filename is taken directly from the "#include" directive without prepending any path. -MG also suppresses preprocessed output, as a missing header file renders this useless. This feature is used in automatic updating of makefiles.

-MP

add a phony target for each dependency other than the main file, causing each to depend on nothing. to work around errors make gives if header files are removed without updating the Makefile to match. Example:



                   test.o: test.c test.h

                   test.h:

-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.

For example, -MT '$(objpfx)foo.o' might give

                   $(objpfx)foo.o: foo.c

-MQ target

Same as -MT, but it quotes any characters which are special to Make.

-MQ '$(objpfx)foo.o' gives

                   $$(objpfx)foo.o: foo.c

The default target is automatically quoted, as if it were given with -MQ.

-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.
If -MD is used in conjunction with -E, any -o switch is understood to specify the dependency output file, but if used without -E, each -o is understood to specify a target object file. Since -E is not implied, -MD can be used to generate a dependency output file as a side-effect of
the compilation process.

-MMD Like -MD except mention only user header files, not system header files.

-fpch-deps cause the dependency-output flags to 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

-fpch-preprocess allows use of a precompiled header with -E.
Inserts #pragma GCC pch_preprocess filename" to mark the place where the precompiled header was . When -fpreprocessed is in use, GCC recognizes this "#pragma" and loads the PCH. Off by default, the resulting preprocessed output is only suitable as input to GCC. It is on with -save-temps.
Do not write this "#pragma" in your own code, but it is safe to edit the filename if the PCH file is available in a different location. The filename may be absolute or it may be relative to GCC's current directory.


-x c

-x c++

-x objective-c

-x objective-c++

-x assembler-with-cpp

source base syntax . Normally cpp will deduce the language from the extension . default to C; -ansi
-std=standard

Specify the standard to which the code should conform.
`"gnu89"`	1990 C standard plus GNU extensions. This is the default.
`"gnu99" "gnu9x" 1999`	C standard plus GNU extensions.
`"gnu++98"`	same as -std=c++98 plus GNU extensions. This is the default for C++ code.
`"iso9899:1990`	"
`"c89"`	The ISO C standard from 1990. c89 is the shorthand for this version -ansi is equivalent to -std=c89.
`"c++98"`	1998 ISO C++ standard plus amendments.
`"iso9899:199409"`	1990 C standard, as amended in 1994.
`"iso9899:1999" "c99" "iso9899:199x" "c9x"`	revised ISO C standard, December 1999. was known as C9X.

-I- deprecated. Split the include path. Any directories specified with -I options before -I- are searched only for headers requested with #include "file"; not for #include file. If additional directories are specified with -I after -I-, those directories are searched for all #include directives. This inhibits using the current directory as the first search directory for "#include "file"".

include options

-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.

-nostdinc++ Do not search for header files in the C++-specific standard directories, but do still search the other standard directories. (This option is used when building the C++ library.)

-include file++ Process file as if "#include "file"" appeared as the first line of the primary source file. However, the first directory searched for file is the preprocessor's working directory instead of the directory containing the main source file. If not found there, it is searched for in the remainder of the "#include "..."" search chain as normal.
If multiple -include options are given, the files are included in the order they appear on the command line.

-imacros file like -include except that output discarded.
Macros remain defined. Acquire macros from a header without processing its declarations.
Files specified by -imacros are processed before -includes.

-idirafter dir Search dir for header files, but after directories specified with -I and the standard system directories have been exhausted.
dir is treated as a system include directory.

-iprefix prefix prefix is used for subsequent -iwithprefix .
If the prefix represents a directory, include the final /.

-iwithprefix dir -iwithprefixbefore dir Append dir to the prefix previous -iprefix!, and
add the resulting directory to the include search path.
-iwithprefix puts it where -idirafter would. -iwithprefixbefore puts it in the same place -I would;

-isystem dirtd>
           Search dir for header files, after directories specified by -I but 

before the standard system directories.  

Mark it as a system directory, so that it gets the same special treatment

-iquote dir Search dir only for header files requested with #include "file";
they are not searched for #include <file>,
before directories specified by -I and before the standard system directories.

-fdollars-in-identifiers @anchor{fdollars-in-identifiers} Accept $ in identifiers.

-fpreprocessed Indicate to the preprocessor that the input file has already been preprocessed. This suppresses things like macro expansion, trigraph conversion, escaped newline splicing, and processing of most directives. The preprocessor still recognizes and removes comments, so that you can pass a file preprocessed with -C to the compiler without problems. In this mode the integrated preprocessor is little more than a tokenizer for the front ends. -fpreprocessed is implicit if the input file has one of the extensions .i, .ii or .mi. These are the extensions that GCC uses for preprocessed files created by -save-temps.

-ftabstop=width Set the distance between tab stops. This helps the preprocessor report correct column numbers in warnings or errors, even if tabs appear on the line. If the value is less than 1 or greater than 100, the option is ignored. The default is 8.

-fexec-charset=charset Set the execution character set, used for string and character constants. The default is UTF-8. charset can be any encoding supported by the system's "iconv" library routine.

-fwide-exec-charset=charset Set the wide execution character set, used for wide string and character constants. The default is UTF-32 or UTF-16, whichever corresponds to the width of "wchar_t". As with -fexec-charset, charset can be any encoding supported by the system's "iconv" library routine; however, you will have problems with encodings that do not fit exactly in "wchar_t".

-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.

-fno-show-column Do not output column numbers in diagnostics.
Used when output is input to another program that does not understand the column numbers, such as dejagnu.

-P DO not output linemarkers in the output from the preprocessor.
Useful when running the preprocessor on something that is not C code to be input to another program .

-A predicate=answer Make an assertion with the predicate predicate and answer answer.
Preferred to -A predicate(answer),

-A -predicate=answer Cancel an assertion with the predicate predicate and answer answer.

-d [M][D][N][I]

diagnose #defines.

`-dM…`	Instead of the normal output, generate a list of `#define` directives for predefined macros and those defined by the preprocessor . With an empty file: `touch foo.h; cpp -dM foo.h` shows the over 400 predefined macros.
`-dD…`	Like `-dM` except does not include the predefined macros and outputs both the `#define` directives and the result of preprocessing to standard output .
`-dN…`	Like `-dD`, but output only macro names
`-dI…`	Output `#include` directives in addition to the result of preprocessing. touch foo.h; cpp -dI foo.h # 1 "foo.h" # 1 "" 1 # 1 "" 3 # 413 "" 3 # 1 "" 1 # 1 "" 2 # 1 "foo.h" 2

Other characters are interpreted by the compiler proper, or reserved

-C Do not discard comments. All comments are passed through to the output file, except for comments in processed directives, which are deleted along with the directive. You should be prepared for side effects when using -C; it causes the preprocessor to treat comments as tokens in their own right. For example, comments appearing at the start of what would be a directive line have the effect of turning that line into an ordinary source line, since the first token on the line is no longer a #.

-CC Do not discard comments, including during macro expansion.
Like -C, except comments in macros are passed to the output file where the macro is expanded.
Converts C++- style comments inside a macro to C-style preventing later use of that macro from inadvertently commenting out the remainder of the source line.
Used to support lint comments.

-traditional-cpp imitate old C preprocessors, as opposed to ISO C preprocessors.

-trigraphs

Process trigraph sequences to stand for single character. Ignored by default. In standard-conforming modes they are converted . See -std and -ansi The nine trigraphs and their replacements are:

                   Trigraph:       ??(  ??)  ??<  ??>  ??=  ??/  ??'  ??!  ??-
                   Replacement:      [    ]    {    }    #    \    ^    |    ~

-remap Enable special code to handle file systems which only permit short file names, such as MS-DOS.

--help --target-help Output text describing the command line options

-v Verbose mode. Output version number and report the final form of the include path.

-H Print the name of each header file used, in addition to other normal activities. Each name is indented to show how deep in the #include stack it is. Precompiled header files are also printed, even if they are found to be invalid; an invalid precompiled header file is printed with ...x and a valid one with ...! .

-version --version output GNU CPP's version number. With one dash, proceed to preprocess as normal. With two dashes, exit immediately.

`-Wa,option`	Pass option as an option to the assembler. If option contains commas, it is split into multiple options at the commas.
`-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. If you want to pass an option that takes an argument, you must use -Xassembler twice, once for the option and once for the argument.

`object-file-name`	A file name that does not end in a special recognized suffix is considered to name an object file or library. (Object files are distinguished from libraries by the linker according to the file contents.) If linking is done, these object files are used as input to the linker.
`-c -S -E`	the linker is not run, and object file names should not be used as arguments.
`-llibrary`	Search libraries and object files in order. The linker searches a standard list of directories for the library, `liblibrary.a.` The directories searched include standard system directories plus any specified with `-L.` library files are archive files whose members are object files. The linker handles by scanning it for members which define symbols that have so far been referenced but not defined. if the file that is found is an object file, it is linked in the usual fashion. The difference between using `-l` and specifying a file name is that -l surrounds library with `lib` and `.a` and searches several directories.
`-lobjc`	special case of `-l` to link an Objective-C or Objective-C++ program.
`-nostartfiles`	Do not use the standard system startup files . The standard system libraries are used normally, unless `-nostdlib or -nodefaultlibs` is used.
`-nodefaultlibs`	Do not use the standard system libraries . 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 must be supplied with this option
`-nostdlib`	Do not use the standard system startup files or libraries . No startup files and only the libraries specifed 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, which is needed a even when avoiding other standard libraries. when you specify -nostdlib or -nodefaultlibs you should usually specify `-lgcc`
`-pie`	Produce a position independent executable . Specify the same set of options used to generate code (`-fpie, -fPIE`, or model suboptions)
`-s`	Remove symbol table and relocation information from the executable.
`-static`	prevents linking with the shared libraries. On Mac OS all libraries (including libgcc.a) have also been compiled with `-static`.
`-shared`	Produce a shared object which can then be linked with other objects to form an executable. also specify the same set of options that were used to generate code (-fpic, -fPIC, or model suboptions) when you specify this option.[1] Not supported on Mac OS .
`-shared-libgcc -static-libgcc`	force the use of either the shared or static version drivers add -shared-libgcc whenever buildding a shared library or a main executable, because C++ and Java programs typically use exceptions, using the GCC driver to create shared libraries, 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. if a library or main executable is supposed to throw or catch exceptions, link it using the G++ or GCJ driver, the option -shared-libgcc, with the shared libgcc.
`-symbolic`	Bind references to global symbols when building a shared object. Warn about any unresolved references (unless overridden by the -Xlinker -z -Xlinker defs).
`-Xlinker option`	Pass option to the linker. which GCC does not know to pass an option that takes an argument, 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.
`-Wl,option`	Pass an option to the linker.
`-u symbol`	Treat the `symbol` as undefined, to force linking of library modules to define it. May be used multiple times to force loading of additional library modules.

`-Idir`	Add `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. Do not use to add directories that contain vendor-supplied system header files (use `-isystem` for that). With than one `-I` 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`, `-I` 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. To change the search order for system directories, use the `-nostdinc` and/or `-isystem` .
`-iquotedir dir`	Add `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.`
`-Ldir`	Add `dir,/code> to the list of directories to be searched for -l^.`
`-Bprefix`	specifies where to find the executables, libraries, include files, and data files of the compiler itself. The compiler driver program runs one or more of `cpp, cc1, as and ld.` It tries `prefix` for each program it tries to run, both with and without machine/version/. the compiler driver first tries the `-B prefix`, 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` 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` for the linker. They also apply to includes files in the preprocessor, because the compiler translates these options into `-isystem` 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 are tried, . The file is left out of the link if it is not found by those means. Another way to specify a prefix to use the `$GCC_EXEC_PREFIX.` if the path provided by `-B is [dir/]stageN/`, where `N` 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, 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 can be specified on the command line, and are processed in order,`

`-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 i386v, meaning to compile for an 80386 running System V, then you would specify -b i386v to run that cross compiler.
`-V version`	which version of GCC to run when multiple versions are installed. For example, version might be 2.0, meaning to run GCC version 2.0.

`-mabi=name`	Generate code for the specified ABI. `apcs-gnu, atpcs, aapcs and iwmmxt.`
`-mapcs-frame -mapcs`	Generate a stack frame that is compliant with the ARM Procedure Call Standard for all functions, `-fomit-frame-pointer` with this will cause the stack frames not to be generated for leaf functions. The default is `-mno-apcs-frame.`
`-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`
`-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. 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 `-msoft-float` changes the calling convention in the output file; therefore, it is only useful if you compile all of a program with this option. In particular, you need to compile libgcc.a, the library that comes with GCC, with -msoft-float in order for this to work.
`-mfloat-abi=name`	Specifies which ABI to use for floating point values. `soft\| softfp \|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.
`-mlittle-endian`	Generate code for a processor running in little-endian mode. This is the default
`-mbig-endian`	Generate code for a processor running in big-endian mode;
`-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`	similar to `-mcpu` , except that instead of specifying the actual target processor type, 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`	specifies what floating point hardware (or hardware emulation) is available on the target. Permissible names are: `fpa, fpe2, fpe3, maverick, vfp. 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. 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.
`-mpoke-function-name`	Write the name of each function into the text section, directly preceding the function prologue. The generated code is similar to this: t0 .ascii "arm_poke_function_name", 0 .align t1 .word 0xff000000 + (t1 - t0) arm_poke_function_name mov ip, sp stmfd sp!, {fp, ip, lr, pc} sub fp, ip, #4 When performing a stack backtrace, code can inspect the value of "pc" stored at "fp + 0". If the trace function then looks at location "pc - 12" and the top 8 bits are set, then we know that there is a function name embedded immediately preceding this location and has length "((pc[-3]) & 0xff000000)".
`-mthumb`	Generate code for the 16-bit Thumb instruction set. The default is to use the 32-bit ARM instruction set.
`-mtpcs-frame`	Generate a stack frame that is compliant with the Thumb Procedure Call Standard for all non-leaf functions. (A leaf function is one that does not call any other functions.) The default is -mno-tpcs-frame.
`-mtpcs-leaf-frame`	Generate a stack frame that is compliant with the Thumb Procedure Call Standard for all leaf functions. (A leaf function is one that does not call any other functions.) The default is -mno-apcs-leaf-frame.
`-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.

gcc

GNU project C and C++ compiler

Overall Options

C++ Language Options

Debugging Options

ARM Options

Code Generation Options

Options Controlling the Kind of Output

Compiling C++ Programs

Options Controlling C Dialect

Controlling C++ Dialect

Options Controlling Objective-C and Objective-C++ Dialects

Control Diagnostic Messages Formatting

Include or Suppress Warnings

Options for Debugging

Optimization

Optimization levels

Options Controlling the Preprocessor

Make related options

Passing Options to the Assembler

Options for Linking

Options for Directory Search

Specifying Target Machine and Compiler Version

Hardware Models and Configurations

ARM Options

Darwin Options

ENVIRONMENT

Notes

See

`$LANG $LC_CTYPE $LC_MESSAGES $LC_ALL`	control the way GCC uses localization . if it has been configured . A typical value is en_GB.UTF-8 for English in the United Kingdom encoded in UTF-8. `$LC_CTYPE` specifies character classification. determines the character boundaries in a string; this is needed for some multibyte encodings that contain quote and escape characters that would otherwise be interpreted as a string end or escape. `$LC_MESSAGES` language for diagnostic messages. `$LC_ALL` overrides `$LC_CTYPE and $LC_MESSAGES`; otherwise, `$LC_CTYPE and $LC_MESSAGES` default to the value of `$LANG` `$LANG` character set to be used when character literals, string literals and comments are parsed . When the compiler is configured to allow multibyte characters, the following values are recognized: C-JIS Recognize JIS characters. C-SJIS Recognize SJIS characters. C-EUCJP Recognize EUCJP characters. If $`LANG` is not defined the compiler will use `mblen` and `mbtowc` from the default locale to recognize and translate multibyte characters.
`$TMPDIR`	directory is used for temporary files for the output of one stage of compilation used as input to the next stage:
`$GCC_EXEC_PREFIX`	Prefix for the subprograms executed by the compiler. No slash is added Default a prefix is based on the pathname it was invoked with. The default is `prefix/lib/gcc/` where prefix defined in the configure script. prefixes with `-B` take precedence over this prefix. This prefix is used with files such as `crt0.o` for linking. prefix is used in finding the directories to search for headers. For each of the standard directories whose name normally begins with `/usr/local/lib/gcc` (more precisely, with the value of GCC_INCLUDE_DIR), GCC replaces that beginning with the specified prefix to produce an alternate directory name. Thus, with `-Bfoo/` , GCC searchs `foo/bar` where it would search `/usr/local/lib/bar.` These alternate directories are searched first; the standard directories come next.
`$COMPILER_PATH`	colon-separated list of directories, GCC the directories specified when searching for subprograms, if it can't find the subprograms using GCC_EXEC_PREFIX.
`$LIBRARY_PATH`	a colon-separated list of directories, As a native compiler, GCC tries these directories when searching for special linker files, If it can't find them using `$GCC_EXEC_PREFIX`. Linking uses these directories when searching for libraries with `-l` after searching those with `-L`.
`$CPATH`	a list directories separated by a "`PATH_SEPARATOR`", in which to look for header files. For MS-based targets it is a semicolon, and for other targets a colon. Directories from `$CPATH` as used as if specified with `-I`, after paths on the command line.
$C_INCLUDE_PATH $CPLUS_INCLUDE_PATH $OBJC_INCLUDE_PATH	a list of directories to be searched as if specified with `-isystem`, after paths given with `-isystem` on the command line. In all these variables, an empty element instructs the compiler to search its current working directory. Empty elements can appear at the beginning or end of a path. For instance, if `$CPATH` is `:/special/include` it is the same as `-I. -I/special/include`.
`$DEPENDENCIES_OUTPUT`	how to output dependencies for Make based on the non-system header files processed by the compiler. System header files are ignored in the dependency output. `$DEPENDENCIES_OUTPUT` can be a file, the Make rules are written to that file, using the target name from the source file name. Or the value can have the form file target, in which case the rules are written to file file using target as the target name. This is equivalent to combining the options -MM and -MF, with an optional -MT switch .
`$SUNPRO_DEPENDENCIES`	As with `$DEPENDENCIES_OUTPUT` except that system header files are not ignored, so it implies -M rather than -MM. The dependence on the main input file is omitted.