1 @c Copyright (C) 1988,89,92,93,94,95,96,1997 Free Software Foundation, Inc.
2 @c This is part of the GCC manual.
3 @c For copying conditions, see the file gcc.texi.
6 @chapter GNU CC Command Options
7 @cindex GNU CC command options
8 @cindex command options
9 @cindex options, GNU CC command
11 When you invoke GNU CC, it normally does preprocessing, compilation,
12 assembly and linking. The ``overall options'' allow you to stop this
13 process at an intermediate stage. For example, the @samp{-c} option
14 says not to run the linker. Then the output consists of object files
15 output by the assembler.
17 Other options are passed on to one stage of processing. Some options
18 control the preprocessor and others the compiler itself. Yet other
19 options control the assembler and linker; most of these are not
20 documented here, since you rarely need to use any of them.
22 @cindex C compilation options
23 Most of the command line options that you can use with GNU CC are useful
24 for C programs; when an option is only useful with another language
25 (usually C++), the explanation says so explicitly. If the description
26 for a particular option does not mention a source language, you can use
27 that option with all supported languages.
29 @cindex C++ compilation options
30 @xref{Invoking G++,,Compiling C++ Programs}, for a summary of special
31 options for compiling C++ programs.
33 @cindex grouping options
34 @cindex options, grouping
35 The @code{gcc} program accepts options and file names as operands. Many
36 options have multiletter names; therefore multiple single-letter options
37 may @emph{not} be grouped: @samp{-dr} is very different from @w{@samp{-d
40 @cindex order of options
41 @cindex options, order
42 You can mix options and other arguments. For the most part, the order
43 you use doesn't matter. Order does matter when you use several options
44 of the same kind; for example, if you specify @samp{-L} more than once,
45 the directories are searched in the order specified.
47 Many options have long names starting with @samp{-f} or with
48 @samp{-W}---for example, @samp{-fforce-mem},
49 @samp{-fstrength-reduce}, @samp{-Wformat} and so on. Most of
50 these have both positive and negative forms; the negative form of
51 @samp{-ffoo} would be @samp{-fno-foo}. This manual documents
52 only one of these two forms, whichever one is not the default.
55 * Option Summary:: Brief list of all options, without explanations.
56 * Overall Options:: Controlling the kind of output:
57 an executable, object files, assembler files,
58 or preprocessed source.
59 * Invoking G++:: Compiling C++ programs.
60 * C Dialect Options:: Controlling the variant of C language compiled.
61 * C++ Dialect Options:: Variations on C++.
62 * Warning Options:: How picky should the compiler be?
63 * Debugging Options:: Symbol tables, measurements, and debugging dumps.
64 * Optimize Options:: How much optimization?
65 * Preprocessor Options:: Controlling header files and macro definitions.
66 Also, getting dependency information for Make.
67 * Assembler Options:: Passing options to the assembler.
68 * Link Options:: Specifying libraries and so on.
69 * Directory Options:: Where to find header files and libraries.
70 Where to find the compiler executable files.
71 * Target Options:: Running a cross-compiler, or an old version of GNU CC.
72 * Submodel Options:: Specifying minor hardware or convention variations,
73 such as 68010 vs 68020.
74 * Code Gen Options:: Specifying conventions for function calls, data layout
76 * Environment Variables:: Env vars that affect GNU CC.
77 * Running Protoize:: Automatically adding or removing function prototypes.
81 @section Option Summary
83 Here is a summary of all the options, grouped by type. Explanations are
84 in the following sections.
88 @xref{Overall Options,,Options Controlling the Kind of Output}.
90 -c -S -E -o @var{file} -pipe -v -x @var{language}
93 @item C Language Options
94 @xref{C Dialect Options,,Options Controlling C Dialect}.
96 -ansi -fallow-single-precision -fcond-mismatch -fno-asm
97 -fno-builtin -ffreestanding -fhosted -fsigned-bitfields -fsigned-char
98 -funsigned-bitfields -funsigned-char -fwritable-strings
99 -traditional -traditional-cpp -trigraphs
102 @item C++ Language Options
103 @xref{C++ Dialect Options,,Options Controlling C++ Dialect}.
105 -fall-virtual -fdollars-in-identifiers -felide-constructors
106 -fenum-int-equiv -fexternal-templates -ffor-scope -fno-for-scope
107 -fhandle-signatures -fmemoize-lookups -fname-mangling-version-@var{n}
108 -fno-default-inline -fno-gnu-keywords -fnonnull-objects -fguiding-decls
109 -foperator-names -fstrict-prototype -fthis-is-variable
110 -ftemplate-depth-@var{n} -nostdinc++ -traditional +e@var{n}
113 @item Warning Options
114 @xref{Warning Options,,Options to Request or Suppress Warnings}.
116 -fsyntax-only -pedantic -pedantic-errors
117 -w -W -Wall -Waggregate-return -Wbad-function-cast
118 -Wcast-align -Wcast-qual -Wchar-subscript -Wcomment
119 -Wconversion -Werror -Wformat
120 -Wid-clash-@var{len} -Wimplicit -Wimplicit-int
121 -Wimplicit-function-declarations -Wimport -Winline
122 -Wlarger-than-@var{len} -Wmain -Wmissing-declarations
123 -Wmissing-prototypes -Wnested-externs
124 -Wno-import -Wold-style-cast -Woverloaded-virtual -Wparentheses
125 -Wpointer-arith -Wredundant-decls -Wreorder -Wreturn-type -Wshadow
126 -Wsign-compare -Wstrict-prototypes -Wswitch -Wsynth
127 -Wtemplate-debugging -Wtraditional -Wtrigraphs
128 -Wundef -Wuninitialized -Wunused -Wwrite-strings
131 @item Debugging Options
132 @xref{Debugging Options,,Options for Debugging Your Program or GCC}.
134 -a -ax -d@var{letters} -fpretend-float
135 -fprofile-arcs -ftest-coverage
136 -g -g@var{level} -gcoff -gdwarf -gdwarf-1 -gdwarf-1+ -gdwarf-2
137 -ggdb -gstabs -gstabs+ -gxcoff -gxcoff+
138 -p -pg -print-file-name=@var{library} -print-libgcc-file-name
139 -print-prog-name=@var{program} -print-search-dirs -save-temps
142 @item Optimization Options
143 @xref{Optimize Options,,Options that Control Optimization}.
145 -fbranch-probabilities
146 -fcaller-saves -fcse-follow-jumps -fcse-skip-blocks
147 -fdelayed-branch -fexpensive-optimizations
148 -ffast-math -ffloat-store -fforce-addr -fforce-mem
149 -ffunction-sections -finline-functions
150 -fkeep-inline-functions -fno-default-inline
151 -fno-defer-pop -fno-function-cse
152 -fno-inline -fno-peephole -fomit-frame-pointer -fregmove
153 -frerun-cse-after-loop -frerun-loop-opt -fschedule-insns
154 -fschedule-insns2 -fstrength-reduce -fthread-jumps
155 -funroll-all-loops -funroll-loops
156 -fmove-all-movables -freduce-all-givs
160 @item Preprocessor Options
161 @xref{Preprocessor Options,,Options Controlling the Preprocessor}.
163 -A@var{question}(@var{answer}) -C -dD -dM -dN
164 -D@var{macro}@r{[}=@var{defn}@r{]} -E -H
166 -include @var{file} -imacros @var{file}
167 -iprefix @var{file} -iwithprefix @var{dir}
168 -iwithprefixbefore @var{dir} -isystem @var{dir}
169 -M -MD -MM -MMD -MG -nostdinc -P -trigraphs
170 -undef -U@var{macro} -Wp,@var{option}
173 @item Assembler Option
174 @xref{Assembler Options,,Passing Options to the Assembler}.
180 @xref{Link Options,,Options for Linking}.
182 @var{object-file-name} -l@var{library}
183 -nostartfiles -nodefaultlibs -nostdlib
184 -s -static -shared -symbolic
185 -Wl,@var{option} -Xlinker @var{option}
189 @item Directory Options
190 @xref{Directory Options,,Options for Directory Search}.
192 -B@var{prefix} -I@var{dir} -I- -L@var{dir} -specs=@var{file}
196 @c I wrote this xref this way to avoid overfull hbox. -- rms
197 @xref{Target Options}.
199 -b @var{machine} -V @var{version}
202 @item Machine Dependent Options
203 @xref{Submodel Options,,Hardware Models and Configurations}.
205 @emph{M680x0 Options}
206 -m68000 -m68020 -m68020-40 -m68020-60 -m68030 -m68040
207 -m68060 -m5200 -m68881 -mbitfield -mc68000 -mc68020 -mfpa
208 -mnobitfield -mrtd -mshort -msoft-float -malign-int
215 -mtune=@var{cpu type}
216 -mcmodel=@var{code model}
217 -malign-jumps=@var{num} -malign-loops=@var{num}
218 -malign-functions=@var{num}
220 -mapp-regs -mbroken-saverestore -mcypress -mepilogue
221 -mflat -mfpu -mhard-float -mhard-quad-float
222 -mimpure-text -mlive-g0 -mno-app-regs -mno-epilogue
223 -mno-flat -mno-fpu -mno-impure-text
224 -mno-stack-bias -mno-unaligned-doubles
225 -msoft-float -msoft-quad-float -msparclite -mstack-bias
226 -msupersparc -munaligned-doubles -mv8
228 @emph{Convex Options}
229 -mc1 -mc2 -mc32 -mc34 -mc38
230 -margcount -mnoargcount
232 -mvolatile-cache -mvolatile-nocache
234 @emph{AMD29K Options}
235 -m29000 -m29050 -mbw -mnbw -mdw -mndw
236 -mlarge -mnormal -msmall
237 -mkernel-registers -mno-reuse-arg-regs
238 -mno-stack-check -mno-storem-bug
239 -mreuse-arg-regs -msoft-float -mstack-check
240 -mstorem-bug -muser-registers
243 -mapcs-frame -mapcs-26 -mapcs-32
244 -mlittle-endian -mbig-endian -mwords-little-endian
245 -mshort-load-bytes -mno-short-load-bytes
246 -msoft-float -mhard-float
247 -mbsd -mxopen -mno-symrename
249 @emph{MN10300 Options}
253 @emph{M32R/D Options}
254 -mcode-model=@var{model type} -msdata=@var{sdata type}
258 -m88000 -m88100 -m88110 -mbig-pic
259 -mcheck-zero-division -mhandle-large-shift
260 -midentify-revision -mno-check-zero-division
261 -mno-ocs-debug-info -mno-ocs-frame-position
262 -mno-optimize-arg-area -mno-serialize-volatile
263 -mno-underscores -mocs-debug-info
264 -mocs-frame-position -moptimize-arg-area
265 -mserialize-volatile -mshort-data-@var{num} -msvr3
266 -msvr4 -mtrap-large-shift -muse-div-instruction
267 -mversion-03.00 -mwarn-passed-structs
269 @emph{RS/6000 and PowerPC Options}
271 -mtune=@var{cpu type}
272 -mpower -mno-power -mpower2 -mno-power2
273 -mpowerpc -mno-powerpc
274 -mpowerpc-gpopt -mno-powerpc-gpopt
275 -mpowerpc-gfxopt -mno-powerpc-gfxopt
276 -mnew-mnemonics -mno-new-mnemonics
277 -mfull-toc -mminimal-toc -mno-fop-in-toc -mno-sum-in-toc
278 -mxl-call -mno-xl-call -mthreads -mpe
279 -msoft-float -mhard-float -mmultiple -mno-multiple
280 -mstring -mno-string -mupdate -mno-update
281 -mfused-madd -mno-fused-madd -mbit-align -mno-bit-align
282 -mstrict-align -mno-strict-align -mrelocatable
283 -mno-relocatable -mrelocatable-lib -mno-relocatable-lib
284 -mtoc -mno-toc -mtraceback -mno-traceback
285 -mlittle -mlittle-endian -mbig -mbig-endian
286 -mcall-aix -mcall-sysv -mprototype -mno-prototype
287 -msim -mmvme -mads -myellowknife -memb
288 -msdata -msdata=@var{opt} -G @var{num}
291 -mcall-lib-mul -mfp-arg-in-fpregs -mfp-arg-in-gregs
292 -mfull-fp-blocks -mhc-struct-return -min-line-mul
293 -mminimum-fp-blocks -mnohc-struct-return
296 -mabicalls -mcpu=@var{cpu type} -membedded-data
297 -membedded-pic -mfp32 -mfp64 -mgas -mgp32 -mgp64
298 -mgpopt -mhalf-pic -mhard-float -mint64 -mips1
299 -mips2 -mips3 -mlong64 -mlong-calls -mmemcpy
300 -mmips-as -mmips-tfile -mno-abicalls
301 -mno-embedded-data -mno-embedded-pic
302 -mno-gpopt -mno-long-calls
303 -mno-memcpy -mno-mips-tfile -mno-rnames -mno-stats
304 -mrnames -msoft-float
305 -m4650 -msingle-float -mmad
306 -mstats -EL -EB -G @var{num} -nocpp
310 -march=@var{cpu type}
311 -mieee-fp -mno-fancy-math-387
312 -mno-fp-ret-in-387 -msoft-float -msvr3-shlib
313 -mno-wide-multiply -mrtd -malign-double
314 -mreg-alloc=@var{list} -mregparm=@var{num}
315 -malign-jumps=@var{num} -malign-loops=@var{num}
316 -malign-functions=@var{num}
319 -mbig-switch -mdisable-fpregs -mdisable-indexing -mfast-indirect-calls
320 -mgas -mjump-in-delay -mlong-load-store -mno-big-switch -mno-disable-fpregs
321 -mno-disable-indexing -mno-fast-indirect-calls -mno-gas
324 -mno-portable-runtime -mno-soft-float -mno-space -mno-space-regs
326 -mpa-risc-1-0 -mpa-risc-1-1 -mportable-runtime
327 -mschedule=@var{list} -mspace -mspace-regs
329 @emph{Intel 960 Options}
330 -m@var{cpu type} -masm-compat -mclean-linkage
331 -mcode-align -mcomplex-addr -mleaf-procedures
332 -mic-compat -mic2.0-compat -mic3.0-compat
333 -mintel-asm -mno-clean-linkage -mno-code-align
334 -mno-complex-addr -mno-leaf-procedures
335 -mno-old-align -mno-strict-align -mno-tail-call
336 -mnumerics -mold-align -msoft-float -mstrict-align
339 @emph{DEC Alpha Options}
340 -mfp-regs -mno-fp-regs
341 -mno-soft-float -msoft-float
342 -mieee -mieee-with-inexact -mieee-conformant
343 -mfp-trap-mode -mfp-rounding-mode -mtrap-precision
346 @emph{Clipper Options}
349 @emph{H8/300 Options}
350 -mrelax -mh -ms -mint32 -malign-300
353 -m1 -m2 -m3 -m3e -mb -ml -mrelax
355 @emph{System V Options}
356 -Qy -Qn -YP,@var{paths} -Ym,@var{dir}
359 -mlong-calls -mno-long-calls -mep -mno-ep
360 -mprolog-function -mno-prolog-function -mspace
361 -mtda=@var{n} -msda=@var{n} -mzda=@var{n}
365 @item Code Generation Options
366 @xref{Code Gen Options,,Options for Code Generation Conventions}.
368 -fcall-saved-@var{reg} -fcall-used-@var{reg}
369 -ffixed-@var{reg} -finhibit-size-directive
370 -fcheck-memory-usage -fprefix-function-name
371 -fno-common -fno-ident -fno-gnu-linker
372 -fpcc-struct-return -fpic -fPIC
373 -freg-struct-return -fshared-data -fshort-enums
374 -fshort-double -fvolatile -fvolatile-global
375 -fverbose-asm -fpack-struct -fstack-check +e0 +e1
376 -fargument-alias -fargument-noalias
377 -fargument-noalias-global
382 * Overall Options:: Controlling the kind of output:
383 an executable, object files, assembler files,
384 or preprocessed source.
385 * C Dialect Options:: Controlling the variant of C language compiled.
386 * C++ Dialect Options:: Variations on C++.
387 * Warning Options:: How picky should the compiler be?
388 * Debugging Options:: Symbol tables, measurements, and debugging dumps.
389 * Optimize Options:: How much optimization?
390 * Preprocessor Options:: Controlling header files and macro definitions.
391 Also, getting dependency information for Make.
392 * Assembler Options:: Passing options to the assembler.
393 * Link Options:: Specifying libraries and so on.
394 * Directory Options:: Where to find header files and libraries.
395 Where to find the compiler executable files.
396 * Target Options:: Running a cross-compiler, or an old version of GNU CC.
399 @node Overall Options
400 @section Options Controlling the Kind of Output
402 Compilation can involve up to four stages: preprocessing, compilation
403 proper, assembly and linking, always in that order. The first three
404 stages apply to an individual source file, and end by producing an
405 object file; linking combines all the object files (those newly
406 compiled, and those specified as input) into an executable file.
408 @cindex file name suffix
409 For any given input file, the file name suffix determines what kind of
414 C source code which must be preprocessed.
417 C source code which should not be preprocessed.
420 C++ source code which should not be preprocessed.
423 Objective-C source code. Note that you must link with the library
424 @file{libobjc.a} to make an Objective-C program work.
427 C header file (not to be compiled or linked).
430 @itemx @var{file}.cxx
431 @itemx @var{file}.cpp
433 C++ source code which must be preprocessed. Note that in @samp{.cxx},
434 the last two letters must both be literally @samp{x}. Likewise,
435 @samp{.C} refers to a literal capital C.
441 Assembler code which must be preprocessed.
444 An object file to be fed straight into linking.
445 Any file name with no recognized suffix is treated this way.
448 You can specify the input language explicitly with the @samp{-x} option:
451 @item -x @var{language}
452 Specify explicitly the @var{language} for the following input files
453 (rather than letting the compiler choose a default based on the file
454 name suffix). This option applies to all following input files until
455 the next @samp{-x} option. Possible values for @var{language} are:
458 c-header cpp-output c++-cpp-output
459 assembler assembler-with-cpp
463 Turn off any specification of a language, so that subsequent files are
464 handled according to their file name suffixes (as they are if @samp{-x}
465 has not been used at all).
468 If you only want some of the stages of compilation, you can use
469 @samp{-x} (or filename suffixes) to tell @code{gcc} where to start, and
470 one of the options @samp{-c}, @samp{-S}, or @samp{-E} to say where
471 @code{gcc} is to stop. Note that some combinations (for example,
472 @samp{-x cpp-output -E} instruct @code{gcc} to do nothing at all.
476 Compile or assemble the source files, but do not link. The linking
477 stage simply is not done. The ultimate output is in the form of an
478 object file for each source file.
480 By default, the object file name for a source file is made by replacing
481 the suffix @samp{.c}, @samp{.i}, @samp{.s}, etc., with @samp{.o}.
483 Unrecognized input files, not requiring compilation or assembly, are
487 Stop after the stage of compilation proper; do not assemble. The output
488 is in the form of an assembler code file for each non-assembler input
491 By default, the assembler file name for a source file is made by
492 replacing the suffix @samp{.c}, @samp{.i}, etc., with @samp{.s}.
494 Input files that don't require compilation are ignored.
497 Stop after the preprocessing stage; do not run the compiler proper. The
498 output is in the form of preprocessed source code, which is sent to the
501 Input files which don't require preprocessing are ignored.
503 @cindex output file option
505 Place output in file @var{file}. This applies regardless to whatever
506 sort of output is being produced, whether it be an executable file,
507 an object file, an assembler file or preprocessed C code.
509 Since only one output file can be specified, it does not make sense to
510 use @samp{-o} when compiling more than one input file, unless you are
511 producing an executable file as output.
513 If @samp{-o} is not specified, the default is to put an executable file
514 in @file{a.out}, the object file for @file{@var{source}.@var{suffix}} in
515 @file{@var{source}.o}, its assembler file in @file{@var{source}.s}, and
516 all preprocessed C source on standard output.@refill
519 Print (on standard error output) the commands executed to run the stages
520 of compilation. Also print the version number of the compiler driver
521 program and of the preprocessor and the compiler proper.
524 Use pipes rather than temporary files for communication between the
525 various stages of compilation. This fails to work on some systems where
526 the assembler is unable to read from a pipe; but the GNU assembler has
531 @section Compiling C++ Programs
533 @cindex suffixes for C++ source
534 @cindex C++ source file suffixes
535 C++ source files conventionally use one of the suffixes @samp{.C},
536 @samp{.cc}, @samp{cpp}, or @samp{.cxx}; preprocessed C++ files use the
537 suffix @samp{.ii}. GNU CC recognizes files with these names and
538 compiles them as C++ programs even if you call the compiler the same way
539 as for compiling C programs (usually with the name @code{gcc}).
543 However, C++ programs often require class libraries as well as a
544 compiler that understands the C++ language---and under some
545 circumstances, you might want to compile programs from standard input,
546 or otherwise without a suffix that flags them as C++ programs.
547 @code{g++} is a program that calls GNU CC with the default language
548 set to C++, and automatically specifies linking against the GNU class
550 @cindex @code{g++ 1.@var{xx}}
551 @cindex @code{g++}, separate compiler
552 @cindex @code{g++} older version
553 @footnote{Prior to release 2 of the compiler,
554 there was a separate @code{g++} compiler. That version was based on GNU
555 CC, but not integrated with it. Versions of @code{g++} with a
556 @samp{1.@var{xx}} version number---for example, @code{g++} version 1.37
557 or 1.42---are much less reliable than the versions integrated with GCC
558 2. Moreover, combining G++ @samp{1.@var{xx}} with a version 2 GCC will
559 simply not work.} On many systems, the script @code{g++} is also
560 installed with the name @code{c++}.
562 @cindex invoking @code{g++}
563 When you compile C++ programs, you may specify many of the same
564 command-line options that you use for compiling programs in any
565 language; or command-line options meaningful for C and related
566 languages; or options that are meaningful only for C++ programs.
567 @xref{C Dialect Options,,Options Controlling C Dialect}, for
568 explanations of options for languages related to C.
569 @xref{C++ Dialect Options,,Options Controlling C++ Dialect}, for
570 explanations of options that are meaningful only for C++ programs.
572 @node C Dialect Options
573 @section Options Controlling C Dialect
574 @cindex dialect options
575 @cindex language dialect options
576 @cindex options, dialect
578 The following options control the dialect of C (or languages derived
579 from C, such as C++ and Objective C) that the compiler accepts:
584 Support all ANSI standard C programs.
586 This turns off certain features of GNU C that are incompatible with ANSI
587 C, such as the @code{asm}, @code{inline} and @code{typeof} keywords, and
588 predefined macros such as @code{unix} and @code{vax} that identify the
589 type of system you are using. It also enables the undesirable and
590 rarely used ANSI trigraph feature, and it disables recognition of C++
591 style @samp{//} comments.
593 The alternate keywords @code{__asm__}, @code{__extension__},
594 @code{__inline__} and @code{__typeof__} continue to work despite
595 @samp{-ansi}. You would not want to use them in an ANSI C program, of
596 course, but it is useful to put them in header files that might be included
597 in compilations done with @samp{-ansi}. Alternate predefined macros
598 such as @code{__unix__} and @code{__vax__} are also available, with or
599 without @samp{-ansi}.
601 The @samp{-ansi} option does not cause non-ANSI programs to be
602 rejected gratuitously. For that, @samp{-pedantic} is required in
603 addition to @samp{-ansi}. @xref{Warning Options}.
605 The macro @code{__STRICT_ANSI__} is predefined when the @samp{-ansi}
606 option is used. Some header files may notice this macro and refrain
607 from declaring certain functions or defining certain macros that the
608 ANSI standard doesn't call for; this is to avoid interfering with any
609 programs that might use these names for other things.
611 The functions @code{alloca}, @code{abort}, @code{exit}, and
612 @code{_exit} are not builtin functions when @samp{-ansi} is used.
615 Do not recognize @code{asm}, @code{inline} or @code{typeof} as a
616 keyword, so that code can use these words as identifiers. You can use
617 the keywords @code{__asm__}, @code{__inline__} and @code{__typeof__}
618 instead. @samp{-ansi} implies @samp{-fno-asm}.
620 In C++, this switch only affects the @code{typeof} keyword, since
621 @code{asm} and @code{inline} are standard keywords. You may want to
622 use the @samp{-fno-gnu-keywords} flag instead, as it also disables the
623 other, C++-specific, extension keywords such as @code{headof}.
626 @cindex builtin functions
642 Don't recognize builtin functions that do not begin with two leading
643 underscores. Currently, the functions affected include @code{abort},
644 @code{abs}, @code{alloca}, @code{cos}, @code{exit}, @code{fabs},
645 @code{ffs}, @code{labs}, @code{memcmp}, @code{memcpy}, @code{sin},
646 @code{sqrt}, @code{strcmp}, @code{strcpy}, and @code{strlen}.
648 GCC normally generates special code to handle certain builtin functions
649 more efficiently; for instance, calls to @code{alloca} may become single
650 instructions that adjust the stack directly, and calls to @code{memcpy}
651 may become inline copy loops. The resulting code is often both smaller
652 and faster, but since the function calls no longer appear as such, you
653 cannot set a breakpoint on those calls, nor can you change the behavior
654 of the functions by linking with a different library.
656 The @samp{-ansi} option prevents @code{alloca} and @code{ffs} from being
657 builtin functions, since these functions do not have an ANSI standard
661 @cindex hosted environment
663 Assert that compilation takes place in a hosted environment. This implies
664 @samp{-fbuiltin}. A hosted environment is one in which the
665 entire standard library is available, and in which @code{main} has a return
666 type of @code{int}. Examples are nearly everything except a kernel.
667 This is equivalent to @samp{-fno-freestanding}.
670 @cindex hosted environment
672 Assert that compilation takes place in a freestanding environment. This
673 implies @samp{-fno-builtin}. A freestanding environment
674 is one in which the standard library may not exist, and program startup may
675 not necessarily be at @code{main}. The most obvious example is an OS kernel.
676 This is equivalent to @samp{-fno-hosted}.
679 Support ANSI C trigraphs. You don't want to know about this
680 brain-damage. The @samp{-ansi} option implies @samp{-trigraphs}.
682 @cindex traditional C language
683 @cindex C language, traditional
685 Attempt to support some aspects of traditional C compilers.
690 All @code{extern} declarations take effect globally even if they
691 are written inside of a function definition. This includes implicit
692 declarations of functions.
695 The newer keywords @code{typeof}, @code{inline}, @code{signed}, @code{const}
696 and @code{volatile} are not recognized. (You can still use the
697 alternative keywords such as @code{__typeof__}, @code{__inline__}, and
701 Comparisons between pointers and integers are always allowed.
704 Integer types @code{unsigned short} and @code{unsigned char} promote
705 to @code{unsigned int}.
708 Out-of-range floating point literals are not an error.
711 Certain constructs which ANSI regards as a single invalid preprocessing
712 number, such as @samp{0xe-0xd}, are treated as expressions instead.
715 String ``constants'' are not necessarily constant; they are stored in
716 writable space, and identical looking constants are allocated
717 separately. (This is the same as the effect of
718 @samp{-fwritable-strings}.)
720 @cindex @code{longjmp} and automatic variables
722 All automatic variables not declared @code{register} are preserved by
723 @code{longjmp}. Ordinarily, GNU C follows ANSI C: automatic variables
724 not declared @code{volatile} may be clobbered.
729 @cindex escape sequences, traditional
730 The character escape sequences @samp{\x} and @samp{\a} evaluate as the
731 literal characters @samp{x} and @samp{a} respectively. Without
732 @w{@samp{-traditional}}, @samp{\x} is a prefix for the hexadecimal
733 representation of a character, and @samp{\a} produces a bell.
736 In C++ programs, assignment to @code{this} is permitted with
737 @samp{-traditional}. (The option @samp{-fthis-is-variable} also has
741 You may wish to use @samp{-fno-builtin} as well as @samp{-traditional}
742 if your program uses names that are normally GNU C builtin functions for
743 other purposes of its own.
745 You cannot use @samp{-traditional} if you include any header files that
746 rely on ANSI C features. Some vendors are starting to ship systems with
747 ANSI C header files and you cannot use @samp{-traditional} on such
748 systems to compile files that include any system headers.
750 The @samp{-traditional} option also enables the @samp{-traditional-cpp}
751 option, which is described next.
753 @item -traditional-cpp
754 Attempt to support some aspects of traditional C preprocessors.
759 Comments convert to nothing at all, rather than to a space. This allows
760 traditional token concatenation.
763 In a preprocessing directive, the @samp{#} symbol must appear as the first
767 Macro arguments are recognized within string constants in a macro
768 definition (and their values are stringified, though without additional
769 quote marks, when they appear in such a context). The preprocessor
770 always considers a string constant to end at a newline.
773 @cindex detecting @w{@samp{-traditional}}
774 The predefined macro @code{__STDC__} is not defined when you use
775 @samp{-traditional}, but @code{__GNUC__} is (since the GNU extensions
776 which @code{__GNUC__} indicates are not affected by
777 @samp{-traditional}). If you need to write header files that work
778 differently depending on whether @samp{-traditional} is in use, by
779 testing both of these predefined macros you can distinguish four
780 situations: GNU C, traditional GNU C, other ANSI C compilers, and other
781 old C compilers. The predefined macro @code{__STDC_VERSION__} is also
782 not defined when you use @samp{-traditional}. @xref{Standard
783 Predefined,,Standard Predefined Macros,cpp.info,The C Preprocessor},
784 for more discussion of these and other predefined macros.
787 @cindex string constants vs newline
788 @cindex newline vs string constants
789 The preprocessor considers a string constant to end at a newline (unless
790 the newline is escaped with @samp{\}). (Without @w{@samp{-traditional}},
791 string constants can contain the newline character as typed.)
794 @item -fcond-mismatch
795 Allow conditional expressions with mismatched types in the second and
796 third arguments. The value of such an expression is void.
798 @item -funsigned-char
799 Let the type @code{char} be unsigned, like @code{unsigned char}.
801 Each kind of machine has a default for what @code{char} should
802 be. It is either like @code{unsigned char} by default or like
803 @code{signed char} by default.
805 Ideally, a portable program should always use @code{signed char} or
806 @code{unsigned char} when it depends on the signedness of an object.
807 But many programs have been written to use plain @code{char} and
808 expect it to be signed, or expect it to be unsigned, depending on the
809 machines they were written for. This option, and its inverse, let you
810 make such a program work with the opposite default.
812 The type @code{char} is always a distinct type from each of
813 @code{signed char} or @code{unsigned char}, even though its behavior
814 is always just like one of those two.
817 Let the type @code{char} be signed, like @code{signed char}.
819 Note that this is equivalent to @samp{-fno-unsigned-char}, which is
820 the negative form of @samp{-funsigned-char}. Likewise, the option
821 @samp{-fno-signed-char} is equivalent to @samp{-funsigned-char}.
823 You may wish to use @samp{-fno-builtin} as well as @samp{-traditional}
824 if your program uses names that are normally GNU C builtin functions for
825 other purposes of its own.
827 You cannot use @samp{-traditional} if you include any header files that
828 rely on ANSI C features. Some vendors are starting to ship systems with
829 ANSI C header files and you cannot use @samp{-traditional} on such
830 systems to compile files that include any system headers.
832 @item -fsigned-bitfields
833 @itemx -funsigned-bitfields
834 @itemx -fno-signed-bitfields
835 @itemx -fno-unsigned-bitfields
836 These options control whether a bitfield is signed or unsigned, when the
837 declaration does not use either @code{signed} or @code{unsigned}. By
838 default, such a bitfield is signed, because this is consistent: the
839 basic integer types such as @code{int} are signed types.
841 However, when @samp{-traditional} is used, bitfields are all unsigned
844 @item -fwritable-strings
845 Store string constants in the writable data segment and don't uniquize
846 them. This is for compatibility with old programs which assume they can
847 write into string constants. The option @samp{-traditional} also has
850 Writing into string constants is a very bad idea; ``constants'' should
853 @item -fallow-single-precision
854 Do not promote single precision math operations to double precision,
855 even when compiling with @samp{-traditional}.
857 Traditional K&R C promotes all floating point operations to double
858 precision, regardless of the sizes of the operands. On the
859 architecture for which you are compiling, single precision may be faster
860 than double precision. If you must use @samp{-traditional}, but want
861 to use single precision operations when the operands are single
862 precision, use this option. This option has no effect when compiling
863 with ANSI or GNU C conventions (the default).
867 @node C++ Dialect Options
868 @section Options Controlling C++ Dialect
870 @cindex compiler options, C++
871 @cindex C++ options, command line
873 This section describes the command-line options that are only meaningful
874 for C++ programs; but you can also use most of the GNU compiler options
875 regardless of what language your program is in. For example, you
876 might compile a file @code{firstClass.C} like this:
879 g++ -g -felide-constructors -O -c firstClass.C
883 In this example, only @samp{-felide-constructors} is an option meant
884 only for C++ programs; you can use the other options with any
885 language supported by GNU CC.
887 Here is a list of options that are @emph{only} for compiling C++ programs:
890 @item -fno-access-control
891 Turn off all access checking. This switch is mainly useful for working
892 around bugs in the access control code.
895 Treat all possible member functions as virtual, implicitly.
896 All member functions (except for constructor functions and @code{new} or
897 @code{delete} member operators) are treated as virtual functions of the
898 class where they appear.
900 This does not mean that all calls to these member functions will be made
901 through the internal table of virtual functions. Under some
902 circumstances, the compiler can determine that a call to a given virtual
903 function can be made directly; in these cases the calls are direct in
907 Check that the pointer returned by @code{operator new} is non-null
908 before attempting to modify the storage allocated. The current Working
909 Paper requires that @code{operator new} never return a null pointer, so
910 this check is normally unnecessary.
912 @item -fconserve-space
913 Put uninitialized or runtime-initialized global variables into the
914 common segment, as C does. This saves space in the executable at the
915 cost of not diagnosing duplicate definitions. If you compile with this
916 flag and your program mysteriously crashes after @code{main()} has
917 completed, you may have an object that is being destroyed twice because
918 two definitions were merged.
920 @item -fdollars-in-identifiers
921 Accept @samp{$} in identifiers. You can also explicitly prohibit use of
922 @samp{$} with the option @samp{-fno-dollars-in-identifiers}. (GNU C allows
923 @samp{$} by default on most target systems, but there are a few exceptions.)
924 Traditional C allowed the character @samp{$} to form part of
925 identifiers. However, ANSI C and C++ forbid @samp{$} in identifiers.
927 @item -fenum-int-equiv
928 Anachronistically permit implicit conversion of @code{int} to
929 enumeration types. Current C++ allows conversion of @code{enum} to
930 @code{int}, but not the other way around.
932 @item -fexternal-templates
933 Cause template instantiations to obey @samp{#pragma interface} and
934 @samp{implementation}; template instances are emitted or not according
935 to the location of the template definition. @xref{Template
936 Instantiation}, for more information.
938 This option is deprecated.
940 @item -falt-external-templates
941 Similar to -fexternal-templates, but template instances are emitted or
942 not according to the place where they are first instantiated.
943 @xref{Template Instantiation}, for more information.
945 This option is deprecated.
948 @itemx -fno-for-scope
949 If -ffor-scope is specified, the scope of variables declared in
950 a @i{for-init-statement} is limited to the @samp{for} loop itself,
951 as specified by the draft C++ standard.
952 If -fno-for-scope is specified, the scope of variables declared in
953 a @i{for-init-statement} extends to the end of the enclosing scope,
954 as was the case in old versions of gcc, and other (traditional)
955 implementations of C++.
957 The default if neither flag is given to follow the standard,
958 but to allow and give a warning for old-style code that would
959 otherwise be invalid, or have different behavior.
961 @item -fno-gnu-keywords
962 Do not recognize @code{classof}, @code{headof}, @code{signature},
963 @code{sigof} or @code{typeof} as a keyword, so that code can use these
964 words as identifiers. You can use the keywords @code{__classof__},
965 @code{__headof__}, @code{__signature__}, @code{__sigof__}, and
966 @code{__typeof__} instead. @samp{-ansi} implies
967 @samp{-fno-gnu-keywords}.
969 @item -fguiding-decls
970 Treat a function declaration with the same type as a potential function
971 template instantiation as though it declares that instantiation, not a
972 normal function. If a definition is given for the function later in the
973 translation unit (or another translation unit if the target supports
974 weak symbols), that definition will be used; otherwise the template will
975 be instantiated. This behavior reflects the C++ language prior to
976 September 1996, when guiding declarations were removed.
978 This option implies @samp{-fname-mangling-version-0}, and will not work
979 with other name mangling versions.
981 @item -fno-implicit-templates
982 Never emit code for templates which are instantiated implicitly (i.e. by
983 use); only emit code for explicit instantiations. @xref{Template
984 Instantiation}, for more information.
986 @item -fhandle-signatures
987 Recognize the @code{signature} and @code{sigof} keywords for specifying
988 abstract types. The default (@samp{-fno-handle-signatures}) is not to
989 recognize them. @xref{C++ Signatures, Type Abstraction using
993 Support virtual function calls for objects that exceed the size
994 representable by a @samp{short int}. Users should not use this flag by
995 default; if you need to use it, the compiler will tell you so. If you
996 compile any of your code with this flag, you must compile @emph{all} of
997 your code with this flag (including libg++, if you use it).
999 This flag is not useful when compiling with -fvtable-thunks.
1001 @item -fno-implement-inlines
1002 To save space, do not emit out-of-line copies of inline functions
1003 controlled by @samp{#pragma implementation}. This will cause linker
1004 errors if these functions are not inlined everywhere they are called.
1006 @item -fmemoize-lookups
1007 @itemx -fsave-memoized
1008 Use heuristics to compile faster. These heuristics are not enabled by
1009 default, since they are only effective for certain input files. Other
1010 input files compile more slowly.
1012 The first time the compiler must build a call to a member function (or
1013 reference to a data member), it must (1) determine whether the class
1014 implements member functions of that name; (2) resolve which member
1015 function to call (which involves figuring out what sorts of type
1016 conversions need to be made); and (3) check the visibility of the member
1017 function to the caller. All of this adds up to slower compilation.
1018 Normally, the second time a call is made to that member function (or
1019 reference to that data member), it must go through the same lengthy
1020 process again. This means that code like this:
1023 cout << "This " << p << " has " << n << " legs.\n";
1027 makes six passes through all three steps. By using a software cache, a
1028 ``hit'' significantly reduces this cost. Unfortunately, using the cache
1029 introduces another layer of mechanisms which must be implemented, and so
1030 incurs its own overhead. @samp{-fmemoize-lookups} enables the software
1033 Because access privileges (visibility) to members and member functions
1034 may differ from one function context to the next, G++ may need to flush
1035 the cache. With the @samp{-fmemoize-lookups} flag, the cache is flushed
1036 after every function that is compiled. The @samp{-fsave-memoized} flag
1037 enables the same software cache, but when the compiler determines that
1038 the context of the last function compiled would yield the same access
1039 privileges of the next function to compile, it preserves the cache.
1040 This is most helpful when defining many member functions for the same
1041 class: with the exception of member functions which are friends of other
1042 classes, each member function has exactly the same access privileges as
1043 every other, and the cache need not be flushed.
1045 The code that implements these flags has rotted; you should probably
1048 @item -fstrict-prototype
1049 Within an @samp{extern "C"} linkage specification, treat a function
1050 declaration with no arguments, such as @samp{int foo ();}, as declaring
1051 the function to take no arguments. Normally, such a declaration means
1052 that the function @code{foo} can take any combination of arguments, as
1053 in C. @samp{-pedantic} implies @samp{-fstrict-prototype} unless
1054 overridden with @samp{-fno-strict-prototype}.
1056 This flag no longer affects declarations with C++ linkage.
1058 @item -fname-mangling-version-@var{n}
1059 Control the way in which names are mangled. Version 0 is compatible
1060 with versions of g++ before 2.8. Version 1 is the default. Version 1
1061 will allow correct mangling of function templates. For example,
1062 version 0 mangling does not mangle foo<int, double> and foo<int, char>
1063 given this declaration:
1066 template <class T, class U> void foo(T t);
1069 @item -fno-nonnull-objects
1070 Don't assume that a reference is initialized to refer to a valid object.
1071 Although the current C++ Working Paper prohibits null references, some
1072 old code may rely on them, and you can use @samp{-fno-nonnull-objects}
1073 to turn on checking.
1075 At the moment, the compiler only does this checking for conversions to
1076 virtual base classes.
1078 @item -foperator-names
1079 Recognize the operator name keywords @code{and}, @code{bitand},
1080 @code{bitor}, @code{compl}, @code{not}, @code{or} and @code{xor} as
1081 synonyms for the symbols they refer to. @samp{-ansi} implies
1082 @samp{-foperator-names}.
1085 Enable automatic template instantiation. This option also implies
1086 @samp{-fno-implicit-templates}. @xref{Template Instantiation}, for more
1089 @item -fthis-is-variable
1090 Permit assignment to @code{this}. The incorporation of user-defined
1091 free store management into C++ has made assignment to @samp{this} an
1092 anachronism. Therefore, by default it is invalid to assign to
1093 @code{this} within a class member function; that is, GNU C++ treats
1094 @samp{this} in a member function of class @code{X} as a non-lvalue of
1095 type @samp{X *}. However, for backwards compatibility, you can make it
1096 valid with @samp{-fthis-is-variable}.
1098 @item -fvtable-thunks
1099 Use @samp{thunks} to implement the virtual function dispatch table
1100 (@samp{vtable}). The traditional (cfront-style) approach to
1101 implementing vtables was to store a pointer to the function and two
1102 offsets for adjusting the @samp{this} pointer at the call site. Newer
1103 implementations store a single pointer to a @samp{thunk} function which
1104 does any necessary adjustment and then calls the target function.
1106 This option also enables a heuristic for controlling emission of
1107 vtables; if a class has any non-inline virtual functions, the vtable
1108 will be emitted in the translation unit containing the first one of
1111 @item -ftemplate-depth-@var{n}
1112 Set the maximum instantiation depth for template classes to @var{n}.
1113 A limit on the template instantiation depth is needed to detect
1114 endless recursions during template class instantiation. ANSI/ISO C++
1115 conforming programs must not rely on a maximum depth greater than 17.
1118 Do not search for header files in the standard directories specific to
1119 C++, but do still search the other standard directories. (This option
1120 is used when building libg++.)
1123 For C++ programs (in addition to the effects that apply to both C and
1124 C++), this has the same effect as @samp{-fthis-is-variable}.
1125 @xref{C Dialect Options,, Options Controlling C Dialect}.
1128 In addition, these optimization, warning, and code generation options
1129 have meanings only for C++ programs:
1132 @item -fno-default-inline
1133 Do not assume @samp{inline} for functions defined inside a class scope.
1134 @xref{Optimize Options,,Options That Control Optimization}.
1136 @item -Wold-style-cast
1137 @itemx -Woverloaded-virtual
1138 @itemx -Wtemplate-debugging
1139 Warnings that apply only to C++ programs. @xref{Warning
1140 Options,,Options to Request or Suppress Warnings}.
1143 Warn about violation of some style rules from Effective C++ by Scott Myers.
1146 Control how virtual function definitions are used, in a fashion
1147 compatible with @code{cfront} 1.x. @xref{Code Gen Options,,Options for
1148 Code Generation Conventions}.
1151 @node Warning Options
1152 @section Options to Request or Suppress Warnings
1153 @cindex options to control warnings
1154 @cindex warning messages
1155 @cindex messages, warning
1156 @cindex suppressing warnings
1158 Warnings are diagnostic messages that report constructions which
1159 are not inherently erroneous but which are risky or suggest there
1160 may have been an error.
1162 You can request many specific warnings with options beginning @samp{-W},
1163 for example @samp{-Wimplicit} to request warnings on implicit
1164 declarations. Each of these specific warning options also has a
1165 negative form beginning @samp{-Wno-} to turn off warnings;
1166 for example, @samp{-Wno-implicit}. This manual lists only one of the
1167 two forms, whichever is not the default.
1169 These options control the amount and kinds of warnings produced by GNU
1173 @cindex syntax checking
1175 Check the code for syntax errors, but don't do anything beyond that.
1178 Issue all the warnings demanded by strict ANSI standard C; reject
1179 all programs that use forbidden extensions.
1181 Valid ANSI standard C programs should compile properly with or without
1182 this option (though a rare few will require @samp{-ansi}). However,
1183 without this option, certain GNU extensions and traditional C features
1184 are supported as well. With this option, they are rejected.
1186 @samp{-pedantic} does not cause warning messages for use of the
1187 alternate keywords whose names begin and end with @samp{__}. Pedantic
1188 warnings are also disabled in the expression that follows
1189 @code{__extension__}. However, only system header files should use
1190 these escape routes; application programs should avoid them.
1191 @xref{Alternate Keywords}.
1193 This option is not intended to be @i{useful}; it exists only to satisfy
1194 pedants who would otherwise claim that GNU CC fails to support the ANSI
1197 Some users try to use @samp{-pedantic} to check programs for strict ANSI
1198 C conformance. They soon find that it does not do quite what they want:
1199 it finds some non-ANSI practices, but not all---only those for which
1200 ANSI C @emph{requires} a diagnostic.
1202 A feature to report any failure to conform to ANSI C might be useful in
1203 some instances, but would require considerable additional work and would
1204 be quite different from @samp{-pedantic}. We recommend, rather, that
1205 users take advantage of the extensions of GNU C and disregard the
1206 limitations of other compilers. Aside from certain supercomputers and
1207 obsolete small machines, there is less and less reason ever to use any
1208 other C compiler other than for bootstrapping GNU CC.
1210 @item -pedantic-errors
1211 Like @samp{-pedantic}, except that errors are produced rather than
1215 Inhibit all warning messages.
1218 Inhibit warning messages about the use of @samp{#import}.
1220 @item -Wchar-subscripts
1221 Warn if an array subscript has type @code{char}. This is a common cause
1222 of error, as programmers often forget that this type is signed on some
1226 Warn whenever a comment-start sequence @samp{/*} appears in a @samp{/*}
1227 comment, or whenever a Backslash-Newline appears in a @samp{//} comment.
1230 Check calls to @code{printf} and @code{scanf}, etc., to make sure that
1231 the arguments supplied have types appropriate to the format string
1234 @item -Wimplicit-int
1235 Warn when a declaration does not specify a type.
1237 @item -Wimplicit-function-declarations
1238 Warn whenever a function is used before being declared.
1241 Same as @samp{-Wimplicit-int} @samp{-Wimplicit-function-declaration}.
1244 Warn if the type of @samp{main} is suspicious. @samp{main} should be a
1245 function with external linkage, returning int, taking either zero
1246 arguments, two, or three arguments of appropriate types.
1249 Warn if parentheses are omitted in certain contexts, such
1250 as when there is an assignment in a context where a truth value
1251 is expected, or when operators are nested whose precedence people
1252 often get confused about.
1254 Also warn about constructions where there may be confusion to which
1255 @code{if} statement an @code{else} branch belongs. Here is an example of
1268 In C, every @code{else} branch belongs to the innermost possible @code{if}
1269 statement, which in this example is @code{if (b)}. This is often not
1270 what the programmer expected, as illustrated in the above example by
1271 indentation the programmer chose. When there is the potential for this
1272 confusion, GNU C will issue a warning when this flag is specified.
1273 To eliminate the warning, add explicit braces around the innermost
1274 @code{if} statement so there is no way the @code{else} could belong to
1275 the enclosing @code{if}. The resulting code would look like this:
1290 Warn whenever a function is defined with a return-type that defaults
1291 to @code{int}. Also warn about any @code{return} statement with no
1292 return-value in a function whose return-type is not @code{void}.
1295 Warn whenever a @code{switch} statement has an index of enumeral type
1296 and lacks a @code{case} for one or more of the named codes of that
1297 enumeration. (The presence of a @code{default} label prevents this
1298 warning.) @code{case} labels outside the enumeration range also
1299 provoke warnings when this option is used.
1302 Warn if any trigraphs are encountered (assuming they are enabled).
1305 Warn whenever a variable is unused aside from its declaration,
1306 whenever a function is declared static but never defined, whenever a
1307 label is declared but not used, and whenever a statement computes a
1308 result that is explicitly not used.
1310 To suppress this warning for an expression, simply cast it to void. For
1311 unused variables and parameters, use the @samp{unused} attribute
1312 (@pxref{Variable Attributes}).
1314 @item -Wuninitialized
1315 An automatic variable is used without first being initialized.
1317 These warnings are possible only in optimizing compilation,
1318 because they require data flow information that is computed only
1319 when optimizing. If you don't specify @samp{-O}, you simply won't
1322 These warnings occur only for variables that are candidates for
1323 register allocation. Therefore, they do not occur for a variable that
1324 is declared @code{volatile}, or whose address is taken, or whose size
1325 is other than 1, 2, 4 or 8 bytes. Also, they do not occur for
1326 structures, unions or arrays, even when they are in registers.
1328 Note that there may be no warning about a variable that is used only
1329 to compute a value that itself is never used, because such
1330 computations may be deleted by data flow analysis before the warnings
1333 These warnings are made optional because GNU CC is not smart
1334 enough to see all the reasons why the code might be correct
1335 despite appearing to have an error. Here is one example of how
1354 If the value of @code{y} is always 1, 2 or 3, then @code{x} is
1355 always initialized, but GNU CC doesn't know this. Here is
1356 another common case:
1361 if (change_y) save_y = y, y = new_y;
1363 if (change_y) y = save_y;
1368 This has no bug because @code{save_y} is used only if it is set.
1370 Some spurious warnings can be avoided if you declare all the functions
1371 you use that never return as @code{noreturn}. @xref{Function
1374 @item -Wreorder (C++ only)
1375 @cindex reordering, warning
1376 @cindex warning for reordering of member initializers
1377 Warn when the order of member initializers given in the code does not
1378 match the order in which they must be executed. For instance:
1384 A(): j (0), i (1) @{ @}
1388 Here the compiler will warn that the member initializers for @samp{i}
1389 and @samp{j} will be rearranged to match the declaration order of the
1392 @item -Wtemplate-debugging
1393 @cindex template debugging
1394 When using templates in a C++ program, warn if debugging is not yet
1395 fully available (C++ only).
1398 All of the above @samp{-W} options combined. This enables all the
1399 warnings about constructions that some users consider questionable, and
1400 that are easy to avoid (or modify to prevent the warning), even in
1401 conjunction with macros.
1404 The following @samp{-W@dots{}} options are not implied by @samp{-Wall}.
1405 Some of them warn about constructions that users generally do not
1406 consider questionable, but which occasionally you might wish to check
1407 for; others warn about constructions that are necessary or hard to avoid
1408 in some cases, and there is no simple way to modify the code to suppress
1413 Print extra warning messages for these events:
1416 @cindex @code{longjmp} warnings
1418 A nonvolatile automatic variable might be changed by a call to
1419 @code{longjmp}. These warnings as well are possible only in
1420 optimizing compilation.
1422 The compiler sees only the calls to @code{setjmp}. It cannot know
1423 where @code{longjmp} will be called; in fact, a signal handler could
1424 call it at any point in the code. As a result, you may get a warning
1425 even when there is in fact no problem because @code{longjmp} cannot
1426 in fact be called at the place which would cause a problem.
1429 A function can return either with or without a value. (Falling
1430 off the end of the function body is considered returning without
1431 a value.) For example, this function would evoke such a
1445 An expression-statement or the left-hand side of a comma expression
1446 contains no side effects.
1447 To suppress the warning, cast the unused expression to void.
1448 For example, an expression such as @samp{x[i,j]} will cause a warning,
1449 but @samp{x[(void)i,j]} will not.
1452 An unsigned value is compared against zero with @samp{<} or @samp{<=}.
1455 A comparison like @samp{x<=y<=z} appears; this is equivalent to
1456 @samp{(x<=y ? 1 : 0) <= z}, which is a different interpretation from
1457 that of ordinary mathematical notation.
1460 Storage-class specifiers like @code{static} are not the first things in
1461 a declaration. According to the C Standard, this usage is obsolescent.
1464 If @samp{-Wall} or @samp{-Wunused} is also specified, warn about unused
1468 A comparison between signed and unsigned values could produce an
1469 incorrect result when the signed value is converted to unsigned.
1470 (But do not warn if @samp{-Wno-sign-compare} is also specified.)
1473 An aggregate has a partly bracketed initializer.
1474 For example, the following code would evoke such a warning,
1475 because braces are missing around the initializer for @code{x.h}:
1478 struct s @{ int f, g; @};
1479 struct t @{ struct s h; int i; @};
1480 struct t x = @{ 1, 2, 3 @};
1485 Warn about certain constructs that behave differently in traditional and
1490 Macro arguments occurring within string constants in the macro body.
1491 These would substitute the argument in traditional C, but are part of
1492 the constant in ANSI C.
1495 A function declared external in one block and then used after the end of
1499 A @code{switch} statement has an operand of type @code{long}.
1503 Warn if an undefined identifier is evaluated in an @samp{#if} directive.
1506 Warn whenever a local variable shadows another local variable.
1508 @item -Wid-clash-@var{len}
1509 Warn whenever two distinct identifiers match in the first @var{len}
1510 characters. This may help you prepare a program that will compile
1511 with certain obsolete, brain-damaged compilers.
1513 @item -Wlarger-than-@var{len}
1514 Warn whenever an object of larger than @var{len} bytes is defined.
1516 @item -Wpointer-arith
1517 Warn about anything that depends on the ``size of'' a function type or
1518 of @code{void}. GNU C assigns these types a size of 1, for
1519 convenience in calculations with @code{void *} pointers and pointers
1522 @item -Wbad-function-cast
1523 Warn whenever a function call is cast to a non-matching type.
1524 For example, warn if @code{int malloc()} is cast to @code{anything *}.
1527 Warn whenever a pointer is cast so as to remove a type qualifier from
1528 the target type. For example, warn if a @code{const char *} is cast
1529 to an ordinary @code{char *}.
1532 Warn whenever a pointer is cast such that the required alignment of the
1533 target is increased. For example, warn if a @code{char *} is cast to
1534 an @code{int *} on machines where integers can only be accessed at
1535 two- or four-byte boundaries.
1537 @item -Wwrite-strings
1538 Give string constants the type @code{const char[@var{length}]} so that
1539 copying the address of one into a non-@code{const} @code{char *}
1540 pointer will get a warning. These warnings will help you find at
1541 compile time code that can try to write into a string constant, but
1542 only if you have been very careful about using @code{const} in
1543 declarations and prototypes. Otherwise, it will just be a nuisance;
1544 this is why we did not make @samp{-Wall} request these warnings.
1547 Warn if a prototype causes a type conversion that is different from what
1548 would happen to the same argument in the absence of a prototype. This
1549 includes conversions of fixed point to floating and vice versa, and
1550 conversions changing the width or signedness of a fixed point argument
1551 except when the same as the default promotion.
1553 Also, warn if a negative integer constant expression is implicitly
1554 converted to an unsigned type. For example, warn about the assignment
1555 @code{x = -1} if @code{x} is unsigned. But do not warn about explicit
1556 casts like @code{(unsigned) -1}.
1558 @item -Wsign-compare
1559 @cindex warning for comparison of signed and unsigned values
1560 @cindex comparison of signed and unsigned values, warning
1561 @cindex signed and unsigned values, comparison warning
1562 Warn when a comparison between signed and unsigned values could produce
1563 an incorrect result when the signed value is converted to unsigned.
1564 This warning is also enabled by @samp{-W}; to get the other warnings
1565 of @samp{-W} without this warning, use @samp{-W -Wno-sign-compare}.
1567 @item -Waggregate-return
1568 Warn if any functions that return structures or unions are defined or
1569 called. (In languages where you can return an array, this also elicits
1572 @item -Wstrict-prototypes
1573 Warn if a function is declared or defined without specifying the
1574 argument types. (An old-style function definition is permitted without
1575 a warning if preceded by a declaration which specifies the argument
1578 @item -Wmissing-prototypes
1579 Warn if a global function is defined without a previous prototype
1580 declaration. This warning is issued even if the definition itself
1581 provides a prototype. The aim is to detect global functions that fail
1582 to be declared in header files.
1584 @item -Wmissing-declarations
1585 Warn if a global function is defined without a previous declaration.
1586 Do so even if the definition itself provides a prototype.
1587 Use this option to detect global functions that are not declared in
1590 @item -Wredundant-decls
1591 Warn if anything is declared more than once in the same scope, even in
1592 cases where multiple declaration is valid and changes nothing.
1594 @item -Wnested-externs
1595 Warn if an @code{extern} declaration is encountered within an function.
1598 Warn if a function can not be inlined, and either it was declared as inline,
1599 or else the @samp{-finline-functions} option was given.
1601 @item -Wold-style-cast
1602 Warn if an old-style (C-style) cast is used within a program.
1604 @item -Woverloaded-virtual
1605 @cindex overloaded virtual fn, warning
1606 @cindex warning for overloaded virtual fn
1607 Warn when a derived class function declaration may be an error in
1608 defining a virtual function (C++ only). In a derived class, the
1609 definitions of virtual functions must match the type signature of a
1610 virtual function declared in the base class. With this option, the
1611 compiler warns when you define a function with the same name as a
1612 virtual function, but with a type signature that does not match any
1613 declarations from the base class.
1615 @item -Wsynth (C++ only)
1616 @cindex warning for synthesized methods
1617 @cindex synthesized methods, warning
1618 Warn when g++'s synthesis behavior does not match that of cfront. For
1624 A& operator = (int);
1634 In this example, g++ will synthesize a default @samp{A& operator =
1635 (const A&);}, while cfront will use the user-defined @samp{operator =}.
1638 Make all warnings into errors.
1641 @node Debugging Options
1642 @section Options for Debugging Your Program or GNU CC
1643 @cindex options, debugging
1644 @cindex debugging information options
1646 GNU CC has various special options that are used for debugging
1647 either your program or GCC:
1651 Produce debugging information in the operating system's native format
1652 (stabs, COFF, XCOFF, or DWARF). GDB can work with this debugging
1655 On most systems that use stabs format, @samp{-g} enables use of extra
1656 debugging information that only GDB can use; this extra information
1657 makes debugging work better in GDB but will probably make other debuggers
1659 refuse to read the program. If you want to control for certain whether
1660 to generate the extra information, use @samp{-gstabs+}, @samp{-gstabs},
1661 @samp{-gxcoff+}, @samp{-gxcoff}, @samp{-gdwarf-1+}, or @samp{-gdwarf-1}
1664 Unlike most other C compilers, GNU CC allows you to use @samp{-g} with
1665 @samp{-O}. The shortcuts taken by optimized code may occasionally
1666 produce surprising results: some variables you declared may not exist
1667 at all; flow of control may briefly move where you did not expect it;
1668 some statements may not be executed because they compute constant
1669 results or their values were already at hand; some statements may
1670 execute in different places because they were moved out of loops.
1672 Nevertheless it proves possible to debug optimized output. This makes
1673 it reasonable to use the optimizer for programs that might have bugs.
1675 The following options are useful when GNU CC is generated with the
1676 capability for more than one debugging format.
1679 Produce debugging information for use by GDB. This means to use the
1680 most expressive format available (DWARF 2, stabs, or the native format
1681 if neither of those are supported), including GDB extensions if at all
1685 Produce debugging information in stabs format (if that is supported),
1686 without GDB extensions. This is the format used by DBX on most BSD
1687 systems. On MIPS, Alpha and System V Release 4 systems this option
1688 produces stabs debugging output which is not understood by DBX or SDB.
1689 On System V Release 4 systems this option requires the GNU assembler.
1692 Produce debugging information in stabs format (if that is supported),
1693 using GNU extensions understood only by the GNU debugger (GDB). The
1694 use of these extensions is likely to make other debuggers crash or
1695 refuse to read the program.
1698 Produce debugging information in COFF format (if that is supported).
1699 This is the format used by SDB on most System V systems prior to
1703 Produce debugging information in XCOFF format (if that is supported).
1704 This is the format used by the DBX debugger on IBM RS/6000 systems.
1707 Produce debugging information in XCOFF format (if that is supported),
1708 using GNU extensions understood only by the GNU debugger (GDB). The
1709 use of these extensions is likely to make other debuggers crash or
1710 refuse to read the program, and may cause assemblers other than the GNU
1711 assembler (GAS) to fail with an error.
1714 Produce debugging information in DWARF version 1 format (if that is
1715 supported). This is the format used by SDB on most System V Release 4
1719 Produce debugging information in DWARF version 1 format (if that is
1720 supported), using GNU extensions understood only by the GNU debugger
1721 (GDB). The use of these extensions is likely to make other debuggers
1722 crash or refuse to read the program.
1725 Produce debugging information in DWARF version 2 format (if that is
1726 supported). This is the format used by DBX on IRIX 6.
1729 @itemx -ggdb@var{level}
1730 @itemx -gstabs@var{level}
1731 @itemx -gcoff@var{level}
1732 @itemx -gxcoff@var{level}
1733 @itemx -gdwarf@var{level}
1734 @itemx -gdwarf-2@var{level}
1735 Request debugging information and also use @var{level} to specify how
1736 much information. The default level is 2.
1738 Level 1 produces minimal information, enough for making backtraces in
1739 parts of the program that you don't plan to debug. This includes
1740 descriptions of functions and external variables, but no information
1741 about local variables and no line numbers.
1743 Level 3 includes extra information, such as all the macro definitions
1744 present in the program. Some debuggers support macro expansion when
1749 Generate extra code to write profile information suitable for the
1750 analysis program @code{prof}. You must use this option when compiling
1751 the source files you want data about, and you must also use it when
1754 @cindex @code{gprof}
1756 Generate extra code to write profile information suitable for the
1757 analysis program @code{gprof}. You must use this option when compiling
1758 the source files you want data about, and you must also use it when
1763 Generate extra code to write profile information for basic blocks, which will
1764 record the number of times each basic block is executed, the basic block start
1765 address, and the function name containing the basic block. If @samp{-g} is
1766 used, the line number and filename of the start of the basic block will also be
1767 recorded. If not overridden by the machine description, the default action is
1768 to append to the text file @file{bb.out}.
1770 This data could be analyzed by a program like @code{tcov}. Note,
1771 however, that the format of the data is not what @code{tcov} expects.
1772 Eventually GNU @code{gprof} should be extended to process this data.
1775 Generate extra code to profile basic blocks. Your executable will
1776 produce output that is a superset of that produced when @samp{-a} is
1777 used. Additional output is the source and target address of the basic
1778 blocks where a jump takes place, the number of times a jump is executed,
1779 and (optionally) the complete sequence of basic blocks being executed.
1780 The output is appended to file @file{bb.out}.
1782 You can examine different profiling aspects without recompilation. Your
1783 execuable will read a list of function names from file @file{bb.in}.
1784 Profiling starts when a function on the list is entered and stops when
1785 that invocation is exited. To exclude a function from profiling, prefix
1786 its name with `-'. If a function name is not unique, you can
1787 disambiguate it by writing it in the form
1788 @samp{/path/filename.d:functionname}. Your executable will write the
1789 available paths and filenames in file @file{bb.out}.
1791 Several function names have a special meaning:
1794 Write source, target and frequency of jumps to file @file{bb.out}.
1795 @item __bb_hidecall__
1796 Exclude function calls from frequency count.
1797 @item __bb_showret__
1798 Include function returns in frequency count.
1800 Write the sequence of basic blocks executed to file @file{bbtrace.gz}.
1801 The file will be compressed using the program @samp{gzip}, which must
1802 exist in your @code{PATH}. On systems without the @samp{popen}
1803 function, the file will be named @file{bbtrace} and will not be
1804 compressed. @strong{Profiling for even a few seconds on these systems
1805 will produce a very large file.} Note: @code{__bb_hidecall__} and
1806 @code{__bb_showret__} will not affect the sequence written to
1810 Here's a short example using different profiling parameters
1811 in file @file{bb.in}. Assume function @code{foo} consists of basic blocks
1812 1 and 2 and is called twice from block 3 of function @code{main}. After
1813 the calls, block 3 transfers control to block 4 of @code{main}.
1815 With @code{__bb_trace__} and @code{main} contained in file @file{bb.in},
1816 the following sequence of blocks is written to file @file{bbtrace.gz}:
1817 0 3 1 2 1 2 4. The return from block 2 to block 3 is not shown, because
1818 the return is to a point inside the block and not to the top. The
1819 block address 0 always indicates, that control is transferred
1820 to the trace from somewhere outside the observed functions. With
1821 @samp{-foo} added to @file{bb.in}, the blocks of function
1822 @code{foo} are removed from the trace, so only 0 3 4 remains.
1824 With @code{__bb_jumps__} and @code{main} contained in file @file{bb.in},
1825 jump frequencies will be written to file @file{bb.out}. The
1826 frequencies are obtained by constructing a trace of blocks
1827 and incrementing a counter for every neighbouring pair of blocks
1828 in the trace. The trace 0 3 1 2 1 2 4 displays the following
1832 Jump from block 0x0 to block 0x3 executed 1 time(s)
1833 Jump from block 0x3 to block 0x1 executed 1 time(s)
1834 Jump from block 0x1 to block 0x2 executed 2 time(s)
1835 Jump from block 0x2 to block 0x1 executed 1 time(s)
1836 Jump from block 0x2 to block 0x4 executed 1 time(s)
1839 With @code{__bb_hidecall__}, control transfer due to call instructions
1840 is removed from the trace, that is the trace is cut into three parts: 0
1841 3 4, 0 1 2 and 0 1 2. With @code{__bb_showret__}, control transfer due
1842 to return instructions is added to the trace. The trace becomes: 0 3 1
1843 2 3 1 2 3 4. Note, that this trace is not the same, as the sequence
1844 written to @file{bbtrace.gz}. It is solely used for counting jump
1847 @item -fprofile-arcs
1848 Instrument @dfn{arcs} during compilation. For each function of your
1849 program, GNU CC creates a program flow graph, then finds a spanning tree
1850 for the graph. Only arcs that are not on the spanning tree have to be
1851 instrumented: the compiler adds code to count the number of times that these
1852 arcs are executed. When an arc is the only exit or only entrance to a
1853 block, the instrumentation code can be added to the block; otherwise, a
1854 new basic block must be created to hold the instrumentation code.
1856 Since not every arc in the program must be instrumented, programs
1857 compiled with this option run faster than programs compiled with
1858 @samp{-a}, which adds instrumentation code to every basic block in the
1859 program. The tradeoff: since @code{gcov} does not have
1860 execution counts for all branches, it must start with the execution
1861 counts for the instrumented branches, and then iterate over the program
1862 flow graph until the entire graph has been solved. Hence, @code{gcov}
1863 runs a little more slowly than a program which uses information from
1866 @samp{-fprofile-arcs} also makes it possible to estimate branch
1867 probabilities, and to calculate basic block execution counts. In
1868 general, basic block execution counts do not give enough information to
1869 estimate all branch probabilities. When the compiled program exits, it
1870 saves the arc execution counts to a file called
1871 @file{@var{sourcename}.da}. Use the compiler option
1872 @samp{-fbranch-probabilities} (@pxref{Optimize Options,,Options that
1873 Control Optimization}) when recompiling, to optimize using estimated
1874 branch probabilities.
1877 @item -ftest-coverage
1878 Create data files for the @code{gcov} code-coverage utility
1879 (@pxref{Gcov,, @code{gcov}: a GNU CC Test Coverage Program}).
1880 The data file names begin with the name of your source file:
1883 @item @var{sourcename}.bb
1884 A mapping from basic blocks to line numbers, which @code{gcov} uses to
1885 associate basic block execution counts with line numbers.
1887 @item @var{sourcename}.bbg
1888 A list of all arcs in the program flow graph. This allows @code{gcov}
1889 to reconstruct the program flow graph, so that it can compute all basic
1890 block and arc execution counts from the information in the
1891 @code{@var{sourcename}.da} file (this last file is the output from
1892 @samp{-fprofile-arcs}).
1895 @item -d@var{letters}
1896 Says to make debugging dumps during compilation at times specified by
1897 @var{letters}. This is used for debugging the compiler. The file names
1898 for most of the dumps are made by appending a word to the source file
1899 name (e.g. @file{foo.c.rtl} or @file{foo.c.jump}). Here are the
1900 possible letters for use in @var{letters}, and their meanings:
1904 Dump all macro definitions, at the end of preprocessing, and write no
1907 Dump all macro names, at the end of preprocessing.
1909 Dump all macro definitions, at the end of preprocessing, in addition to
1912 Dump debugging information during parsing, to standard error.
1914 Dump after RTL generation, to @file{@var{file}.rtl}.
1916 Just generate RTL for a function instead of compiling it. Usually used
1919 Dump after first jump optimization, to @file{@var{file}.jump}.
1921 Dump after CSE (including the jump optimization that sometimes
1922 follows CSE), to @file{@var{file}.cse}.
1924 Dump after loop optimization, to @file{@var{file}.loop}.
1926 Dump after the second CSE pass (including the jump optimization that
1927 sometimes follows CSE), to @file{@var{file}.cse2}.
1929 Dump after flow analysis, to @file{@var{file}.flow}.
1931 Dump after instruction combination, to the file
1932 @file{@var{file}.combine}.
1934 Dump after the first instruction scheduling pass, to
1935 @file{@var{file}.sched}.
1937 Dump after local register allocation, to
1938 @file{@var{file}.lreg}.
1940 Dump after global register allocation, to
1941 @file{@var{file}.greg}.
1943 Dump after the second instruction scheduling pass, to
1944 @file{@var{file}.sched2}.
1946 Dump after last jump optimization, to @file{@var{file}.jump2}.
1948 Dump after delayed branch scheduling, to @file{@var{file}.dbr}.
1950 Dump after conversion from registers to stack, to @file{@var{file}.stack}.
1952 Produce all the dumps listed above.
1954 Print statistics on memory usage, at the end of the run, to
1957 Annotate the assembler output with a comment indicating which
1958 pattern and alternative was used.
1960 Annotate the assembler output with miscellaneous debugging information.
1963 @item -fpretend-float
1964 When running a cross-compiler, pretend that the target machine uses the
1965 same floating point format as the host machine. This causes incorrect
1966 output of the actual floating constants, but the actual instruction
1967 sequence will probably be the same as GNU CC would make when running on
1971 Store the usual ``temporary'' intermediate files permanently; place them
1972 in the current directory and name them based on the source file. Thus,
1973 compiling @file{foo.c} with @samp{-c -save-temps} would produce files
1974 @file{foo.i} and @file{foo.s}, as well as @file{foo.o}.
1976 @item -print-file-name=@var{library}
1977 Print the full absolute name of the library file @var{library} that
1978 would be used when linking---and don't do anything else. With this
1979 option, GNU CC does not compile or link anything; it just prints the
1982 @item -print-prog-name=@var{program}
1983 Like @samp{-print-file-name}, but searches for a program such as @samp{cpp}.
1985 @item -print-libgcc-file-name
1986 Same as @samp{-print-file-name=libgcc.a}.
1988 This is useful when you use @samp{-nostdlib} or @samp{-nodefaultlibs}
1989 but you do want to link with @file{libgcc.a}. You can do
1992 gcc -nostdlib @var{files}@dots{} `gcc -print-libgcc-file-name`
1995 @item -print-search-dirs
1996 Print the name of the configured installation directory and a list of
1997 program and library directories gcc will search---and don't do anything else.
1999 This is useful when gcc prints the error message
2000 @samp{installation problem, cannot exec cpp: No such file or directory}.
2001 To resolve this you either need to put @file{cpp} and the other compiler
2002 components where gcc expects to find them, or you can set the environment
2003 variable @code{GCC_EXEC_PREFIX} to the directory where you installed them.
2004 Don't forget the trailing '/'.
2005 @xref{Environment Variables}.
2008 @node Optimize Options
2009 @section Options That Control Optimization
2010 @cindex optimize options
2011 @cindex options, optimization
2013 These options control various sorts of optimizations:
2018 Optimize. Optimizing compilation takes somewhat more time, and a lot
2019 more memory for a large function.
2021 Without @samp{-O}, the compiler's goal is to reduce the cost of
2022 compilation and to make debugging produce the expected results.
2023 Statements are independent: if you stop the program with a breakpoint
2024 between statements, you can then assign a new value to any variable or
2025 change the program counter to any other statement in the function and
2026 get exactly the results you would expect from the source code.
2028 Without @samp{-O}, the compiler only allocates variables declared
2029 @code{register} in registers. The resulting compiled code is a little
2030 worse than produced by PCC without @samp{-O}.
2032 With @samp{-O}, the compiler tries to reduce code size and execution
2035 When you specify @samp{-O}, the compiler turns on @samp{-fthread-jumps}
2036 and @samp{-fdefer-pop} on all machines. The compiler turns on
2037 @samp{-fdelayed-branch} on machines that have delay slots, and
2038 @samp{-fomit-frame-pointer} on machines that can support debugging even
2039 without a frame pointer. On some machines the compiler also turns
2040 on other flags.@refill
2043 Optimize even more. GNU CC performs nearly all supported optimizations
2044 that do not involve a space-speed tradeoff. The compiler does not
2045 perform loop unrolling or function inlining when you specify @samp{-O2}.
2046 As compared to @samp{-O}, this option increases both compilation time
2047 and the performance of the generated code.
2049 @samp{-O2} turns on all optional optimizations except for loop unrolling
2050 and function inlining. It also turns on the @samp{-fforce-mem} option
2051 on all machines and frame pointer elimination on machines where doing so
2052 does not interfere with debugging.
2055 Optimize yet more. @samp{-O3} turns on all optimizations specified by
2056 @samp{-O2} and also turns on the @samp{inline-functions} option.
2061 If you use multiple @samp{-O} options, with or without level numbers,
2062 the last such option is the one that is effective.
2065 Options of the form @samp{-f@var{flag}} specify machine-independent
2066 flags. Most flags have both positive and negative forms; the negative
2067 form of @samp{-ffoo} would be @samp{-fno-foo}. In the table below,
2068 only one of the forms is listed---the one which is not the default.
2069 You can figure out the other form by either removing @samp{no-} or
2074 Do not store floating point variables in registers, and inhibit other
2075 options that might change whether a floating point value is taken from a
2078 @cindex floating point precision
2079 This option prevents undesirable excess precision on machines such as
2080 the 68000 where the floating registers (of the 68881) keep more
2081 precision than a @code{double} is supposed to have. Similarly for the
2082 x86 architecture. For most programs, the excess precision does only
2083 good, but a few programs rely on the precise definition of IEEE floating
2084 point. Use @samp{-ffloat-store} for such programs.
2086 @item -fno-default-inline
2087 Do not make member functions inline by default merely because they are
2088 defined inside the class scope (C++ only). Otherwise, when you specify
2089 @w{@samp{-O}}, member functions defined inside class scope are compiled
2090 inline by default; i.e., you don't need to add @samp{inline} in front of
2091 the member function name.
2093 @item -fno-defer-pop
2094 Always pop the arguments to each function call as soon as that function
2095 returns. For machines which must pop arguments after a function call,
2096 the compiler normally lets arguments accumulate on the stack for several
2097 function calls and pops them all at once.
2100 Force memory operands to be copied into registers before doing
2101 arithmetic on them. This produces better code by making all memory
2102 references potential common subexpressions. When they are not common
2103 subexpressions, instruction combination should eliminate the separate
2104 register-load. The @samp{-O2} option turns on this option.
2107 Force memory address constants to be copied into registers before
2108 doing arithmetic on them. This may produce better code just as
2109 @samp{-fforce-mem} may.
2111 @item -fomit-frame-pointer
2112 Don't keep the frame pointer in a register for functions that
2113 don't need one. This avoids the instructions to save, set up and
2114 restore frame pointers; it also makes an extra register available
2115 in many functions. @strong{It also makes debugging impossible on
2119 On some machines, such as the Vax, this flag has no effect, because
2120 the standard calling sequence automatically handles the frame pointer
2121 and nothing is saved by pretending it doesn't exist. The
2122 machine-description macro @code{FRAME_POINTER_REQUIRED} controls
2123 whether a target machine supports this flag. @xref{Registers}.@refill
2126 On some machines, such as the Vax, this flag has no effect, because
2127 the standard calling sequence automatically handles the frame pointer
2128 and nothing is saved by pretending it doesn't exist. The
2129 machine-description macro @code{FRAME_POINTER_REQUIRED} controls
2130 whether a target machine supports this flag. @xref{Registers,,Register
2131 Usage, gcc.info, Using and Porting GCC}.@refill
2135 Don't pay attention to the @code{inline} keyword. Normally this option
2136 is used to keep the compiler from expanding any functions inline.
2137 Note that if you are not optimizing, no functions can be expanded inline.
2139 @item -finline-functions
2140 Integrate all simple functions into their callers. The compiler
2141 heuristically decides which functions are simple enough to be worth
2142 integrating in this way.
2144 If all calls to a given function are integrated, and the function is
2145 declared @code{static}, then the function is normally not output as
2146 assembler code in its own right.
2148 @item -fkeep-inline-functions
2149 Even if all calls to a given function are integrated, and the function
2150 is declared @code{static}, nevertheless output a separate run-time
2151 callable version of the function. This switch does not affect
2152 @code{extern inline} functions.
2154 @item -fkeep-static-consts
2155 Emit variables declared @code{static const} when optimization isn't turned
2156 on, even if the variables aren't referenced.
2158 GNU CC enables this option by default. If you want to force the compiler to
2159 check if the variable was referenced, regardless of whether or not
2160 optimization is turned on, use the @samp{-fno-keep-static-consts} option.
2162 @item -fno-function-cse
2163 Do not put function addresses in registers; make each instruction that
2164 calls a constant function contain the function's address explicitly.
2166 This option results in less efficient code, but some strange hacks
2167 that alter the assembler output may be confused by the optimizations
2168 performed when this option is not used.
2171 This option allows GCC to violate some ANSI or IEEE rules and/or
2172 specifications in the interest of optimizing code for speed. For
2173 example, it allows the compiler to assume arguments to the @code{sqrt}
2174 function are non-negative numbers and that no floating-point values
2177 This option should never be turned on by any @samp{-O} option since
2178 it can result in incorrect output for programs which depend on
2179 an exact implementation of IEEE or ANSI rules/specifications for
2183 @c following causes underfulls.. they don't look great, but we deal.
2185 The following options control specific optimizations. The @samp{-O2}
2186 option turns on all of these optimizations except @samp{-funroll-loops}
2187 and @samp{-funroll-all-loops}. On most machines, the @samp{-O} option
2188 turns on the @samp{-fthread-jumps} and @samp{-fdelayed-branch} options,
2189 but specific machines may handle it differently.
2191 You can use the following flags in the rare cases when ``fine-tuning''
2192 of optimizations to be performed is desired.
2195 @item -fstrength-reduce
2196 Perform the optimizations of loop strength reduction and
2197 elimination of iteration variables.
2199 @item -fthread-jumps
2200 Perform optimizations where we check to see if a jump branches to a
2201 location where another comparison subsumed by the first is found. If
2202 so, the first branch is redirected to either the destination of the
2203 second branch or a point immediately following it, depending on whether
2204 the condition is known to be true or false.
2206 @item -fcse-follow-jumps
2207 In common subexpression elimination, scan through jump instructions
2208 when the target of the jump is not reached by any other path. For
2209 example, when CSE encounters an @code{if} statement with an
2210 @code{else} clause, CSE will follow the jump when the condition
2213 @item -fcse-skip-blocks
2214 This is similar to @samp{-fcse-follow-jumps}, but causes CSE to
2215 follow jumps which conditionally skip over blocks. When CSE
2216 encounters a simple @code{if} statement with no else clause,
2217 @samp{-fcse-skip-blocks} causes CSE to follow the jump around the
2218 body of the @code{if}.
2220 @item -frerun-cse-after-loop
2221 Re-run common subexpression elimination after loop optimizations has been
2224 @item -frerun-loop-opt
2225 Run the loop optimizer twice.
2227 @item -fexpensive-optimizations
2228 Perform a number of minor optimizations that are relatively expensive.
2230 @item -fdelayed-branch
2231 If supported for the target machine, attempt to reorder instructions
2232 to exploit instruction slots available after delayed branch
2235 @item -fschedule-insns
2236 If supported for the target machine, attempt to reorder instructions to
2237 eliminate execution stalls due to required data being unavailable. This
2238 helps machines that have slow floating point or memory load instructions
2239 by allowing other instructions to be issued until the result of the load
2240 or floating point instruction is required.
2242 @item -fschedule-insns2
2243 Similar to @samp{-fschedule-insns}, but requests an additional pass of
2244 instruction scheduling after register allocation has been done. This is
2245 especially useful on machines with a relatively small number of
2246 registers and where memory load instructions take more than one cycle.
2248 @item -ffunction-sections
2249 Place each function into its own section in the output file if the
2250 target supports arbitrary sections. The function's name determines
2251 the section's name in the output file.
2253 Use this option on systems where the linker can perform optimizations
2254 to improve locality of reference in the instruction space. HPPA
2255 processors running HP-UX and Sparc processors running Solaris 2 have
2256 linkers with such optimizations. Other systems using the ELF object format
2257 as well as AIX may have these optimizations in the future.
2259 Only use this option when there are significant benefits from doing
2260 so. When you specify this option, the assembler and linker will
2261 create larger object and executable files and will also be slower.
2262 You will not be able to use @code{gprof} on all systems if you
2263 specify this option and you may have problems with debugging if
2264 you specify both this option and @samp{-g}.
2266 @item -fcaller-saves
2267 Enable values to be allocated in registers that will be clobbered by
2268 function calls, by emitting extra instructions to save and restore the
2269 registers around such calls. Such allocation is done only when it
2270 seems to result in better code than would otherwise be produced.
2272 This option is enabled by default on certain machines, usually those
2273 which have no call-preserved registers to use instead.
2275 @item -funroll-loops
2276 Perform the optimization of loop unrolling. This is only done for loops
2277 whose number of iterations can be determined at compile time or run time.
2278 @samp{-funroll-loop} implies both @samp{-fstrength-reduce} and
2279 @samp{-frerun-cse-after-loop}.
2281 @item -funroll-all-loops
2282 Perform the optimization of loop unrolling. This is done for all loops
2283 and usually makes programs run more slowly. @samp{-funroll-all-loops}
2284 implies @samp{-fstrength-reduce} as well as @samp{-frerun-cse-after-loop}.
2286 @item -fmove-all-movables
2287 Forces all invariant computations in loops to be moved
2290 @item -freduce-all-givs
2291 Forces all general-induction variables in loops to be
2294 @emph{Note:} When compiling programs written in Fortran,
2295 @samp{-fmove-all-moveables} and @samp{-freduce-all-givs} are enabled
2296 by default when you use the optimizer.
2298 These options may generate better or worse code; results are highly
2299 dependent on the structure of loops within the source code.
2301 These two options are intended to be removed someday, once
2302 they have helped determine the efficacy of various
2303 approaches to improving loop optimizations.
2305 Please let us (@code{egcs@@cygnus.com} and @code{fortran@@gnu.ai.mit.edu})
2306 know how use of these options affects
2307 the performance of your production code.
2308 We're very interested in code that runs @emph{slower}
2309 when these options are @emph{enabled}.
2312 Disable any machine-specific peephole optimizations.
2314 @item -fbranch-probabilities
2315 After running a program compiled with @samp{-fprofile-arcs}
2316 (@pxref{Debugging Options,, Options for Debugging Your Program or
2317 @code{gcc}}), you can compile it a second time using
2318 @samp{-fbranch-probabilities}, to improve optimizations based on
2319 guessing the path a branch might take.
2322 With @samp{-fbranch-probabilities}, GNU CC puts a @samp{REG_EXEC_COUNT}
2323 note on the first instruction of each basic block, and a
2324 @samp{REG_BR_PROB} note on each @samp{JUMP_INSN} and @samp{CALL_INSN}.
2325 These can be used to improve optimization. Currently, they are only
2326 used in one place: in @file{reorg.c}, instead of guessing which path a
2327 branch is mostly to take, the @samp{REG_BR_PROB} values are used to
2328 exactly determine which path is taken more often.
2332 Some machines only support 2 operands per instruction. On such
2333 machines, GNU CC might have to do extra copies. The @samp{-fregmove}
2334 option overrides the default for the machine to do the copy before
2335 register allocation.
2338 @node Preprocessor Options
2339 @section Options Controlling the Preprocessor
2340 @cindex preprocessor options
2341 @cindex options, preprocessor
2343 These options control the C preprocessor, which is run on each C source
2344 file before actual compilation.
2346 If you use the @samp{-E} option, nothing is done except preprocessing.
2347 Some of these options make sense only together with @samp{-E} because
2348 they cause the preprocessor output to be unsuitable for actual
2352 @item -include @var{file}
2353 Process @var{file} as input before processing the regular input file.
2354 In effect, the contents of @var{file} are compiled first. Any @samp{-D}
2355 and @samp{-U} options on the command line are always processed before
2356 @samp{-include @var{file}}, regardless of the order in which they are
2357 written. All the @samp{-include} and @samp{-imacros} options are
2358 processed in the order in which they are written.
2360 @item -imacros @var{file}
2361 Process @var{file} as input, discarding the resulting output, before
2362 processing the regular input file. Because the output generated from
2363 @var{file} is discarded, the only effect of @samp{-imacros @var{file}}
2364 is to make the macros defined in @var{file} available for use in the
2367 Any @samp{-D} and @samp{-U} options on the command line are always
2368 processed before @samp{-imacros @var{file}}, regardless of the order in
2369 which they are written. All the @samp{-include} and @samp{-imacros}
2370 options are processed in the order in which they are written.
2372 @item -idirafter @var{dir}
2373 @cindex second include path
2374 Add the directory @var{dir} to the second include path. The directories
2375 on the second include path are searched when a header file is not found
2376 in any of the directories in the main include path (the one that
2379 @item -iprefix @var{prefix}
2380 Specify @var{prefix} as the prefix for subsequent @samp{-iwithprefix}
2383 @item -iwithprefix @var{dir}
2384 Add a directory to the second include path. The directory's name is
2385 made by concatenating @var{prefix} and @var{dir}, where @var{prefix} was
2386 specified previously with @samp{-iprefix}. If you have not specified a
2387 prefix yet, the directory containing the installed passes of the
2388 compiler is used as the default.
2390 @item -iwithprefixbefore @var{dir}
2391 Add a directory to the main include path. The directory's name is made
2392 by concatenating @var{prefix} and @var{dir}, as in the case of
2393 @samp{-iwithprefix}.
2395 @item -isystem @var{dir}
2396 Add a directory to the beginning of the second include path, marking it
2397 as a system directory, so that it gets the same special treatment as
2398 is applied to the standard system directories.
2401 Do not search the standard system directories for header files. Only
2402 the directories you have specified with @samp{-I} options (and the
2403 current directory, if appropriate) are searched. @xref{Directory
2404 Options}, for information on @samp{-I}.
2406 By using both @samp{-nostdinc} and @samp{-I-}, you can limit the include-file
2407 search path to only those directories you specify explicitly.
2410 Do not predefine any nonstandard macros. (Including architecture flags).
2413 Run only the C preprocessor. Preprocess all the C source files
2414 specified and output the results to standard output or to the
2415 specified output file.
2418 Tell the preprocessor not to discard comments. Used with the
2422 Tell the preprocessor not to generate @samp{#line} directives.
2423 Used with the @samp{-E} option.
2426 @cindex dependencies, make
2428 Tell the preprocessor to output a rule suitable for @code{make}
2429 describing the dependencies of each object file. For each source file,
2430 the preprocessor outputs one @code{make}-rule whose target is the object
2431 file name for that source file and whose dependencies are all the
2432 @code{#include} header files it uses. This rule may be a single line or
2433 may be continued with @samp{\}-newline if it is long. The list of rules
2434 is printed on standard output instead of the preprocessed C program.
2436 @samp{-M} implies @samp{-E}.
2438 Another way to specify output of a @code{make} rule is by setting
2439 the environment variable @code{DEPENDENCIES_OUTPUT} (@pxref{Environment
2443 Like @samp{-M} but the output mentions only the user header files
2444 included with @samp{#include "@var{file}"}. System header files
2445 included with @samp{#include <@var{file}>} are omitted.
2448 Like @samp{-M} but the dependency information is written to a file made by
2449 replacing ".c" with ".d" at the end of the input file names.
2450 This is in addition to compiling the file as specified---@samp{-MD} does
2451 not inhibit ordinary compilation the way @samp{-M} does.
2453 In Mach, you can use the utility @code{md} to merge multiple dependency
2454 files into a single dependency file suitable for using with the @samp{make}
2458 Like @samp{-MD} except mention only user header files, not system
2462 Treat missing header files as generated files and assume they live in the
2463 same directory as the source file. If you specify @samp{-MG}, you
2464 must also specify either @samp{-M} or @samp{-MM}. @samp{-MG} is not
2465 supported with @samp{-MD} or @samp{-MMD}.
2468 Print the name of each header file used, in addition to other normal
2471 @item -A@var{question}(@var{answer})
2472 Assert the answer @var{answer} for @var{question}, in case it is tested
2473 with a preprocessing conditional such as @samp{#if
2474 #@var{question}(@var{answer})}. @samp{-A-} disables the standard
2475 assertions that normally describe the target machine.
2478 Define macro @var{macro} with the string @samp{1} as its definition.
2480 @item -D@var{macro}=@var{defn}
2481 Define macro @var{macro} as @var{defn}. All instances of @samp{-D} on
2482 the command line are processed before any @samp{-U} options.
2485 Undefine macro @var{macro}. @samp{-U} options are evaluated after all
2486 @samp{-D} options, but before any @samp{-include} and @samp{-imacros}
2490 Tell the preprocessor to output only a list of the macro definitions
2491 that are in effect at the end of preprocessing. Used with the @samp{-E}
2495 Tell the preprocessing to pass all macro definitions into the output, in
2496 their proper sequence in the rest of the output.
2499 Like @samp{-dD} except that the macro arguments and contents are omitted.
2500 Only @samp{#define @var{name}} is included in the output.
2503 Support ANSI C trigraphs. The @samp{-ansi} option also has this effect.
2505 @item -Wp,@var{option}
2506 Pass @var{option} as an option to the preprocessor. If @var{option}
2507 contains commas, it is split into multiple options at the commas.
2510 @node Assembler Options
2511 @section Passing Options to the Assembler
2513 @c prevent bad page break with this line
2514 You can pass options to the assembler.
2517 @item -Wa,@var{option}
2518 Pass @var{option} as an option to the assembler. If @var{option}
2519 contains commas, it is split into multiple options at the commas.
2523 @section Options for Linking
2524 @cindex link options
2525 @cindex options, linking
2527 These options come into play when the compiler links object files into
2528 an executable output file. They are meaningless if the compiler is
2529 not doing a link step.
2533 @item @var{object-file-name}
2534 A file name that does not end in a special recognized suffix is
2535 considered to name an object file or library. (Object files are
2536 distinguished from libraries by the linker according to the file
2537 contents.) If linking is done, these object files are used as input
2543 If any of these options is used, then the linker is not run, and
2544 object file names should not be used as arguments. @xref{Overall
2548 @item -l@var{library}
2549 Search the library named @var{library} when linking.
2551 It makes a difference where in the command you write this option; the
2552 linker searches processes libraries and object files in the order they
2553 are specified. Thus, @samp{foo.o -lz bar.o} searches library @samp{z}
2554 after file @file{foo.o} but before @file{bar.o}. If @file{bar.o} refers
2555 to functions in @samp{z}, those functions may not be loaded.
2557 The linker searches a standard list of directories for the library,
2558 which is actually a file named @file{lib@var{library}.a}. The linker
2559 then uses this file as if it had been specified precisely by name.
2561 The directories searched include several standard system directories
2562 plus any that you specify with @samp{-L}.
2564 Normally the files found this way are library files---archive files
2565 whose members are object files. The linker handles an archive file by
2566 scanning through it for members which define symbols that have so far
2567 been referenced but not defined. But if the file that is found is an
2568 ordinary object file, it is linked in the usual fashion. The only
2569 difference between using an @samp{-l} option and specifying a file name
2570 is that @samp{-l} surrounds @var{library} with @samp{lib} and @samp{.a}
2571 and searches several directories.
2574 You need this special case of the @samp{-l} option in order to
2575 link an Objective C program.
2578 Do not use the standard system startup files when linking.
2579 The standard system libraries are used normally, unless @code{-nostdlib}
2580 or @code{-nodefaultlibs} is used.
2582 @item -nodefaultlibs
2583 Do not use the standard system libraries when linking.
2584 Only the libraries you specify will be passed to the linker.
2585 The standard startup files are used normally, unless @code{-nostartfiles}
2589 Do not use the standard system startup files or libraries when linking.
2590 No startup files and only the libraries you specify will be passed to
2593 @cindex @code{-lgcc}, use with @code{-nostdlib}
2594 @cindex @code{-nostdlib} and unresolved references
2595 @cindex unresolved references and @code{-nostdlib}
2596 @cindex @code{-lgcc}, use with @code{-nodefaultlibs}
2597 @cindex @code{-nodefaultlibs} and unresolved references
2598 @cindex unresolved references and @code{-nodefaultlibs}
2599 One of the standard libraries bypassed by @samp{-nostdlib} and
2600 @samp{-nodefaultlibs} is @file{libgcc.a}, a library of internal subroutines
2601 that GNU CC uses to overcome shortcomings of particular machines, or special
2602 needs for some languages.
2604 (@xref{Interface,,Interfacing to GNU CC Output}, for more discussion of
2608 (@xref{Interface,,Interfacing to GNU CC Output,gcc.info,Porting GNU CC},
2609 for more discussion of @file{libgcc.a}.)
2611 In most cases, you need @file{libgcc.a} even when you want to avoid
2612 other standard libraries. In other words, when you specify @samp{-nostdlib}
2613 or @samp{-nodefaultlibs} you should usually specify @samp{-lgcc} as well.
2614 This ensures that you have no unresolved references to internal GNU CC
2615 library subroutines. (For example, @samp{__main}, used to ensure C++
2616 constructors will be called; @pxref{Collect2,,@code{collect2}}.)
2619 Remove all symbol table and relocation information from the executable.
2622 On systems that support dynamic linking, this prevents linking with the shared
2623 libraries. On other systems, this option has no effect.
2626 Produce a shared object which can then be linked with other objects to
2627 form an executable. Not all systems support this option. You must
2628 also specify @samp{-fpic} or @samp{-fPIC} on some systems when
2629 you specify this option.
2632 Bind references to global symbols when building a shared object. Warn
2633 about any unresolved references (unless overridden by the link editor
2634 option @samp{-Xlinker -z -Xlinker defs}). Only a few systems support
2637 @item -Xlinker @var{option}
2638 Pass @var{option} as an option to the linker. You can use this to
2639 supply system-specific linker options which GNU CC does not know how to
2642 If you want to pass an option that takes an argument, you must use
2643 @samp{-Xlinker} twice, once for the option and once for the argument.
2644 For example, to pass @samp{-assert definitions}, you must write
2645 @samp{-Xlinker -assert -Xlinker definitions}. It does not work to write
2646 @samp{-Xlinker "-assert definitions"}, because this passes the entire
2647 string as a single argument, which is not what the linker expects.
2649 @item -Wl,@var{option}
2650 Pass @var{option} as an option to the linker. If @var{option} contains
2651 commas, it is split into multiple options at the commas.
2653 @item -u @var{symbol}
2654 Pretend the symbol @var{symbol} is undefined, to force linking of
2655 library modules to define it. You can use @samp{-u} multiple times with
2656 different symbols to force loading of additional library modules.
2659 @node Directory Options
2660 @section Options for Directory Search
2661 @cindex directory options
2662 @cindex options, directory search
2665 These options specify directories to search for header files, for
2666 libraries and for parts of the compiler:
2670 Add the directory @var{dir} to the head of the list of directories to be
2671 searched for header files. This can be used to override a system header
2672 file, substituting your own version, since these directories are
2673 searched before the system header file directories. If you use more
2674 than one @samp{-I} option, the directories are scanned in left-to-right
2675 order; the standard system directories come after.
2678 Any directories you specify with @samp{-I} options before the @samp{-I-}
2679 option are searched only for the case of @samp{#include "@var{file}"};
2680 they are not searched for @samp{#include <@var{file}>}.
2682 If additional directories are specified with @samp{-I} options after
2683 the @samp{-I-}, these directories are searched for all @samp{#include}
2684 directives. (Ordinarily @emph{all} @samp{-I} directories are used
2687 In addition, the @samp{-I-} option inhibits the use of the current
2688 directory (where the current input file came from) as the first search
2689 directory for @samp{#include "@var{file}"}. There is no way to
2690 override this effect of @samp{-I-}. With @samp{-I.} you can specify
2691 searching the directory which was current when the compiler was
2692 invoked. That is not exactly the same as what the preprocessor does
2693 by default, but it is often satisfactory.
2695 @samp{-I-} does not inhibit the use of the standard system directories
2696 for header files. Thus, @samp{-I-} and @samp{-nostdinc} are
2700 Add directory @var{dir} to the list of directories to be searched
2703 @item -B@var{prefix}
2704 This option specifies where to find the executables, libraries,
2705 include files, and data files of the compiler itself.
2707 The compiler driver program runs one or more of the subprograms
2708 @file{cpp}, @file{cc1}, @file{as} and @file{ld}. It tries
2709 @var{prefix} as a prefix for each program it tries to run, both with and
2710 without @samp{@var{machine}/@var{version}/} (@pxref{Target Options}).
2712 For each subprogram to be run, the compiler driver first tries the
2713 @samp{-B} prefix, if any. If that name is not found, or if @samp{-B}
2714 was not specified, the driver tries two standard prefixes, which are
2715 @file{/usr/lib/gcc/} and @file{/usr/local/lib/gcc-lib/}. If neither of
2716 those results in a file name that is found, the unmodified program
2717 name is searched for using the directories specified in your
2718 @samp{PATH} environment variable.
2720 @samp{-B} prefixes that effectively specify directory names also apply
2721 to libraries in the linker, because the compiler translates these
2722 options into @samp{-L} options for the linker. They also apply to
2723 includes files in the preprocessor, because the compiler translates these
2724 options into @samp{-isystem} options for the preprocessor. In this case,
2725 the compiler appends @samp{include} to the prefix.
2727 The run-time support file @file{libgcc.a} can also be searched for using
2728 the @samp{-B} prefix, if needed. If it is not found there, the two
2729 standard prefixes above are tried, and that is all. The file is left
2730 out of the link if it is not found by those means.
2732 Another way to specify a prefix much like the @samp{-B} prefix is to use
2733 the environment variable @code{GCC_EXEC_PREFIX}. @xref{Environment
2736 @item -specs=@var{file}
2737 Process @var{file} after the compiler reads in the standard @file{specs}
2738 file, in order to override the defaults that the @file{gcc} driver
2739 program uses when determining what switches to pass to @file{cc1},
2740 @file{cc1plus}, @file{as}, @file{ld}, etc. More than one
2741 @samp{-specs=}@var{file} can be specified on the command line, and they
2742 are processed in order, from left to right.
2745 @node Target Options
2746 @section Specifying Target Machine and Compiler Version
2747 @cindex target options
2748 @cindex cross compiling
2749 @cindex specifying machine version
2750 @cindex specifying compiler version and target machine
2751 @cindex compiler version, specifying
2752 @cindex target machine, specifying
2754 By default, GNU CC compiles code for the same type of machine that you
2755 are using. However, it can also be installed as a cross-compiler, to
2756 compile for some other type of machine. In fact, several different
2757 configurations of GNU CC, for different target machines, can be
2758 installed side by side. Then you specify which one to use with the
2761 In addition, older and newer versions of GNU CC can be installed side
2762 by side. One of them (probably the newest) will be the default, but
2763 you may sometimes wish to use another.
2766 @item -b @var{machine}
2767 The argument @var{machine} specifies the target machine for compilation.
2768 This is useful when you have installed GNU CC as a cross-compiler.
2770 The value to use for @var{machine} is the same as was specified as the
2771 machine type when configuring GNU CC as a cross-compiler. For
2772 example, if a cross-compiler was configured with @samp{configure
2773 i386v}, meaning to compile for an 80386 running System V, then you
2774 would specify @samp{-b i386v} to run that cross compiler.
2776 When you do not specify @samp{-b}, it normally means to compile for
2777 the same type of machine that you are using.
2779 @item -V @var{version}
2780 The argument @var{version} specifies which version of GNU CC to run.
2781 This is useful when multiple versions are installed. For example,
2782 @var{version} might be @samp{2.0}, meaning to run GNU CC version 2.0.
2784 The default version, when you do not specify @samp{-V}, is the last
2785 version of GNU CC that you installed.
2788 The @samp{-b} and @samp{-V} options actually work by controlling part of
2789 the file name used for the executable files and libraries used for
2790 compilation. A given version of GNU CC, for a given target machine, is
2791 normally kept in the directory @file{/usr/local/lib/gcc-lib/@var{machine}/@var{version}}.@refill
2793 Thus, sites can customize the effect of @samp{-b} or @samp{-V} either by
2794 changing the names of these directories or adding alternate names (or
2795 symbolic links). If in directory @file{/usr/local/lib/gcc-lib/} the
2796 file @file{80386} is a link to the file @file{i386v}, then @samp{-b
2797 80386} becomes an alias for @samp{-b i386v}.
2799 In one respect, the @samp{-b} or @samp{-V} do not completely change
2800 to a different compiler: the top-level driver program @code{gcc}
2801 that you originally invoked continues to run and invoke the other
2802 executables (preprocessor, compiler per se, assembler and linker)
2803 that do the real work. However, since no real work is done in the
2804 driver program, it usually does not matter that the driver program
2805 in use is not the one for the specified target and version.
2807 The only way that the driver program depends on the target machine is
2808 in the parsing and handling of special machine-specific options.
2809 However, this is controlled by a file which is found, along with the
2810 other executables, in the directory for the specified version and
2811 target machine. As a result, a single installed driver program adapts
2812 to any specified target machine and compiler version.
2814 The driver program executable does control one significant thing,
2815 however: the default version and target machine. Therefore, you can
2816 install different instances of the driver program, compiled for
2817 different targets or versions, under different names.
2819 For example, if the driver for version 2.0 is installed as @code{ogcc}
2820 and that for version 2.1 is installed as @code{gcc}, then the command
2821 @code{gcc} will use version 2.1 by default, while @code{ogcc} will use
2822 2.0 by default. However, you can choose either version with either
2823 command with the @samp{-V} option.
2825 @node Submodel Options
2826 @section Hardware Models and Configurations
2827 @cindex submodel options
2828 @cindex specifying hardware config
2829 @cindex hardware models and configurations, specifying
2830 @cindex machine dependent options
2832 Earlier we discussed the standard option @samp{-b} which chooses among
2833 different installed compilers for completely different target
2834 machines, such as Vax vs. 68000 vs. 80386.
2836 In addition, each of these target machine types can have its own
2837 special options, starting with @samp{-m}, to choose among various
2838 hardware models or configurations---for example, 68010 vs 68020,
2839 floating coprocessor or none. A single installed version of the
2840 compiler can compile for any model or configuration, according to the
2843 Some configurations of the compiler also support additional special
2844 options, usually for compatibility with other compilers on the same
2848 These options are defined by the macro @code{TARGET_SWITCHES} in the
2849 machine description. The default for the options is also defined by
2850 that macro, which enables you to change the defaults.
2863 * RS/6000 and PowerPC Options::
2868 * Intel 960 Options::
2869 * DEC Alpha Options::
2873 * System V Options::
2877 @node M680x0 Options
2878 @subsection M680x0 Options
2879 @cindex M680x0 options
2881 These are the @samp{-m} options defined for the 68000 series. The default
2882 values for these options depends on which style of 68000 was selected when
2883 the compiler was configured; the defaults for the most common choices are
2889 Generate output for a 68000. This is the default
2890 when the compiler is configured for 68000-based systems.
2894 Generate output for a 68020. This is the default
2895 when the compiler is configured for 68020-based systems.
2898 Generate output containing 68881 instructions for floating point.
2899 This is the default for most 68020 systems unless @samp{-nfp} was
2900 specified when the compiler was configured.
2903 Generate output for a 68030. This is the default when the compiler is
2904 configured for 68030-based systems.
2907 Generate output for a 68040. This is the default when the compiler is
2908 configured for 68040-based systems.
2910 This option inhibits the use of 68881/68882 instructions that have to be
2911 emulated by software on the 68040. If your 68040 does not have code to
2912 emulate those instructions, use @samp{-m68040}.
2915 Generate output for a 68060. This is the default when the compiler is
2916 configured for 68060-based systems.
2918 This option inhibits the use of 68020 and 68881/68882 instructions that
2919 have to be emulated by software on the 68060. If your 68060 does not
2920 have code to emulate those instructions, use @samp{-m68060}.
2923 Generate output for a 520X "coldfire" family cpu. This is the default
2924 when the compiler is configured for 520X-based systems.
2928 Generate output for a 68040, without using any of the new instructions.
2929 This results in code which can run relatively efficiently on either a
2930 68020/68881 or a 68030 or a 68040. The generated code does use the
2931 68881 instructions that are emulated on the 68040.
2934 Generate output for a 68060, without using any of the new instructions.
2935 This results in code which can run relatively efficiently on either a
2936 68020/68881 or a 68030 or a 68040. The generated code does use the
2937 68881 instructions that are emulated on the 68060.
2940 Generate output containing Sun FPA instructions for floating point.
2943 Generate output containing library calls for floating point.
2944 @strong{Warning:} the requisite libraries are not available for all m68k
2945 targets. Normally the facilities of the machine's usual C compiler are
2946 used, but this can't be done directly in cross-compilation. You must
2947 make your own arrangements to provide suitable library functions for
2948 cross-compilation. The embedded targets @samp{m68k-*-aout} and
2949 @samp{m68k-*-coff} do provide software floating point support.
2952 Consider type @code{int} to be 16 bits wide, like @code{short int}.
2955 Do not use the bit-field instructions. The @samp{-m68000} option
2956 implies @w{@samp{-mnobitfield}}.
2959 Do use the bit-field instructions. The @samp{-m68020} option implies
2960 @samp{-mbitfield}. This is the default if you use a configuration
2961 designed for a 68020.
2964 Use a different function-calling convention, in which functions
2965 that take a fixed number of arguments return with the @code{rtd}
2966 instruction, which pops their arguments while returning. This
2967 saves one instruction in the caller since there is no need to pop
2968 the arguments there.
2970 This calling convention is incompatible with the one normally
2971 used on Unix, so you cannot use it if you need to call libraries
2972 compiled with the Unix compiler.
2974 Also, you must provide function prototypes for all functions that
2975 take variable numbers of arguments (including @code{printf});
2976 otherwise incorrect code will be generated for calls to those
2979 In addition, seriously incorrect code will result if you call a
2980 function with too many arguments. (Normally, extra arguments are
2981 harmlessly ignored.)
2983 The @code{rtd} instruction is supported by the 68010, 68020, 68030,
2984 68040, and 68060 processors, but not by the 68000 or 5200.
2987 @itemx -mno-align-int
2988 Control whether GNU CC aligns @code{int}, @code{long}, @code{long long},
2989 @code{float}, @code{double}, and @code{long double} variables on a 32-bit
2990 boundary (@samp{-malign-int}) or a 16-bit boundary (@samp{-mno-align-int}).
2991 Aligning variables on 32-bit boundaries produces code that runs somewhat
2992 faster on processors with 32-bit busses at the expense of more memory.
2994 @strong{Warning:} if you use the @samp{-malign-int} switch, GNU CC will
2995 align structures containing the above types differently than
2996 most published application binary interface specifications for the m68k.
3001 @subsection VAX Options
3004 These @samp{-m} options are defined for the Vax:
3008 Do not output certain jump instructions (@code{aobleq} and so on)
3009 that the Unix assembler for the Vax cannot handle across long
3013 Do output those jump instructions, on the assumption that you
3014 will assemble with the GNU assembler.
3017 Output code for g-format floating point numbers instead of d-format.
3021 @subsection SPARC Options
3022 @cindex SPARC options
3024 These @samp{-m} switches are supported on the SPARC:
3029 Specify @samp{-mapp-regs} to generate output using the global registers
3030 2 through 4, which the SPARC SVR4 ABI reserves for applications. This
3033 To be fully SVR4 ABI compliant at the cost of some performance loss,
3034 specify @samp{-mno-app-regs}. You should compile libraries and system
3035 software with this option.
3039 Generate output containing floating point instructions. This is the
3044 Generate output containing library calls for floating point.
3045 @strong{Warning:} the requisite libraries are not available for all SPARC
3046 targets. Normally the facilities of the machine's usual C compiler are
3047 used, but this cannot be done directly in cross-compilation. You must make
3048 your own arrangements to provide suitable library functions for
3049 cross-compilation. The embedded targets @samp{sparc-*-aout} and
3050 @samp{sparclite-*-*} do provide software floating point support.
3052 @samp{-msoft-float} changes the calling convention in the output file;
3053 therefore, it is only useful if you compile @emph{all} of a program with
3054 this option. In particular, you need to compile @file{libgcc.a}, the
3055 library that comes with GNU CC, with @samp{-msoft-float} in order for
3058 @item -mhard-quad-float
3059 Generate output containing quad-word (long double) floating point
3062 @item -msoft-quad-float
3063 Generate output containing library calls for quad-word (long double)
3064 floating point instructions. The functions called are those specified
3065 in the SPARC ABI. This is the default.
3067 As of this writing, there are no sparc implementations that have hardware
3068 support for the quad-word floating point instructions. They all invoke
3069 a trap handler for one of these instructions, and then the trap handler
3070 emulates the effect of the instruction. Because of the trap handler overhead,
3071 this is much slower than calling the ABI library routines. Thus the
3072 @samp{-msoft-quad-float} option is the default.
3076 With @samp{-mepilogue} (the default), the compiler always emits code for
3077 function exit at the end of each function. Any function exit in
3078 the middle of the function (such as a return statement in C) will
3079 generate a jump to the exit code at the end of the function.
3081 With @samp{-mno-epilogue}, the compiler tries to emit exit code inline
3082 at every function exit.
3086 With @samp{-mflat}, the compiler does not generate save/restore instructions
3087 and will use a "flat" or single register window calling convention.
3088 This model uses %i7 as the frame pointer and is compatible with the normal
3089 register window model. Code from either may be intermixed.
3090 The local registers and the input registers (0-5) are still treated as
3091 "call saved" registers and will be saved on the stack as necessary.
3093 With @samp{-mno-flat} (the default), the compiler emits save/restore
3094 instructions (except for leaf functions) and is the normal mode of operation.
3096 @item -mno-unaligned-doubles
3097 @itemx -munaligned-doubles
3098 Assume that doubles have 8 byte alignment. This is the default.
3100 With @samp{-munaligned-doubles}, GNU CC assumes that doubles have 8 byte
3101 alignment only if they are contained in another type, or if they have an
3102 absolute address. Otherwise, it assumes they have 4 byte alignment.
3103 Specifying this option avoids some rare compatibility problems with code
3104 generated by other compilers. It is not the default because it results
3105 in a performance loss, especially for floating point code.
3109 These two options select variations on the SPARC architecture.
3111 By default (unless specifically configured for the Fujitsu SPARClite),
3112 GCC generates code for the v7 variant of the SPARC architecture.
3114 @samp{-mv8} will give you SPARC v8 code. The only difference from v7
3115 code is that the compiler emits the integer multiply and integer
3116 divide instructions which exist in SPARC v8 but not in SPARC v7.
3118 @samp{-msparclite} will give you SPARClite code. This adds the integer
3119 multiply, integer divide step and scan (@code{ffs}) instructions which
3120 exist in SPARClite but not in SPARC v7.
3122 These options are deprecated and will be deleted in GNU CC 2.9.
3123 They have been replaced with @samp{-mcpu=xxx}.
3127 These two options select the processor for which the code is optimised.
3129 With @samp{-mcypress} (the default), the compiler optimizes code for the
3130 Cypress CY7C602 chip, as used in the SparcStation/SparcServer 3xx series.
3131 This is also appropriate for the older SparcStation 1, 2, IPX etc.
3133 With @samp{-msupersparc} the compiler optimizes code for the SuperSparc cpu, as
3134 used in the SparcStation 10, 1000 and 2000 series. This flag also enables use
3135 of the full SPARC v8 instruction set.
3137 These options are deprecated and will be deleted in GNU CC 2.9.
3138 They have been replaced with @samp{-mcpu=xxx}.
3140 @item -mcpu=@var{cpu_type}
3141 Set the instruction set, register set, and instruction scheduling parameters
3142 for machine type @var{cpu_type}. Supported values for @var{cpu_type} are
3143 @samp{v7}, @samp{cypress}, @samp{v8}, @samp{supersparc}, @samp{sparclite},
3144 @samp{f930}, @samp{f934}, @samp{sparclet}, @samp{tsc701}, @samp{v9}, and
3147 Default instruction scheduling parameters are used for values that select
3148 an architecture and not an implementation. These are @samp{v7}, @samp{v8},
3149 @samp{sparclite}, @samp{sparclet}, @samp{v9}.
3151 Here is a list of each supported architecture and their supported
3157 sparclite: f930, f934
3162 @item -mtune=@var{cpu_type}
3163 Set the instruction scheduling parameters for machine type
3164 @var{cpu_type}, but do not set the instruction set or register set that the
3165 option @samp{-mcpu=}@var{cpu_type} would.
3167 The same values for @samp{-mcpu=}@var{cpu_type} are used for
3168 @samp{-mtune=}@var{cpu_type}, though the only useful values are those that
3169 select a particular cpu implementation: @samp{cypress}, @samp{supersparc},
3170 @samp{f930}, @samp{f934}, @samp{tsc701}, @samp{ultrasparc}.
3172 @item -malign-loops=@var{num}
3173 Align loops to a 2 raised to a @var{num} byte boundary. If
3174 @samp{-malign-loops} is not specified, the default is 2.
3176 @item -malign-jumps=@var{num}
3177 Align instructions that are only jumped to to a 2 raised to a @var{num}
3178 byte boundary. If @samp{-malign-jumps} is not specified, the default is 2.
3180 @item -malign-functions=@var{num}
3181 Align the start of functions to a 2 raised to @var{num} byte boundary.
3182 If @samp{-malign-functions} is not specified, the default is 2 if compiling
3183 for 32 bit sparc, and 5 if compiling for 64 bit sparc.
3187 These @samp{-m} switches are supported in addition to the above
3188 on the SPARCLET processor.
3191 @item -mlittle-endian
3192 Generate code for a processor running in little-endian mode.
3195 Treat register @code{%g0} as a normal register.
3196 GCC will continue to clobber it as necessary but will not assume
3197 it always reads as 0.
3199 @item -mbroken-saverestore
3200 Generate code that does not use non-trivial forms of the @code{save} and
3201 @code{restore} instructions. Early versions of the SPARCLET processor do
3202 not correctly handle @code{save} and @code{restore} instructions used with
3203 arguments. They correctly handle them used without arguments. A @code{save}
3204 instruction used without arguments increments the current window pointer
3205 but does not allocate a new stack frame. It is assumed that the window
3206 overflow trap handler will properly handle this case as will interrupt
3210 These @samp{-m} switches are supported in addition to the above
3211 on SPARC V9 processors in 64 bit environments.
3214 @item -mlittle-endian
3215 Generate code for a processor running in little-endian mode.
3219 Generate code for a 32 bit or 64 bit environment.
3220 The 32 bit environment sets int, long and pointer to 32 bits.
3221 The 64 bit environment sets int to 32 bits and long and pointer
3224 @item -mcmodel=medlow
3225 Generate code for the Medium/Low code model: the program must be linked
3226 in the low 32 bits of the address space. Pointers are 64 bits.
3227 Programs can be statically or dynamically linked.
3229 @item -mcmodel=medmid
3230 Generate code for the Medium/Middle code model: the program must be linked
3231 in the low 44 bits of the address space, the text segment must be less than
3232 2G bytes, and data segment must be within 2G of the text segment.
3233 Pointers are 64 bits.
3235 @item -mcmodel=medany
3236 Generate code for the Medium/Anywhere code model: the program may be linked
3237 anywhere in the address space, the text segment must be less than
3238 2G bytes, and data segment must be within 2G of the text segment.
3239 Pointers are 64 bits.
3241 @item -mcmodel=embmedany
3242 Generate code for the Medium/Anywhere code model for embedded systems:
3243 assume a 32 bit text and a 32 bit data segment, both starting anywhere
3244 (determined at link time). Register %g4 points to the base of the
3245 data segment. Pointers still 64 bits.
3246 Programs are statically linked, PIC is not supported.
3249 @itemx -mno-stack-bias
3250 With @samp{-mstack-bias}, GNU CC assumes that the stack pointer, and
3251 frame pointer if present, are offset by -2047 which must be added back
3252 when making stack frame references.
3253 Otherwise, assume no such offset is present.
3256 @node Convex Options
3257 @subsection Convex Options
3258 @cindex Convex options
3260 These @samp{-m} options are defined for Convex:
3264 Generate output for C1. The code will run on any Convex machine.
3265 The preprocessor symbol @code{__convex__c1__} is defined.
3268 Generate output for C2. Uses instructions not available on C1.
3269 Scheduling and other optimizations are chosen for max performance on C2.
3270 The preprocessor symbol @code{__convex_c2__} is defined.
3273 Generate output for C32xx. Uses instructions not available on C1.
3274 Scheduling and other optimizations are chosen for max performance on C32.
3275 The preprocessor symbol @code{__convex_c32__} is defined.
3278 Generate output for C34xx. Uses instructions not available on C1.
3279 Scheduling and other optimizations are chosen for max performance on C34.
3280 The preprocessor symbol @code{__convex_c34__} is defined.
3283 Generate output for C38xx. Uses instructions not available on C1.
3284 Scheduling and other optimizations are chosen for max performance on C38.
3285 The preprocessor symbol @code{__convex_c38__} is defined.
3288 Generate code which puts an argument count in the word preceding each
3289 argument list. This is compatible with regular CC, and a few programs
3290 may need the argument count word. GDB and other source-level debuggers
3291 do not need it; this info is in the symbol table.
3294 Omit the argument count word. This is the default.
3296 @item -mvolatile-cache
3297 Allow volatile references to be cached. This is the default.
3299 @item -mvolatile-nocache
3300 Volatile references bypass the data cache, going all the way to memory.
3301 This is only needed for multi-processor code that does not use standard
3302 synchronization instructions. Making non-volatile references to volatile
3303 locations will not necessarily work.
3306 Type long is 32 bits, the same as type int. This is the default.
3309 Type long is 64 bits, the same as type long long. This option is useless,
3310 because no library support exists for it.
3313 @node AMD29K Options
3314 @subsection AMD29K Options
3315 @cindex AMD29K options
3317 These @samp{-m} options are defined for the AMD Am29000:
3322 @cindex DW bit (29k)
3323 Generate code that assumes the @code{DW} bit is set, i.e., that byte and
3324 halfword operations are directly supported by the hardware. This is the
3329 Generate code that assumes the @code{DW} bit is not set.
3333 @cindex byte writes (29k)
3334 Generate code that assumes the system supports byte and halfword write
3335 operations. This is the default.
3339 Generate code that assumes the systems does not support byte and
3340 halfword write operations. @samp{-mnbw} implies @samp{-mndw}.
3344 @cindex memory model (29k)
3345 Use a small memory model that assumes that all function addresses are
3346 either within a single 256 KB segment or at an absolute address of less
3347 than 256k. This allows the @code{call} instruction to be used instead
3348 of a @code{const}, @code{consth}, @code{calli} sequence.
3352 Use the normal memory model: Generate @code{call} instructions only when
3353 calling functions in the same file and @code{calli} instructions
3354 otherwise. This works if each file occupies less than 256 KB but allows
3355 the entire executable to be larger than 256 KB. This is the default.
3358 Always use @code{calli} instructions. Specify this option if you expect
3359 a single file to compile into more than 256 KB of code.
3363 @cindex processor selection (29k)
3364 Generate code for the Am29050.
3368 Generate code for the Am29000. This is the default.
3370 @item -mkernel-registers
3371 @kindex -mkernel-registers
3372 @cindex kernel and user registers (29k)
3373 Generate references to registers @code{gr64-gr95} instead of to
3374 registers @code{gr96-gr127}. This option can be used when compiling
3375 kernel code that wants a set of global registers disjoint from that used
3378 Note that when this option is used, register names in @samp{-f} flags
3379 must use the normal, user-mode, names.
3381 @item -muser-registers
3382 @kindex -muser-registers
3383 Use the normal set of global registers, @code{gr96-gr127}. This is the
3387 @itemx -mno-stack-check
3388 @kindex -mstack-check
3389 @cindex stack checks (29k)
3390 Insert (or do not insert) a call to @code{__msp_check} after each stack
3391 adjustment. This is often used for kernel code.
3394 @itemx -mno-storem-bug
3395 @kindex -mstorem-bug
3396 @cindex storem bug (29k)
3397 @samp{-mstorem-bug} handles 29k processors which cannot handle the
3398 separation of a mtsrim insn and a storem instruction (most 29000 chips
3399 to date, but not the 29050).
3401 @item -mno-reuse-arg-regs
3402 @itemx -mreuse-arg-regs
3403 @kindex -mreuse-arg-regs
3404 @samp{-mno-reuse-arg-regs} tells the compiler to only use incoming argument
3405 registers for copying out arguments. This helps detect calling a function
3406 with fewer arguments than it was declared with.
3408 @item -mno-impure-text
3409 @itemx -mimpure-text
3410 @kindex -mimpure-text
3411 @samp{-mimpure-text}, used in addition to @samp{-shared}, tells the compiler to
3412 not pass @samp{-assert pure-text} to the linker when linking a shared object.
3415 @kindex -msoft-float
3416 Generate output containing library calls for floating point.
3417 @strong{Warning:} the requisite libraries are not part of GNU CC.
3418 Normally the facilities of the machine's usual C compiler are used, but
3419 this can't be done directly in cross-compilation. You must make your
3420 own arrangements to provide suitable library functions for
3425 @subsection ARM Options
3428 These @samp{-m} options are defined for Advanced RISC Machines (ARM)
3433 @kindex -mapcs-frame
3434 Generate a stack frame that is compliant with the ARM Procedure Call
3435 Standard for all functions, even if this is not strictly necessary for
3436 correct execution of the code.
3440 Generate code for a processor running with a 26-bit program counter,
3441 and conforming to the function calling standards for the APCS 26-bit
3442 option. This option replaces the @samp{-m2} and @samp{-m3} options
3443 of previous releases of the compiler.
3447 Generate code for a processor running with a 32-bit program counter,
3448 and conforming to the function calling standards for the APCS 32-bit
3449 option. This option replaces the @samp{-m6} option of previous releases
3453 Generate output containing floating point instructions. This is the
3457 Generate output containing library calls for floating point.
3458 @strong{Warning:} the requisite libraries are not available for all ARM
3459 targets. Normally the facilities of the machine's usual C compiler are
3460 used, but this cannot be done directly in cross-compilation. You must make
3461 your own arrangements to provide suitable library functions for
3464 @samp{-msoft-float} changes the calling convention in the output file;
3465 therefore, it is only useful if you compile @emph{all} of a program with
3466 this option. In particular, you need to compile @file{libgcc.a}, the
3467 library that comes with GNU CC, with @samp{-msoft-float} in order for
3470 @item -mlittle-endian
3471 Generate code for a processor running in little-endian mode. This is
3472 the default for all standard configurations.
3475 Generate code for a processor running in big-endian mode; the default is
3476 to compile code for a little-endian processor.
3478 @item -mwords-little-endian
3479 This option only applies when generating code for big-endian processors.
3480 Generate code for a little-endian word order but a big-endian byte
3481 order. That is, a byte order of the form @samp{32107654}. Note: this
3482 option should only be used if you require compatibility with code for
3483 big-endian ARM processors generated by versions of the compiler prior to
3486 @item -mshort-load-bytes
3487 @kindex -mshort-load-bytes
3488 Do not try to load half-words (eg @samp{short}s) by loading a word from
3489 an unaligned address. For some targets the MMU is configured to trap
3490 unaligned loads; use this option to generate code that is safe in these
3493 @item -mno-short-load-bytes
3494 @kindex -mno-short-load-bytes
3495 Use unaligned word loads to load half-words (eg @samp{short}s). This
3496 option produces more efficient code, but the MMU is sometimes configured
3497 to trap these instructions.
3501 This option only applies to RISC iX. Emulate the native BSD-mode
3502 compiler. This is the default if @samp{-ansi} is not specified.
3506 This option only applies to RISC iX. Emulate the native X/Open-mode
3509 @item -mno-symrename
3510 @kindex -mno-symrename
3511 This option only applies to RISC iX. Do not run the assembler
3512 post-processor, @samp{symrename}, after code has been assembled.
3513 Normally it is necessary to modify some of the standard symbols in
3514 preparation for linking with the RISC iX C library; this option
3515 suppresses this pass. The post-processor is never run when the
3516 compiler is built for cross-compilation.
3519 @node MN10300 Options
3520 @subsection MN10300 Options
3521 @cindex MN10300 options
3522 These @samp{-m} options are defined for Matsushita MN10300 architectures:
3526 Generate code to avoid bugs in the multiply instructions for the MN10300
3527 processors. This is the default.
3530 Do not generate code to avoid bugs in the multiply instructions for the
3534 @node M32R/D Options
3535 @subsection M32R/D Options
3536 @cindex M32R/D options
3538 These @samp{-m} options are defined for Mitsubishi M32R/D architectures:
3541 @item -mcode-model=small
3542 Assume all objects live in the lower 16MB of memory (so that their addresses
3543 can be loaded with the @code{ld24} instruction), and assume all subroutines
3544 are reachable with the @code{bl} instruction.
3545 This is the default.
3547 The addressability of a particular object can be set with the
3548 @code{model} attribute.
3550 @item -mcode-model=medium
3551 Assume objects may be anywhere in the 32 bit address space (the compiler
3552 will generate @code{seth/add3} instructions to load their addresses), and
3553 assume all subroutines are reachable with the @code{bl} instruction.
3555 @item -mcode-model=large
3556 Assume objects may be anywhere in the 32 bit address space (the compiler
3557 will generate @code{seth/add3} instructions to load their addresses), and
3558 assume subroutines may not be reachable with the @code{bl} instruction
3559 (the compiler will generate the much slower @code{seth/add3/jl}
3560 instruction sequence).
3563 Disable use of the small data area. Variables will be put into
3564 one of @samp{.data}, @samp{bss}, or @samp{.rodata} (unless the
3565 @code{section} attribute has been specified).
3566 This is the default.
3568 The small data area consists of sections @samp{.sdata} and @samp{.sbss}.
3569 Objects may be explicitly put in the small data area with the
3570 @code{section} attribute using one of these sections.
3573 Put small global and static data in the small data area, but do not
3574 generate special code to reference them.
3577 Put small global and static data in the small data area, and generate
3578 special instructions to reference them.
3581 @cindex smaller data references
3582 Put global and static objects less than or equal to @var{num} bytes
3583 into the small data or bss sections instead of the normal data or bss
3584 sections. The default value of @var{num} is 8.
3585 The @samp{-msdata} option must be set to one of @samp{sdata} or @samp{use}
3586 for this option to have any effect.
3588 All modules should be compiled with the same @samp{-G @var{num}} value.
3589 Compiling with different values of @var{num} may or may not work; if it
3590 doesn't the linker will give an error message - incorrect code will not be
3596 @subsection M88K Options
3597 @cindex M88k options
3599 These @samp{-m} options are defined for Motorola 88k architectures:
3604 Generate code that works well on both the m88100 and the
3609 Generate code that works best for the m88100, but that also
3614 Generate code that works best for the m88110, and may not run
3619 Obsolete option to be removed from the next revision.
3622 @item -midentify-revision
3623 @kindex -midentify-revision
3625 @cindex identifying source, compiler (88k)
3626 Include an @code{ident} directive in the assembler output recording the
3627 source file name, compiler name and version, timestamp, and compilation
3630 @item -mno-underscores
3631 @kindex -mno-underscores
3632 @cindex underscores, avoiding (88k)
3633 In assembler output, emit symbol names without adding an underscore
3634 character at the beginning of each name. The default is to use an
3635 underscore as prefix on each name.
3637 @item -mocs-debug-info
3638 @itemx -mno-ocs-debug-info
3639 @kindex -mocs-debug-info
3640 @kindex -mno-ocs-debug-info
3642 @cindex debugging, 88k OCS
3643 Include (or omit) additional debugging information (about registers used
3644 in each stack frame) as specified in the 88open Object Compatibility
3645 Standard, ``OCS''. This extra information allows debugging of code that
3646 has had the frame pointer eliminated. The default for DG/UX, SVr4, and
3647 Delta 88 SVr3.2 is to include this information; other 88k configurations
3648 omit this information by default.
3650 @item -mocs-frame-position
3651 @kindex -mocs-frame-position
3652 @cindex register positions in frame (88k)
3653 When emitting COFF debugging information for automatic variables and
3654 parameters stored on the stack, use the offset from the canonical frame
3655 address, which is the stack pointer (register 31) on entry to the
3656 function. The DG/UX, SVr4, Delta88 SVr3.2, and BCS configurations use
3657 @samp{-mocs-frame-position}; other 88k configurations have the default
3658 @samp{-mno-ocs-frame-position}.
3660 @item -mno-ocs-frame-position
3661 @kindex -mno-ocs-frame-position
3662 @cindex register positions in frame (88k)
3663 When emitting COFF debugging information for automatic variables and
3664 parameters stored on the stack, use the offset from the frame pointer
3665 register (register 30). When this option is in effect, the frame
3666 pointer is not eliminated when debugging information is selected by the
3669 @item -moptimize-arg-area
3670 @itemx -mno-optimize-arg-area
3671 @kindex -moptimize-arg-area
3672 @kindex -mno-optimize-arg-area
3673 @cindex arguments in frame (88k)
3674 Control how function arguments are stored in stack frames.
3675 @samp{-moptimize-arg-area} saves space by optimizing them, but this
3676 conflicts with the 88open specifications. The opposite alternative,
3677 @samp{-mno-optimize-arg-area}, agrees with 88open standards. By default
3678 GNU CC does not optimize the argument area.
3680 @item -mshort-data-@var{num}
3681 @kindex -mshort-data-@var{num}
3682 @cindex smaller data references (88k)
3683 @cindex r0-relative references (88k)
3684 Generate smaller data references by making them relative to @code{r0},
3685 which allows loading a value using a single instruction (rather than the
3686 usual two). You control which data references are affected by
3687 specifying @var{num} with this option. For example, if you specify
3688 @samp{-mshort-data-512}, then the data references affected are those
3689 involving displacements of less than 512 bytes.
3690 @samp{-mshort-data-@var{num}} is not effective for @var{num} greater
3693 @item -mserialize-volatile
3694 @kindex -mserialize-volatile
3695 @itemx -mno-serialize-volatile
3696 @kindex -mno-serialize-volatile
3697 @cindex sequential consistency on 88k
3698 Do, or don't, generate code to guarantee sequential consistency
3699 of volatile memory references. By default, consistency is
3702 The order of memory references made by the MC88110 processor does
3703 not always match the order of the instructions requesting those
3704 references. In particular, a load instruction may execute before
3705 a preceding store instruction. Such reordering violates
3706 sequential consistency of volatile memory references, when there
3707 are multiple processors. When consistency must be guaranteed,
3708 GNU C generates special instructions, as needed, to force
3709 execution in the proper order.
3711 The MC88100 processor does not reorder memory references and so
3712 always provides sequential consistency. However, by default, GNU
3713 C generates the special instructions to guarantee consistency
3714 even when you use @samp{-m88100}, so that the code may be run on an
3715 MC88110 processor. If you intend to run your code only on the
3716 MC88100 processor, you may use @samp{-mno-serialize-volatile}.
3718 The extra code generated to guarantee consistency may affect the
3719 performance of your application. If you know that you can safely
3720 forgo this guarantee, you may use @samp{-mno-serialize-volatile}.
3726 @cindex assembler syntax, 88k
3728 Turn on (@samp{-msvr4}) or off (@samp{-msvr3}) compiler extensions
3729 related to System V release 4 (SVr4). This controls the following:
3733 Which variant of the assembler syntax to emit.
3735 @samp{-msvr4} makes the C preprocessor recognize @samp{#pragma weak}
3736 that is used on System V release 4.
3738 @samp{-msvr4} makes GNU CC issue additional declaration directives used in
3742 @samp{-msvr4} is the default for the m88k-motorola-sysv4 and
3743 m88k-dg-dgux m88k configurations. @samp{-msvr3} is the default for all
3744 other m88k configurations.
3746 @item -mversion-03.00
3747 @kindex -mversion-03.00
3748 This option is obsolete, and is ignored.
3749 @c ??? which asm syntax better for GAS? option there too?
3751 @item -mno-check-zero-division
3752 @itemx -mcheck-zero-division
3753 @kindex -mno-check-zero-division
3754 @kindex -mcheck-zero-division
3755 @cindex zero division on 88k
3756 Do, or don't, generate code to guarantee that integer division by
3757 zero will be detected. By default, detection is guaranteed.
3759 Some models of the MC88100 processor fail to trap upon integer
3760 division by zero under certain conditions. By default, when
3761 compiling code that might be run on such a processor, GNU C
3762 generates code that explicitly checks for zero-valued divisors
3763 and traps with exception number 503 when one is detected. Use of
3764 mno-check-zero-division suppresses such checking for code
3765 generated to run on an MC88100 processor.
3767 GNU C assumes that the MC88110 processor correctly detects all
3768 instances of integer division by zero. When @samp{-m88110} is
3769 specified, both @samp{-mcheck-zero-division} and
3770 @samp{-mno-check-zero-division} are ignored, and no explicit checks for
3771 zero-valued divisors are generated.
3773 @item -muse-div-instruction
3774 @kindex -muse-div-instruction
3775 @cindex divide instruction, 88k
3776 Use the div instruction for signed integer division on the
3777 MC88100 processor. By default, the div instruction is not used.
3779 On the MC88100 processor the signed integer division instruction
3780 div) traps to the operating system on a negative operand. The
3781 operating system transparently completes the operation, but at a
3782 large cost in execution time. By default, when compiling code
3783 that might be run on an MC88100 processor, GNU C emulates signed
3784 integer division using the unsigned integer division instruction
3785 divu), thereby avoiding the large penalty of a trap to the
3786 operating system. Such emulation has its own, smaller, execution
3787 cost in both time and space. To the extent that your code's
3788 important signed integer division operations are performed on two
3789 nonnegative operands, it may be desirable to use the div
3790 instruction directly.
3792 On the MC88110 processor the div instruction (also known as the
3793 divs instruction) processes negative operands without trapping to
3794 the operating system. When @samp{-m88110} is specified,
3795 @samp{-muse-div-instruction} is ignored, and the div instruction is used
3796 for signed integer division.
3798 Note that the result of dividing INT_MIN by -1 is undefined. In
3799 particular, the behavior of such a division with and without
3800 @samp{-muse-div-instruction} may differ.
3802 @item -mtrap-large-shift
3803 @itemx -mhandle-large-shift
3804 @kindex -mtrap-large-shift
3805 @kindex -mhandle-large-shift
3806 @cindex bit shift overflow (88k)
3807 @cindex large bit shifts (88k)
3808 Include code to detect bit-shifts of more than 31 bits; respectively,
3809 trap such shifts or emit code to handle them properly. By default GNU CC
3810 makes no special provision for large bit shifts.
3812 @item -mwarn-passed-structs
3813 @kindex -mwarn-passed-structs
3814 @cindex structure passing (88k)
3815 Warn when a function passes a struct as an argument or result.
3816 Structure-passing conventions have changed during the evolution of the C
3817 language, and are often the source of portability problems. By default,
3818 GNU CC issues no such warning.
3821 @node RS/6000 and PowerPC Options
3822 @subsection IBM RS/6000 and PowerPC Options
3823 @cindex RS/6000 and PowerPC Options
3824 @cindex IBM RS/6000 and PowerPC Options
3826 These @samp{-m} options are defined for the IBM RS/6000 and PowerPC:
3834 @itemx -mpowerpc-gpopt
3835 @itemx -mno-powerpc-gpopt
3836 @itemx -mpowerpc-gfxopt
3837 @itemx -mno-powerpc-gfxopt
3841 @kindex -mpowerpc-gpopt
3842 @kindex -mpowerpc-gfxopt
3843 GNU CC supports two related instruction set architectures for the
3844 RS/6000 and PowerPC. The @dfn{POWER} instruction set are those
3845 instructions supported by the @samp{rios} chip set used in the original
3846 RS/6000 systems and the @dfn{PowerPC} instruction set is the
3847 architecture of the Motorola MPC5xx, MPC6xx, MPC8xx microprocessors, and
3848 the IBM 4xx microprocessors.
3850 Neither architecture is a subset of the other. However there is a
3851 large common subset of instructions supported by both. An MQ
3852 register is included in processors supporting the POWER architecture.
3854 You use these options to specify which instructions are available on the
3855 processor you are using. The default value of these options is
3856 determined when configuring GNU CC. Specifying the
3857 @samp{-mcpu=@var{cpu_type}} overrides the specification of these
3858 options. We recommend you use the @samp{-mcpu=@var{cpu_type}} option
3859 rather than the options listed above.
3861 The @samp{-mpower} option allows GNU CC to generate instructions that
3862 are found only in the POWER architecture and to use the MQ register.
3863 Specifying @samp{-mpower2} implies @samp{-power} and also allows GNU CC
3864 to generate instructions that are present in the POWER2 architecture but
3865 not the original POWER architecture.
3867 The @samp{-mpowerpc} option allows GNU CC to generate instructions that
3868 are found only in the 32-bit subset of the PowerPC architecture.
3869 Specifying @samp{-mpowerpc-gpopt} implies @samp{-mpowerpc} and also allows
3870 GNU CC to use the optional PowerPC architecture instructions in the
3871 General Purpose group, including floating-point square root. Specifying
3872 @samp{-mpowerpc-gfxopt} implies @samp{-mpowerpc} and also allows GNU CC to
3873 use the optional PowerPC architecture instructions in the Graphics
3874 group, including floating-point select.
3876 If you specify both @samp{-mno-power} and @samp{-mno-powerpc}, GNU CC
3877 will use only the instructions in the common subset of both
3878 architectures plus some special AIX common-mode calls, and will not use
3879 the MQ register. Specifying both @samp{-mpower} and @samp{-mpowerpc}
3880 permits GNU CC to use any instruction from either architecture and to
3881 allow use of the MQ register; specify this for the Motorola MPC601.
3883 @item -mnew-mnemonics
3884 @itemx -mold-mnemonics
3885 @kindex -mnew-mnemonics
3886 @kindex -mold-mnemonics
3887 Select which mnemonics to use in the generated assembler code.
3888 @samp{-mnew-mnemonics} requests output that uses the assembler mnemonics
3889 defined for the PowerPC architecture, while @samp{-mold-mnemonics}
3890 requests the assembler mnemonics defined for the POWER architecture.
3891 Instructions defined in only one architecture have only one mnemonic;
3892 GNU CC uses that mnemonic irrespective of which of these options is
3895 PowerPC assemblers support both the old and new mnemonics, as will later
3896 POWER assemblers. Current POWER assemblers only support the old
3897 mnemonics. Specify @samp{-mnew-mnemonics} if you have an assembler that
3898 supports them, otherwise specify @samp{-mold-mnemonics}.
3900 The default value of these options depends on how GNU CC was configured.
3901 Specifying @samp{-mcpu=@var{cpu_type}} sometimes overrides the value of
3902 these option. Unless you are building a cross-compiler, you should
3903 normally not specify either @samp{-mnew-mnemonics} or
3904 @samp{-mold-mnemonics}, but should instead accept the default.
3906 @item -mcpu=@var{cpu_type}
3907 Set architecture type, register usage, choice of mnemonics, and
3908 instruction scheduling parameters for machine type @var{cpu_type}.
3909 Supported values for @var{cpu_type} are @samp{rs6000}, @samp{rios1},
3910 @samp{rios2}, @samp{rsc}, @samp{601}, @samp{602}, @samp{603},
3911 @samp{603e}, @samp{604}, @samp{604e}, @samp{620}, @samp{power},
3912 @samp{power2}, @samp{powerpc}, @samp{403}, @samp{505}, @samp{801},
3913 @samp{821}, @samp{823}, and @samp{860} and @samp{common}.
3914 @samp{-mcpu=power}, @samp{-mcpu=power2}, and @samp{-mcpu=powerpc}
3915 specify generic POWER, POWER2 and pure PowerPC (i.e., not MPC601)
3916 architecture machine types, with an appropriate, generic processor model
3917 assumed for scheduling purposes.@refill
3919 @c overfull hbox here --bob 22 jul96
3920 @c original text between ignore ... end ignore
3922 Specifying any of the @samp{-mcpu=rios1}, @samp{-mcpu=rios2},
3923 @samp{-mcpu=rsc}, @samp{-mcpu=power}, or @samp{-mcpu=power2} options
3924 enables the @samp{-mpower} option and disables the @samp{-mpowerpc}
3925 option; @samp{-mcpu=601} enables both the @samp{-mpower} and
3926 @samp{-mpowerpc} options; all of @samp{-mcpu=602}, @samp{-mcpu=603},
3927 @samp{-mcpu=603e}, @samp{-mcpu=604}, @samp{-mcpu=604e},
3928 @samp{-mcpu=620}, @samp{-mcpu=403}, @samp{-mcpu=505}, @samp{-mcpu=801},
3929 @samp{-mcpu=821}, @samp{-mcpu=823}, @samp{-mcpu=860} and
3930 @samp{-mcpu=powerpc} enable the @samp{-mpowerpc} option and disable the
3931 @samp{-mpower} option; @samp{-mcpu=common} disables both the
3932 @samp{-mpower} and @samp{-mpowerpc} options.@refill
3934 @c changed paragraph
3935 Specifying any of the following options:
3936 @samp{-mcpu=rios1}, @samp{-mcpu=rios2}, @samp{-mcpu=rsc},
3937 @samp{-mcpu=power}, or @samp{-mcpu=power2}
3938 enables the @samp{-mpower} option and disables the @samp{-mpowerpc} option;
3939 @samp{-mcpu=601} enables both the @samp{-mpower} and @samp{-mpowerpc} options.
3940 All of @samp{-mcpu=602}, @samp{-mcpu=603}, @samp{-mcpu=603e},
3941 @samp{-mcpu=604}, @samp{-mcpu=620},
3942 enable the @samp{-mpowerpc} option and disable the @samp{-mpower} option.
3943 Exactly similarly, all of @samp{-mcpu=403},
3944 @samp{-mcpu=505}, @samp{-mcpu=821}, @samp{-mcpu=860} and @samp{-mcpu=powerpc}
3945 enable the @samp{-mpowerpc} option and disable the @samp{-mpower} option.
3946 @samp{-mcpu=common} disables both the
3947 @samp{-mpower} and @samp{-mpowerpc} options.@refill
3948 @c end changes to prevent overfull hboxes
3950 AIX versions 4 or greater selects @samp{-mcpu=common} by default, so
3951 that code will operate on all members of the RS/6000 and PowerPC
3952 families. In that case, GNU CC will use only the instructions in the
3953 common subset of both architectures plus some special AIX common-mode
3954 calls, and will not use the MQ register. GNU CC assumes a generic
3955 processor model for scheduling purposes.
3957 Specifying any of the options @samp{-mcpu=rios1}, @samp{-mcpu=rios2},
3958 @samp{-mcpu=rsc}, @samp{-mcpu=power}, or @samp{-mcpu=power2} also
3959 disables the @samp{new-mnemonics} option. Specifying @samp{-mcpu=601},
3960 @samp{-mcpu=602}, @samp{-mcpu=603}, @samp{-mcpu=603e}, @samp{-mcpu=604},
3961 @samp{620}, @samp{403}, or @samp{-mcpu=powerpc} also enables the
3962 @samp{new-mnemonics} option.@refill
3964 Specifying @samp{-mcpu=403}, @samp{-mcpu=821}, or @samp{-mcpu=860} also
3965 enables the @samp{-msoft-float} option.
3967 @item -mtune=@var{cpu_type}
3968 Set the instruction scheduling parameters for machine type
3969 @var{cpu_type}, but do not set the architecture type, register usage,
3970 choice of mnemonics like @samp{-mcpu=}@var{cpu_type} would. The same
3971 values for @var{cpu_type} are used for @samp{-mtune=}@var{cpu_type} as
3972 for @samp{-mcpu=}@var{cpu_type}. The @samp{-mtune=}@var{cpu_type}
3973 option overrides the @samp{-mcpu=}@var{cpu_type} option in terms of
3974 instruction scheduling parameters.
3977 @itemx -mno-fp-in-toc
3978 @itemx -mno-sum-in-toc
3979 @itemx -mminimal-toc
3980 Modify generation of the TOC (Table Of Contents), which is created for
3981 every executable file. The @samp{-mfull-toc} option is selected by
3982 default. In that case, GNU CC will allocate at least one TOC entry for
3983 each unique non-automatic variable reference in your program. GNU CC
3984 will also place floating-point constants in the TOC. However, only
3985 16,384 entries are available in the TOC.
3987 If you receive a linker error message that saying you have overflowed
3988 the available TOC space, you can reduce the amount of TOC space used
3989 with the @samp{-mno-fp-in-toc} and @samp{-mno-sum-in-toc} options.
3990 @samp{-mno-fp-in-toc} prevents GNU CC from putting floating-point
3991 constants in the TOC and @samp{-mno-sum-in-toc} forces GNU CC to
3992 generate code to calculate the sum of an address and a constant at
3993 run-time instead of putting that sum into the TOC. You may specify one
3994 or both of these options. Each causes GNU CC to produce very slightly
3995 slower and larger code at the expense of conserving TOC space.
3997 If you still run out of space in the TOC even when you specify both of
3998 these options, specify @samp{-mminimal-toc} instead. This option causes
3999 GNU CC to make only one TOC entry for every file. When you specify this
4000 option, GNU CC will produce code that is slower and larger but which
4001 uses extremely little TOC space. You may wish to use this option
4002 only on files that contain less frequently executed code. @refill
4006 On AIX, pass floating-point arguments to prototyped functions beyond the
4007 register save area (RSA) on the stack in addition to argument FPRs. The
4008 AIX calling convention was extended but not initially documented to
4009 handle an obscure K&R C case of calling a function that takes the
4010 address of its arguments with fewer arguments than declared. AIX XL
4011 compilers assume that floating point arguments which do not fit in the
4012 RSA are on the stack when they compile a subroutine without
4013 optimization. Because always storing floating-point arguments on the
4014 stack is inefficient and rarely needed, this option is not enabled by
4015 default and only is necessary when calling subroutines compiled by AIX
4016 XL compilers without optimization.
4019 Support @dfn{AIX Threads}. Link an application written to use
4020 @dfn{pthreads} with special libraries and startup code to enable the
4024 Support @dfn{IBM RS/6000 SP} @dfn{Parallel Environment} (PE). Link an
4025 application written to use message passing with special startup code to
4026 enable the application to run. The system must have PE installed in the
4027 standard location (@file{/usr/lpp/ppe.poe/}), or the @file{specs} file
4028 must be overridden with the @samp{-specs=} option to specify the
4029 appropriate directory location. The Parallel Environment does not
4030 support threads, so the @samp{-mpe} option and the @samp{-mthreads}
4031 option are incompatible.
4035 Generate code that does not use (uses) the floating-point register set.
4036 Software floating point emulation is provided if you use the
4037 @samp{-msoft-float} option, and pass the option to GNU CC when linking.
4040 @itemx -mno-multiple
4041 Generate code that uses (does not use) the load multiple word
4042 instructions and the store multiple word instructions. These
4043 instructions are generated by default on POWER systems, and not
4044 generated on PowerPC systems. Do not use @samp{-mmultiple} on little
4045 endian PowerPC systems, since those instructions do not work when the
4046 processor is in little endian mode.
4050 Generate code that uses (does not use) the load string instructions and the
4051 store string word instructions to save multiple registers and do small block
4052 moves. These instructions are generated by default on POWER systems, and not
4053 generated on PowerPC systems. Do not use @samp{-mstring} on little endian
4054 PowerPC systems, since those instructions do not work when the processor is in
4059 Generate code that uses (does not use) the load or store instructions
4060 that update the base register to the address of the calculated memory
4061 location. These instructions are generated by default. If you use
4062 @samp{-mno-update}, there is a small window between the time that the
4063 stack pointer is updated and the address of the previous frame is
4064 stored, which means code that walks the stack frame across interrupts or
4065 signals may get corrupted data.
4068 @itemx -mno-fused-madd
4069 Generate code that uses (does not use) the floating point multiply and
4070 accumulate instructions. These instructions are generated by default if
4071 hardware floating is used.
4073 @item -mno-bit-align
4075 On System V.4 and embedded PowerPC systems do not (do) force structures
4076 and unions that contain bit fields to be aligned to the base type of the
4079 For example, by default a structure containing nothing but 8
4080 @code{unsigned} bitfields of length 1 would be aligned to a 4 byte
4081 boundary and have a size of 4 bytes. By using @samp{-mno-bit-align},
4082 the structure would be aligned to a 1 byte boundary and be one byte in
4085 @item -mno-strict-align
4086 @itemx -mstrict-align
4087 On System V.4 and embedded PowerPC systems do not (do) assume that
4088 unaligned memory references will be handled by the system.
4091 @itemx -mno-relocatable
4092 On embedded PowerPC systems generate code that allows (does not allow)
4093 the program to be relocated to a different address at runtime. If you
4094 use @samp{-mrelocatable} on any module, all objects linked together must
4095 be compiled with @samp{-mrelocatable} or @samp{-mrelocatable-lib}.
4097 @item -mrelocatable-lib
4098 @itemx -mno-relocatable-lib
4099 On embedded PowerPC systems generate code that allows (does not allow)
4100 the program to be relocated to a different address at runtime. Modules
4101 compiled with @samp{-mreloctable-lib} can be linked with either modules
4102 compiled without @samp{-mrelocatable} and @samp{-mrelocatable-lib} or
4103 with modules compiled with the @samp{-mrelocatable} options.
4107 On System V.4 and embedded PowerPC systems do not (do) assume that
4108 register 2 contains a pointer to a global area pointing to the addresses
4109 used in the program.
4111 @item -mno-traceback
4113 On embedded PowerPC systems do not (do) generate a traceback tag before
4114 the start of the function. This tag can be used by the debugger to
4115 identify where the start of a function is.
4118 @itemx -mlittle-endian
4119 On System V.4 and embedded PowerPC systems compile code for the
4120 processor in little endian mode. The @samp{-mlittle-endian} option is
4121 the same as @samp{-mlittle}.
4125 On System V.4 and embedded PowerPC systems compile code for the
4126 processor in big endian mode. The @samp{-mbig-endian} option is
4127 the same as @samp{-mbig}.
4130 On System V.4 and embedded PowerPC systems compile code using calling
4131 conventions that adheres to the March 1995 draft of the System V
4132 Application Binary Interface, PowerPC processor supplement. This is the
4133 default unless you configured GCC using @samp{powerpc-*-eabiaix}.
4135 @item -mcall-sysv-eabi
4136 Specify both @samp{-mcall-sysv} and @samp{-meabi} options.
4138 @item -mcall-sysv-noeabi
4139 Specify both @samp{-mcall-sysv} and @samp{-mno-eabi} options.
4142 On System V.4 and embedded PowerPC systems compile code using calling
4143 conventions that are similar to those used on AIX. This is the
4144 default if you configured GCC using @samp{powerpc-*-eabiaix}.
4146 @item -mcall-solaris
4147 On System V.4 and embedded PowerPC systems compile code for the Solaris
4151 On System V.4 and embedded PowerPC systems compile code for the
4152 Linux-based GNU system.
4155 @itemx -mno-prototype
4156 On System V.4 and embedded PowerPC systems assume that all calls to
4157 variable argument functions are properly prototyped. Otherwise, the
4158 compiler must insert an instruction before every non prototyped call to
4159 set or clear bit 6 of the condition code register (@var{CR}) to
4160 indicate whether floating point values were passed in the floating point
4161 registers in case the function takes a variable arguments. With
4162 @samp{-mprototype}, only calls to prototyped variable argument functions
4163 will set or clear the bit.
4166 On embedded PowerPC systems, assume that the startup module is called
4167 @file{sim-crt0.o} and that the standard C libraries are @file{libsim.a} and
4168 @file{libc.a}. This is the default for @samp{powerpc-*-eabisim}.
4172 On embedded PowerPC systems, assume that the startup module is called
4173 @file{crt0.o} and the standard C libraries are @file{libmvme.a} and
4177 On embedded PowerPC systems, assume that the startup module is called
4178 @file{crt0.o} and the standard C libraries are @file{libads.a} and
4182 On embedded PowerPC systems, assume that the startup module is called
4183 @file{crt0.o} and the standard C libraries are @file{libyk.a} and
4187 On embedded PowerPC systems, set the @var{PPC_EMB} bit in the ELF flags
4188 header to indicate that @samp{eabi} extended relocations are used.
4192 On System V.4 and embedded PowerPC systems do (do not) adhere to the
4193 Embedded Applications Binary Interface (eabi) which is a set of
4194 modifications to the System V.4 specifications. Selecting @code{-meabi}
4195 means that the stack is aligned to an 8 byte boundary, a function
4196 @code{__eabi} is called to from @code{main} to set up the eabi
4197 environment, and the @samp{-msdata} option can use both @code{r2} and
4198 @code{r13} to point to two separate small data areas. Selecting
4199 @code{-mno-eabi} means that the stack is aligned to a 16 byte boundary,
4200 do not call an initialization function from @code{main}, and the
4201 @samp{-msdata} option will only use @code{r13} to point to a single
4202 small data area. The @samp{-meabi} option is on by default if you
4203 configured GCC using one of the @samp{powerpc*-*-eabi*} options.
4206 On System V.4 and embedded PowerPC systems, put small initialized
4207 @code{const} global and static data in the @samp{.sdata2} section, which
4208 is pointed to by register @code{r2}. Put small initialized
4209 non-@code{const} global and static data in the @samp{.sdata} section,
4210 which is pointed to by register @code{r13}. Put small uninitialized
4211 global and static data in the @samp{.sbss} section, which is adjacent to
4212 the @samp{.sdata} section. The @samp{-msdata=eabi} option is
4213 incompatible with the @samp{-mrelocatable} option. The
4214 @samp{-msdata=eabi} option also sets the @samp{-memb} option.
4217 On System V.4 and embedded PowerPC systems, put small global and static
4218 data in the @samp{.sdata} section, which is pointed to by register
4219 @code{r13}. Put small uninitialized global and static data in the
4220 @samp{.sbss} section, which is adjacent to the @samp{.sdata} section.
4221 The @samp{-msdata=sysv} option is incompatible with the
4222 @samp{-mrelocatable} option.
4224 @item -msdata=default
4226 On System V.4 and embedded PowerPC systems, if @samp{-meabi} is used,
4227 compile code the same as @samp{-msdata=eabi}, otherwise compile code the
4228 same as @samp{-msdata=sysv}.
4231 On System V.4 and embedded PowerPC systems, put small global and static
4232 data in the @samp{.sdata} section. Put small uninitialized global and
4233 static data in the @samp{.sbss} section. Do not use register @code{r13}
4234 to address small data however. This is the default behavior unless
4235 other @samp{-msdata} options are used.
4239 On embedded PowerPC systems, put all initialized global and static data
4240 in the @samp{.data} section, and all uninitialized data in the
4241 @samp{.bss} section.
4244 @cindex smaller data references (PowerPC)
4245 @cindex .sdata/.sdata2 references (PowerPC)
4246 On embbeded PowerPC systems, put global and static items less than or
4247 equal to @var{num} bytes into the small data or bss sections instead of
4248 the normal data or bss section. By default, @var{num} is 8. The
4249 @samp{-G @var{num}} switch is also passed to the linker.
4250 All modules should be compiled with the same @samp{-G @var{num}} value.
4253 @itemx -mno-regnames
4254 On System V.4 and embedded PowerPC systems do (do not) emit register
4255 names in the assembly language output using symbolic forms.
4258 @subsection IBM RT Options
4260 @cindex IBM RT options
4262 These @samp{-m} options are defined for the IBM RT PC:
4266 Use an in-line code sequence for integer multiplies. This is the
4269 @item -mcall-lib-mul
4270 Call @code{lmul$$} for integer multiples.
4272 @item -mfull-fp-blocks
4273 Generate full-size floating point data blocks, including the minimum
4274 amount of scratch space recommended by IBM. This is the default.
4276 @item -mminimum-fp-blocks
4277 Do not include extra scratch space in floating point data blocks. This
4278 results in smaller code, but slower execution, since scratch space must
4279 be allocated dynamically.
4281 @cindex @file{varargs.h} and RT PC
4282 @cindex @file{stdarg.h} and RT PC
4283 @item -mfp-arg-in-fpregs
4284 Use a calling sequence incompatible with the IBM calling convention in
4285 which floating point arguments are passed in floating point registers.
4286 Note that @code{varargs.h} and @code{stdargs.h} will not work with
4287 floating point operands if this option is specified.
4289 @item -mfp-arg-in-gregs
4290 Use the normal calling convention for floating point arguments. This is
4293 @item -mhc-struct-return
4294 Return structures of more than one word in memory, rather than in a
4295 register. This provides compatibility with the MetaWare HighC (hc)
4296 compiler. Use the option @samp{-fpcc-struct-return} for compatibility
4297 with the Portable C Compiler (pcc).
4299 @item -mnohc-struct-return
4300 Return some structures of more than one word in registers, when
4301 convenient. This is the default. For compatibility with the
4302 IBM-supplied compilers, use the option @samp{-fpcc-struct-return} or the
4303 option @samp{-mhc-struct-return}.
4307 @subsection MIPS Options
4308 @cindex MIPS options
4310 These @samp{-m} options are defined for the MIPS family of computers:
4313 @item -mcpu=@var{cpu type}
4314 Assume the defaults for the machine type @var{cpu type} when scheduling
4315 instructions. The choices for @var{cpu type} are @samp{r2000}, @samp{r3000},
4316 @samp{r4000}, @samp{r4400}, @samp{r4600}, and @samp{r6000}. While picking a
4317 specific @var{cpu type} will schedule things appropriately for that
4318 particular chip, the compiler will not generate any code that does not
4319 meet level 1 of the MIPS ISA (instruction set architecture) without
4320 the @samp{-mips2} or @samp{-mips3} switches being used.
4323 Issue instructions from level 1 of the MIPS ISA. This is the default.
4324 @samp{r3000} is the default @var{cpu type} at this ISA level.
4327 Issue instructions from level 2 of the MIPS ISA (branch likely, square
4328 root instructions). @samp{r6000} is the default @var{cpu type} at this
4332 Issue instructions from level 3 of the MIPS ISA (64 bit instructions).
4333 @samp{r4000} is the default @var{cpu type} at this ISA level.
4334 This option does not change the sizes of any of the C data types.
4337 Assume that 32 32-bit floating point registers are available. This is
4341 Assume that 32 64-bit floating point registers are available. This is
4342 the default when the @samp{-mips3} option is used.
4345 Assume that 32 32-bit general purpose registers are available. This is
4349 Assume that 32 64-bit general purpose registers are available. This is
4350 the default when the @samp{-mips3} option is used.
4353 Types long, int, and pointer are 64 bits. This works only if @samp{-mips3}
4357 Types long and pointer are 64 bits, and type int is 32 bits.
4358 This works only if @samp{-mips3} is also specified.
4361 Generate code for the MIPS assembler, and invoke @file{mips-tfile} to
4362 add normal debug information. This is the default for all
4363 platforms except for the OSF/1 reference platform, using the OSF/rose
4364 object format. If the either of the @samp{-gstabs} or @samp{-gstabs+}
4365 switches are used, the @file{mips-tfile} program will encapsulate the
4366 stabs within MIPS ECOFF.
4369 Generate code for the GNU assembler. This is the default on the OSF/1
4370 reference platform, using the OSF/rose object format. Also, this is
4371 the default if the configure option @samp{--with-gnu-as} is used.
4373 @item -msplit-addresses
4374 @itemx -mno-split-addresses
4375 Generate code to load the high and low parts of address constants separately.
4376 This allows @code{gcc} to optimize away redundant loads of the high order
4377 bits of addresses. This optimization requires GNU as and GNU ld.
4378 This optimization is enabled by default for some embedded targets where
4379 GNU as and GNU ld are standard.
4383 The @samp{-mrnames} switch says to output code using the MIPS software
4384 names for the registers, instead of the hardware names (ie, @var{a0}
4385 instead of @var{$4}). The only known assembler that supports this option
4386 is the Algorithmics assembler.
4390 The @samp{-mgpopt} switch says to write all of the data declarations
4391 before the instructions in the text section, this allows the MIPS
4392 assembler to generate one word memory references instead of using two
4393 words for short global or static data items. This is on by default if
4394 optimization is selected.
4398 For each non-inline function processed, the @samp{-mstats} switch
4399 causes the compiler to emit one line to the standard error file to
4400 print statistics about the program (number of registers saved, stack
4405 The @samp{-mmemcpy} switch makes all block moves call the appropriate
4406 string function (@samp{memcpy} or @samp{bcopy}) instead of possibly
4407 generating inline code.
4410 @itemx -mno-mips-tfile
4411 The @samp{-mno-mips-tfile} switch causes the compiler not
4412 postprocess the object file with the @file{mips-tfile} program,
4413 after the MIPS assembler has generated it to add debug support. If
4414 @file{mips-tfile} is not run, then no local variables will be
4415 available to the debugger. In addition, @file{stage2} and
4416 @file{stage3} objects will have the temporary file names passed to the
4417 assembler embedded in the object file, which means the objects will
4418 not compare the same. The @samp{-mno-mips-tfile} switch should only
4419 be used when there are bugs in the @file{mips-tfile} program that
4420 prevents compilation.
4423 Generate output containing library calls for floating point.
4424 @strong{Warning:} the requisite libraries are not part of GNU CC.
4425 Normally the facilities of the machine's usual C compiler are used, but
4426 this can't be done directly in cross-compilation. You must make your
4427 own arrangements to provide suitable library functions for
4431 Generate output containing floating point instructions. This is the
4432 default if you use the unmodified sources.
4435 @itemx -mno-abicalls
4436 Emit (or do not emit) the pseudo operations @samp{.abicalls},
4437 @samp{.cpload}, and @samp{.cprestore} that some System V.4 ports use for
4438 position independent code.
4441 @itemx -mno-long-calls
4442 Do all calls with the @samp{JALR} instruction, which requires
4443 loading up a function's address into a register before the call.
4444 You need to use this switch, if you call outside of the current
4445 512 megabyte segment to functions that are not through pointers.
4448 @itemx -mno-half-pic
4449 Put pointers to extern references into the data section and load them
4450 up, rather than put the references in the text section.
4452 @item -membedded-pic
4453 @itemx -mno-embedded-pic
4454 Generate PIC code suitable for some embedded systems. All calls are made
4455 using PC relative address, and all data is addressed using the $gp register.
4456 This requires GNU as and GNU ld which do most of the work.
4458 @item -membedded-data
4459 @itemx -mno-embedded-data
4460 Allocate variables to the read-only data section first if possible, then
4461 next in the small data section if possible, otherwise in data. This gives
4462 slightly slower code than the default, but reduces the amount of RAM required
4463 when executing, and thus may be preferred for some embedded systems.
4465 @item -msingle-float
4466 @itemx -mdouble-float
4467 The @samp{-msingle-float} switch tells gcc to assume that the floating
4468 point coprocessor only supports single precision operations, as on the
4469 @samp{r4650} chip. The @samp{-mdouble-float} switch permits gcc to use
4470 double precision operations. This is the default.
4474 Permit use of the @samp{mad}, @samp{madu} and @samp{mul} instructions,
4475 as on the @samp{r4650} chip.
4478 Turns on @samp{-msingle-float}, @samp{-mmad}, and, at least for now,
4482 Compile code for the processor in little endian mode.
4483 The requisite libraries are assumed to exist.
4486 Compile code for the processor in big endian mode.
4487 The requisite libraries are assumed to exist.
4490 @cindex smaller data references (MIPS)
4491 @cindex gp-relative references (MIPS)
4492 Put global and static items less than or equal to @var{num} bytes into
4493 the small data or bss sections instead of the normal data or bss
4494 section. This allows the assembler to emit one word memory reference
4495 instructions based on the global pointer (@var{gp} or @var{$28}),
4496 instead of the normal two words used. By default, @var{num} is 8 when
4497 the MIPS assembler is used, and 0 when the GNU assembler is used. The
4498 @samp{-G @var{num}} switch is also passed to the assembler and linker.
4499 All modules should be compiled with the same @samp{-G @var{num}}
4503 Tell the MIPS assembler to not run it's preprocessor over user
4504 assembler files (with a @samp{.s} suffix) when assembling them.
4508 These options are defined by the macro
4509 @code{TARGET_SWITCHES} in the machine description. The default for the
4510 options is also defined by that macro, which enables you to change the
4515 @subsection Intel 386 Options
4516 @cindex i386 Options
4517 @cindex Intel 386 Options
4519 These @samp{-m} options are defined for the i386 family of computers:
4521 @item -mcpu=@var{cpu type}
4522 Assume the defaults for the machine type @var{cpu type} when scheduling
4523 instructions. The choices for @var{cpu type} are: @samp{i386},
4524 @samp{i486}, @samp{i586} (@samp{pentium}), @samp{pentium}, @samp{i686}
4525 (@samp{pentiumpro}) and @samp{pentiumpro}. While picking a specific
4526 @var{cpu type} will schedule things appropriately for that particular
4527 chip, the compiler will not generate any code that does not run on the
4528 i386 without the @samp{-march=@var{cpu type}} option being used.
4530 @item -march=@var{cpu type}
4531 Generate instructions for the machine type @var{cpu type}. The choices
4532 for @var{cpu type} are: @samp{i386}, @samp{i486}, @samp{pentium}, and
4533 @samp{pentiumpro}. Specifying @samp{-march=@var{cpu type}} implies
4534 @samp{-mcpu=@var{cpu type}}.
4540 Synonyms for -mcpu=i386, -mcpu=i486, -mcpu=pentium, and -mcpu=pentiumpro
4545 Control whether or not the compiler uses IEEE floating point
4546 comparisons. These handle correctly the case where the result of a
4547 comparison is unordered.
4550 Generate output containing library calls for floating point.
4551 @strong{Warning:} the requisite libraries are not part of GNU CC.
4552 Normally the facilities of the machine's usual C compiler are used, but
4553 this can't be done directly in cross-compilation. You must make your
4554 own arrangements to provide suitable library functions for
4557 On machines where a function returns floating point results in the 80387
4558 register stack, some floating point opcodes may be emitted even if
4559 @samp{-msoft-float} is used.
4561 @item -mno-fp-ret-in-387
4562 Do not use the FPU registers for return values of functions.
4564 The usual calling convention has functions return values of types
4565 @code{float} and @code{double} in an FPU register, even if there
4566 is no FPU. The idea is that the operating system should emulate
4569 The option @samp{-mno-fp-ret-in-387} causes such values to be returned
4570 in ordinary CPU registers instead.
4572 @item -mno-fancy-math-387
4573 Some 387 emulators do not support the @code{sin}, @code{cos} and
4574 @code{sqrt} instructions for the 387. Specify this option to avoid
4575 generating those instructions. This option is the default on FreeBSD.
4576 As of revision 2.6.1, these instructions are not generated unless you
4577 also use the @samp{-ffast-math} switch.
4579 @item -malign-double
4580 @itemx -mno-align-double
4581 Control whether GNU CC aligns @code{double}, @code{long double}, and
4582 @code{long long} variables on a two word boundary or a one word
4583 boundary. Aligning @code{double} variables on a two word boundary will
4584 produce code that runs somewhat faster on a @samp{Pentium} at the
4585 expense of more memory.
4587 @strong{Warning:} if you use the @samp{-malign-double} switch,
4588 structures containing the above types will be aligned differently than
4589 the published application binary interface specifications for the 386.
4592 @itemx -mno-svr3-shlib
4593 Control whether GNU CC places uninitialized locals into @code{bss} or
4594 @code{data}. @samp{-msvr3-shlib} places these locals into @code{bss}.
4595 These options are meaningful only on System V Release 3.
4597 @item -mno-wide-multiply
4598 @itemx -mwide-multiply
4599 Control whether GNU CC uses the @code{mul} and @code{imul} that produce
4600 64 bit results in @code{eax:edx} from 32 bit operands to do @code{long
4601 long} multiplies and 32-bit division by constants.
4604 Use a different function-calling convention, in which functions that
4605 take a fixed number of arguments return with the @code{ret} @var{num}
4606 instruction, which pops their arguments while returning. This saves one
4607 instruction in the caller since there is no need to pop the arguments
4610 You can specify that an individual function is called with this calling
4611 sequence with the function attribute @samp{stdcall}. You can also
4612 override the @samp{-mrtd} option by using the function attribute
4613 @samp{cdecl}. @xref{Function Attributes}
4615 @strong{Warning:} this calling convention is incompatible with the one
4616 normally used on Unix, so you cannot use it if you need to call
4617 libraries compiled with the Unix compiler.
4619 Also, you must provide function prototypes for all functions that
4620 take variable numbers of arguments (including @code{printf});
4621 otherwise incorrect code will be generated for calls to those
4624 In addition, seriously incorrect code will result if you call a
4625 function with too many arguments. (Normally, extra arguments are
4626 harmlessly ignored.)
4628 @item -mreg-alloc=@var{regs}
4629 Control the default allocation order of integer registers. The
4630 string @var{regs} is a series of letters specifying a register. The
4631 supported letters are: @code{a} allocate EAX; @code{b} allocate EBX;
4632 @code{c} allocate ECX; @code{d} allocate EDX; @code{S} allocate ESI;
4633 @code{D} allocate EDI; @code{B} allocate EBP.
4635 @item -mregparm=@var{num}
4636 Control how many registers are used to pass integer arguments. By
4637 default, no registers are used to pass arguments, and at most 3
4638 registers can be used. You can control this behavior for a specific
4639 function by using the function attribute @samp{regparm}. @xref{Function Attributes}
4641 @strong{Warning:} if you use this switch, and
4642 @var{num} is nonzero, then you must build all modules with the same
4643 value, including any libraries. This includes the system libraries and
4646 @item -malign-loops=@var{num}
4647 Align loops to a 2 raised to a @var{num} byte boundary. If
4648 @samp{-malign-loops} is not specified, the default is 2.
4650 @item -malign-jumps=@var{num}
4651 Align instructions that are only jumped to to a 2 raised to a @var{num}
4652 byte boundary. If @samp{-malign-jumps} is not specified, the default is
4653 2 if optimizing for a 386, and 4 if optimizing for a 486.
4655 @item -malign-functions=@var{num}
4656 Align the start of functions to a 2 raised to @var{num} byte boundary.
4657 If @samp{-malign-functions} is not specified, the default is 2 if optimizing
4658 for a 386, and 4 if optimizing for a 486.
4662 @subsection HPPA Options
4663 @cindex HPPA Options
4665 These @samp{-m} options are defined for the HPPA family of computers:
4669 Generate code for a PA 1.0 processor.
4672 Generate code for a PA 1.1 processor.
4675 Generate code suitable for big switch tables. Use this option only if
4676 the assembler/linker complain about out of range branches within a switch
4679 @item -mjump-in-delay
4680 Fill delay slots of function calls with unconditional jump instructions
4681 by modifying the return pointer for the function call to be the target
4682 of the conditional jump.
4684 @item -mdisable-fpregs
4685 Prevent floating point registers from being used in any manner. This is
4686 necessary for compiling kernels which perform lazy context switching of
4687 floating point registers. If you use this option and attempt to perform
4688 floating point operations, the compiler will abort.
4690 @item -mdisable-indexing
4691 Prevent the compiler from using indexing address modes. This avoids some
4692 rather obscure problems when compiling MIG generated code under MACH.
4694 @item -mno-space-regs
4695 Generate code that assumes the target has no space registers. This allows
4696 GCC to generate faster indirect calls and use unscaled index address modes.
4698 Such code is suitable for level 0 PA systems and kernels.
4700 @item -mfast-indirect-calls
4701 Generate code that assumes calls never cross space boundaries. This
4702 allows GCC to emit code which performs faster indirect calls.
4704 This option will not work in the presense of shared libraries or nested
4708 Optimize for space rather than execution time. Currently this only
4709 enables out of line function prologues and epilogues. This option is
4710 incompatable with PIC code generation and profiling.
4712 @item -mlong-load-store
4713 Generate 3-instruction load and store sequences as sometimes required by
4714 the HP-UX 10 linker. This is equivalent to the @samp{+k} option to
4717 @item -mportable-runtime
4718 Use the portable calling conventions proposed by HP for ELF systems.
4721 Enable the use of assembler directives only GAS understands.
4723 @item -mschedule=@var{cpu type}
4724 Schedule code according to the constraints for the machine type
4725 @var{cpu type}. The choices for @var{cpu type} are @samp{700} for
4726 7@var{n}0 machines, @samp{7100} for 7@var{n}5 machines, and @samp{7100}
4727 for 7@var{n}2 machines. @samp{7100} is the default for @var{cpu type}.
4729 Note the @samp{7100LC} scheduling information is incomplete and using
4730 @samp{7100LC} often leads to bad schedules. For now it's probably best
4731 to use @samp{7100} instead of @samp{7100LC} for the 7@var{n}2 machines.
4734 Enable the optimization pass in the HPUX linker. Note this makes symbolic
4735 debugging impossible. It also triggers a bug in the HPUX 8 and HPUX 9 linkers
4736 in which they give bogus error messages when linking some programs.
4739 Generate output containing library calls for floating point.
4740 @strong{Warning:} the requisite libraries are not available for all HPPA
4741 targets. Normally the facilities of the machine's usual C compiler are
4742 used, but this cannot be done directly in cross-compilation. You must make
4743 your own arrangements to provide suitable library functions for
4744 cross-compilation. The embedded target @samp{hppa1.1-*-pro}
4745 does provide software floating point support.
4747 @samp{-msoft-float} changes the calling convention in the output file;
4748 therefore, it is only useful if you compile @emph{all} of a program with
4749 this option. In particular, you need to compile @file{libgcc.a}, the
4750 library that comes with GNU CC, with @samp{-msoft-float} in order for
4754 @node Intel 960 Options
4755 @subsection Intel 960 Options
4757 These @samp{-m} options are defined for the Intel 960 implementations:
4760 @item -m@var{cpu type}
4761 Assume the defaults for the machine type @var{cpu type} for some of
4762 the other options, including instruction scheduling, floating point
4763 support, and addressing modes. The choices for @var{cpu type} are
4764 @samp{ka}, @samp{kb}, @samp{mc}, @samp{ca}, @samp{cf},
4765 @samp{sa}, and @samp{sb}.
4771 The @samp{-mnumerics} option indicates that the processor does support
4772 floating-point instructions. The @samp{-msoft-float} option indicates
4773 that floating-point support should not be assumed.
4775 @item -mleaf-procedures
4776 @itemx -mno-leaf-procedures
4777 Do (or do not) attempt to alter leaf procedures to be callable with the
4778 @code{bal} instruction as well as @code{call}. This will result in more
4779 efficient code for explicit calls when the @code{bal} instruction can be
4780 substituted by the assembler or linker, but less efficient code in other
4781 cases, such as calls via function pointers, or using a linker that doesn't
4782 support this optimization.
4785 @itemx -mno-tail-call
4786 Do (or do not) make additional attempts (beyond those of the
4787 machine-independent portions of the compiler) to optimize tail-recursive
4788 calls into branches. You may not want to do this because the detection of
4789 cases where this is not valid is not totally complete. The default is
4790 @samp{-mno-tail-call}.
4792 @item -mcomplex-addr
4793 @itemx -mno-complex-addr
4794 Assume (or do not assume) that the use of a complex addressing mode is a
4795 win on this implementation of the i960. Complex addressing modes may not
4796 be worthwhile on the K-series, but they definitely are on the C-series.
4797 The default is currently @samp{-mcomplex-addr} for all processors except
4801 @itemx -mno-code-align
4802 Align code to 8-byte boundaries for faster fetching (or don't bother).
4803 Currently turned on by default for C-series implementations only.
4806 @item -mclean-linkage
4807 @itemx -mno-clean-linkage
4808 These options are not fully implemented.
4812 @itemx -mic2.0-compat
4813 @itemx -mic3.0-compat
4814 Enable compatibility with iC960 v2.0 or v3.0.
4818 Enable compatibility with the iC960 assembler.
4820 @item -mstrict-align
4821 @itemx -mno-strict-align
4822 Do not permit (do permit) unaligned accesses.
4825 Enable structure-alignment compatibility with Intel's gcc release version
4826 1.3 (based on gcc 1.37). This option implies @samp{-mstrict-align}.
4829 @node DEC Alpha Options
4830 @subsection DEC Alpha Options
4832 These @samp{-m} options are defined for the DEC Alpha implementations:
4835 @item -mno-soft-float
4837 Use (do not use) the hardware floating-point instructions for
4838 floating-point operations. When @code{-msoft-float} is specified,
4839 functions in @file{libgcc1.c} will be used to perform floating-point
4840 operations. Unless they are replaced by routines that emulate the
4841 floating-point operations, or compiled in such a way as to call such
4842 emulations routines, these routines will issue floating-point
4843 operations. If you are compiling for an Alpha without floating-point
4844 operations, you must ensure that the library is built so as not to call
4847 Note that Alpha implementations without floating-point operations are
4848 required to have floating-point registers.
4852 Generate code that uses (does not use) the floating-point register set.
4853 @code{-mno-fp-regs} implies @code{-msoft-float}. If the floating-point
4854 register set is not used, floating point operands are passed in integer
4855 registers as if they were integers and floating-point results are passed
4856 in $0 instead of $f0. This is a non-standard calling sequence, so any
4857 function with a floating-point argument or return value called by code
4858 compiled with @code{-mno-fp-regs} must also be compiled with that
4861 A typical use of this option is building a kernel that does not use,
4862 and hence need not save and restore, any floating-point registers.
4865 The Alpha architecture implements floating-point hardware optimized for
4866 maximum performance. It is mostly compliant with the IEEE floating
4867 point standard. However, for full compliance, software assistance is
4868 required. This option generates code fully IEEE compliant code
4869 @emph{except} that the @var{inexact flag} is not maintained (see below).
4870 If this option is turned on, the CPP macro @code{_IEEE_FP} is defined
4871 during compilation. The option is a shorthand for: @samp{-D_IEEE_FP
4872 -mfp-trap-mode=su -mtrap-precision=i -mieee-conformant}. The resulting
4873 code is less efficient but is able to correctly support denormalized
4874 numbers and exceptional IEEE values such as not-a-number and plus/minus
4875 infinity. Other Alpha compilers call this option
4876 @code{-ieee_with_no_inexact}.
4878 @item -mieee-with-inexact
4879 @c overfull hbox here --bob 22 jul96
4880 @c original text between ignore ... end ignore
4882 This is like @samp{-mieee} except the generated code also maintains the
4883 IEEE @var{inexact flag}. Turning on this option causes the generated
4884 code to implement fully-compliant IEEE math. The option is a shorthand
4885 for @samp{-D_IEEE_FP -D_IEEE_FP_INEXACT} plus @samp{-mieee-conformant},
4886 @samp{-mfp-trap-mode=sui}, and @samp{-mtrap-precision=i}. On some Alpha
4887 implementations the resulting code may execute significantly slower than
4888 the code generated by default. Since there is very little code that
4889 depends on the @var{inexact flag}, you should normally not specify this
4890 option. Other Alpha compilers call this option
4891 @samp{-ieee_with_inexact}.
4893 @c changed paragraph
4894 This is like @samp{-mieee} except the generated code also maintains the
4895 IEEE @var{inexact flag}. Turning on this option causes the generated
4896 code to implement fully-compliant IEEE math. The option is a shorthand
4897 for @samp{-D_IEEE_FP -D_IEEE_FP_INEXACT} plus the three following:
4898 @samp{-mieee-conformant},
4899 @samp{-mfp-trap-mode=sui},
4900 and @samp{-mtrap-precision=i}.
4901 On some Alpha implementations the resulting code may execute
4902 significantly slower than the code generated by default. Since there
4903 is very little code that depends on the @var{inexact flag}, you should
4904 normally not specify this option. Other Alpha compilers call this
4905 option @samp{-ieee_with_inexact}.
4906 @c end changes to prevent overfull hboxes
4908 @item -mfp-trap-mode=@var{trap mode}
4909 This option controls what floating-point related traps are enabled.
4910 Other Alpha compilers call this option @samp{-fptm }@var{trap mode}.
4911 The trap mode can be set to one of four values:
4915 This is the default (normal) setting. The only traps that are enabled
4916 are the ones that cannot be disabled in software (e.g., division by zero
4920 In addition to the traps enabled by @samp{n}, underflow traps are enabled
4924 Like @samp{su}, but the instructions are marked to be safe for software
4925 completion (see Alpha architecture manual for details).
4928 Like @samp{su}, but inexact traps are enabled as well.
4931 @item -mfp-rounding-mode=@var{rounding mode}
4932 Selects the IEEE rounding mode. Other Alpha compilers call this option
4933 @samp{-fprm }@var{rounding mode}. The @var{rounding mode} can be one
4938 Normal IEEE rounding mode. Floating point numbers are rounded towards
4939 the nearest machine number or towards the even machine number in case
4943 Round towards minus infinity.
4946 Chopped rounding mode. Floating point numbers are rounded towards zero.
4949 Dynamic rounding mode. A field in the floating point control register
4950 (@var{fpcr}, see Alpha architecture reference manual) controls the
4951 rounding mode in effect. The C library initializes this register for
4952 rounding towards plus infinity. Thus, unless your program modifies the
4953 @var{fpcr}, @samp{d} corresponds to round towards plus infinity.@end table
4955 @item -mtrap-precision=@var{trap precision}
4956 In the Alpha architecture, floating point traps are imprecise. This
4957 means without software assistance it is impossible to recover from a
4958 floating trap and program execution normally needs to be terminated.
4959 GNU CC can generate code that can assist operating system trap handlers
4960 in determining the exact location that caused a floating point trap.
4961 Depending on the requirements of an application, different levels of
4962 precisions can be selected:
4966 Program precision. This option is the default and means a trap handler
4967 can only identify which program caused a floating point exception.
4970 Function precision. The trap handler can determine the function that
4971 caused a floating point exception.
4974 Instruction precision. The trap handler can determine the exact
4975 instruction that caused a floating point exception.
4978 Other Alpha compilers provide the equivalent options called
4979 @samp{-scope_safe} and @samp{-resumption_safe}.
4981 @item -mieee-conformant
4982 This option marks the generated code as IEEE conformant. You must not
4983 use this option unless you also specify @samp{-mtrap-precision=i} and either
4984 @samp{-mfp-trap-mode=su} or @samp{-mfp-trap-mode=sui}. Its only effect
4985 is to emit the line @samp{.eflag 48} in the function prologue of the
4986 generated assembly file. Under DEC Unix, this has the effect that
4987 IEEE-conformant math library routines will be linked in.
4989 @item -mbuild-constants
4990 Normally GNU CC examines a 32- or 64-bit integer constant to
4991 see if it can construct it from smaller constants in two or three
4992 instructions. If it cannot, it will output the constant as a literal and
4993 generate code to load it from the data segement at runtime.
4995 Use this option to require GNU CC to construct @emph{all} integer constants
4996 using code, even if it takes more instructions (the maximum is six).
4998 You would typically use this option to build a shared library dynamic
4999 loader. Itself a shared library, it must relocate itself in memory
5000 before it can find the variables and constants in its own data segment.
5003 @node Clipper Options
5004 @subsection Clipper Options
5006 These @samp{-m} options are defined for the Clipper implementations:
5010 Produce code for a C300 Clipper processor. This is the default.
5013 Produce code for a C400 Clipper processor i.e. use floating point
5017 @node H8/300 Options
5018 @subsection H8/300 Options
5020 These @samp{-m} options are defined for the H8/300 implementations:
5024 Shorten some address references at link time, when possible; uses the
5025 linker option @samp{-relax}. @xref{H8/300,, @code{ld} and the H8/300,
5026 ld.info, Using ld}, for a fuller description.
5029 Generate code for the H8/300H.
5032 Generate code for the H8/S.
5035 Make @code{int} data 32 bits by default.
5038 On the h8/300h, use the same alignment rules as for the h8/300.
5039 The default for the h8/300h is to align longs and floats on 4 byte boundaries.
5040 @samp{-malign-300} causes them to be aligned on 2 byte boundaries.
5041 This option has no effect on the h8/300.
5045 @subsection SH Options
5047 These @samp{-m} options are defined for the SH implementations:
5051 Generate code for the SH1.
5054 Generate code for the SH2.
5057 Generate code for the SH3.
5060 Generate code for the SH3e.
5063 Compile code for the processor in big endian mode.
5066 Compile code for the processor in little endian mode.
5069 Shorten some address references at link time, when possible; uses the
5070 linker option @samp{-relax}.
5073 @node System V Options
5074 @subsection Options for System V
5076 These additional options are available on System V Release 4 for
5077 compatibility with other compilers on those systems:
5081 Create a shared object.
5082 It is recommended that @samp{-symbolic} or @samp{-shared} be used instead.
5085 Identify the versions of each tool used by the compiler, in a
5086 @code{.ident} assembler directive in the output.
5089 Refrain from adding @code{.ident} directives to the output file (this is
5092 @item -YP,@var{dirs}
5093 Search the directories @var{dirs}, and no others, for libraries
5094 specified with @samp{-l}.
5097 Look in the directory @var{dir} to find the M4 preprocessor.
5098 The assembler uses this option.
5099 @c This is supposed to go with a -Yd for predefined M4 macro files, but
5100 @c the generic assembler that comes with Solaris takes just -Ym.
5104 @subsection V850 Options
5105 @cindex V850 Options
5107 These @samp{-m} options are defined for V850 implementations:
5111 @itemx -mno-long-calls
5112 Treat all calls as being far away (near). If calls are assumed to be
5113 far away, the compiler will always load the functions address up into a
5114 register, and call indirect through the pointer.
5118 Do not optimize (do optimize) basic blocks that use the same index
5119 pointer 4 or more times to copy pointer into the @code{ep} register, and
5120 use the shorter @code{sld} and @code{sst} instructions. The @samp{-mep}
5121 option is on by default if you optimize.
5123 @item -mno-prolog-function
5124 @itemx -mprolog-function
5125 Do not use (do use) external functions to save and restore registers at
5126 the prolog and epilog of a function. The external functions are slower,
5127 but use less code space if more than one function saves the same number
5128 of registers. The @samp{-mprolog-function} option is on by default if
5132 Try to make the code as small as possible. At present, this just turns
5133 on the @samp{-mep} and @samp{-mprolog-function} options.
5136 Put static or global variables whose size is @var{n} bytes or less into
5137 the tiny data area that register @code{ep} points to. The tiny data
5138 area can hold up to 256 bytes in total (128 bytes for byte references).
5141 Put static or global variables whose size is @var{n} bytes or less into
5142 the small data area that register @code{gp} points to. The small data
5143 area can hold up to 64 kilobytes.
5146 Put static or global variables whose size is @var{n} bytes or less into
5147 the first 32 kilobytes of memory.
5150 Specify that the target processor is the V850.
5153 Generate code suitable for big switch tables. Use this option only if
5154 the assembler/linker complain about out of range branches within a switch
5158 @node Code Gen Options
5159 @section Options for Code Generation Conventions
5160 @cindex code generation conventions
5161 @cindex options, code generation
5162 @cindex run-time options
5164 These machine-independent options control the interface conventions
5165 used in code generation.
5167 Most of them have both positive and negative forms; the negative form
5168 of @samp{-ffoo} would be @samp{-fno-foo}. In the table below, only
5169 one of the forms is listed---the one which is not the default. You
5170 can figure out the other form by either removing @samp{no-} or adding
5174 @item -fpcc-struct-return
5175 Return ``short'' @code{struct} and @code{union} values in memory like
5176 longer ones, rather than in registers. This convention is less
5177 efficient, but it has the advantage of allowing intercallability between
5178 GNU CC-compiled files and files compiled with other compilers.
5180 The precise convention for returning structures in memory depends
5181 on the target configuration macros.
5183 Short structures and unions are those whose size and alignment match
5184 that of some integer type.
5186 @item -freg-struct-return
5187 Use the convention that @code{struct} and @code{union} values are
5188 returned in registers when possible. This is more efficient for small
5189 structures than @samp{-fpcc-struct-return}.
5191 If you specify neither @samp{-fpcc-struct-return} nor its contrary
5192 @samp{-freg-struct-return}, GNU CC defaults to whichever convention is
5193 standard for the target. If there is no standard convention, GNU CC
5194 defaults to @samp{-fpcc-struct-return}, except on targets where GNU CC
5195 is the principal compiler. In those cases, we can choose the standard,
5196 and we chose the more efficient register return alternative.
5199 Allocate to an @code{enum} type only as many bytes as it needs for the
5200 declared range of possible values. Specifically, the @code{enum} type
5201 will be equivalent to the smallest integer type which has enough room.
5203 @item -fshort-double
5204 Use the same size for @code{double} as for @code{float}.
5207 Requests that the data and non-@code{const} variables of this
5208 compilation be shared data rather than private data. The distinction
5209 makes sense only on certain operating systems, where shared data is
5210 shared between processes running the same program, while private data
5211 exists in one copy per process.
5214 Allocate even uninitialized global variables in the bss section of the
5215 object file, rather than generating them as common blocks. This has the
5216 effect that if the same variable is declared (without @code{extern}) in
5217 two different compilations, you will get an error when you link them.
5218 The only reason this might be useful is if you wish to verify that the
5219 program will work on other systems which always work this way.
5222 Ignore the @samp{#ident} directive.
5224 @item -fno-gnu-linker
5225 Do not output global initializations (such as C++ constructors and
5226 destructors) in the form used by the GNU linker (on systems where the GNU
5227 linker is the standard method of handling them). Use this option when
5228 you want to use a non-GNU linker, which also requires using the
5229 @code{collect2} program to make sure the system linker includes
5230 constructors and destructors. (@code{collect2} is included in the GNU CC
5231 distribution.) For systems which @emph{must} use @code{collect2}, the
5232 compiler driver @code{gcc} is configured to do this automatically.
5234 @item -finhibit-size-directive
5235 Don't output a @code{.size} assembler directive, or anything else that
5236 would cause trouble if the function is split in the middle, and the
5237 two halves are placed at locations far apart in memory. This option is
5238 used when compiling @file{crtstuff.c}; you should not need to use it
5242 Put extra commentary information in the generated assembly code to
5243 make it more readable. This option is generally only of use to those
5244 who actually need to read the generated assembly code (perhaps while
5245 debugging the compiler itself).
5247 @samp{-fverbose-asm} is the default. @samp{-fno-verbose-asm} causes the
5248 extra information to be omitted and is useful when comparing two assembler
5252 Consider all memory references through pointers to be volatile.
5254 @item -fvolatile-global
5255 Consider all memory references to extern and global data items to
5259 @cindex global offset table
5261 Generate position-independent code (PIC) suitable for use in a shared
5262 library, if supported for the target machine. Such code accesses all
5263 constant addresses through a global offset table (GOT). The dynamic
5264 loader resolves the GOT entries when the program starts (the dynamic
5265 loader is not part of GNU CC; it is part of the operating system). If
5266 the GOT size for the linked executable exceeds a machine-specific
5267 maximum size, you get an error message from the linker indicating that
5268 @samp{-fpic} does not work; in that case, recompile with @samp{-fPIC}
5269 instead. (These maximums are 16k on the m88k, 8k on the Sparc, and 32k
5270 on the m68k and RS/6000. The 386 has no such limit.)
5272 Position-independent code requires special support, and therefore works
5273 only on certain machines. For the 386, GNU CC supports PIC for System V
5274 but not for the Sun 386i. Code generated for the IBM RS/6000 is always
5275 position-independent.
5278 If supported for the target machine, emit position-independent code,
5279 suitable for dynamic linking and avoiding any limit on the size of the
5280 global offset table. This option makes a difference on the m68k, m88k,
5283 Position-independent code requires special support, and therefore works
5284 only on certain machines.
5286 @item -ffixed-@var{reg}
5287 Treat the register named @var{reg} as a fixed register; generated code
5288 should never refer to it (except perhaps as a stack pointer, frame
5289 pointer or in some other fixed role).
5291 @var{reg} must be the name of a register. The register names accepted
5292 are machine-specific and are defined in the @code{REGISTER_NAMES}
5293 macro in the machine description macro file.
5295 This flag does not have a negative form, because it specifies a
5298 @item -fcall-used-@var{reg}
5299 Treat the register named @var{reg} as an allocatable register that is
5300 clobbered by function calls. It may be allocated for temporaries or
5301 variables that do not live across a call. Functions compiled this way
5302 will not save and restore the register @var{reg}.
5304 Use of this flag for a register that has a fixed pervasive role in the
5305 machine's execution model, such as the stack pointer or frame pointer,
5306 will produce disastrous results.
5308 This flag does not have a negative form, because it specifies a
5311 @item -fcall-saved-@var{reg}
5312 Treat the register named @var{reg} as an allocatable register saved by
5313 functions. It may be allocated even for temporaries or variables that
5314 live across a call. Functions compiled this way will save and restore
5315 the register @var{reg} if they use it.
5317 Use of this flag for a register that has a fixed pervasive role in the
5318 machine's execution model, such as the stack pointer or frame pointer,
5319 will produce disastrous results.
5321 A different sort of disaster will result from the use of this flag for
5322 a register in which function values may be returned.
5324 This flag does not have a negative form, because it specifies a
5328 Pack all structure members together without holes. Usually you would
5329 not want to use this option, since it makes the code suboptimal, and
5330 the offsets of structure members won't agree with system libraries.
5332 @item -fcheck-memory-usage
5333 Generate extra code to check each memory access. GNU CC will generate
5334 code that is suitable for a detector of bad memory accesses such as
5335 @file{Checker}. If you specify this option, you can not use the
5336 @code{asm} or @code{__asm__} keywords.
5338 You must also specify this option when you compile functions you call that
5339 have side effects. If you do not, you may get erronous messages from
5340 the detector. Normally, you should compile all your code with this option.
5341 If you use functions from a library that have side-effects (such as
5342 @code{read}), you may not be able to recompile the library and
5343 specify this option. In that case, you can enable the
5344 @samp{-fprefix-function-name} option, which requests GNU CC to encapsulate
5345 your code and make other functions look as if they were compiled with
5346 @samp{-fcheck-memory-usage}. This is done by calling ``stubs'',
5347 which are provided by the detector. If you cannot find or build
5348 stubs for every function you call, you may have to specify
5349 @samp{-fcheck-memory-usage} without @samp{-fprefix-function-name}.
5351 @item -fprefix-function-name
5352 Request GNU CC to add a prefix to the symbols generated for function names.
5353 GNU CC adds a prefix to the names of functions defined as well as
5354 functions called. Code compiled with this option and code compiled
5355 without the option can't be linked together, unless or stubs are used.
5357 If you compile the following code with @samp{-fprefix-function-name}
5359 extern void bar (int);
5369 GNU CC will compile the code as if it was written:
5371 extern void prefix_bar (int);
5375 return prefix_bar (a + 5);
5378 This option is designed to be used with @samp{-fcheck-memory-usage}.
5381 Generate code to verify that you do not go beyond the boundary of the
5382 stack. You should specify this flag if you are running in an
5383 environment with multiple threads, but only rarely need to specify it in
5384 a single-threaded environment since stack overflow is automatically
5385 detected on nearly all systems if there is only one stack.
5389 Control whether virtual function definitions in classes are used to
5390 generate code, or only to define interfaces for their callers. (C++
5393 These options are provided for compatibility with @code{cfront} 1.x
5394 usage; the recommended alternative GNU C++ usage is in flux. @xref{C++
5395 Interface,,Declarations and Definitions in One Header}.
5397 With @samp{+e0}, virtual function definitions in classes are declared
5398 @code{extern}; the declaration is used only as an interface
5399 specification, not to generate code for the virtual functions (in this
5402 With @samp{+e1}, G++ actually generates the code implementing virtual
5403 functions defined in the code, and makes them publicly visible.
5405 @cindex aliasing of parameters
5406 @cindex parameters, aliased
5407 @item -fargument-alias
5408 @item -fargument-noalias
5409 @item -fargument-noalias-global
5410 Specify the possible relationships among parameters and between
5411 parameters and global data.
5413 @samp{-fargument-alias} specifies that arguments (parameters) may
5414 alias each other and may alias global storage.
5415 @samp{-fargument-noalias} specifies that arguments do not alias
5416 each other, but may alias global storage.
5417 @samp{-fargument-noalias-global} specifies that arguments do not
5418 alias each other and do not alias global storage.
5420 Each language will automatically use whatever option is required by
5421 the language standard. You should not need to use these options yourself.
5424 @node Environment Variables
5425 @section Environment Variables Affecting GNU CC
5426 @cindex environment variables
5428 This section describes several environment variables that affect how GNU
5429 CC operates. They work by specifying directories or prefixes to use
5430 when searching for various kinds of files.
5433 Note that you can also specify places to search using options such as
5434 @samp{-B}, @samp{-I} and @samp{-L} (@pxref{Directory Options}). These
5435 take precedence over places specified using environment variables, which
5436 in turn take precedence over those specified by the configuration of GNU
5440 Note that you can also specify places to search using options such as
5441 @samp{-B}, @samp{-I} and @samp{-L} (@pxref{Directory Options}). These
5442 take precedence over places specified using environment variables, which
5443 in turn take precedence over those specified by the configuration of GNU
5450 If @code{TMPDIR} is set, it specifies the directory to use for temporary
5451 files. GNU CC uses temporary files to hold the output of one stage of
5452 compilation which is to be used as input to the next stage: for example,
5453 the output of the preprocessor, which is the input to the compiler
5456 @item GCC_EXEC_PREFIX
5457 @findex GCC_EXEC_PREFIX
5458 If @code{GCC_EXEC_PREFIX} is set, it specifies a prefix to use in the
5459 names of the subprograms executed by the compiler. No slash is added
5460 when this prefix is combined with the name of a subprogram, but you can
5461 specify a prefix that ends with a slash if you wish.
5463 If GNU CC cannot find the subprogram using the specified prefix, it
5464 tries looking in the usual places for the subprogram.
5466 The default value of @code{GCC_EXEC_PREFIX} is
5467 @file{@var{prefix}/lib/gcc-lib/} where @var{prefix} is the value
5468 of @code{prefix} when you ran the @file{configure} script.
5470 Other prefixes specified with @samp{-B} take precedence over this prefix.
5472 This prefix is also used for finding files such as @file{crt0.o} that are
5475 In addition, the prefix is used in an unusual way in finding the
5476 directories to search for header files. For each of the standard
5477 directories whose name normally begins with @samp{/usr/local/lib/gcc-lib}
5478 (more precisely, with the value of @code{GCC_INCLUDE_DIR}), GNU CC tries
5479 replacing that beginning with the specified prefix to produce an
5480 alternate directory name. Thus, with @samp{-Bfoo/}, GNU CC will search
5481 @file{foo/bar} where it would normally search @file{/usr/local/lib/bar}.
5482 These alternate directories are searched first; the standard directories
5486 @findex COMPILER_PATH
5487 The value of @code{COMPILER_PATH} is a colon-separated list of
5488 directories, much like @code{PATH}. GNU CC tries the directories thus
5489 specified when searching for subprograms, if it can't find the
5490 subprograms using @code{GCC_EXEC_PREFIX}.
5493 @findex LIBRARY_PATH
5494 The value of @code{LIBRARY_PATH} is a colon-separated list of
5495 directories, much like @code{PATH}. When configured as a native compiler,
5496 GNU CC tries the directories thus specified when searching for special
5497 linker files, if it can't find them using @code{GCC_EXEC_PREFIX}. Linking
5498 using GNU CC also uses these directories when searching for ordinary
5499 libraries for the @samp{-l} option (but directories specified with
5500 @samp{-L} come first).
5502 @item C_INCLUDE_PATH
5503 @itemx CPLUS_INCLUDE_PATH
5504 @itemx OBJC_INCLUDE_PATH
5505 @findex C_INCLUDE_PATH
5506 @findex CPLUS_INCLUDE_PATH
5507 @findex OBJC_INCLUDE_PATH
5508 @c @itemx OBJCPLUS_INCLUDE_PATH
5509 These environment variables pertain to particular languages. Each
5510 variable's value is a colon-separated list of directories, much like
5511 @code{PATH}. When GNU CC searches for header files, it tries the
5512 directories listed in the variable for the language you are using, after
5513 the directories specified with @samp{-I} but before the standard header
5516 @item DEPENDENCIES_OUTPUT
5517 @findex DEPENDENCIES_OUTPUT
5518 @cindex dependencies for make as output
5519 If this variable is set, its value specifies how to output dependencies
5520 for Make based on the header files processed by the compiler. This
5521 output looks much like the output from the @samp{-M} option
5522 (@pxref{Preprocessor Options}), but it goes to a separate file, and is
5523 in addition to the usual results of compilation.
5525 The value of @code{DEPENDENCIES_OUTPUT} can be just a file name, in
5526 which case the Make rules are written to that file, guessing the target
5527 name from the source file name. Or the value can have the form
5528 @samp{@var{file} @var{target}}, in which case the rules are written to
5529 file @var{file} using @var{target} as the target name.
5532 @node Running Protoize
5533 @section Running Protoize
5535 The program @code{protoize} is an optional part of GNU C. You can use
5536 it to add prototypes to a program, thus converting the program to ANSI
5537 C in one respect. The companion program @code{unprotoize} does the
5538 reverse: it removes argument types from any prototypes that are found.
5540 When you run these programs, you must specify a set of source files as
5541 command line arguments. The conversion programs start out by compiling
5542 these files to see what functions they define. The information gathered
5543 about a file @var{foo} is saved in a file named @file{@var{foo}.X}.
5545 After scanning comes actual conversion. The specified files are all
5546 eligible to be converted; any files they include (whether sources or
5547 just headers) are eligible as well.
5549 But not all the eligible files are converted. By default,
5550 @code{protoize} and @code{unprotoize} convert only source and header
5551 files in the current directory. You can specify additional directories
5552 whose files should be converted with the @samp{-d @var{directory}}
5553 option. You can also specify particular files to exclude with the
5554 @samp{-x @var{file}} option. A file is converted if it is eligible, its
5555 directory name matches one of the specified directory names, and its
5556 name within the directory has not been excluded.
5558 Basic conversion with @code{protoize} consists of rewriting most
5559 function definitions and function declarations to specify the types of
5560 the arguments. The only ones not rewritten are those for varargs
5563 @code{protoize} optionally inserts prototype declarations at the
5564 beginning of the source file, to make them available for any calls that
5565 precede the function's definition. Or it can insert prototype
5566 declarations with block scope in the blocks where undeclared functions
5569 Basic conversion with @code{unprotoize} consists of rewriting most
5570 function declarations to remove any argument types, and rewriting
5571 function definitions to the old-style pre-ANSI form.
5573 Both conversion programs print a warning for any function declaration or
5574 definition that they can't convert. You can suppress these warnings
5577 The output from @code{protoize} or @code{unprotoize} replaces the
5578 original source file. The original file is renamed to a name ending
5579 with @samp{.save}. If the @samp{.save} file already exists, then
5580 the source file is simply discarded.
5582 @code{protoize} and @code{unprotoize} both depend on GNU CC itself to
5583 scan the program and collect information about the functions it uses.
5584 So neither of these programs will work until GNU CC is installed.
5586 Here is a table of the options you can use with @code{protoize} and
5587 @code{unprotoize}. Each option works with both programs unless
5591 @item -B @var{directory}
5592 Look for the file @file{SYSCALLS.c.X} in @var{directory}, instead of the
5593 usual directory (normally @file{/usr/local/lib}). This file contains
5594 prototype information about standard system functions. This option
5595 applies only to @code{protoize}.
5597 @item -c @var{compilation-options}
5598 Use @var{compilation-options} as the options when running @code{gcc} to
5599 produce the @samp{.X} files. The special option @samp{-aux-info} is
5600 always passed in addition, to tell @code{gcc} to write a @samp{.X} file.
5602 Note that the compilation options must be given as a single argument to
5603 @code{protoize} or @code{unprotoize}. If you want to specify several
5604 @code{gcc} options, you must quote the entire set of compilation options
5605 to make them a single word in the shell.
5607 There are certain @code{gcc} arguments that you cannot use, because they
5608 would produce the wrong kind of output. These include @samp{-g},
5609 @samp{-O}, @samp{-c}, @samp{-S}, and @samp{-o} If you include these in
5610 the @var{compilation-options}, they are ignored.
5613 Rename files to end in @samp{.C} instead of @samp{.c}.
5614 This is convenient if you are converting a C program to C++.
5615 This option applies only to @code{protoize}.
5618 Add explicit global declarations. This means inserting explicit
5619 declarations at the beginning of each source file for each function
5620 that is called in the file and was not declared. These declarations
5621 precede the first function definition that contains a call to an
5622 undeclared function. This option applies only to @code{protoize}.
5624 @item -i @var{string}
5625 Indent old-style parameter declarations with the string @var{string}.
5626 This option applies only to @code{protoize}.
5628 @code{unprotoize} converts prototyped function definitions to old-style
5629 function definitions, where the arguments are declared between the
5630 argument list and the initial @samp{@{}. By default, @code{unprotoize}
5631 uses five spaces as the indentation. If you want to indent with just
5632 one space instead, use @samp{-i " "}.
5635 Keep the @samp{.X} files. Normally, they are deleted after conversion
5639 Add explicit local declarations. @code{protoize} with @samp{-l} inserts
5640 a prototype declaration for each function in each block which calls the
5641 function without any declaration. This option applies only to
5645 Make no real changes. This mode just prints information about the conversions
5646 that would have been done without @samp{-n}.
5649 Make no @samp{.save} files. The original files are simply deleted.
5650 Use this option with caution.
5652 @item -p @var{program}
5653 Use the program @var{program} as the compiler. Normally, the name
5657 Work quietly. Most warnings are suppressed.
5660 Print the version number, just like @samp{-v} for @code{gcc}.
5663 If you need special compiler options to compile one of your program's
5664 source files, then you should generate that file's @samp{.X} file
5665 specially, by running @code{gcc} on that source file with the
5666 appropriate options and the option @samp{-aux-info}. Then run
5667 @code{protoize} on the entire set of files. @code{protoize} will use
5668 the existing @samp{.X} file because it is newer than the source file.
5672 gcc -Dfoo=bar file1.c -aux-info
5677 You need to include the special files along with the rest in the
5678 @code{protoize} command, even though their @samp{.X} files already
5679 exist, because otherwise they won't get converted.
5681 @xref{Protoize Caveats}, for more information on how to use
5682 @code{protoize} successfully.