Return to invoke.rtf CVS log

Up to [Apple XNU] / GNUtools / cc

GNU tools for NeXTSTEP 3.3

{\rtf0\ansi{\fonttbl\f0\fnil Times-Roman;\f1\fmodern Courier;\f3\ftech Symbol;\f2\fmodern Ohlfs;\f4\fswiss Helvetica;}
\f0\fs28 {\info{\comment build from /build/cc_proj/cc/cc/invoke.texi}}
\
{{\NeXTHelpMarker \markername Invoking GCC;}
,}{\fs88 {\f4 1}\i\
GNU CC Command Options}\
\
When you invoke GNU CC, it normally does preprocessing, 
compilation, assembly and linking. The ``overall options'' allow you to stop 
this process at an intermediate stage. For example, the {\f4\fs24 -c} option says not to 
run the linker. Then the output consists of object files output by the 
assembler. \
Other options are passed on to one stage of processing. Some 
options control the preprocessor and others the compiler itself. Yet other 
options control the assembler and linker; most of these are not documented 
here, since you rarely need to use any of them. \
Most of the command line 
options that you can use with GNU CC are useful for C programs; when an option 
is only useful with another language (usually C++), the explanation says so 
explicitly. If the description for a particular option does not mention a 
source language, you can use that option with all supported languages. \
{See `Compiling C++ Programs' {\NeXTHelpLink \markername ;\linkFilename /build/cc_proj/cc/cc/invoke.rtf;\linkMarkername {Invoking G++;}
,}., for a 
summary of special options for compiling C++ programs. \
The {\f1\fs24 gcc} program accepts 
options and file names as operands. Many options have multiletter names; 
therefore multiple single-letter options may {\i not} be grouped: {\f4\fs24 -dr} is very 
different from {\f4\fs24 -d -r}. \
You can mix options and other arguments. For the most 
part, the order you use doesn't matter. Order does matter when you use several 
options of the same kind; for example, if you specify {\f4\fs24 -L} more than once, the 
directories are searched in the order specified. \
Many options have long names 
starting with {\f4\fs24 -f} or with {\f4\fs24 -W}---for example, {\f4\fs24 -fforce-mem}, {\f4\fs24 -fstrength-reduce}, {\f4\fs24 
-Wformat} and so on. Most of these have both positive and negative forms; the 
negative form of {\f4\fs24 -ffoo} would be {\f4\fs24 -fno-foo}. This manual documents only one of 
these two forms, whichever one is not the default. \
 \
{{\NeXTHelpMarker \markername Option Summary;}
,}{\b\fs48\f4 1.1 Option Summary}\
\
Here is a 
summary of all the options, grouped by type. Explanations are in the following 
sections. \
\
{\i Overall Options} {See `Options Controlling the Kind of Output' {\NeXTHelpLink \markername ;\linkFilename /build/cc_proj/cc/cc/invoke.rtf;\linkMarkername {Overall Options;}
,}.. {\f1\fs24 -c  -S  -E  -o {\i file}  -pipe  -v  -x {\i language}  }\
\
\
{\i C 
Language Options} {See `Options Controlling C Dialect' {\NeXTHelpLink \markername ;\linkFilename /build/cc_proj/cc/cc/invoke.rtf;\linkMarkername {C Dialect Options;}
,}.. {\f1\fs24 -ansi  -fcond-mismatch  -fno-asm  -fno-builtin }\
{\f1\fs24 
-fsigned-bitfields  -fsigned-char  }\
{\f1\fs24 
-funsigned-bitfields  -funsigned-char  -fwritable-strings }\
{\f1\fs24 
-traditional  -traditional-cpp  -trigraphs }\
\
\
{\i C++ Language Options} {See `Options Controlling C++ Dialect' {\NeXTHelpLink \markername ;\linkFilename /build/cc_proj/cc/cc/invoke.rtf;\linkMarkername {C++ Dialect Options;}
,}.. {\f1\fs24 
-fall-virtual  -fdollars-in-identifiers }\
{\f1\fs24 -felide-constructors  -fenum-int-equiv }\
{\f1\fs24 
-fexternal-templates  -fmemoize-lookups }\
{\f1\fs24 
-fno-strict-prototype  -fnonnull-objects }\
{\f1\fs24 -fthis-is-variable  -nostdinc++ }\
\
\
{\i 
Warning Options} {See `Options to Request or Suppress Warnings' {\NeXTHelpLink \markername ;\linkFilename /build/cc_proj/cc/cc/invoke.rtf;\linkMarkername {Warning Options;}
,}.. {\f1\fs24 -fsyntax-only  -pedantic  -pedantic-errors }\
{\f1\fs24 
-w  -W  -Wall  -Waggregate-return  -Wcast-align   }\
{\f1\fs24 
-Wcast-qual  -Wchar-subscript  -Wcomment  -Wconversion }\
{\f1\fs24 
-Wenum-clash  -Werror  -Wformat  -Wid-clash-{\i len} }\
{\f1\fs24 
-Wimplicit  -Wimport  -Winline  -Wmissing-prototypes }\
{\f1\fs24 
-Wnested-externs  -Woverloaded-virtual  -Wparentheses }\
{\f1\fs24 
-Wpointer-arith  -Wredundant-decls  -Wreturn-type }\
{\f1\fs24 
-Wshadow  -Wstrict-prototypes  -Wswitch }\
{\f1\fs24 
-Wtemplate-debugging  -Wtraditional  -Wtrigraphs }\
{\f1\fs24 
-Wuninitialized  -Wunused  -Wwrite-strings }\
\
\
{\i Debugging Options} {See `Options for Debugging Your Program or GCC' {\NeXTHelpLink \markername ;\linkFilename /build/cc_proj/cc/cc/invoke.rtf;\linkMarkername {Debugging Options;}
,}.. {\f1\fs24 -a  -d{\i letters}
  -fpretend-float  }\
{\f1\fs24 -g  -g{\i level} -ggdb  -gdwarf -gdwarf+ }\
{\f1\fs24 
-gstabs  -gstabs+  -gcoff -gxcoff  -gxcoff+ }\
{\f1\fs24 
-p  -pg  -save-temps  -print-libgcc-file-name }\
\
\
{\i Optimization Options} {See `Options that Control Optimization' {\NeXTHelpLink \markername ;\linkFilename /build/cc_proj/cc/cc/invoke.rtf;\linkMarkername {Optimize Options;}
,}.. {\f1\fs24 
-fcaller-saves  -fcse-follow-jumps  -fcse-skip-blocks }\
{\f1\fs24 
-fdelayed-branch   -fexpensive-optimizations   }\
{\f1\fs24 
-ffast-math  -ffloat-store  -fforce-addr  -fforce-mem }\
{\f1\fs24 
-finline-functions  -fkeep-inline-functions   }\
{\f1\fs24 
-fno-default-inline  -fno-defer-pop  -fno-function-cse }\
{\f1\fs24 
-fno-inline  -fno-peephole  -fomit-frame-pointer   }\
{\f1\fs24 
-frerun-cse-after-loop  -fschedule-insns   }\
{\f1\fs24 
-fschedule-insns2  -fstrength-reduce  -fthread-jumps  }\
{\f1\fs24 
-funroll-all-loops  -funroll-loops }\
{\f1\fs24 -O  -O2 }\
\
\
{\i Preprocessor Options} {See `Options Controlling the Preprocessor' {\NeXTHelpLink \markername ;\linkFilename /build/cc_proj/cc/cc/invoke.rtf;\linkMarkername {Preprocessor Options;}
,}.. {\f1\fs24 -A{\i assertion}
  -C  -dD  -dM  -dN }\
{\f1\fs24 -D{\i macro}={\i defn}  -E  -H }\
{\f1\fs24 -idirafter {\i dir} }\
{\f1\fs24 -include {\i file}
  -imacros {\i file} }\
{\f1\fs24 -iprefix {\i file}  -iwithprefix {\i dir} }\
{\f1\fs24 -iwithprefixbefore {\i dir} }\
{\f1\fs24 
-M  -MD  -MM  -MMD  -nostdinc  -P  -trigraphs  -U{\i macro} }\
\
\
{\i Assembler Option} {See `Passing Options to the Assembler' {\NeXTHelpLink \markername ;\linkFilename /build/cc_proj/cc/cc/invoke.rtf;\linkMarkername {Assembler Options;}
,}.. {\f1\fs24 -Wa,{\i 
option} }\
\
\
{\i Linker Options} {See `Options for Linking' {\NeXTHelpLink \markername ;\linkFilename /build/cc_proj/cc/cc/invoke.rtf;\linkMarkername {Link Options;}
,}.. {\f1\fs24 {\i object-file-name} }\
{\f1\fs24 -l{\i library}  -nostartfiles  -nostdlib   }\
{\f1\fs24 
-static  -shared  -symbolic   }\
{\f1\fs24 -Wl,{\i option}  -Xlinker {\i option} }\
{\f1\fs24 -u {\i symbol} }\
\
\
{\i Directory 
Options} {See `Options for Directory Search' {\NeXTHelpLink \markername ;\linkFilename /build/cc_proj/cc/cc/invoke.rtf;\linkMarkername {Directory Options;}
,}.. {\f1\fs24 -B{\i prefix}  -I{\i dir}  -I-  -L{\i dir} }\
\
\
{\i Target Options} {See `' {\NeXTHelpLink \markername ;\linkFilename .
is way to avoid overfull hbox. -- rms
sor}.
.
are
pes.

;\linkMarkername {Target Options;}
,}.. {\f1\fs24 -b {\i machine}  -V {\i version} }\
\
\
{\i 
Machine Dependent Options} {See `Hardware Models and Configurations' {\NeXTHelpLink \markername ;\linkFilename /build/cc_proj/cc/cc/invoke.rtf;\linkMarkername {Submodel Options;}
,}.. {\f1\fs24 {\i M680x0 Options} }\
{\f1\fs24 
-m68000  -m68020  -m68020-40  -m68030  -m68040  -m68881   }\
{\f1\fs24 
-mbitfield  -mc68000  -mc68020  -mfpa  -mnobitfield   }\
{\f1\fs24 
-mrtd  -mshort  -msoft-float  }\
\
{\f1\fs24 {\i VAX Options} }\
{\f1\fs24 -mg  -mgnu  -munix }\
\
{\f1\fs24 {\i SPARC Options} }\
{\f1\fs24 
-mepilogue  -mfpu  -mhard-float }\
{\f1\fs24 -mno-fpu  -mno-epilogue  -msoft-float }\
{\f1\fs24 
-msparclite  -mv8 }\
\
{\f1\fs24 {\i Convex Options} }\
{\f1\fs24 -mc1  -mc2  -mc32  -mc34  -mc38 }\
{\f1\fs24 
-margcount  -mnoargcount }\
{\f1\fs24 -mlong32  -mlong64 }\
{\f1\fs24 
-mbolatile-cache  -mvolatile-nocache }\
\
{\f1\fs24 {\i AMD29K Options}  }\
{\f1\fs24 
-m29000  -m29050  -mbw  -mdw  -mkernel-registers }\
{\f1\fs24 
-mlarge  -mnbw  -mnodw  -mnormal  -msmall  -mstack-check }\
{\f1\fs24 -muser-registers }\
\
{\f1\fs24 {\i 
M88K Options} }\
{\f1\fs24 -m88000  -m88100  -m88110  -mbig-pic   }\
{\f1\fs24 
-mcheck-zero-division  -mhandle-large-shift  }\
{\f1\fs24 
-midentify-revision  -mno-check-zero-division  }\
{\f1\fs24 
-mno-ocs-debug-info  -mno-ocs-frame-position  }\
{\f1\fs24 
-mno-optimize-arg-area  -mno-serialize-volatile }\
{\f1\fs24 
-mno-underscores  -mocs-debug-info }\
{\f1\fs24 -mocs-frame-position  -moptimize-arg-area }\
{\f1\fs24 
-mserialize-volatile  -mshort-data-{\i num}  -msvr3  }\
{\f1\fs24 
-msvr4  -mtrap-large-shift  -muse-div-instruction  }\
{\f1\fs24 
-mversion-03.00  -mwarn-passed-structs }\
\
{\f1\fs24 {\i RS/6000 Options and PowerPC} }\
{\f1\fs24 -mcpu={\i 
cpu type} }\
{\f1\fs24 -mpower -mno-power -mpower2 -pno-power2 }\
{\f1\fs24 
-mpowerpc -mno-powerpc -mpowerpcsqr -mno-powerpcsqr }\
{\f1\fs24 -mpowerpc64 -mno-powerpc64 }\
{\f1\fs24 
-mnew-mnemonics -mno-new-mnemonics }\
{\f1\fs24 
-mnormal-toc   -mminimal-toc  -mno-fop-in-toc }\
\
{\f1\fs24 {\i RT Options} }\
{\f1\fs24 
-mcall-lib-mul  -mfp-arg-in-fpregs  -mfp-arg-in-gregs }\
{\f1\fs24 
-mfull-fp-blocks  -mhc-struct-return  -min-line-mul }\
{\f1\fs24 
-mminimum-fp-blocks  -mnohc-struct-return }\
\
{\f1\fs24 {\i MIPS Options} }\
{\f1\fs24 -mcpu={\i cpu  type}
  -mips2  -mips3  -mint64 }\
{\f1\fs24 -mlong64  -mlonglong128  -mmips-as  -mgas  -mrnames }\
{\f1\fs24 
-mno-rnames  -mgpopt  -mno-gpopt  -mstats  -mno-stats }\
{\f1\fs24 
-mmemcpy  -mno-memcpy  -mno-mips-tfile  -mmips-tfile }\
{\f1\fs24 
-msoft-float  -mhard-float  -mabicalls  -mno-abicalls }\
{\f1\fs24 
-mhalf-pic  -mno-half-pic -mlong-calls -mno-long-calls }\
{\f1\fs24 -G  {\i num}  -nocpp }\
\
{\f1\fs24 {\i 
i386 Options} }\
{\f1\fs24 -m486  -mno-486  -msoft-float  -msvr3-shlib  -mieee-fp }\
{\f1\fs24 
-mno-fp-ret-in-387 }\
\
{\f1\fs24 {\i HPPA Options} }\
{\f1\fs24 -mpa-risc-1-0 }\
{\f1\fs24 -mpa-risc-1-1 }\
{\f1\fs24 -mlong-calls }\
{\f1\fs24 
-mdisable-fpregs }\
{\f1\fs24 -mdisable-indexing }\
{\f1\fs24 -mtrailing-colon }\
\
{\f1\fs24 {\i Intel 960 Options} }\
{\f1\fs24 -m{\i 
cpu type} }\
{\f1\fs24 -mnumerics  -msoft-float }\
{\f1\fs24 -mcode-align  -mno-code-align }\
{\f1\fs24 
-mleaf-procedures  -mno-leaf-procedures }\
{\f1\fs24 -mtail-call  -mno-tail-call }\
{\f1\fs24 
-mcomplex-addr  -mno-complex-addr }\
{\f1\fs24 -mclean-linkage  -mno-clean-linkage }\
{\f1\fs24 
-mic-compat  -mic2.0-compat  -mic3.0-compat }\
{\f1\fs24 -masm-compat  -mintel-asm }\
{\f1\fs24 
-mstrict-align  -mno-strict-align }\
{\f1\fs24 -mold-align  -mno-old-align }\
\
{\f1\fs24 {\i 
DEC Alpha Options} }\
{\f1\fs24 -mfp-regs  -mno-fp-regs  -mno-soft-float }\
{\f1\fs24 -msoft-float }\
\
{\f1\fs24 {\i 
Clipper Options} }\
{\f1\fs24 -mc300 -mc400 }\
\
{\f1\fs24 {\i System V Options} }\
{\f1\fs24 -G  -Qy  -Qn  -YP,{\i paths}  -Ym,{\i 
dir} }\
\
\
{\i Code Generation Options} {See `Options for Code Generation Conventions' {\NeXTHelpLink \markername ;\linkFilename /build/cc_proj/cc/cc/invoke.rtf;\linkMarkername {Code Gen Options;}
,}.. {\f1\fs24 -fcall-saved-{\i reg}  -fcall-used-{\i reg}  }\
{\f1\fs24 -ffixed-{\i reg}
  -finhibit-size-directive  }\
{\f1\fs24 -fno-common  -fno-ident }\
{\f1\fs24 
-fno-gnu-linker  -fpcc-struct-return  -fpic  -fPIC  }\
{\f1\fs24 
-freg-struct-return  -fshared-data  -fshort-enums }\
{\f1\fs24 
-fshort-double  -fvolatile  -fvolatile-global }\
{\f1\fs24 -fverbose-asm }\
\
\
 \
{{\NeXTHelpMarker \markername Overall Options;}
,}{\b\fs48\f4 1.2 Options 
Controlling the Kind of Output}\
\
Compilation can involve up to four stages: 
preprocessing, compilation proper, assembly and linking, always in that order. 
The first three stages apply to an individual source file, and end by 
producing an object file; linking combines all the object files (those newly 
compiled, and those specified as input) into an executable file. \
For any given 
input file, the file name suffix determines what kind of compilation is done: \
\
{\f1\fs24 {\i 
file}.c} C source code which must be preprocessed. \
\
{\f1\fs24 {\i file}.i} C source code which 
should not be preprocessed. \
\
{\f1\fs24 {\i file}.ii} C++ source code which should not be 
preprocessed. \
\
{\f1\fs24 {\i file}.m} Objective-C source code. Note that you must link with the 
library `{\f1\fs24 libobjc.a}' to make an Objective-C program work. \
\
{\f1\fs24 {\i file}.h} C header file 
(not to be compiled or linked). \
\
{\f1\fs24 {\i file}.cc} \
{\f1\fs24 {\i file}.cxx} \
{\f1\fs24 {\i file}.C} C++ source code which 
must be preprocessed. Note that in {\f4\fs24 .cxx}, the last two letters must both be 
literally {\f4\fs24 x}. Likewise, {\f4\fs24 .C} refers to a literal capital C. \
\
{\f1\fs24 {\i file}.s} Assembler 
code. \
\
{\f1\fs24 {\i file}.S} Assembler code which must be preprocessed. \
\
{\f1\fs24 {\i other}} An object file 
to be fed straight into linking. Any file name with no recognized suffix is 
treated this way. \
\
You can specify the input language explicitly with the {\f4\fs24 -x} 
option: \
\
{\f1\fs24 -x {\i language}} Specify explicitly the {\i language} for the following input 
files (rather than letting the compiler choose a default based on the file 
name suffix). This option applies to all following input files until the next {\f4\fs24 
-x} option. Possible values for {\i language} are: {\f1\fs24 c  objective-c  c++ }\
{\f1\fs24 
c-header  cpp-output  c++-cpp-output }\
{\f1\fs24 assembler  assembler-with-cpp }\
\
\
{\f1\fs24 -x none} 
Turn off any specification of a language, so that subsequent files are handled 
according to their file name suffixes (as they are if {\f4\fs24 -x} has not been used at 
all). \
\
If you only want some of the stages of compilation, you can use {\f4\fs24 -x} (or 
filename suffixes) to tell {\f1\fs24 gcc} where to start, and one of the options {\f4\fs24 -c}, {\f4\fs24 -S}, 
or {\f4\fs24 -E} to say where {\f1\fs24 gcc} is to stop. Note that some combinations (for example, {\f4\fs24 
-x cpp-output -E} instruct {\f1\fs24 gcc} to do nothing at all. \
\
{\f1\fs24 -c} Compile or assemble the 
source files, but do not link. The linking stage simply is not done. The 
ultimate output is in the form of an object file for each source file. \
By 
default, the object file name for a source file is made by replacing the 
suffix {\f4\fs24 .c}, {\f4\fs24 .i}, {\f4\fs24 .s}, etc., with {\f4\fs24 .o}. \
Unrecognized input files, not requiring 
compilation or assembly, are ignored. \
\
{\f1\fs24 -S} Stop after the stage of compilation 
proper; do not assemble. The output is in the form of an assembler code file 
for each non-assembler input file specified. \
By default, the assembler file 
name for a source file is made by replacing the suffix {\f4\fs24 .c}, {\f4\fs24 .i}, etc., with {\f4\fs24 .s}. \

Input files that don't require compilation are ignored. \
\
{\f1\fs24 -E} Stop after the 
preprocessing stage; do not run the compiler proper. The output is in the form 
of preprocessed source code, which is sent to the standard output. \
Input files 
which don't require preprocessing are ignored. \
\
{\f1\fs24 -o {\i file}} Place output in file {\i 
file}. This applies regardless to whatever sort of output is being produced, 
whether it be an executable file, an object file, an assembler file or 
preprocessed C code. \
Since only one output file can be specified, it does not 
make sense to use {\f4\fs24 -o} when compiling more than one input file, unless you are 
producing an executable file as output. \
If {\f4\fs24 -o} is not specified, the default is 
to put an executable file in `{\f1\fs24 a.out}', the object file for `{\f1\fs24 {\i source}.{\i suffix}}' in `{\f1\fs24 {\i 
source}.o}', its assembler file in `{\f1\fs24 {\i source}.s}', and all preprocessed C source on 
standard output. \
\
{\f1\fs24 -v} Print (on standard error output) the commands executed to 
run the stages of compilation. Also print the version number of the compiler 
driver program and of the preprocessor and the compiler proper. \
\
{\f1\fs24 -pipe} Use 
pipes rather than temporary files for communication between the various stages 
of compilation. This fails to work on some systems where the assembler is 
unable to read from a pipe; but the GNU assembler has no trouble. \
\
{{\NeXTHelpMarker \markername Invoking G++;}
,}{\b\fs48\f4 1.3 Compiling 
C++ Programs}\
\
C++ source files conventionally use one of the suffixes {\f4\fs24 .C}, {\f4\fs24 .cc}, 
or {\f4\fs24 .cxx}; preprocessed C++ files use the suffix {\f4\fs24 .ii}. GNU CC recognizes files 
with these names and compiles them as C++ programs even if you call the 
compiler the same way as for compiling C programs (usually with the name {\f1\fs24 gcc}). \

However, C++ programs often require class libraries as well as a compiler that 
understands the C++ language---and under some circumstances, you might want to 
compile programs from standard input, or otherwise without a suffix that flags 
them as C++ programs. {\f1\fs24 g++} is a shell script that calls GNU CC with the default 
language set to C++, and automatically specifies linking against the GNU class 
library libg++. {\fs18 Prior to release 2 of the compiler, there was a separate {\f1\fs24 g++} 
compiler. That version was based on GNU CC, but not integrated with it. 
Versions of {\f1\fs24 g++} with a {\f4\fs24 1.{\i xx}} version number---for example, {\f1\fs24 g++} version 1.37 or 
1.42---are much less reliable than the versions integrated with GCC 2. 
Moreover, combining G++ {\f4\fs24 1.{\i xx}} with a version 2 GCC will simply not work.} On 
many systems, the script {\f1\fs24 g++} is also installed with the name {\f1\fs24 c++}. \
When you 
compile C++ programs, you may specify many of the same command-line options 
that you use for compiling programs in any language; or command-line options 
meaningful for C and related languages; or options that are meaningful only 
for C++ programs. {See `Options Controlling C Dialect' {\NeXTHelpLink \markername ;\linkFilename /build/cc_proj/cc/cc/invoke.rtf;\linkMarkername {C Dialect Options;}
,}., for explanations of options for languages related to C. {See `Options Controlling C++ Dialect' {\NeXTHelpLink \markername ;\linkFilename /build/cc_proj/cc/cc/invoke.rtf;\linkMarkername {C++ Dialect Options;}
,}., 
for explanations of options that are meaningful only for C++ programs. \
{{\NeXTHelpMarker \markername C Dialect Options;}
,}{\b\fs48\f4 1.4 Options 
Controlling C Dialect}\
\
The following options control the dialect of C (or 
languages derived from C, such as C++ and Objective C) that the compiler 
accepts: \
\
{\f1\fs24 -ansi} Support all ANSI standard C programs. \
This turns off certain 
features of GNU C that are incompatible with ANSI C, such as the {\f1\fs24 asm}, {\f1\fs24 inline} 
and {\f1\fs24 typeof} keywords, and predefined macros such as {\f1\fs24 unix} and {\f1\fs24 vax} that identify 
the type of system you are using. It also enables the undesirable and rarely 
used ANSI trigraph feature, and disallows {\f4\fs24 $} as part of identifiers. \
The 
alternate keywords {\f1\fs24 __asm__}, {\f1\fs24 __extension__}, {\f1\fs24 __inline__} and {\f1\fs24 __typeof__} continue 
to work despite {\f4\fs24 -ansi}. You would not want to use them in an ANSI C program, of 
course, but it useful to put them in header files that might be included in 
compilations done with {\f4\fs24 -ansi}. Alternate predefined macros such as {\f1\fs24 __unix__} and {\f1\fs24 
__vax__} are also available, with or without {\f4\fs24 -ansi}. \
The {\f4\fs24 -ansi} option does not 
cause non-ANSI programs to be rejected gratuitously. For that, {\f4\fs24 -pedantic} is 
required in addition to {\f4\fs24 -ansi}. {See `' {\NeXTHelpLink \markername ;\linkFilename .
is required in
h or
d
g++} compiler.  That version was based on GNU
CC;\linkMarkername {Warning Options;}
,}.. \
The macro {\f1\fs24 __STRICT_ANSI__} is predefined when 
the {\f4\fs24 -ansi} option is used. Some header files may notice this macro and refrain 
from declaring certain functions or defining certain macros that the ANSI 
standard doesn't call for; this is to avoid interfering with any programs that 
might use these names for other things. \
The functions {\f1\fs24 alloca}, {\f1\fs24 abort}, {\f1\fs24 exit}, and {\f1\fs24 
_exit} are not builtin functions when {\f4\fs24 -ansi} is used. \
\
{\f1\fs24 -fno-asm} Do not recognize {\f1\fs24 
asm}, {\f1\fs24 inline} or {\f1\fs24 typeof} as a keyword. These words may then be used as 
identifiers. You can use the keywords {\f1\fs24 __asm__}, {\f1\fs24 __inline__} and {\f1\fs24 __typeof__} 
instead. {\f4\fs24 -ansi} implies {\f4\fs24 -fno-asm}. \
\
{\f1\fs24 -fno-builtin} Don't recognize builtin 
functions that do not begin with two leading underscores. Currently, the 
functions affected include {\f1\fs24 abort}, {\f1\fs24 abs}, {\f1\fs24 alloca}, {\f1\fs24 cos}, {\f1\fs24 exit}, {\f1\fs24 fabs}, {\f1\fs24 ffs}, {\f1\fs24 labs}, {\f1\fs24 
memcmp}, {\f1\fs24 memcpy}, {\f1\fs24 sin}, {\f1\fs24 sqrt}, {\f1\fs24 strcmp}, {\f1\fs24 strcpy}, and {\f1\fs24 strlen}. \
GCC normally generates 
special code to handle certain builtin functions more efficiently; for 
instance, calls to {\f1\fs24 alloca} may become single instructions that adjust the stack 
directly, and calls to {\f1\fs24 memcpy} may become inline copy loops. The resulting code 
is often both smaller and faster, but since the function calls no longer 
appear as such, you cannot set a breakpoint on those calls, nor can you change 
the behavior of the functions by linking with a different library. \
The {\f4\fs24 -ansi} 
option prevents {\f1\fs24 alloca} and {\f1\fs24 ffs} from being builtin functions, since these 
functions do not have an ANSI standard meaning. \
\
{\f1\fs24 -trigraphs} Support ANSI C 
trigraphs. You don't want to know about this brain-damage. The {\f4\fs24 -ansi} option 
implies {\f4\fs24 -trigraphs}. \
\
{\f1\fs24 -traditional} Attempt to support some aspects of 
traditional C compilers. Specifically: \
All {\f1\fs24 extern} declarations take effect 
globally even if they are written inside of a function definition. This 
includes implicit declarations of functions. \
The newer keywords {\f1\fs24 typeof}, {\f1\fs24 inline}
, {\f1\fs24 signed}, {\f1\fs24 const} and {\f1\fs24 volatile} are not recognized. (You can still use the 
alternative keywords such as {\f1\fs24 __typeof__}, {\f1\fs24 __inline__}, and so on.) \
Comparisons 
between pointers and integers are always allowed. \
Integer types {\f1\fs24 unsigned short} 
and {\f1\fs24 unsigned char} promote to {\f1\fs24 unsigned int}. \
Out-of-range floating point 
literals are not an error. \
Certain constructs which ANSI regards as a single 
invalid preprocessing number, such as {\f4\fs24 0xe-0xd}, are treated as expressions 
instead. \
String ``constants'' are not necessarily constant; they are stored in 
writable space, and identical looking constants are allocated separately. 
(This is the same as the effect of {\f4\fs24 -fwritable-strings}.) \
All automatic 
variables not declared {\f1\fs24 register} are preserved by {\f1\fs24 longjmp}. Ordinarily, GNU C 
follows ANSI C: automatic variables not declared {\f1\fs24 volatile} may be clobbered. \
In 
the preprocessor, comments convert to nothing at all, rather than to a space. 
This allows traditional token concatenation. \
In the preprocessor, macro 
arguments are recognized within string constants in a macro definition (and 
their values are stringified, though without additional quote marks, when they 
appear in such a context). The preprocessor always considers a string constant 
to end at a newline. \
The predefined macro {\f1\fs24 __STDC__} is not defined when you use {\f4\fs24 
-traditional}, but {\f1\fs24 __GNUC__} is (since the GNU extensions which {\f1\fs24 __GNUC__} 
indicates are not affected by {\f4\fs24 -traditional}). If you need to write header files 
that work differently depending on whether {\f4\fs24 -traditional} is in use, by testing 
both of these predefined macros you can distinguish four situations: GNU C, 
traditional GNU C, other ANSI C compilers, and other old C compilers. {See `Standard Predefined
Macros,cpp.info,The C Preprocessor' {\NeXTHelpLink \markername ;\linkFilename /build/cc_proj/cc/cc/invoke.rtf;\linkMarkername {Standard Predefined;}
,}., for 
more discussion of these and other predefined macros. \
The preprocessor 
considers a string constant to end at a newline (unless the newline is escaped 
with {\f4\fs24 \\}). (Without {\f4\fs24 -traditional}, string constants can contain the newline 
character as typed.) \
The character escape sequences {\f4\fs24 \\x} and {\f4\fs24 \\a} evaluate as 
the literal characters {\f4\fs24 x} and {\f4\fs24 a} respectively. Without {\f4\fs24 -traditional}, {\f4\fs24 \\x} is a 
prefix for the hexadecimal representation of a character, and {\f4\fs24 \\a} produces a 
bell. \
In C++ programs, assignment to {\f1\fs24 this} is permitted with {\f4\fs24 -traditional}. (The 
option {\f4\fs24 -fthis-is-variable} also has this effect.) \
\
You may wish to use {\f4\fs24 
-fno-builtin} as well as {\f4\fs24 -traditional} if your program uses names that are 
normally GNU C builtin functions for other purposes of its own. \
\
{\f1\fs24 
-traditional-cpp} Attempt to support some aspects of traditional C 
preprocessors. This includes the last three items in the table immediately 
above, but none of the other effects of {\f4\fs24 -traditional}. \
\
{\f1\fs24 -fcond-mismatch} Allow 
conditional expressions with mismatched types in the second and third 
arguments. The value of such an expression is void. \
\
{\f1\fs24 -funsigned-char} Let the 
type {\f1\fs24 char} be unsigned, like {\f1\fs24 unsigned char}. \
Each kind of machine has a default 
for what {\f1\fs24 char} should be. It is either like {\f1\fs24 unsigned char} by default or like {\f1\fs24 
signed char} by default. \
Ideally, a portable program should always use {\f1\fs24 signed 
char} or {\f1\fs24 unsigned char} when it depends on the signedness of an object. But many 
programs have been written to use plain {\f1\fs24 char} and expect it to be signed, or 
expect it to be unsigned, depending on the machines they were written for. 
This option, and its inverse, let you make such a program work with the 
opposite default. \
The type {\f1\fs24 char} is always a distinct type from each of {\f1\fs24 signed 
char} or {\f1\fs24 unsigned char}, even though its behavior is always just like one of 
those two. \
\
{\f1\fs24 -fsigned-char} Let the type {\f1\fs24 char} be signed, like {\f1\fs24 signed char}. \
Note 
that this is equivalent to {\f4\fs24 -fno-unsigned-char}, which is the negative form of {\f4\fs24 
-funsigned-char}. Likewise, the option {\f4\fs24 -fno-signed-char} is equivalent to {\f4\fs24 
-funsigned-char}. \
\
{\f1\fs24 -fsigned-bitfields} \
{\f1\fs24 -funsigned-bitfields} \
{\f1\fs24 -fno-signed-bitfields} \
{\f1\fs24 
-fno-unsigned-bitfields} These options control whether a bitfield is signed or 
unsigned, when the declaration does not use either {\f1\fs24 signed} or {\f1\fs24 unsigned}. By 
default, such a bitfield is signed, because this is consistent: the basic 
integer types such as {\f1\fs24 int} are signed types. \
However, when {\f4\fs24 -traditional} is 
used, bitfields are all unsigned no matter what. \
\
{\f1\fs24 -fwritable-strings} Store 
string constants in the writable data segment and don't uniquize them. This is 
for compatibility with old programs which assume they can write into string 
constants. The option {\f4\fs24 -traditional} also has this effect. \
Writing into string 
constants is a very bad idea; ``constants'' should be constant. \
\
{\f1\fs24 
-fallow-single-precision} Do not promote single precision math operations to 
double precision, even when compiling with {\f4\fs24 -traditional}. \
Traditional K&R C 
promotes all floating point operations to double precision, regardless of the 
sizes of the operands. On the architecture for which you are compiling, single 
precision may be faster than double precision. If you must use {\f4\fs24 -traditional}, 
but want to use single precision operations when the operands are single 
precision, use this option. This option has no effect when compiling with ANSI 
or GNU C conventions (the default). \
\
\
{{\NeXTHelpMarker \markername C++ Dialect Options;}
,}{\b\fs48\f4 1.5 Options Controlling C++ Dialect}\
\
This 
section describes the command-line options that are only meaningful for C++ 
programs; but you can also use most of the GNU compiler options regardless of 
what language your program is in. For example, you might compile a file {\f1\fs24 
firstClass.C} like this: \
{\f1\fs24 g++ -g -felide-constructors -O -c firstClass.C }\
\
 In 
this example, only {\f4\fs24 -felide-constructors} is an option meant only for C++ 
programs; you can use the other options with any language supported by GNU CC. \

Here is a list of options that are {\i only} for compiling C++ programs: \
\
{\f1\fs24 
-fall-virtual} Treat all possible member functions as virtual, implicitly. All 
member functions (except for constructor functions and {\f1\fs24 new} or {\f1\fs24 delete} member 
operators) are treated as virtual functions of the class where they appear. \

This does not mean that all calls to these member functions will be made 
through the internal table of virtual functions. Under some circumstances, the 
compiler can determine that a call to a given virtual function can be made 
directly; in these cases the calls are direct in any case. \
\
{\f1\fs24 
-fdollars-in-identifiers} Accept {\f4\fs24 $} in identifiers. You can also explicitly 
prohibit use of {\f4\fs24 $} with the option {\f4\fs24 -fno-dollars-in-identifiers}. (GNU C++ allows {\f4\fs24 
$} by default on some target systems but not others.) Traditional C allowed the 
character {\f4\fs24 $} to form part of identifiers. However, ANSI C and C++ forbid {\f4\fs24 $} in 
identifiers. \
\
{\f1\fs24 -felide-constructors} Elide constructors when this seems 
plausible. With this option, GNU C++ initializes {\f1\fs24 y} directly from the call to {\f1\fs24 
foo} without going through a temporary in the following code: \
{\f1\fs24 A foo (); }\
{\f1\fs24 
A y = foo (); }\
\
Without this option, GNU C++ (1) initializes {\f1\fs24 y} by calling the 
appropriate constructor for type {\f1\fs24 A}; (2) assigns the result of {\f1\fs24 foo} to a 
temporary; and, finally, (3) replaces the initial value of {\f1\fs24 y} with the 
temporary. \
The default behavior ({\f4\fs24 -fno-elide-constructors}) is specified by the 
draft ANSI C++ standard. If your program's constructors have side effects, {\f4\fs24 
-felide-constructors} can change your program's behavior, since some 
constructor calls may be omitted. \
\
{\f1\fs24 -fenum-int-equiv} Permit implicit conversion 
of {\f1\fs24 int} to enumeration types. Normally GNU C++ allows conversion of {\f1\fs24 enum} to {\f1\fs24 int}
, but not the other way around. \
\
{\f1\fs24 -fexternal-templates} Produce smaller code for 
template declarations, by generating only a single copy of each template 
function where it is defined. To use this option successfully, you must also 
mark all files that use templates with either {\f4\fs24 #pragma implementation} (the 
definition) or {\f4\fs24 #pragma interface} (declarations). {See `Declarations and Definitions in One Header' {\NeXTHelpLink \markername ;\linkFilename /build/cc_proj/cc/cc/invoke.rtf;\linkMarkername {C++
Interface;}
,}., for more discussion of 
these pragmas. \
When your code is compiled with {\f4\fs24 -fexternal-templates}, all 
template instantiations are external. You must arrange for all necessary 
instantiations to appear in the implementation file; you can do this with a {\f1\fs24 
typedef} that references each instantiation needed. Conversely, when you 
compile using the default option {\f4\fs24 -fno-external-templates}, all template 
instantiations are explicitly internal. \
You do not need to specify {\f4\fs24 
-fexternal-templates} when compiling a file that does not define and 
instantiate templates used in other files, even if your file {\i uses} templates 
defined in other files that are compiled with {\f4\fs24 -fexternal-templates}. The only 
side effect is an increase in object size for each file that you compile 
without {\f4\fs24 -fexternal-templates}. \
\
{\f1\fs24 -fmemoize-lookups} \
{\f1\fs24 -fsave-memoized} Use heuristics 
to compile faster. These heuristics are not enabled by default, since they are 
only effective for certain input files. Other input files compile more slowly. \

The first time the compiler must build a call to a member function (or 
reference to a data member), it must (1) determine whether the class 
implements member functions of that name; (2) resolve which member function to 
call (which involves figuring out what sorts of type conversions need to be 
made); and (3) check the visibility of the member function to the caller. All 
of this adds up to slower compilation. Normally, the second time a call is 
made to that member function (or reference to that data member), it must go 
through the same lengthy process again. This means that code like this: \
{\f1\fs24 
cout << "This " << p << " has " << n << " legs.\\n"; }\
\
 makes six passes through 
all three steps. By using a software cache, a ``hit'' significantly reduces 
this cost. Unfortunately, using the cache introduces another layer of 
mechanisms which must be implemented, and so incurs its own overhead. {\f4\fs24 
-fmemoize-lookups} enables the software cache. \
Because access privileges 
(visibility) to members and member functions may differ from one function 
context to the next, G++ may need to flush the cache. With the {\f4\fs24 
-fmemoize-lookups} flag, the cache is flushed after every function that is 
compiled. The {\f4\fs24 -fsave-memoized} flag enables the same software cache, but when 
the compiler determines that the context of the last function compiled would 
yield the same access privileges of the next function to compile, it preserves 
the cache. This is most helpful when defining many member functions for the 
same class: with the exception of member functions which are friends of other 
classes, each member function has exactly the same access privileges as every 
other, and the cache need not be flushed. \
\
{\f1\fs24 -fno-strict-prototype} Treat a 
function declaration with no arguments, such as {\f4\fs24 int foo ();}, as C would treat 
it---as saying nothing about the number of arguments or their types. Normally, 
such a declaration in C++ means that the function {\f1\fs24 foo} takes no arguments. \
\
{\f1\fs24 
-fnonnull-objects} Assume that objects reached through references are not null. \

Normally, GNU C++ makes conservative assumptions about objects reached through 
references. For example, the compiler must check that {\f1\fs24 a} is not null in code 
like the following: \
{\f1\fs24 obj &a = g (); }\
{\f1\fs24 a.f (2); }\
\
Checking that references of this 
sort have non-null values requires extra code, however, and it is unnecessary 
for many programs. You can use {\f4\fs24 -fnonnull-objects} to omit the checks for null, 
if your program doesn't require checking. \
\
{\f1\fs24 -fthis-is-variable} Permit assignment 
to {\f1\fs24 this}. The incorporation of user-defined free store management into C++ has 
made assignment to {\f4\fs24 this} an anachronism. Therefore, by default it is invalid to 
assign to {\f1\fs24 this} within a class member function; that is, GNU C++ treats the 
type of {\f4\fs24 this} in a member function of class {\f1\fs24 X} to be {\f4\fs24 X *const}. However, for 
backwards compatibility, you can make it valid with {\f4\fs24 -fthis-is-variable}. \
\
{\f1\fs24 
-nostdinc++} Do not search for header files in the standard directories 
specific to C++, but do still search the other standard directories. (This 
option is used when building libg++.) \
\
{\f1\fs24 -traditional} For C++ programs (in 
addition to the effects that apply to both C and C++), this has the same 
effect as {\f4\fs24 -fthis-is-variable}. {See ` Options Controlling C Dialect' {\NeXTHelpLink \markername ;\linkFilename /build/cc_proj/cc/cc/invoke.rtf;\linkMarkername {C Dialect Options;}
,}.. \
\
In addition, these optimization, warning, and 
code generation options have meanings only for C++ programs: \
\
{\f1\fs24 
-fno-default-inline} Do not assume {\f4\fs24 inline} for functions defined inside a class 
scope. {See `Options That Control Optimization' {\NeXTHelpLink \markername ;\linkFilename /build/cc_proj/cc/cc/invoke.rtf;\linkMarkername {Optimize Options;}
,}.. \
\
{\f1\fs24 -Wenum-clash} \
{\f1\fs24 -Woverloaded-virtual} \
{\f1\fs24 -Wtemplate-debugging} Warnings that 
apply only to C++ programs. {See `Options to Request or Suppress Warnings' {\NeXTHelpLink \markername ;\linkFilename /build/cc_proj/cc/cc/invoke.rtf;\linkMarkername {Warning
Options;}
,}.. \
\
{\f1\fs24 +e{\i n}} Control how virtual function definitions are 
used, in a fashion compatible with {\f1\fs24 cfront} 1.x. {See `Options for
Code Generation Conventions' {\NeXTHelpLink \markername ;\linkFilename /build/cc_proj/cc/cc/invoke.rtf;\linkMarkername {Code Gen Options;}
,}.. \
\
{{\NeXTHelpMarker \markername Warning Options;}
,}{\b\fs48\f4 1.6 Options to Request or 
Suppress Warnings}\
\
Warnings are diagnostic messages that report constructions 
which are not inherently erroneous but which are risky or suggest there may 
have been an error. \
You can request many specific warnings with options 
beginning {\f4\fs24 -W}, for example {\f4\fs24 -Wimplicit} to request warnings on implicit 
declarations. Each of these specific warning options also has a negative form 
beginning {\f4\fs24 -Wno-} to turn off warnings; for example, {\f4\fs24 -Wno-implicit}. This manual 
lists only one of the two forms, whichever is not the default. \
These options 
control the amount and kinds of warnings produced by GNU CC: \
\
{\f1\fs24 -fsyntax-only} 
Check the code for syntax errors, but don't do anything beyond that. \
\
{\f1\fs24 -w} 
Inhibit all warning messages. \
\
{\f1\fs24 -Wno-import} Inhibit warning messages about the 
use of {\f4\fs24 #import}. \
\
{\f1\fs24 -pedantic} Issue all the warnings demanded by strict ANSI 
standard C; reject all programs that use forbidden extensions. \
Valid ANSI 
standard C programs should compile properly with or without this option 
(though a rare few will require {\f4\fs24 -ansi}). However, without this option, certain 
GNU extensions and traditional C features are supported as well. With this 
option, they are rejected. \
{\f4\fs24 -pedantic} does not cause warning messages for use 
of the alternate keywords whose names begin and end with {\f4\fs24 __}. Pedantic warnings 
are also disabled in the expression that follows {\f1\fs24 __extension__}. However, only 
system header files should use these escape routes; application programs 
should avoid them. {See `' {\NeXTHelpLink \markername ;\linkFilename .
ation programs should avoid them.
ld use
ic
;\linkMarkername {Alternate Keywords;}
,}.. \
This option is not intended to be ; it exists only to 
satisfy \
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
{{\NeXTHelpMarker \markername M680x0 Options;}
,}{\b\fs32\f4 M680x0 Options}\
\
These are the {\f4\fs24 -m} options defined for the 68000 series. 
The default values for these options depends on which style of 68000 was 
selected when the compiler was configured; the defaults for the most common 
choices are given below. \
\
{\f1\fs24 -m68000} \
{\f1\fs24 -mc68000} Generate output for a 68000. This is 
the default when the compiler is configured for 68000-based systems. \
\
{\f1\fs24 -m68020} \
{\f1\fs24 
-mc68020} Generate output for a 68020. This is the default when the compiler is 
configured for 68020-based systems. \
\
{\f1\fs24 -m68881} Generate output containing 68881 
instructions for floating point. This is the default for most 68020 systems 
unless {\f4\fs24 -nfp} was specified when the compiler was configured. \
\
{\f1\fs24 -m68030} Generate 
output for a 68030. This is the default when the compiler is configured for 
68030-based systems. \
\
{\f1\fs24 -m68040} Generate output for a 68040. This is the default 
when the compiler is configured for 68040-based systems. \
This option inhibits 
the use of 68881/68882 instructions that have to be emulated by software on 
the 68040. If your 68040 does not have code to emulate those instructions, use {\f4\fs24 
-m68040}. \
\
{\f1\fs24 -m68020-40} Generate output for a 68040, without using any of the new 
instructions. This results in code which can run relatively efficiently on 
either a 68020/68881 or a 68030 or a 68040. The generated code does use the 
68881 instructions that are emulated on the 68040. \
\
{\f1\fs24 -mfpa} Generate output 
containing Sun FPA instructions for floating point. \
\
{\f1\fs24 -msoft-float} Generate 
output containing library calls for floating point. {\b Warning:} the requisite 
libraries are not part of GNU CC. Normally the facilities of the machine's 
usual C compiler are used, but this can't be done directly in 
cross-compilation. You must make your own arrangements to provide suitable 
library functions for cross-compilation. \
\
{\f1\fs24 -mshort} Consider type {\f1\fs24 int} to be 16 
bits wide, like {\f1\fs24 short int}. \
\
{\f1\fs24 -mnobitfield} Do not use the bit-field instructions. 
The {\f4\fs24 -m68000} option implies {\f4\fs24 -mnobitfield}. \
\
{\f1\fs24 -mbitfield} Do use the bit-field 
instructions. The {\f4\fs24 -m68020} option implies {\f4\fs24 -mbitfield}. This is the default if 
you use a configuration designed for a 68020. \
\
{\f1\fs24 -mrtd} Use a different 
function-calling convention, in which functions that take a fixed number of 
arguments return with the {\f1\fs24 rtd} instruction, which pops their arguments while 
returning. This saves one instruction in the caller since there is no need to 
pop the arguments there. \
This calling convention is incompatible with the one 
normally used on Unix, so you cannot use it if you need to call libraries 
compiled with the Unix compiler. \
Also, you must provide function prototypes 
for all functions that take variable numbers of arguments (including {\f1\fs24 printf}); 
otherwise incorrect code will be generated for calls to those functions. \
In 
addition, seriously incorrect code will result if you call a function with too 
many arguments. (Normally, extra arguments are harmlessly ignored.) \
The {\f1\fs24 rtd} 
instruction is supported by the 68010 and 68020 processors, but not by the 
68000. \
\
{{\NeXTHelpMarker \markername VAX Options;}
,}{\b\fs32\f4 VAX Options}\
\
These {\f4\fs24 -m} options are defined for the Vax: \
\
{\f1\fs24 -munix} Do not 
output certain jump instructions ({\f1\fs24 aobleq} and so on) that the Unix assembler 
for the Vax cannot handle across long ranges. \
\
{\f1\fs24 -mgnu} Do output those jump 
instructions, on the assumption that you will assemble with the GNU assembler. \
\
{\f1\fs24 
-mg} Output code for g-format floating point numbers instead of d-format. \
\
{{\NeXTHelpMarker \markername SPARC Options;}
,}{\b\fs32\f4 SPARC 
Options}\
\
These {\f4\fs24 -m} switches are supported on the SPARC: \
\
{\f1\fs24 -mfpu} \
{\f1\fs24 -mhard-float} 
Generate output containing floating point instructions. This is the default. \
\
{\f1\fs24 
-mno-fpu} \
{\f1\fs24 -msoft-float} Generate output containing library calls for floating 
point. {\b Warning:} there is no GNU floating-point library for SPARC. 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. \
{\f4\fs24 -msoft-float} changes the 
calling convention in the output file; therefore, it is only useful if you 
compile {\i all} of a program with this option. In particular, you need to compile `{\f1\fs24 
libgcc.a}', the library that comes with GNU CC, with {\f4\fs24 -msoft-float} in order for 
this to work. \
 \
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
\
}

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.