1 @c Copyright (C) 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000 Free Software Foundation, Inc.
2 @c This is part of the GCC manual.
3 @c For copying conditions, see the file gcc.texi.
7 Copyright @copyright{} 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997,
8 1998, 1999, 2000 Free Software Foundation, Inc.
10 Permission is granted to make and distribute verbatim copies of this
11 manual provided the copyright notice and this permission notice are
12 preserved on all copies.
14 Permission is granted to copy and distribute modified versions of this
15 manual under the conditions for verbatim copying, provided also that the
16 entire resulting derived work is distributed under the terms of a
17 permission notice identical to this one.
19 Permission is granted to copy and distribute translations of this manual
20 into another language, under the above conditions for modified versions,
21 except that this permission notice may be included in translations
22 approved by the Free Software Foundation instead of in the original
25 @c Set file name and title for the man page.
27 @settitle GNU project C and C++ compiler
29 gcc [@samp{-c}|@samp{-S}|@samp{-E}] [@samp{-std=}@var{standard}]
30 [@samp{-g}] [@samp{-pg}] [@samp{-O}@var{level}]
31 [@samp{-W}@var{warn}...] [@samp{-pedantic}]
32 [@samp{-I}@var{dir}...] [@samp{-L}@var{dir}...]
33 [@samp{-D}@var{macro}[=@var{defn}]...] [@samp{-U}@var{macro}]
34 [@samp{-f}@var{option}...] [@samp{-m}@var{machine-option}...]
35 [@samp{-o} @var{outfile}] @var{infile}...
37 Only the most useful options are listed here; see below for the
38 remainder. @samp{g++} accepts mostly the same options as @samp{gcc}.
41 cpp(1), gcov(1), g77(1), as(1), ld(1), gdb(1), adb(1), dbx(1), sdb(1)
42 and the Info entries for @file{gcc}, @file{cpp}, @file{g77}, @file{as},
43 @file{ld}, @file{binutils} and @file{gdb}.
48 @chapter GCC Command Options
49 @cindex GCC command options
50 @cindex command options
51 @cindex options, GCC command
53 @c man begin DESCRIPTION
55 When you invoke GCC, it normally does preprocessing, compilation,
56 assembly and linking. The ``overall options'' allow you to stop this
57 process at an intermediate stage. For example, the @samp{-c} option
58 says not to run the linker. Then the output consists of object files
59 output by the assembler.
61 Other options are passed on to one stage of processing. Some options
62 control the preprocessor and others the compiler itself. Yet other
63 options control the assembler and linker; most of these are not
64 documented here, since you rarely need to use any of them.
66 @cindex C compilation options
67 Most of the command line options that you can use with GCC are useful
68 for C programs; when an option is only useful with another language
69 (usually C++), the explanation says so explicitly. If the description
70 for a particular option does not mention a source language, you can use
71 that option with all supported languages.
73 @cindex C++ compilation options
74 @xref{Invoking G++,,Compiling C++ Programs}, for a summary of special
75 options for compiling C++ programs.
77 @cindex grouping options
78 @cindex options, grouping
79 The @code{gcc} program accepts options and file names as operands. Many
80 options have multi-letter names; therefore multiple single-letter options
81 may @emph{not} be grouped: @samp{-dr} is very different from @w{@samp{-d
84 @cindex order of options
85 @cindex options, order
86 You can mix options and other arguments. For the most part, the order
87 you use doesn't matter. Order does matter when you use several options
88 of the same kind; for example, if you specify @samp{-L} more than once,
89 the directories are searched in the order specified.
91 Many options have long names starting with @samp{-f} or with
92 @samp{-W}---for example, @samp{-fforce-mem},
93 @samp{-fstrength-reduce}, @samp{-Wformat} and so on. Most of
94 these have both positive and negative forms; the negative form of
95 @samp{-ffoo} would be @samp{-fno-foo}. This manual documents
96 only one of these two forms, whichever one is not the default.
101 * Option Summary:: Brief list of all options, without explanations.
102 * Overall Options:: Controlling the kind of output:
103 an executable, object files, assembler files,
104 or preprocessed source.
105 * Invoking G++:: Compiling C++ programs.
106 * C Dialect Options:: Controlling the variant of C language compiled.
107 * C++ Dialect Options:: Variations on C++.
108 * Language Independent Options:: Controlling how diagnostics should be
110 * Warning Options:: How picky should the compiler be?
111 * Debugging Options:: Symbol tables, measurements, and debugging dumps.
112 * Optimize Options:: How much optimization?
113 * Preprocessor Options:: Controlling header files and macro definitions.
114 Also, getting dependency information for Make.
115 * Assembler Options:: Passing options to the assembler.
116 * Link Options:: Specifying libraries and so on.
117 * Directory Options:: Where to find header files and libraries.
118 Where to find the compiler executable files.
119 * Spec Files:: How to pass switches to sub-processes.
120 * Target Options:: Running a cross-compiler, or an old version of GCC.
121 * Submodel Options:: Specifying minor hardware or convention variations,
122 such as 68010 vs 68020.
123 * Code Gen Options:: Specifying conventions for function calls, data layout
125 * Environment Variables:: Env vars that affect GCC.
126 * Running Protoize:: Automatically adding or removing function prototypes.
130 @section Option Summary
132 Here is a summary of all the options, grouped by type. Explanations are
133 in the following sections.
136 @item Overall Options
137 @xref{Overall Options,,Options Controlling the Kind of Output}.
139 -c -S -E -o @var{file} -pipe -pass-exit-codes -x @var{language}
140 -v --target-help --help
143 @item C Language Options
144 @xref{C Dialect Options,,Options Controlling C Dialect}.
146 -ansi -std=@var{standard} -fno-asm -fno-builtin
147 -fhosted -ffreestanding
148 -trigraphs -traditional -traditional-cpp
149 -fallow-single-precision -fcond-mismatch
150 -fsigned-bitfields -fsigned-char
151 -funsigned-bitfields -funsigned-char
152 -fwritable-strings -fshort-wchar
155 @item C++ Language Options
156 @xref{C++ Dialect Options,,Options Controlling C++ Dialect}.
158 -fno-access-control -fcheck-new -fconserve-space
159 -fdollars-in-identifiers -fno-elide-constructors
160 -fno-enforce-eh-specs -fexternal-templates
161 -falt-external-templates
162 -ffor-scope -fno-for-scope -fno-gnu-keywords -fhonor-std
163 -fhuge-objects -fno-implicit-templates
164 -fno-implicit-inline-templates -finit-priority
165 -fno-implement-inlines -fms-extensions
166 -fname-mangling-version-@var{n} -fno-operator-names
167 -fno-optional-diags -fpermissive
168 -frepo -fno-rtti -fsquangle -ftemplate-depth-@var{n}
169 -fuse-cxa-atexit -fvtable-thunks -nostdinc++
170 -fno-default-inline -Wctor-dtor-privacy
171 -Wnon-virtual-dtor -Wreorder
172 -Weffc++ -Wno-deprecated
173 -Wno-non-template-friend -Wold-style-cast
174 -Woverloaded-virtual -Wno-pmf-conversions
178 @item Language Independent Options
179 @xref{Language Independent Options,,Options to Control Diagnostic Messages Formatting}.
181 -fmessage-length=@var{n}
182 -fdiagnostics-show-location=@r{[}once@r{|}every-line@r{]}
185 @item Warning Options
186 @xref{Warning Options,,Options to Request or Suppress Warnings}.
188 -fsyntax-only -pedantic -pedantic-errors
189 -w -W -Wall -Waggregate-return
190 -Wcast-align -Wcast-qual -Wchar-subscripts -Wcomment
191 -Wconversion -Wdisabled-optimization -Werror
192 -Wfloat-equal -Wformat -Wformat=2
194 -Wid-clash-@var{len} -Wimplicit -Wimplicit-int
195 -Wimplicit-function-declaration
196 -Werror-implicit-function-declaration
198 -Wlarger-than-@var{len} -Wlong-long
199 -Wmain -Wmissing-declarations
200 -Wmissing-format-attribute -Wmissing-noreturn
201 -Wmultichar -Wno-format-extra-args -Wno-format-y2k
202 -Wno-import -Wpacked -Wpadded
203 -Wparentheses -Wpointer-arith -Wredundant-decls
204 -Wreturn-type -Wsequence-point -Wshadow
205 -Wsign-compare -Wswitch -Wsystem-headers
206 -Wtrigraphs -Wundef -Wuninitialized
207 -Wunknown-pragmas -Wunreachable-code
208 -Wunused -Wunused-function -Wunused-label -Wunused-parameter
209 -Wunused-value -Wunused-variable -Wwrite-strings
212 @item C-only Warning Options
214 -Wbad-function-cast -Wmissing-prototypes -Wnested-externs
215 -Wstrict-prototypes -Wtraditional
218 @item Debugging Options
219 @xref{Debugging Options,,Options for Debugging Your Program or GCC}.
221 -a -ax -d@var{letters} -fdump-unnumbered -fdump-translation-unit-@var{file}
222 -fpretend-float -fprofile-arcs -ftest-coverage
223 -g -g@var{level} -gcoff -gdwarf -gdwarf-1 -gdwarf-1+ -gdwarf-2
224 -ggdb -gstabs -gstabs+ -gxcoff -gxcoff+
225 -p -pg -print-file-name=@var{library} -print-libgcc-file-name
226 -print-prog-name=@var{program} -print-search-dirs -Q
230 @item Optimization Options
231 @xref{Optimize Options,,Options that Control Optimization}.
233 -falign-functions=@var{n} -falign-jumps=@var{n}
234 -falign-labels=@var{n} -falign-loops=@var{n}
235 -fbranch-probabilities -fcaller-saves
236 -fcse-follow-jumps -fcse-skip-blocks -fdata-sections -fdce
237 -fdelayed-branch -fdelete-null-pointer-checks
238 -fexpensive-optimizations -ffast-math -ffloat-store
239 -fforce-addr -fforce-mem -ffunction-sections -fgcse
240 -finline-functions -finline-limit=@var{n} -fkeep-inline-functions
241 -fkeep-static-consts -fmove-all-movables
242 -fno-default-inline -fno-defer-pop
243 -fno-function-cse -fno-inline -fno-math-errno -fno-peephole
244 -fomit-frame-pointer -foptimize-register-move
245 -foptimize-sibling-calls -freduce-all-givs
246 -fregmove -frename-registers
247 -frerun-cse-after-loop -frerun-loop-opt
248 -fschedule-insns -fschedule-insns2
249 -fsingle-precision-constant -fssa
250 -fstrength-reduce -fstrict-aliasing -fthread-jumps -ftrapv
251 -funroll-all-loops -funroll-loops
252 -O -O0 -O1 -O2 -O3 -Os
255 @item Preprocessor Options
256 @xref{Preprocessor Options,,Options Controlling the Preprocessor}.
258 -A@var{question}(@var{answer}) -C -dD -dM -dN
259 -D@var{macro}@r{[}=@var{defn}@r{]} -E -H
261 -include @var{file} -imacros @var{file}
262 -iprefix @var{file} -iwithprefix @var{dir}
263 -iwithprefixbefore @var{dir} -isystem @var{dir} -isystem-c++ @var{dir}
264 -M -MD -MM -MMD -MG -nostdinc -P -trigraphs
265 -undef -U@var{macro} -Wp,@var{option}
268 @item Assembler Option
269 @xref{Assembler Options,,Passing Options to the Assembler}.
275 @xref{Link Options,,Options for Linking}.
277 @var{object-file-name} -l@var{library}
278 -nostartfiles -nodefaultlibs -nostdlib
279 -s -static -shared -symbolic
280 -Wl,@var{option} -Xlinker @var{option}
284 @item Directory Options
285 @xref{Directory Options,,Options for Directory Search}.
287 -B@var{prefix} -I@var{dir} -I- -L@var{dir} -specs=@var{file}
291 @c I wrote this xref this way to avoid overfull hbox. -- rms
292 @xref{Target Options}.
294 -b @var{machine} -V @var{version}
297 @item Machine Dependent Options
298 @xref{Submodel Options,,Hardware Models and Configurations}.
300 @emph{M680x0 Options}
301 -m68000 -m68020 -m68020-40 -m68020-60 -m68030 -m68040
302 -m68060 -mcpu32 -m5200 -m68881 -mbitfield -mc68000 -mc68020
303 -mfpa -mnobitfield -mrtd -mshort -msoft-float -mpcrel
304 -malign-int -mstrict-align
306 @emph{M68hc1x Options}
307 -m6811 -m6812 -m68hc11 -m68hc12
308 -mauto-incdec -mshort -msoft-reg-count=@var{count}
315 -mtune=@var{cpu type}
316 -mcmodel=@var{code model}
318 -mapp-regs -mbroken-saverestore -mcypress
319 -mepilogue -mfaster-structs -mflat
320 -mfpu -mhard-float -mhard-quad-float
321 -mimpure-text -mlive-g0 -mno-app-regs
322 -mno-epilogue -mno-faster-structs -mno-flat -mno-fpu
323 -mno-impure-text -mno-stack-bias -mno-unaligned-doubles
324 -msoft-float -msoft-quad-float -msparclite -mstack-bias
325 -msupersparc -munaligned-doubles -mv8
327 @emph{Convex Options}
328 -mc1 -mc2 -mc32 -mc34 -mc38
329 -margcount -mnoargcount
331 -mvolatile-cache -mvolatile-nocache
333 @emph{AMD29K Options}
334 -m29000 -m29050 -mbw -mnbw -mdw -mndw
335 -mlarge -mnormal -msmall
336 -mkernel-registers -mno-reuse-arg-regs
337 -mno-stack-check -mno-storem-bug
338 -mreuse-arg-regs -msoft-float -mstack-check
339 -mstorem-bug -muser-registers
342 -mapcs-frame -mno-apcs-frame
344 -mapcs-stack-check -mno-apcs-stack-check
345 -mapcs-float -mno-apcs-float
346 -mapcs-reentrant -mno-apcs-reentrant
347 -msched-prolog -mno-sched-prolog
348 -mlittle-endian -mbig-endian -mwords-little-endian
349 -malignment-traps -mno-alignment-traps
350 -msoft-float -mhard-float -mfpe
351 -mthumb-interwork -mno-thumb-interwork
352 -mcpu= -march= -mfpe=
353 -mstructure-size-boundary=
354 -mbsd -mxopen -mno-symrename
356 -mlong-calls -mno-long-calls
357 -mnop-fun-dllimport -mno-nop-fun-dllimport
358 -msingle-pic-base -mno-single-pic-base
362 -mtpcs-frame -mno-tpcs-frame
363 -mtpcs-leaf-frame -mno-tpcs-leaf-frame
364 -mlittle-endian -mbig-endian
365 -mthumb-interwork -mno-thumb-interwork
366 -mstructure-size-boundary=
367 -mnop-fun-dllimport -mno-nop-fun-dllimport
368 -mcallee-super-interworking -mno-callee-super-interworking
369 -mcaller-super-interworking -mno-caller-super-interworking
370 -msingle-pic-base -mno-single-pic-base
373 @emph{MN10200 Options}
376 @emph{MN10300 Options}
383 @emph{M32R/D Options}
384 -mcode-model=@var{model type} -msdata=@var{sdata type}
388 -m88000 -m88100 -m88110 -mbig-pic
389 -mcheck-zero-division -mhandle-large-shift
390 -midentify-revision -mno-check-zero-division
391 -mno-ocs-debug-info -mno-ocs-frame-position
392 -mno-optimize-arg-area -mno-serialize-volatile
393 -mno-underscores -mocs-debug-info
394 -mocs-frame-position -moptimize-arg-area
395 -mserialize-volatile -mshort-data-@var{num} -msvr3
396 -msvr4 -mtrap-large-shift -muse-div-instruction
397 -mversion-03.00 -mwarn-passed-structs
399 @emph{RS/6000 and PowerPC Options}
401 -mtune=@var{cpu type}
402 -mpower -mno-power -mpower2 -mno-power2
403 -mpowerpc -mpowerpc64 -mno-powerpc
404 -mpowerpc-gpopt -mno-powerpc-gpopt
405 -mpowerpc-gfxopt -mno-powerpc-gfxopt
406 -mnew-mnemonics -mold-mnemonics
407 -mfull-toc -mminimal-toc -mno-fop-in-toc -mno-sum-in-toc
408 -m64 -m32 -mxl-call -mno-xl-call -mthreads -mpe
409 -msoft-float -mhard-float -mmultiple -mno-multiple
410 -mstring -mno-string -mupdate -mno-update
411 -mfused-madd -mno-fused-madd -mbit-align -mno-bit-align
412 -mstrict-align -mno-strict-align -mrelocatable
413 -mno-relocatable -mrelocatable-lib -mno-relocatable-lib
414 -mtoc -mno-toc -mlittle -mlittle-endian -mbig -mbig-endian
415 -mcall-aix -mcall-sysv -mprototype -mno-prototype
416 -msim -mmvme -mads -myellowknife -memb -msdata
417 -msdata=@var{opt} -mvxworks -G @var{num}
420 -mcall-lib-mul -mfp-arg-in-fpregs -mfp-arg-in-gregs
421 -mfull-fp-blocks -mhc-struct-return -min-line-mul
422 -mminimum-fp-blocks -mnohc-struct-return
425 -mabicalls -mcpu=@var{cpu type}
426 -membedded-data -muninit-const-in-rodata
427 -membedded-pic -mfp32 -mfp64 -mgas -mgp32 -mgp64
428 -mgpopt -mhalf-pic -mhard-float -mint64 -mips1
429 -mips2 -mips3 -mips4 -mlong64 -mlong32 -mlong-calls -mmemcpy
430 -mmips-as -mmips-tfile -mno-abicalls
431 -mno-embedded-data -mno-uninit-const-in-rodata -mno-embedded-pic
432 -mno-gpopt -mno-long-calls
433 -mno-memcpy -mno-mips-tfile -mno-rnames -mno-stats
434 -mrnames -msoft-float
435 -m4650 -msingle-float -mmad
436 -mstats -EL -EB -G @var{num} -nocpp
437 -mabi=32 -mabi=n32 -mabi=64 -mabi=eabi
441 -mcpu=@var{cpu type} -march=@var{cpu type}
442 -mintel-syntax -mieee-fp -mno-fancy-math-387
443 -mno-fp-ret-in-387 -msoft-float -msvr3-shlib
444 -mno-wide-multiply -mrtd -malign-double
445 -mreg-alloc=@var{list} -mregparm=@var{num}
446 -malign-jumps=@var{num} -malign-loops=@var{num}
447 -malign-functions=@var{num} -mpreferred-stack-boundary=@var{num}
448 -mthreads -mno-align-stringops -minline-all-stringops
449 -mpush-args -maccumulate-outgoing-args
452 -march=@var{architecture type}
453 -mbig-switch -mdisable-fpregs -mdisable-indexing
454 -mfast-indirect-calls -mgas -mjump-in-delay
455 -mlong-load-store -mno-big-switch -mno-disable-fpregs
456 -mno-disable-indexing -mno-fast-indirect-calls -mno-gas
457 -mno-jump-in-delay -mno-long-load-store
458 -mno-portable-runtime -mno-soft-float
459 -mno-space-regs -msoft-float -mpa-risc-1-0
460 -mpa-risc-1-1 -mpa-risc-2-0 -mportable-runtime
461 -mschedule=@var{cpu type} -mspace-regs
463 @emph{Intel 960 Options}
464 -m@var{cpu type} -masm-compat -mclean-linkage
465 -mcode-align -mcomplex-addr -mleaf-procedures
466 -mic-compat -mic2.0-compat -mic3.0-compat
467 -mintel-asm -mno-clean-linkage -mno-code-align
468 -mno-complex-addr -mno-leaf-procedures
469 -mno-old-align -mno-strict-align -mno-tail-call
470 -mnumerics -mold-align -msoft-float -mstrict-align
473 @emph{DEC Alpha Options}
474 -mfp-regs -mno-fp-regs -mno-soft-float -msoft-float
476 -mieee -mieee-with-inexact -mieee-conformant
477 -mfp-trap-mode=@var{mode} -mfp-rounding-mode=@var{mode}
478 -mtrap-precision=@var{mode} -mbuild-constants
480 -mbwx -mno-bwx -mcix -mno-cix -mmax -mno-max
481 -mmemory-latency=@var{time}
483 @emph{Clipper Options}
486 @emph{H8/300 Options}
487 -mrelax -mh -ms -mint32 -malign-300
491 -m4-nofpu -m4-single-only -m4-single -m4
492 -mb -ml -mdalign -mrelax
493 -mbigtable -mfmovd -mhitachi -mnomacsave
494 -misize -mpadstruct -mspace
498 @emph{System V Options}
499 -Qy -Qn -YP,@var{paths} -Ym,@var{dir}
503 -mmangle-cpu -mcpu=@var{cpu} -mtext=@var{text section}
504 -mdata=@var{data section} -mrodata=@var{readonly data section}
506 @emph{TMS320C3x/C4x Options}
507 -mcpu=@var{cpu} -mbig -msmall -mregparm -mmemparm
508 -mfast-fix -mmpyi -mbk -mti -mdp-isr-reload
509 -mrpts=@var{count} -mrptb -mdb -mloop-unsigned
510 -mparallel-insns -mparallel-mpy -mpreserve-float
513 -mlong-calls -mno-long-calls -mep -mno-ep
514 -mprolog-function -mno-prolog-function -mspace
515 -mtda=@var{n} -msda=@var{n} -mzda=@var{n}
519 -m32032 -m32332 -m32532 -m32081 -m32381 -mmult-add -mnomult-add
520 -msoft-float -mrtd -mnortd -mregparam -mnoregparam -msb -mnosb
521 -mbitfield -mnobitfield -mhimem -mnohimem
524 -mmcu=@var{mcu} -msize -minit-stack=@var{n} -mno-interrupts
525 -mcall-prologues -mno-tablejump -mtiny-stack
528 -mhardlit, -mno-hardlit -mdiv -mno-div -mrelax-immediates
529 -mno-relax-immediates -mwide-bitfields -mno-wide-bitfields
530 -m4byte-functions -mno-4byte-functions -mcallgraph-data
531 -mno-callgraph-data -mslow-bytes -mno-slow-bytes -mno-lsim
532 -mlittle-endian -mbig-endian -m210 -m340 -mstack-increment
535 @item Code Generation Options
536 @xref{Code Gen Options,,Options for Code Generation Conventions}.
538 -fcall-saved-@var{reg} -fcall-used-@var{reg}
539 -fexceptions -funwind-tables -ffixed-@var{reg}
540 -finhibit-size-directive -finstrument-functions
541 -fcheck-memory-usage -fprefix-function-name
542 -fno-common -fno-ident -fno-gnu-linker
543 -fpcc-struct-return -fpic -fPIC
544 -freg-struct-return -fshared-data -fshort-enums
545 -fshort-double -fvolatile -fvolatile-global -fvolatile-static
546 -fverbose-asm -fpack-struct -fstack-check
547 -fstack-limit-register=@var{reg} -fstack-limit-symbol=@var{sym}
548 -fargument-alias -fargument-noalias
549 -fargument-noalias-global
555 * Overall Options:: Controlling the kind of output:
556 an executable, object files, assembler files,
557 or preprocessed source.
558 * C Dialect Options:: Controlling the variant of C language compiled.
559 * C++ Dialect Options:: Variations on C++.
560 * Language Independent Options:: Controlling how diagnostics should be
562 * Warning Options:: How picky should the compiler be?
563 * Debugging Options:: Symbol tables, measurements, and debugging dumps.
564 * Optimize Options:: How much optimization?
565 * Preprocessor Options:: Controlling header files and macro definitions.
566 Also, getting dependency information for Make.
567 * Assembler Options:: Passing options to the assembler.
568 * Link Options:: Specifying libraries and so on.
569 * Directory Options:: Where to find header files and libraries.
570 Where to find the compiler executable files.
571 * Spec Files:: How to pass switches to sub-processes.
572 * Target Options:: Running a cross-compiler, or an old version of GCC.
577 @node Overall Options
578 @section Options Controlling the Kind of Output
580 Compilation can involve up to four stages: preprocessing, compilation
581 proper, assembly and linking, always in that order. The first three
582 stages apply to an individual source file, and end by producing an
583 object file; linking combines all the object files (those newly
584 compiled, and those specified as input) into an executable file.
586 @cindex file name suffix
587 For any given input file, the file name suffix determines what kind of
592 C source code which must be preprocessed.
595 C source code which should not be preprocessed.
598 C++ source code which should not be preprocessed.
601 Objective-C source code. Note that you must link with the library
602 @file{libobjc.a} to make an Objective-C program work.
605 Objective-C source code which should not be preprocessed.
608 C header file (not to be compiled or linked).
612 @itemx @var{file}.cxx
613 @itemx @var{file}.cpp
614 @itemx @var{file}.c++
616 C++ source code which must be preprocessed. Note that in @samp{.cxx},
617 the last two letters must both be literally @samp{x}. Likewise,
618 @samp{.C} refers to a literal capital C.
621 @itemx @var{file}.for
622 @itemx @var{file}.FOR
623 Fortran source code which should not be preprocessed.
626 @itemx @var{file}.fpp
627 @itemx @var{file}.FPP
628 Fortran source code which must be preprocessed (with the traditional
632 Fortran source code which must be preprocessed with a RATFOR
633 preprocessor (not included with GCC).
635 @xref{Overall Options,,Options Controlling the Kind of Output, g77,
636 Using and Porting GNU Fortran}, for more details of the handling of
639 @c FIXME: Descriptions of Java file types.
645 @c GCC also knows about some suffixes for languages not yet included:
655 @itemx @var{file}.chi
656 CHILL source code (preprocessed with the traditional preprocessor).
662 Assembler code which must be preprocessed.
665 An object file to be fed straight into linking.
666 Any file name with no recognized suffix is treated this way.
669 You can specify the input language explicitly with the @samp{-x} option:
672 @item -x @var{language}
673 Specify explicitly the @var{language} for the following input files
674 (rather than letting the compiler choose a default based on the file
675 name suffix). This option applies to all following input files until
676 the next @samp{-x} option. Possible values for @var{language} are:
678 c c-header cpp-output
680 objective-c objc-cpp-output
681 assembler assembler-with-cpp
682 f77 f77-cpp-input ratfor
685 @c Also f77-version, for internal use only.
688 Turn off any specification of a language, so that subsequent files are
689 handled according to their file name suffixes (as they are if @samp{-x}
690 has not been used at all).
692 @item -pass-exit-codes
693 Normally the @code{gcc} program will exit with the code of 1 if any
694 phase of the compiler returns a non-success return code. If you specify
695 @samp{-pass-exit-codes}, the @code{gcc} program will instead return with
696 numerically highest error produced by any phase that returned an error
700 If you only want some of the stages of compilation, you can use
701 @samp{-x} (or filename suffixes) to tell @code{gcc} where to start, and
702 one of the options @samp{-c}, @samp{-S}, or @samp{-E} to say where
703 @code{gcc} is to stop. Note that some combinations (for example,
704 @samp{-x cpp-output -E} instruct @code{gcc} to do nothing at all.
708 Compile or assemble the source files, but do not link. The linking
709 stage simply is not done. The ultimate output is in the form of an
710 object file for each source file.
712 By default, the object file name for a source file is made by replacing
713 the suffix @samp{.c}, @samp{.i}, @samp{.s}, etc., with @samp{.o}.
715 Unrecognized input files, not requiring compilation or assembly, are
719 Stop after the stage of compilation proper; do not assemble. The output
720 is in the form of an assembler code file for each non-assembler input
723 By default, the assembler file name for a source file is made by
724 replacing the suffix @samp{.c}, @samp{.i}, etc., with @samp{.s}.
726 Input files that don't require compilation are ignored.
729 Stop after the preprocessing stage; do not run the compiler proper. The
730 output is in the form of preprocessed source code, which is sent to the
733 Input files which don't require preprocessing are ignored.
735 @cindex output file option
737 Place output in file @var{file}. This applies regardless to whatever
738 sort of output is being produced, whether it be an executable file,
739 an object file, an assembler file or preprocessed C code.
741 Since only one output file can be specified, it does not make sense to
742 use @samp{-o} when compiling more than one input file, unless you are
743 producing an executable file as output.
745 If @samp{-o} is not specified, the default is to put an executable file
746 in @file{a.out}, the object file for @file{@var{source}.@var{suffix}} in
747 @file{@var{source}.o}, its assembler file in @file{@var{source}.s}, and
748 all preprocessed C source on standard output.@refill
751 Print (on standard error output) the commands executed to run the stages
752 of compilation. Also print the version number of the compiler driver
753 program and of the preprocessor and the compiler proper.
756 Use pipes rather than temporary files for communication between the
757 various stages of compilation. This fails to work on some systems where
758 the assembler is unable to read from a pipe; but the GNU assembler has
762 Print (on the standard output) a description of the command line options
763 understood by @code{gcc}. If the @code{-v} option is also specified
764 then @code{--help} will also be passed on to the various processes
765 invoked by @code{gcc}, so that they can display the command line options
766 they accept. If the @code{-W} option is also specified then command
767 line options which have no documentation associated with them will also
771 Print (on the standard output) a description of target specific command
772 line options for each tool.
776 @section Compiling C++ Programs
778 @cindex suffixes for C++ source
779 @cindex C++ source file suffixes
780 C++ source files conventionally use one of the suffixes @samp{.C},
781 @samp{.cc}, @samp{.cpp}, @samp{.c++}, @samp{.cp}, or @samp{.cxx};
782 preprocessed C++ files use the suffix @samp{.ii}. GCC recognizes
783 files with these names and compiles them as C++ programs even if you
784 call the compiler the same way as for compiling C programs (usually with
785 the name @code{gcc}).
789 However, C++ programs often require class libraries as well as a
790 compiler that understands the C++ language---and under some
791 circumstances, you might want to compile programs from standard input,
792 or otherwise without a suffix that flags them as C++ programs.
793 @code{g++} is a program that calls GCC with the default language
794 set to C++, and automatically specifies linking against the C++
795 library. On many systems, @code{g++} is also
796 installed with the name @code{c++}.
798 @cindex invoking @code{g++}
799 When you compile C++ programs, you may specify many of the same
800 command-line options that you use for compiling programs in any
801 language; or command-line options meaningful for C and related
802 languages; or options that are meaningful only for C++ programs.
803 @xref{C Dialect Options,,Options Controlling C Dialect}, for
804 explanations of options for languages related to C.
805 @xref{C++ Dialect Options,,Options Controlling C++ Dialect}, for
806 explanations of options that are meaningful only for C++ programs.
808 @node C Dialect Options
809 @section Options Controlling C Dialect
810 @cindex dialect options
811 @cindex language dialect options
812 @cindex options, dialect
814 The following options control the dialect of C (or languages derived
815 from C, such as C++ and Objective C) that the compiler accepts:
821 In C mode, support all ISO C89 programs. In C++ mode,
822 remove GNU extensions that conflict with ISO C++.
824 This turns off certain features of GCC that are incompatible with ISO
825 C (when compiling C code), or of standard C++ (when compiling C++ code),
826 such as the @code{asm} and @code{typeof} keywords, and
827 predefined macros such as @code{unix} and @code{vax} that identify the
828 type of system you are using. It also enables the undesirable and
829 rarely used ISO trigraph feature. For the C compiler,
830 it disables recognition of C++ style @samp{//} comments as well as
831 the @code{inline} keyword.
833 The alternate keywords @code{__asm__}, @code{__extension__},
834 @code{__inline__} and @code{__typeof__} continue to work despite
835 @samp{-ansi}. You would not want to use them in an ISO C program, of
836 course, but it is useful to put them in header files that might be included
837 in compilations done with @samp{-ansi}. Alternate predefined macros
838 such as @code{__unix__} and @code{__vax__} are also available, with or
839 without @samp{-ansi}.
841 The @samp{-ansi} option does not cause non-ISO programs to be
842 rejected gratuitously. For that, @samp{-pedantic} is required in
843 addition to @samp{-ansi}. @xref{Warning Options}.
845 The macro @code{__STRICT_ANSI__} is predefined when the @samp{-ansi}
846 option is used. Some header files may notice this macro and refrain
847 from declaring certain functions or defining certain macros that the
848 ISO standard doesn't call for; this is to avoid interfering with any
849 programs that might use these names for other things.
851 Functions which would normally be builtin but do not have semantics
852 defined by ISO C (such as @code{alloca} and @code{ffs}) are not builtin
853 functions with @samp{-ansi} is used. @xref{Other Builtins,,Other
854 built-in functions provided by GNU CC}, for details of the functions
858 Determine the language standard. A value for this option must be provided;
866 ISO C as modified in amend. 1
869 ISO C99. Note that this standard is not yet fully supported; see
870 @uref{http://gcc.gnu.org/c99status.html} for more information.
873 same as -std=iso9899:1990
876 same as -std=iso9899:1999
879 default, iso9899:1990 + gnu extensions
882 iso9899:1999 + gnu extensions
885 same as -std=iso9899:1999, deprecated
888 same as -std=iso9899:1999, deprecated
891 same as -std=gnu99, deprecated
895 Even when this option is not specified, you can still use some of the
896 features of newer standards in so far as they do not conflict with
897 previous C standards. For example, you may use @code{__restrict__} even
898 when -std=c99 is not specified.
900 @xref{Standards,,Language Standards Supported by GCC}, for details of
901 these standard versions.
904 Do not recognize @code{asm}, @code{inline} or @code{typeof} as a
905 keyword, so that code can use these words as identifiers. You can use
906 the keywords @code{__asm__}, @code{__inline__} and @code{__typeof__}
907 instead. @samp{-ansi} implies @samp{-fno-asm}.
909 In C++, this switch only affects the @code{typeof} keyword, since
910 @code{asm} and @code{inline} are standard keywords. You may want to
911 use the @samp{-fno-gnu-keywords} flag instead, which has the same effect.
914 @cindex builtin functions
915 Don't recognize builtin functions that do not begin with
916 @samp{__builtin_} as prefix. @xref{Other Builtins,,Other built-in
917 functions provided by GNU CC}, for details of the functions affected,
918 including those which are not builtin functions when @samp{-ansi} is
919 used because they do not have an ISO standard meaning.
921 GCC normally generates special code to handle certain builtin functions
922 more efficiently; for instance, calls to @code{alloca} may become single
923 instructions that adjust the stack directly, and calls to @code{memcpy}
924 may become inline copy loops. The resulting code is often both smaller
925 and faster, but since the function calls no longer appear as such, you
926 cannot set a breakpoint on those calls, nor can you change the behavior
927 of the functions by linking with a different library.
930 @cindex hosted environment
932 Assert that compilation takes place in a hosted environment. This implies
933 @samp{-fbuiltin}. A hosted environment is one in which the
934 entire standard library is available, and in which @code{main} has a return
935 type of @code{int}. Examples are nearly everything except a kernel.
936 This is equivalent to @samp{-fno-freestanding}.
939 @cindex hosted environment
941 Assert that compilation takes place in a freestanding environment. This
942 implies @samp{-fno-builtin}. A freestanding environment
943 is one in which the standard library may not exist, and program startup may
944 not necessarily be at @code{main}. The most obvious example is an OS kernel.
945 This is equivalent to @samp{-fno-hosted}.
947 @xref{Standards,,Language Standards Supported by GCC}, for details of
948 freestanding and hosted environments.
951 Support ISO C trigraphs. You don't want to know about this
952 brain-damage. The @samp{-ansi} option implies @samp{-trigraphs}.
954 @cindex traditional C language
955 @cindex C language, traditional
957 Attempt to support some aspects of traditional C compilers.
962 All @code{extern} declarations take effect globally even if they
963 are written inside of a function definition. This includes implicit
964 declarations of functions.
967 The newer keywords @code{typeof}, @code{inline}, @code{signed}, @code{const}
968 and @code{volatile} are not recognized. (You can still use the
969 alternative keywords such as @code{__typeof__}, @code{__inline__}, and
973 Comparisons between pointers and integers are always allowed.
976 Integer types @code{unsigned short} and @code{unsigned char} promote
977 to @code{unsigned int}.
980 Out-of-range floating point literals are not an error.
983 Certain constructs which ISO regards as a single invalid preprocessing
984 number, such as @samp{0xe-0xd}, are treated as expressions instead.
987 String ``constants'' are not necessarily constant; they are stored in
988 writable space, and identical looking constants are allocated
989 separately. (This is the same as the effect of
990 @samp{-fwritable-strings}.)
992 @cindex @code{longjmp} and automatic variables
994 All automatic variables not declared @code{register} are preserved by
995 @code{longjmp}. Ordinarily, GNU C follows ISO C: automatic variables
996 not declared @code{volatile} may be clobbered.
1001 @cindex escape sequences, traditional
1002 The character escape sequences @samp{\x} and @samp{\a} evaluate as the
1003 literal characters @samp{x} and @samp{a} respectively. Without
1004 @w{@samp{-traditional}}, @samp{\x} is a prefix for the hexadecimal
1005 representation of a character, and @samp{\a} produces a bell.
1008 You may wish to use @samp{-fno-builtin} as well as @samp{-traditional}
1009 if your program uses names that are normally GNU C builtin functions for
1010 other purposes of its own.
1012 You cannot use @samp{-traditional} if you include any header files that
1013 rely on ISO C features. Some vendors are starting to ship systems with
1014 ISO C header files and you cannot use @samp{-traditional} on such
1015 systems to compile files that include any system headers.
1017 The @samp{-traditional} option also enables @samp{-traditional-cpp},
1018 which is described next.
1020 @item -traditional-cpp
1021 Attempt to support some aspects of traditional C preprocessors.
1026 Comments convert to nothing at all, rather than to a space. This allows
1027 traditional token concatenation.
1030 In a preprocessing directive, the @samp{#} symbol must appear as the first
1031 character of a line.
1034 Macro arguments are recognized within string constants in a macro
1035 definition (and their values are stringified, though without additional
1036 quote marks, when they appear in such a context). The preprocessor
1037 always considers a string constant to end at a newline.
1040 @cindex detecting @w{@samp{-traditional}}
1041 The predefined macro @code{__STDC__} is not defined when you use
1042 @samp{-traditional}, but @code{__GNUC__} is (since the GNU extensions
1043 which @code{__GNUC__} indicates are not affected by
1044 @samp{-traditional}). If you need to write header files that work
1045 differently depending on whether @samp{-traditional} is in use, by
1046 testing both of these predefined macros you can distinguish four
1047 situations: GNU C, traditional GNU C, other ISO C compilers, and other
1048 old C compilers. The predefined macro @code{__STDC_VERSION__} is also
1049 not defined when you use @samp{-traditional}. @xref{Standard
1050 Predefined,,Standard Predefined Macros,cpp.info,The C Preprocessor},
1051 for more discussion of these and other predefined macros.
1054 @cindex string constants vs newline
1055 @cindex newline vs string constants
1056 The preprocessor considers a string constant to end at a newline (unless
1057 the newline is escaped with @samp{\}). (Without @w{@samp{-traditional}},
1058 string constants can contain the newline character as typed.)
1061 @item -fcond-mismatch
1062 Allow conditional expressions with mismatched types in the second and
1063 third arguments. The value of such an expression is void.
1065 @item -funsigned-char
1066 Let the type @code{char} be unsigned, like @code{unsigned char}.
1068 Each kind of machine has a default for what @code{char} should
1069 be. It is either like @code{unsigned char} by default or like
1070 @code{signed char} by default.
1072 Ideally, a portable program should always use @code{signed char} or
1073 @code{unsigned char} when it depends on the signedness of an object.
1074 But many programs have been written to use plain @code{char} and
1075 expect it to be signed, or expect it to be unsigned, depending on the
1076 machines they were written for. This option, and its inverse, let you
1077 make such a program work with the opposite default.
1079 The type @code{char} is always a distinct type from each of
1080 @code{signed char} or @code{unsigned char}, even though its behavior
1081 is always just like one of those two.
1084 Let the type @code{char} be signed, like @code{signed char}.
1086 Note that this is equivalent to @samp{-fno-unsigned-char}, which is
1087 the negative form of @samp{-funsigned-char}. Likewise, the option
1088 @samp{-fno-signed-char} is equivalent to @samp{-funsigned-char}.
1090 You may wish to use @samp{-fno-builtin} as well as @samp{-traditional}
1091 if your program uses names that are normally GNU C builtin functions for
1092 other purposes of its own.
1094 You cannot use @samp{-traditional} if you include any header files that
1095 rely on ISO C features. Some vendors are starting to ship systems with
1096 ISO C header files and you cannot use @samp{-traditional} on such
1097 systems to compile files that include any system headers.
1099 @item -fsigned-bitfields
1100 @itemx -funsigned-bitfields
1101 @itemx -fno-signed-bitfields
1102 @itemx -fno-unsigned-bitfields
1103 These options control whether a bitfield is signed or unsigned, when the
1104 declaration does not use either @code{signed} or @code{unsigned}. By
1105 default, such a bitfield is signed, because this is consistent: the
1106 basic integer types such as @code{int} are signed types.
1108 However, when @samp{-traditional} is used, bitfields are all unsigned
1111 @item -fwritable-strings
1112 Store string constants in the writable data segment and don't uniquize
1113 them. This is for compatibility with old programs which assume they can
1114 write into string constants. The option @samp{-traditional} also has
1117 Writing into string constants is a very bad idea; ``constants'' should
1120 @item -fallow-single-precision
1121 Do not promote single precision math operations to double precision,
1122 even when compiling with @samp{-traditional}.
1124 Traditional K&R C promotes all floating point operations to double
1125 precision, regardless of the sizes of the operands. On the
1126 architecture for which you are compiling, single precision may be faster
1127 than double precision. If you must use @samp{-traditional}, but want
1128 to use single precision operations when the operands are single
1129 precision, use this option. This option has no effect when compiling
1130 with ISO or GNU C conventions (the default).
1133 Override the underlying type for @samp{wchar_t} to be @samp{short
1134 unsigned int} instead of the default for the target. This option is
1135 useful for building programs to run under WINE.
1138 @node C++ Dialect Options
1139 @section Options Controlling C++ Dialect
1141 @cindex compiler options, C++
1142 @cindex C++ options, command line
1143 @cindex options, C++
1144 This section describes the command-line options that are only meaningful
1145 for C++ programs; but you can also use most of the GNU compiler options
1146 regardless of what language your program is in. For example, you
1147 might compile a file @code{firstClass.C} like this:
1150 g++ -g -frepo -O -c firstClass.C
1154 In this example, only @samp{-frepo} is an option meant
1155 only for C++ programs; you can use the other options with any
1156 language supported by GCC.
1158 Here is a list of options that are @emph{only} for compiling C++ programs:
1161 @item -fno-access-control
1162 Turn off all access checking. This switch is mainly useful for working
1163 around bugs in the access control code.
1166 Check that the pointer returned by @code{operator new} is non-null
1167 before attempting to modify the storage allocated. The current Working
1168 Paper requires that @code{operator new} never return a null pointer, so
1169 this check is normally unnecessary.
1171 An alternative to using this option is to specify that your
1172 @code{operator new} does not throw any exceptions; if you declare it
1173 @samp{throw()}, g++ will check the return value. See also @samp{new
1176 @item -fconserve-space
1177 Put uninitialized or runtime-initialized global variables into the
1178 common segment, as C does. This saves space in the executable at the
1179 cost of not diagnosing duplicate definitions. If you compile with this
1180 flag and your program mysteriously crashes after @code{main()} has
1181 completed, you may have an object that is being destroyed twice because
1182 two definitions were merged.
1184 This option is no longer useful on most targets, now that support has
1185 been added for putting variables into BSS without making them common.
1187 @item -fdollars-in-identifiers
1188 Accept @samp{$} in identifiers. You can also explicitly prohibit use of
1189 @samp{$} with the option @samp{-fno-dollars-in-identifiers}. (GNU C allows
1190 @samp{$} by default on most target systems, but there are a few exceptions.)
1191 Traditional C allowed the character @samp{$} to form part of
1192 identifiers. However, ISO C and C++ forbid @samp{$} in identifiers.
1194 @item -fno-elide-constructors
1195 The C++ standard allows an implementation to omit creating a temporary
1196 which is only used to initialize another object of the same type.
1197 Specifying this option disables that optimization, and forces g++ to
1198 call the copy constructor in all cases.
1200 @item -fno-enforce-eh-specs
1201 Don't check for violation of exception specifications at runtime. This
1202 option violates the C++ standard, but may be useful for reducing code
1203 size in production builds, much like defining @samp{NDEBUG}. The compiler
1204 will still optimize based on the exception specifications.
1206 @item -fexternal-templates
1207 Cause template instantiations to obey @samp{#pragma interface} and
1208 @samp{implementation}; template instances are emitted or not according
1209 to the location of the template definition. @xref{Template
1210 Instantiation}, for more information.
1212 This option is deprecated.
1214 @item -falt-external-templates
1215 Similar to -fexternal-templates, but template instances are emitted or
1216 not according to the place where they are first instantiated.
1217 @xref{Template Instantiation}, for more information.
1219 This option is deprecated.
1222 @itemx -fno-for-scope
1223 If -ffor-scope is specified, the scope of variables declared in
1224 a @i{for-init-statement} is limited to the @samp{for} loop itself,
1225 as specified by the C++ standard.
1226 If -fno-for-scope is specified, the scope of variables declared in
1227 a @i{for-init-statement} extends to the end of the enclosing scope,
1228 as was the case in old versions of gcc, and other (traditional)
1229 implementations of C++.
1231 The default if neither flag is given to follow the standard,
1232 but to allow and give a warning for old-style code that would
1233 otherwise be invalid, or have different behavior.
1235 @item -fno-gnu-keywords
1236 Do not recognize @code{typeof} as a keyword, so that code can use this
1237 word as an identifier. You can use the keyword @code{__typeof__} instead.
1238 @samp{-ansi} implies @samp{-fno-gnu-keywords}.
1241 Treat the @code{namespace std} as a namespace, instead of ignoring
1242 it. For compatibility with earlier versions of g++, the compiler will,
1243 by default, ignore @code{namespace-declarations},
1244 @code{using-declarations}, @code{using-directives}, and
1245 @code{namespace-names}, if they involve @code{std}.
1247 @item -fhuge-objects
1248 Support virtual function calls for objects that exceed the size
1249 representable by a @samp{short int}. Users should not use this flag by
1250 default; if you need to use it, the compiler will tell you so.
1252 This flag is not useful when compiling with -fvtable-thunks.
1254 Like all options that change the ABI, all C++ code, @emph{including
1255 libgcc} must be built with the same setting of this option.
1257 @item -fno-implicit-templates
1258 Never emit code for non-inline templates which are instantiated
1259 implicitly (i.e. by use); only emit code for explicit instantiations.
1260 @xref{Template Instantiation}, for more information.
1262 @item -fno-implicit-inline-templates
1263 Don't emit code for implicit instantiations of inline templates, either.
1264 The default is to handle inlines differently so that compiles with and
1265 without optimization will need the same set of explicit instantiations.
1267 @item -finit-priority
1268 Support @samp{__attribute__ ((init_priority (n)))} for controlling the
1269 order of initialization of file-scope objects. On ELF targets, this
1270 requires GNU ld 2.10 or later.
1272 @item -fno-implement-inlines
1273 To save space, do not emit out-of-line copies of inline functions
1274 controlled by @samp{#pragma implementation}. This will cause linker
1275 errors if these functions are not inlined everywhere they are called.
1277 @item -fms-extensions
1278 Disable pedantic warnings about constructs used in MFC, such as implicit
1279 int and getting a pointer to member function via non-standard syntax.
1281 @item -fname-mangling-version-@var{n}
1282 Control the way in which names are mangled. Version 0 is compatible
1283 with versions of g++ before 2.8. Version 1 is the default. Version 1
1284 will allow correct mangling of function templates. For example,
1285 version 0 mangling does not mangle foo<int, double> and foo<int, char>
1286 given this declaration:
1289 template <class T, class U> void foo(T t);
1292 Like all options that change the ABI, all C++ code, @emph{including
1293 libgcc} must be built with the same setting of this option.
1295 @item -fno-operator-names
1296 Do not treat the operator name keywords @code{and}, @code{bitand},
1297 @code{bitor}, @code{compl}, @code{not}, @code{or} and @code{xor} as
1298 synonyms as keywords.
1300 @item -fno-optional-diags
1301 Disable diagnostics that the standard says a compiler does not need to
1302 issue. Currently, the only such diagnostic issued by g++ is the one for
1303 a name having multiple meanings within a class.
1306 Downgrade messages about nonconformant code from errors to warnings. By
1307 default, g++ effectively sets @samp{-pedantic-errors} without
1308 @samp{-pedantic}; this option reverses that. This behavior and this
1309 option are superseded by @samp{-pedantic}, which works as it does for GNU C.
1312 Enable automatic template instantiation. This option also implies
1313 @samp{-fno-implicit-templates}. @xref{Template Instantiation}, for more
1317 Disable generation of information about every class with virtual
1318 functions for use by the C++ runtime type identification features
1319 (@samp{dynamic_cast} and @samp{typeid}). If you don't use those parts
1320 of the language, you can save some space by using this flag. Note that
1321 exception handling uses the same information, but it will generate it as
1325 @itemx -fno-squangle
1326 @samp{-fsquangle} will enable a compressed form of name mangling for
1327 identifiers. In particular, it helps to shorten very long names by recognizing
1328 types and class names which occur more than once, replacing them with special
1329 short ID codes. This option also requires any C++ libraries being used to
1330 be compiled with this option as well. The compiler has this disabled (the
1331 equivalent of @samp{-fno-squangle}) by default.
1333 Like all options that change the ABI, all C++ code, @emph{including
1334 libgcc.a} must be built with the same setting of this option.
1336 @item -ftemplate-depth-@var{n}
1337 Set the maximum instantiation depth for template classes to @var{n}.
1338 A limit on the template instantiation depth is needed to detect
1339 endless recursions during template class instantiation. ANSI/ISO C++
1340 conforming programs must not rely on a maximum depth greater than 17.
1342 @item -fuse-cxa-atexit
1343 Register destructors for objects with static storage duration with the
1344 @code{__cxa_atexit} function rather than the @code{atexit} function.
1345 This option is required for fully standards-compliant handling of static
1346 destructors, but will only work if your C library supports
1347 @code{__cxa_atexit}.
1349 @item -fvtable-thunks
1350 Use @samp{thunks} to implement the virtual function dispatch table
1351 (@samp{vtable}). The traditional (cfront-style) approach to
1352 implementing vtables was to store a pointer to the function and two
1353 offsets for adjusting the @samp{this} pointer at the call site. Newer
1354 implementations store a single pointer to a @samp{thunk} function which
1355 does any necessary adjustment and then calls the target function.
1357 This option also enables a heuristic for controlling emission of
1358 vtables; if a class has any non-inline virtual functions, the vtable
1359 will be emitted in the translation unit containing the first one of
1362 Like all options that change the ABI, all C++ code, @emph{including
1363 libgcc.a} must be built with the same setting of this option.
1366 Do not search for header files in the standard directories specific to
1367 C++, but do still search the other standard directories. (This option
1368 is used when building the C++ library.)
1371 In addition, these optimization, warning, and code generation options
1372 have meanings only for C++ programs:
1375 @item -fno-default-inline
1376 Do not assume @samp{inline} for functions defined inside a class scope.
1377 @xref{Optimize Options,,Options That Control Optimization}. Note that these
1378 functions will have linkage like inline functions; they just won't be
1381 @item -Wctor-dtor-privacy (C++ only)
1382 Warn when a class seems unusable, because all the constructors or
1383 destructors in a class are private and the class has no friends or
1384 public static member functions.
1386 @item -Wnon-virtual-dtor (C++ only)
1387 Warn when a class declares a non-virtual destructor that should probably
1388 be virtual, because it looks like the class will be used polymorphically.
1390 @item -Wreorder (C++ only)
1391 @cindex reordering, warning
1392 @cindex warning for reordering of member initializers
1393 Warn when the order of member initializers given in the code does not
1394 match the order in which they must be executed. For instance:
1400 A(): j (0), i (1) @{ @}
1404 Here the compiler will warn that the member initializers for @samp{i}
1405 and @samp{j} will be rearranged to match the declaration order of the
1409 The following @samp{-W@dots{}} options are not affected by @samp{-Wall}.
1412 @item -Weffc++ (C++ only)
1413 Warn about violations of various style guidelines from Scott Meyers'
1414 @cite{Effective C++} books. If you use this option, you should be aware
1415 that the standard library headers do not obey all of these guidelines;
1416 you can use @samp{grep -v} to filter out those warnings.
1418 @item -Wno-deprecated (C++ only)
1419 Do not warn about usage of deprecated features. @xref{Deprecated Features}.
1421 @item -Wno-non-template-friend (C++ only)
1422 Disable warnings when non-templatized friend functions are declared
1423 within a template. With the advent of explicit template specification
1424 support in g++, if the name of the friend is an unqualified-id (ie,
1425 @samp{friend foo(int)}), the C++ language specification demands that the
1426 friend declare or define an ordinary, nontemplate function. (Section
1427 14.5.3). Before g++ implemented explicit specification, unqualified-ids
1428 could be interpreted as a particular specialization of a templatized
1429 function. Because this non-conforming behavior is no longer the default
1430 behavior for g++, @samp{-Wnon-template-friend} allows the compiler to
1431 check existing code for potential trouble spots, and is on by default.
1432 This new compiler behavior can be turned off with
1433 @samp{-Wno-non-template-friend} which keeps the conformant compiler code
1434 but disables the helpful warning.
1436 @item -Wold-style-cast (C++ only)
1437 Warn if an old-style (C-style) cast is used within a C++ program. The
1438 new-style casts (@samp{static_cast}, @samp{reinterpret_cast}, and
1439 @samp{const_cast}) are less vulnerable to unintended effects.
1441 @item -Woverloaded-virtual (C++ only)
1442 @cindex overloaded virtual fn, warning
1443 @cindex warning for overloaded virtual fn
1444 Warn when a derived class function declaration may be an error in
1445 defining a virtual function. In a derived class, the
1446 definitions of virtual functions must match the type signature of a
1447 virtual function declared in the base class. With this option, the
1448 compiler warns when you define a function with the same name as a
1449 virtual function, but with a type signature that does not match any
1450 declarations from the base class.
1452 @item -Wno-pmf-conversions (C++ only)
1453 Disable the diagnostic for converting a bound pointer to member function
1456 @item -Wsign-promo (C++ only)
1457 Warn when overload resolution chooses a promotion from unsigned or
1458 enumeral type to a signed type over a conversion to an unsigned type of
1459 the same size. Previous versions of g++ would try to preserve
1460 unsignedness, but the standard mandates the current behavior.
1462 @item -Wsynth (C++ only)
1463 @cindex warning for synthesized methods
1464 @cindex synthesized methods, warning
1465 Warn when g++'s synthesis behavior does not match that of cfront. For
1471 A& operator = (int);
1481 In this example, g++ will synthesize a default @samp{A& operator =
1482 (const A&);}, while cfront will use the user-defined @samp{operator =}.
1485 @node Language Independent Options
1486 @section Options to Control Diagnostic Messages Formatting
1487 @cindex options to control diagnostics formatting
1488 @cindex diagnostic messages
1489 @cindex message formatting
1491 Traditionally, diagnostic messages have been formatted irrespective of
1492 the output device's aspect (e.g. its width, ...). The options described
1493 below can be used to control the diagnostic messages formatting
1494 algorithm, e.g. how many characters per line, how often source location
1495 information should be reported. Right now, only the C++ front-end can
1496 honor these options. However it is expected, in the near future, that
1497 the remaining front-ends would be able to digest them correctly.
1500 @item -fmessage-length=@var{n}
1501 Try to format error messages so that they fit on lines of about @var{n}
1502 characters. The default is 72 characters for g++ and 0 for the rest of
1503 the front-ends supported by GCC. If @var{n} is zero, then no
1504 line-wrapping will be done; each error message will appear on a single
1507 @item -fdiagnostics-show-location=once
1508 Only meaningful in line-wrapping mode. Instructs the diagnostic messages
1509 reporter to emit @emph{once} source location information; that is, in
1510 case the message is too long to fit on a single physical line and has to
1511 be wrapped, the source location won't be emitted (as prefix) again,
1512 over and over, in subsequent continuation lines. This is the default
1515 @item -fdiagnostics-show-location=every-line
1516 Only meaningful in line-wrapping mode. Instructs the diagnostic
1517 messages reporter to emit the same source location information (as
1518 prefix) for physical lines that result from the process of breaking a
1519 a message which is too long to fit on a single line.
1523 @node Warning Options
1524 @section Options to Request or Suppress Warnings
1525 @cindex options to control warnings
1526 @cindex warning messages
1527 @cindex messages, warning
1528 @cindex suppressing warnings
1530 Warnings are diagnostic messages that report constructions which
1531 are not inherently erroneous but which are risky or suggest there
1532 may have been an error.
1534 You can request many specific warnings with options beginning @samp{-W},
1535 for example @samp{-Wimplicit} to request warnings on implicit
1536 declarations. Each of these specific warning options also has a
1537 negative form beginning @samp{-Wno-} to turn off warnings;
1538 for example, @samp{-Wno-implicit}. This manual lists only one of the
1539 two forms, whichever is not the default.
1541 These options control the amount and kinds of warnings produced by GCC:
1544 @cindex syntax checking
1546 Check the code for syntax errors, but don't do anything beyond that.
1549 Issue all the warnings demanded by strict ISO C and ISO C++;
1550 reject all programs that use forbidden extensions, and some other
1551 programs that do not follow ISO C and ISO C++. For ISO C, follows the
1552 version of the ISO C standard specified by any @samp{-std} option used.
1554 Valid ISO C and ISO C++ programs should compile properly with or without
1555 this option (though a rare few will require @samp{-ansi}). However,
1556 without this option, certain GNU extensions and traditional C and C++
1557 features are supported as well. With this option, they are rejected.
1559 @samp{-pedantic} does not cause warning messages for use of the
1560 alternate keywords whose names begin and end with @samp{__}. Pedantic
1561 warnings are also disabled in the expression that follows
1562 @code{__extension__}. However, only system header files should use
1563 these escape routes; application programs should avoid them.
1564 @xref{Alternate Keywords}.
1566 Some users try to use @samp{-pedantic} to check programs for strict ISO
1567 C conformance. They soon find that it does not do quite what they want:
1568 it finds some non-ISO practices, but not all---only those for which
1569 ISO C @emph{requires} a diagnostic, and some others for which
1570 diagnostics have been added.
1572 A feature to report any failure to conform to ISO C might be useful in
1573 some instances, but would require considerable additional work and would
1574 be quite different from @samp{-pedantic}. We don't have plans to
1575 support such a feature in the near future.
1577 @item -pedantic-errors
1578 Like @samp{-pedantic}, except that errors are produced rather than
1582 Inhibit all warning messages.
1585 Inhibit warning messages about the use of @samp{#import}.
1587 @item -Wchar-subscripts
1588 Warn if an array subscript has type @code{char}. This is a common cause
1589 of error, as programmers often forget that this type is signed on some
1593 Warn whenever a comment-start sequence @samp{/*} appears in a @samp{/*}
1594 comment, or whenever a Backslash-Newline appears in a @samp{//} comment.
1597 Check calls to @code{printf} and @code{scanf}, etc., to make sure that
1598 the arguments supplied have types appropriate to the format string
1601 @samp{-Wformat} is included in @samp{-Wall}. For more control over some
1602 aspects of format checking, the options @samp{-Wno-format-y2k},
1603 @samp{-Wno-format-extra-args}, @samp{-Wformat-nonliteral} and
1604 @samp{-Wformat=2} are available, but are not included in @samp{-Wall}.
1606 @item -Wno-format-y2k
1607 If @samp{-Wformat} is specified, do not warn about @code{strftime}
1608 formats which may yield only a two-digit year.
1610 @item -Wno-format-extra-args
1611 If @samp{-Wformat} is specified, do not warn about excess arguments to a
1612 @code{printf} or @code{scanf} format function. The C standard specifies
1613 that such arguments are ignored.
1615 @item -Wformat-nonliteral
1616 If @samp{-Wformat} is specified, also warn if the format string is not a
1617 string literal and so cannot be checked, unless the format function
1618 takes its format arguments as a @code{va_list}.
1621 Enable @samp{-Wformat} plus format checks not included in
1622 @samp{-Wformat}. Currently equivalent to @samp{-Wformat
1623 -Wformat-nonliteral}.
1625 @item -Wimplicit-int
1626 Warn when a declaration does not specify a type.
1628 @item -Wimplicit-function-declaration
1629 @itemx -Werror-implicit-function-declaration
1630 Give a warning (or error) whenever a function is used before being
1634 Same as @samp{-Wimplicit-int} and @samp{-Wimplicit-function-}@*
1638 Warn if the type of @samp{main} is suspicious. @samp{main} should be a
1639 function with external linkage, returning int, taking either zero
1640 arguments, two, or three arguments of appropriate types.
1643 Warn if a multicharacter constant (@samp{'FOOF'}) is used. Usually they
1644 indicate a typo in the user's code, as they have implementation-defined
1645 values, and should not be used in portable code.
1648 Warn if parentheses are omitted in certain contexts, such
1649 as when there is an assignment in a context where a truth value
1650 is expected, or when operators are nested whose precedence people
1651 often get confused about.
1653 Also warn about constructions where there may be confusion to which
1654 @code{if} statement an @code{else} branch belongs. Here is an example of
1667 In C, every @code{else} branch belongs to the innermost possible @code{if}
1668 statement, which in this example is @code{if (b)}. This is often not
1669 what the programmer expected, as illustrated in the above example by
1670 indentation the programmer chose. When there is the potential for this
1671 confusion, GNU C will issue a warning when this flag is specified.
1672 To eliminate the warning, add explicit braces around the innermost
1673 @code{if} statement so there is no way the @code{else} could belong to
1674 the enclosing @code{if}. The resulting code would look like this:
1688 @item -Wsequence-point
1689 Warn about code that may have undefined semantics because of violations
1690 of sequence point rules in the C standard.
1692 The C standard defines the order in which expressions in a C program are
1693 evaluated in terms of @dfn{sequence points}, which represent a partial
1694 ordering between the execution of parts of the program: those executed
1695 before the sequence point, and those executed after it. These occur
1696 after the evaluation of a full expression (one which is not part of a
1697 larger expression), after the evaluation of the first operand of a
1698 @code{&&}, @code{||}, @code{? :} or @code{,} (comma) operator, before a
1699 function is called (but after the evaluation of its arguments and the
1700 expression denoting the called function), and in certain other places.
1701 Other than as expressed by the sequence point rules, the order of
1702 evaluation of subexpressions of an expression is not specified. All
1703 these rules describe only a partial order rather than a total order,
1704 since, for example, if two functions are called within one expression
1705 with no sequence point between them, the order in which the functions
1706 are called is not specified. However, the standards committee have
1707 ruled that function calls do not overlap.
1709 It is not specified when between sequence points modifications to the
1710 values of objects take effect. Programs whose behavior depends on this
1711 have undefined behavior; the C standard specifies that ``Between the
1712 previous and next sequence point an object shall have its stored value
1713 modified at most once by the evaluation of an expression. Furthermore,
1714 the prior value shall be read only to determine the value to be
1715 stored.''. If a program breaks these rules, the results on any
1716 particular implementation are entirely unpredictable.
1718 Examples of code with undefined behavior are @code{a = a++;}, @code{a[n]
1719 = b[n++]} and @code{a[i++] = i;}. Some more complicated cases are not
1720 diagnosed by this option, and it may give an occasional false positive
1721 result, but in general it has been found fairly effective at detecting
1722 this sort of problem in programs.
1724 The present implementation of this option only works for C programs. A
1725 future implementation may also work for C++ programs.
1727 There is some controversy over the precise meaning of the sequence point
1728 rules in subtle cases. Alternative formal definitions may be found in
1729 Clive Feather's ``Annex S''
1730 @uref{http://wwwold.dkuug.dk/JTC1/SC22/WG14/www/docs/n925.htm} and in
1731 Michael Norrish's thesis
1732 @uref{http://www.cl.cam.ac.uk/users/mn200/PhD/thesis-report.ps.gz}.
1733 Other discussions are by Raymond Mak
1734 @uref{http://wwwold.dkuug.dk/JTC1/SC22/WG14/www/docs/n926.htm} and
1736 @uref{http://wwwold.dkuug.dk/JTC1/SC22/WG14/www/docs/n927.htm}.
1739 Warn whenever a function is defined with a return-type that defaults to
1740 @code{int}. Also warn about any @code{return} statement with no
1741 return-value in a function whose return-type is not @code{void}.
1743 For C++, a function without return type always produces a diagnostic
1744 message, even when @samp{-Wno-return-type} is specified. The only
1745 exceptions are @samp{main} and functions defined in system headers.
1748 Warn whenever a @code{switch} statement has an index of enumeral type
1749 and lacks a @code{case} for one or more of the named codes of that
1750 enumeration. (The presence of a @code{default} label prevents this
1751 warning.) @code{case} labels outside the enumeration range also
1752 provoke warnings when this option is used.
1755 Warn if any trigraphs are encountered that might change the meaning of
1756 the program (trigraphs within comments are not warned about).
1758 @item -Wunused-function
1759 Warn whenever a static function is declared but not defined or a
1760 non\-inline static function is unused.
1762 @item -Wunused-label
1763 Warn whenever a label is declared but not used.
1765 To suppress this warning use the @samp{unused} attribute
1766 (@pxref{Variable Attributes}).
1768 @item -Wunused-parameter
1769 Warn whenever a function parameter is unused aside from its declaration.
1771 To suppress this warning use the @samp{unused} attribute
1772 (@pxref{Variable Attributes}).
1774 @item -Wunused-variable
1775 Warn whenever a local variable or non-constant static variable is unused
1776 aside from its declaration
1778 To suppress this warning use the @samp{unused} attribute
1779 (@pxref{Variable Attributes}).
1781 @item -Wunused-value
1782 Warn whenever a statement computes a result that is explicitly not used.
1784 To suppress this warning cast the expression to @samp{void}.
1787 All all the above @samp{-Wunused} options combined.
1789 In order to get a warning about an unused function parameter, you must
1790 either specify @samp{-W -Wunused} or separately specify
1791 @samp{-Wunused-parameter}.
1793 @item -Wuninitialized
1794 Warn if an automatic variable is used without first being initialized or
1795 if a variable may be clobbered by a @code{setjmp} call.
1797 These warnings are possible only in optimizing compilation,
1798 because they require data flow information that is computed only
1799 when optimizing. If you don't specify @samp{-O}, you simply won't
1802 These warnings occur only for variables that are candidates for
1803 register allocation. Therefore, they do not occur for a variable that
1804 is declared @code{volatile}, or whose address is taken, or whose size
1805 is other than 1, 2, 4 or 8 bytes. Also, they do not occur for
1806 structures, unions or arrays, even when they are in registers.
1808 Note that there may be no warning about a variable that is used only
1809 to compute a value that itself is never used, because such
1810 computations may be deleted by data flow analysis before the warnings
1813 These warnings are made optional because GCC is not smart
1814 enough to see all the reasons why the code might be correct
1815 despite appearing to have an error. Here is one example of how
1834 If the value of @code{y} is always 1, 2 or 3, then @code{x} is
1835 always initialized, but GCC doesn't know this. Here is
1836 another common case:
1841 if (change_y) save_y = y, y = new_y;
1843 if (change_y) y = save_y;
1848 This has no bug because @code{save_y} is used only if it is set.
1850 @cindex @code{longjmp} warnings
1851 This option also warns when a non-volatile automatic variable might be
1852 changed by a call to @code{longjmp}. These warnings as well are possible
1853 only in optimizing compilation.
1855 The compiler sees only the calls to @code{setjmp}. It cannot know
1856 where @code{longjmp} will be called; in fact, a signal handler could
1857 call it at any point in the code. As a result, you may get a warning
1858 even when there is in fact no problem because @code{longjmp} cannot
1859 in fact be called at the place which would cause a problem.
1861 Some spurious warnings can be avoided if you declare all the functions
1862 you use that never return as @code{noreturn}. @xref{Function
1865 @item -Wreorder (C++ only)
1866 @cindex reordering, warning
1867 @cindex warning for reordering of member initializers
1868 Warn when the order of member initializers given in the code does not
1869 match the order in which they must be executed. For instance:
1871 @item -Wunknown-pragmas
1872 @cindex warning for unknown pragmas
1873 @cindex unknown pragmas, warning
1874 @cindex pragmas, warning of unknown
1875 Warn when a #pragma directive is encountered which is not understood by
1876 GCC. If this command line option is used, warnings will even be issued
1877 for unknown pragmas in system header files. This is not the case if
1878 the warnings were only enabled by the @samp{-Wall} command line option.
1881 All of the above @samp{-W} options combined. This enables all the
1882 warnings about constructions that some users consider questionable, and
1883 that are easy to avoid (or modify to prevent the warning), even in
1884 conjunction with macros.
1886 @item -Wsystem-headers
1887 @cindex warnings from system headers
1888 @cindex system headers, warnings from
1889 Print warning messages for constructs found in system header files.
1890 Warnings from system headers are normally suppressed, on the assumption
1891 that they usually do not indicate real problems and would only make the
1892 compiler output harder to read. Using this command line option tells
1893 GCC to emit warnings from system headers as if they occurred in user
1894 code. However, note that using @samp{-Wall} in conjunction with this
1895 option will @emph{not} warn about unknown pragmas in system
1896 headers---for that, @samp{-Wunknown-pragmas} must also be used.
1899 The following @samp{-W@dots{}} options are not implied by @samp{-Wall}.
1900 Some of them warn about constructions that users generally do not
1901 consider questionable, but which occasionally you might wish to check
1902 for; others warn about constructions that are necessary or hard to avoid
1903 in some cases, and there is no simple way to modify the code to suppress
1908 Print extra warning messages for these events:
1912 A function can return either with or without a value. (Falling
1913 off the end of the function body is considered returning without
1914 a value.) For example, this function would evoke such a
1928 An expression-statement or the left-hand side of a comma expression
1929 contains no side effects.
1930 To suppress the warning, cast the unused expression to void.
1931 For example, an expression such as @samp{x[i,j]} will cause a warning,
1932 but @samp{x[(void)i,j]} will not.
1935 An unsigned value is compared against zero with @samp{<} or @samp{<=}.
1938 A comparison like @samp{x<=y<=z} appears; this is equivalent to
1939 @samp{(x<=y ? 1 : 0) <= z}, which is a different interpretation from
1940 that of ordinary mathematical notation.
1943 Storage-class specifiers like @code{static} are not the first things in
1944 a declaration. According to the C Standard, this usage is obsolescent.
1947 The return type of a function has a type qualifier such as @code{const}.
1948 Such a type qualifier has no effect, since the value returned by a
1949 function is not an lvalue. (But don't warn about the GNU extension of
1950 @code{volatile void} return types. That extension will be warned about
1951 if @samp{-pedantic} is specified.)
1954 If @samp{-Wall} or @samp{-Wunused} is also specified, warn about unused
1958 A comparison between signed and unsigned values could produce an
1959 incorrect result when the signed value is converted to unsigned.
1960 (But don't warn if @samp{-Wno-sign-compare} is also specified.)
1963 An aggregate has a partly bracketed initializer.
1964 For example, the following code would evoke such a warning,
1965 because braces are missing around the initializer for @code{x.h}:
1968 struct s @{ int f, g; @};
1969 struct t @{ struct s h; int i; @};
1970 struct t x = @{ 1, 2, 3 @};
1974 An aggregate has an initializer which does not initialize all members.
1975 For example, the following code would cause such a warning, because
1976 @code{x.h} would be implicitly initialized to zero:
1979 struct s @{ int f, g, h; @};
1980 struct s x = @{ 3, 4 @};
1985 Warn if floating point values are used in equality comparisons.
1987 The idea behind this is that sometimes it is convenient (for the
1988 programmer) to consider floating-point values as approximations to
1989 infinitely precise real numbers. If you are doing this, then you need
1990 to compute (by analysing the code, or in some other way) the maximum or
1991 likely maximum error that the computation introduces, and allow for it
1992 when performing comparisons (and when producing output, but that's a
1993 different problem). In particular, instead of testing for equality, you
1994 would check to see whether the two values have ranges that overlap; and
1995 this is done with the relational operators, so equality comparisons are
1998 @item -Wtraditional (C only)
1999 Warn about certain constructs that behave differently in traditional and
2004 Macro arguments occurring within string constants in the macro body.
2005 These would substitute the argument in traditional C, but are part of
2006 the constant in ISO C.
2009 A function declared external in one block and then used after the end of
2013 A @code{switch} statement has an operand of type @code{long}.
2016 A non-@code{static} function declaration follows a @code{static} one.
2017 This construct is not accepted by some traditional C compilers.
2020 The ISO type of an integer constant has a different width or
2021 signedness from its traditional type. This warning is only issued if
2022 the base of the constant is ten. I.e. hexadecimal or octal values, which
2023 typically represent bit patterns, are not warned about.
2026 Usage of ISO string concatenation is detected.
2029 A function macro appears without arguments.
2032 The unary plus operator.
2035 Initialization of automatic aggregates.
2038 Identifier conflicts with labels. Traditional C lacks a separate
2039 namespace for labels.
2042 Initialization of unions. If the initializer is zero, the warning is
2043 omitted. This is done under the assumption that the zero initializer in
2044 user code appears conditioned on e.g. @code{__STDC__} to avoid missing
2045 initializer warnings and relies on default initialization to zero in the
2049 The `U' integer constant suffix, or the `F' or `L' floating point
2050 constant suffixes. (Traditonal C does support the `L' suffix on integer
2051 constants.) Note, these suffixes appear in macros defined in the system
2052 headers of most modern systems, e.g. the _MIN/_MAX macros in limits.h.
2053 Use of these macros can lead to spurious warnings as they do not
2054 necessarily reflect whether the code in question is any less portable to
2055 traditional C given that suitable backup definitions are provided.
2059 Warn if an undefined identifier is evaluated in an @samp{#if} directive.
2062 Warn whenever a local variable shadows another local variable.
2064 @item -Wid-clash-@var{len}
2065 Warn whenever two distinct identifiers match in the first @var{len}
2066 characters. This may help you prepare a program that will compile
2067 with certain obsolete, brain-damaged compilers.
2069 @item -Wlarger-than-@var{len}
2070 Warn whenever an object of larger than @var{len} bytes is defined.
2072 @item -Wpointer-arith
2073 Warn about anything that depends on the ``size of'' a function type or
2074 of @code{void}. GNU C assigns these types a size of 1, for
2075 convenience in calculations with @code{void *} pointers and pointers
2078 @item -Wbad-function-cast (C only)
2079 Warn whenever a function call is cast to a non-matching type.
2080 For example, warn if @code{int malloc()} is cast to @code{anything *}.
2083 Warn whenever a pointer is cast so as to remove a type qualifier from
2084 the target type. For example, warn if a @code{const char *} is cast
2085 to an ordinary @code{char *}.
2088 Warn whenever a pointer is cast such that the required alignment of the
2089 target is increased. For example, warn if a @code{char *} is cast to
2090 an @code{int *} on machines where integers can only be accessed at
2091 two- or four-byte boundaries.
2093 @item -Wwrite-strings
2094 Give string constants the type @code{const char[@var{length}]} so that
2095 copying the address of one into a non-@code{const} @code{char *}
2096 pointer will get a warning. These warnings will help you find at
2097 compile time code that can try to write into a string constant, but
2098 only if you have been very careful about using @code{const} in
2099 declarations and prototypes. Otherwise, it will just be a nuisance;
2100 this is why we did not make @samp{-Wall} request these warnings.
2103 Warn if a prototype causes a type conversion that is different from what
2104 would happen to the same argument in the absence of a prototype. This
2105 includes conversions of fixed point to floating and vice versa, and
2106 conversions changing the width or signedness of a fixed point argument
2107 except when the same as the default promotion.
2109 Also, warn if a negative integer constant expression is implicitly
2110 converted to an unsigned type. For example, warn about the assignment
2111 @code{x = -1} if @code{x} is unsigned. But do not warn about explicit
2112 casts like @code{(unsigned) -1}.
2114 @item -Wsign-compare
2115 @cindex warning for comparison of signed and unsigned values
2116 @cindex comparison of signed and unsigned values, warning
2117 @cindex signed and unsigned values, comparison warning
2118 Warn when a comparison between signed and unsigned values could produce
2119 an incorrect result when the signed value is converted to unsigned.
2120 This warning is also enabled by @samp{-W}; to get the other warnings
2121 of @samp{-W} without this warning, use @samp{-W -Wno-sign-compare}.
2123 @item -Waggregate-return
2124 Warn if any functions that return structures or unions are defined or
2125 called. (In languages where you can return an array, this also elicits
2128 @item -Wstrict-prototypes (C only)
2129 Warn if a function is declared or defined without specifying the
2130 argument types. (An old-style function definition is permitted without
2131 a warning if preceded by a declaration which specifies the argument
2134 @item -Wmissing-prototypes (C only)
2135 Warn if a global function is defined without a previous prototype
2136 declaration. This warning is issued even if the definition itself
2137 provides a prototype. The aim is to detect global functions that fail
2138 to be declared in header files.
2140 @item -Wmissing-declarations
2141 Warn if a global function is defined without a previous declaration.
2142 Do so even if the definition itself provides a prototype.
2143 Use this option to detect global functions that are not declared in
2146 @item -Wmissing-noreturn
2147 Warn about functions which might be candidates for attribute @code{noreturn}.
2148 Note these are only possible candidates, not absolute ones. Care should
2149 be taken to manually verify functions actually do not ever return before
2150 adding the @code{noreturn} attribute, otherwise subtle code generation
2151 bugs could be introduced.
2153 @item -Wmissing-format-attribute
2154 If @samp{-Wformat} is enabled, also warn about functions which might be
2155 candidates for @code{format} attributes. Note these are only possible
2156 candidates, not absolute ones. GCC will guess that @code{format}
2157 attributes might be appropriate for any function that calls a function
2158 like @code{vprintf} or @code{vscanf}, but this might not always be the
2159 case, and some functions for which @code{format} attributes are
2160 appropriate may not be detected. This option has no effect unless
2161 @samp{-Wformat} is enabled (possibly by @samp{-Wall}).
2164 Warn if a structure is given the packed attribute, but the packed
2165 attribute has no effect on the layout or size of the structure.
2166 Such structures may be mis-aligned for little benefit. For
2167 instance, in this code, the variable @code{f.x} in @code{struct bar}
2168 will be misaligned even though @code{struct bar} does not itself
2169 have the packed attribute:
2176 @} __attribute__((packed));
2185 Warn if padding is included in a structure, either to align an element
2186 of the structure or to align the whole structure. Sometimes when this
2187 happens it is possible to rearrange the fields of the structure to
2188 reduce the padding and so make the structure smaller.
2190 @item -Wredundant-decls
2191 Warn if anything is declared more than once in the same scope, even in
2192 cases where multiple declaration is valid and changes nothing.
2194 @item -Wnested-externs (C only)
2195 Warn if an @code{extern} declaration is encountered within a function.
2197 @item -Wunreachable-code
2198 Warn if the compiler detects that code will never be executed.
2200 This option is intended to warn when the compiler detects that at
2201 least a whole line of source code will never be executed, because
2202 some condition is never satisfied or because it is after a
2203 procedure that never returns.
2205 It is possible for this option to produce a warning even though there
2206 are circumstances under which part of the affected line can be executed,
2207 so care should be taken when removing apparently-unreachable code.
2209 For instance, when a function is inlined, a warning may mean that the
2210 line is unreachable in only one inlined copy of the function.
2212 This option is not made part of @samp{-Wall} because in a debugging
2213 version of a program there is often substantial code which checks
2214 correct functioning of the program and is, hopefully, unreachable
2215 because the program does work. Another common use of unreachable
2216 code is to provide behaviour which is selectable at compile-time.
2219 Warn if a function can not be inlined and it was declared as inline.
2222 Warn if @samp{long long} type is used. This is default. To inhibit
2223 the warning messages, use @samp{-Wno-long-long}. Flags
2224 @samp{-Wlong-long} and @samp{-Wno-long-long} are taken into account
2225 only when @samp{-pedantic} flag is used.
2227 @item -Wdisabled-optimization
2228 Warn if a requested optimization pass is disabled. This warning does
2229 not generally indicate that there is anything wrong with your code; it
2230 merely indicates that GCC's optimizers were unable to handle the code
2231 effectively. Often, the problem is that your code is too big or too
2232 complex; GCC will refuse to optimize programs when the optimization
2233 itself is likely to take inordinate amounts of time.
2236 Make all warnings into errors.
2239 @node Debugging Options
2240 @section Options for Debugging Your Program or GCC
2241 @cindex options, debugging
2242 @cindex debugging information options
2244 GCC has various special options that are used for debugging
2245 either your program or GCC:
2249 Produce debugging information in the operating system's native format
2250 (stabs, COFF, XCOFF, or DWARF). GDB can work with this debugging
2253 On most systems that use stabs format, @samp{-g} enables use of extra
2254 debugging information that only GDB can use; this extra information
2255 makes debugging work better in GDB but will probably make other debuggers
2257 refuse to read the program. If you want to control for certain whether
2258 to generate the extra information, use @samp{-gstabs+}, @samp{-gstabs},
2259 @samp{-gxcoff+}, @samp{-gxcoff}, @samp{-gdwarf-1+}, or @samp{-gdwarf-1}
2262 Unlike most other C compilers, GCC allows you to use @samp{-g} with
2263 @samp{-O}. The shortcuts taken by optimized code may occasionally
2264 produce surprising results: some variables you declared may not exist
2265 at all; flow of control may briefly move where you did not expect it;
2266 some statements may not be executed because they compute constant
2267 results or their values were already at hand; some statements may
2268 execute in different places because they were moved out of loops.
2270 Nevertheless it proves possible to debug optimized output. This makes
2271 it reasonable to use the optimizer for programs that might have bugs.
2273 The following options are useful when GCC is generated with the
2274 capability for more than one debugging format.
2277 Produce debugging information for use by GDB. This means to use the
2278 most expressive format available (DWARF 2, stabs, or the native format
2279 if neither of those are supported), including GDB extensions if at all
2283 Produce debugging information in stabs format (if that is supported),
2284 without GDB extensions. This is the format used by DBX on most BSD
2285 systems. On MIPS, Alpha and System V Release 4 systems this option
2286 produces stabs debugging output which is not understood by DBX or SDB.
2287 On System V Release 4 systems this option requires the GNU assembler.
2290 Produce debugging information in stabs format (if that is supported),
2291 using GNU extensions understood only by the GNU debugger (GDB). The
2292 use of these extensions is likely to make other debuggers crash or
2293 refuse to read the program.
2296 Produce debugging information in COFF format (if that is supported).
2297 This is the format used by SDB on most System V systems prior to
2301 Produce debugging information in XCOFF format (if that is supported).
2302 This is the format used by the DBX debugger on IBM RS/6000 systems.
2305 Produce debugging information in XCOFF format (if that is supported),
2306 using GNU extensions understood only by the GNU debugger (GDB). The
2307 use of these extensions is likely to make other debuggers crash or
2308 refuse to read the program, and may cause assemblers other than the GNU
2309 assembler (GAS) to fail with an error.
2312 Produce debugging information in DWARF version 1 format (if that is
2313 supported). This is the format used by SDB on most System V Release 4
2317 Produce debugging information in DWARF version 1 format (if that is
2318 supported), using GNU extensions understood only by the GNU debugger
2319 (GDB). The use of these extensions is likely to make other debuggers
2320 crash or refuse to read the program.
2323 Produce debugging information in DWARF version 2 format (if that is
2324 supported). This is the format used by DBX on IRIX 6.
2327 @itemx -ggdb@var{level}
2328 @itemx -gstabs@var{level}
2329 @itemx -gcoff@var{level}
2330 @itemx -gxcoff@var{level}
2331 @itemx -gdwarf@var{level}
2332 @itemx -gdwarf-2@var{level}
2333 Request debugging information and also use @var{level} to specify how
2334 much information. The default level is 2.
2336 Level 1 produces minimal information, enough for making backtraces in
2337 parts of the program that you don't plan to debug. This includes
2338 descriptions of functions and external variables, but no information
2339 about local variables and no line numbers.
2341 Level 3 includes extra information, such as all the macro definitions
2342 present in the program. Some debuggers support macro expansion when
2347 Generate extra code to write profile information suitable for the
2348 analysis program @code{prof}. You must use this option when compiling
2349 the source files you want data about, and you must also use it when
2352 @cindex @code{gprof}
2354 Generate extra code to write profile information suitable for the
2355 analysis program @code{gprof}. You must use this option when compiling
2356 the source files you want data about, and you must also use it when
2361 Generate extra code to write profile information for basic blocks, which will
2362 record the number of times each basic block is executed, the basic block start
2363 address, and the function name containing the basic block. If @samp{-g} is
2364 used, the line number and filename of the start of the basic block will also be
2365 recorded. If not overridden by the machine description, the default action is
2366 to append to the text file @file{bb.out}.
2368 This data could be analyzed by a program like @code{tcov}. Note,
2369 however, that the format of the data is not what @code{tcov} expects.
2370 Eventually GNU @code{gprof} should be extended to process this data.
2373 Makes the compiler print out each function name as it is compiled, and
2374 print some statistics about each pass when it finishes.
2377 Generate extra code to profile basic blocks. Your executable will
2378 produce output that is a superset of that produced when @samp{-a} is
2379 used. Additional output is the source and target address of the basic
2380 blocks where a jump takes place, the number of times a jump is executed,
2381 and (optionally) the complete sequence of basic blocks being executed.
2382 The output is appended to file @file{bb.out}.
2384 You can examine different profiling aspects without recompilation. Your
2385 executable will read a list of function names from file @file{bb.in}.
2386 Profiling starts when a function on the list is entered and stops when
2387 that invocation is exited. To exclude a function from profiling, prefix
2388 its name with `-'. If a function name is not unique, you can
2389 disambiguate it by writing it in the form
2390 @samp{/path/filename.d:functionname}. Your executable will write the
2391 available paths and filenames in file @file{bb.out}.
2393 Several function names have a special meaning:
2396 Write source, target and frequency of jumps to file @file{bb.out}.
2397 @item __bb_hidecall__
2398 Exclude function calls from frequency count.
2399 @item __bb_showret__
2400 Include function returns in frequency count.
2402 Write the sequence of basic blocks executed to file @file{bbtrace.gz}.
2403 The file will be compressed using the program @samp{gzip}, which must
2404 exist in your @code{PATH}. On systems without the @samp{popen}
2405 function, the file will be named @file{bbtrace} and will not be
2406 compressed. @strong{Profiling for even a few seconds on these systems
2407 will produce a very large file.} Note: @code{__bb_hidecall__} and
2408 @code{__bb_showret__} will not affect the sequence written to
2412 Here's a short example using different profiling parameters
2413 in file @file{bb.in}. Assume function @code{foo} consists of basic blocks
2414 1 and 2 and is called twice from block 3 of function @code{main}. After
2415 the calls, block 3 transfers control to block 4 of @code{main}.
2417 With @code{__bb_trace__} and @code{main} contained in file @file{bb.in},
2418 the following sequence of blocks is written to file @file{bbtrace.gz}:
2419 0 3 1 2 1 2 4. The return from block 2 to block 3 is not shown, because
2420 the return is to a point inside the block and not to the top. The
2421 block address 0 always indicates, that control is transferred
2422 to the trace from somewhere outside the observed functions. With
2423 @samp{-foo} added to @file{bb.in}, the blocks of function
2424 @code{foo} are removed from the trace, so only 0 3 4 remains.
2426 With @code{__bb_jumps__} and @code{main} contained in file @file{bb.in},
2427 jump frequencies will be written to file @file{bb.out}. The
2428 frequencies are obtained by constructing a trace of blocks
2429 and incrementing a counter for every neighbouring pair of blocks
2430 in the trace. The trace 0 3 1 2 1 2 4 displays the following
2434 Jump from block 0x0 to block 0x3 executed 1 time(s)
2435 Jump from block 0x3 to block 0x1 executed 1 time(s)
2436 Jump from block 0x1 to block 0x2 executed 2 time(s)
2437 Jump from block 0x2 to block 0x1 executed 1 time(s)
2438 Jump from block 0x2 to block 0x4 executed 1 time(s)
2441 With @code{__bb_hidecall__}, control transfer due to call instructions
2442 is removed from the trace, that is the trace is cut into three parts: 0
2443 3 4, 0 1 2 and 0 1 2. With @code{__bb_showret__}, control transfer due
2444 to return instructions is added to the trace. The trace becomes: 0 3 1
2445 2 3 1 2 3 4. Note, that this trace is not the same, as the sequence
2446 written to @file{bbtrace.gz}. It is solely used for counting jump
2449 @item -fprofile-arcs
2450 Instrument @dfn{arcs} during compilation. For each function of your
2451 program, GCC creates a program flow graph, then finds a spanning tree
2452 for the graph. Only arcs that are not on the spanning tree have to be
2453 instrumented: the compiler adds code to count the number of times that these
2454 arcs are executed. When an arc is the only exit or only entrance to a
2455 block, the instrumentation code can be added to the block; otherwise, a
2456 new basic block must be created to hold the instrumentation code.
2458 Since not every arc in the program must be instrumented, programs
2459 compiled with this option run faster than programs compiled with
2460 @samp{-a}, which adds instrumentation code to every basic block in the
2461 program. The tradeoff: since @code{gcov} does not have
2462 execution counts for all branches, it must start with the execution
2463 counts for the instrumented branches, and then iterate over the program
2464 flow graph until the entire graph has been solved. Hence, @code{gcov}
2465 runs a little more slowly than a program which uses information from
2468 @samp{-fprofile-arcs} also makes it possible to estimate branch
2469 probabilities, and to calculate basic block execution counts. In
2470 general, basic block execution counts do not give enough information to
2471 estimate all branch probabilities. When the compiled program exits, it
2472 saves the arc execution counts to a file called
2473 @file{@var{sourcename}.da}. Use the compiler option
2474 @samp{-fbranch-probabilities} (@pxref{Optimize Options,,Options that
2475 Control Optimization}) when recompiling, to optimize using estimated
2476 branch probabilities.
2479 @item -ftest-coverage
2480 Create data files for the @code{gcov} code-coverage utility
2481 (@pxref{Gcov,, @code{gcov}: a GCC Test Coverage Program}).
2482 The data file names begin with the name of your source file:
2485 @item @var{sourcename}.bb
2486 A mapping from basic blocks to line numbers, which @code{gcov} uses to
2487 associate basic block execution counts with line numbers.
2489 @item @var{sourcename}.bbg
2490 A list of all arcs in the program flow graph. This allows @code{gcov}
2491 to reconstruct the program flow graph, so that it can compute all basic
2492 block and arc execution counts from the information in the
2493 @code{@var{sourcename}.da} file (this last file is the output from
2494 @samp{-fprofile-arcs}).
2497 @item -d@var{letters}
2498 Says to make debugging dumps during compilation at times specified by
2499 @var{letters}. This is used for debugging the compiler. The file names
2500 for most of the dumps are made by appending a pass number and a word to
2501 the source file name (e.g. @file{foo.c.00.rtl} or @file{foo.c.01.sibling}).
2502 Here are the possible letters for use in @var{letters}, and their meanings:
2506 Annotate the assembler output with miscellaneous debugging information.
2508 Dump after computing branch probabilities, to @file{@var{file}.11.bp}.
2510 Dump after block reordering, to @file{@var{file}.26.bbro}.
2512 Dump after instruction combination, to the file @file{@var{file}.14.combine}.
2514 Dump after the first if conversion, to the file @file{@var{file}.15.ce}.
2516 Dump after delayed branch scheduling, to @file{@var{file}.29.dbr}.
2518 Dump all macro definitions, at the end of preprocessing, in addition to
2521 Dump after SSA optimizations, to @file{@var{file}.05.ssa} and
2522 @file{@var{file}.06.ussa}.
2524 Dump after the second if conversion, to @file{@var{file}.24.ce2}.
2526 Dump after life analysis, to @file{@var{file}.13.life}.
2528 Dump after purging @code{ADDRESSOF} codes, to @file{@var{file}.04.addressof}.
2530 Dump after global register allocation, to @file{@var{file}.19.greg}.
2532 Dump after post-reload CSE and other optimizations, to @file{@var{file}.20.postreload}.
2534 Dump after GCSE, to @file{@var{file}.08.gcse}.
2536 Dump after sibling call optimizations, to @file{@var{file}.01.sibling}.
2538 Dump after the first jump optimization, to @file{@var{file}.02.jump}.
2540 Dump after the last jump optimization, to @file{@var{file}.27.jump2}.
2542 Dump after conversion from registers to stack, to @file{@var{file}.29.stack}.
2544 Dump after local register allocation, to @file{@var{file}.18.lreg}.
2546 Dump after loop optimization, to @file{@var{file}.09.loop}.
2548 Dump after performing the machine dependent reorganisation pass, to
2549 @file{@var{file}.28.mach}.
2551 Dump after register renumbering, to @file{@var{file}.23.rnreg}.
2553 Dump after the register move pass, to @file{@var{file}.16.regmove}.
2555 Dump after RTL generation, to @file{@var{file}.00.rtl}.
2557 Dump after the second instruction scheduling pass, to
2558 @file{@var{file}.25.sched2}.
2560 Dump after CSE (including the jump optimization that sometimes follows
2561 CSE), to @file{@var{file}.03.cse}.
2563 Dump after the first instruction scheduling pass, to
2564 @file{@var{file}.17.sched}.
2566 Dump after the second CSE pass (including the jump optimization that
2567 sometimes follows CSE), to @file{@var{file}.10.cse2}.
2569 Dump after the second flow pass, to @file{@var{file}.21.flow2}.
2571 Dump after dead code elimination, to @file{@var{file}.06.dce}.
2573 Dump after the peephole pass, to @file{@var{file}.22.peephole2}.
2575 Produce all the dumps listed above.
2577 Print statistics on memory usage, at the end of the run, to
2580 Annotate the assembler output with a comment indicating which
2581 pattern and alternative was used. The length of each instruction is
2584 Dump the RTL in the assembler output as a comment before each instruction.
2585 Also turns on @samp{-dp} annotation.
2587 For each of the other indicated dump files (except for
2588 @file{@var{file}.00.rtl}), dump a representation of the control flow graph
2589 suitable for viewing with VCG to @file{@var{file}.@var{pass}.vcg}.
2591 Just generate RTL for a function instead of compiling it. Usually used
2594 Dump debugging information during parsing, to standard error.
2597 @item -fdump-unnumbered
2598 When doing debugging dumps (see -d option above), suppress instruction
2599 numbers and line number note output. This makes it more feasible to
2600 use diff on debugging dumps for compiler invocations with different
2601 options, in particular with and without -g.
2603 @item -fdump-translation-unit-@var{file} (C and C++ only)
2604 Dump a representation of the tree structure for the entire translation
2607 @item -fpretend-float
2608 When running a cross-compiler, pretend that the target machine uses the
2609 same floating point format as the host machine. This causes incorrect
2610 output of the actual floating constants, but the actual instruction
2611 sequence will probably be the same as GCC would make when running on
2615 Store the usual ``temporary'' intermediate files permanently; place them
2616 in the current directory and name them based on the source file. Thus,
2617 compiling @file{foo.c} with @samp{-c -save-temps} would produce files
2618 @file{foo.i} and @file{foo.s}, as well as @file{foo.o}. This creates a
2619 preprocessed @file{foo.i} output file even though the compiler now
2620 normally uses an integrated preprocessor.
2623 Report the CPU time taken by each subprocess in the compilation
2624 sequence. For C source files, this is the compiler proper and assembler
2625 (plus the linker if linking is done). The output looks like this:
2632 The first number on each line is the ``user time,'' that is time spent
2633 executing the program itself. The second number is ``system time,''
2634 time spent executing operating system routines on behalf of the program.
2635 Both numbers are in seconds.
2637 @item -print-file-name=@var{library}
2638 Print the full absolute name of the library file @var{library} that
2639 would be used when linking---and don't do anything else. With this
2640 option, GCC does not compile or link anything; it just prints the
2643 @item -print-prog-name=@var{program}
2644 Like @samp{-print-file-name}, but searches for a program such as @samp{cpp}.
2646 @item -print-libgcc-file-name
2647 Same as @samp{-print-file-name=libgcc.a}.
2649 This is useful when you use @samp{-nostdlib} or @samp{-nodefaultlibs}
2650 but you do want to link with @file{libgcc.a}. You can do
2653 gcc -nostdlib @var{files}@dots{} `gcc -print-libgcc-file-name`
2656 @item -print-search-dirs
2657 Print the name of the configured installation directory and a list of
2658 program and library directories gcc will search---and don't do anything else.
2660 This is useful when gcc prints the error message
2661 @samp{installation problem, cannot exec cpp: No such file or directory}.
2662 To resolve this you either need to put @file{cpp} and the other compiler
2663 components where gcc expects to find them, or you can set the environment
2664 variable @code{GCC_EXEC_PREFIX} to the directory where you installed them.
2665 Don't forget the trailing '/'.
2666 @xref{Environment Variables}.
2669 @node Optimize Options
2670 @section Options That Control Optimization
2671 @cindex optimize options
2672 @cindex options, optimization
2674 These options control various sorts of optimizations:
2679 Optimize. Optimizing compilation takes somewhat more time, and a lot
2680 more memory for a large function.
2682 Without @samp{-O}, the compiler's goal is to reduce the cost of
2683 compilation and to make debugging produce the expected results.
2684 Statements are independent: if you stop the program with a breakpoint
2685 between statements, you can then assign a new value to any variable or
2686 change the program counter to any other statement in the function and
2687 get exactly the results you would expect from the source code.
2689 Without @samp{-O}, the compiler only allocates variables declared
2690 @code{register} in registers. The resulting compiled code is a little
2691 worse than produced by PCC without @samp{-O}.
2693 With @samp{-O}, the compiler tries to reduce code size and execution
2696 When you specify @samp{-O}, the compiler turns on @samp{-fthread-jumps}
2697 and @samp{-fdefer-pop} on all machines. The compiler turns on
2698 @samp{-fdelayed-branch} on machines that have delay slots, and
2699 @samp{-fomit-frame-pointer} on machines that can support debugging even
2700 without a frame pointer. On some machines the compiler also turns
2701 on other flags.@refill
2704 Optimize even more. GCC performs nearly all supported optimizations
2705 that do not involve a space-speed tradeoff. The compiler does not
2706 perform loop unrolling or function inlining when you specify @samp{-O2}.
2707 As compared to @samp{-O}, this option increases both compilation time
2708 and the performance of the generated code.
2710 @samp{-O2} turns on all optional optimizations except for loop unrolling,
2711 function inlining, and register renaming. It also turns on the
2712 @samp{-fforce-mem} option on all machines and frame pointer elimination
2713 on machines where doing so does not interfere with debugging.
2716 Optimize yet more. @samp{-O3} turns on all optimizations specified by
2717 @samp{-O2} and also turns on the @samp{-finline-functions} and
2718 @samp{-frename-registers} options.
2724 Optimize for size. @samp{-Os} enables all @samp{-O2} optimizations that
2725 do not typically increase code size. It also performs further
2726 optimizations designed to reduce code size.
2728 If you use multiple @samp{-O} options, with or without level numbers,
2729 the last such option is the one that is effective.
2732 Options of the form @samp{-f@var{flag}} specify machine-independent
2733 flags. Most flags have both positive and negative forms; the negative
2734 form of @samp{-ffoo} would be @samp{-fno-foo}. In the table below,
2735 only one of the forms is listed---the one which is not the default.
2736 You can figure out the other form by either removing @samp{no-} or
2741 Do not store floating point variables in registers, and inhibit other
2742 options that might change whether a floating point value is taken from a
2745 @cindex floating point precision
2746 This option prevents undesirable excess precision on machines such as
2747 the 68000 where the floating registers (of the 68881) keep more
2748 precision than a @code{double} is supposed to have. Similarly for the
2749 x86 architecture. For most programs, the excess precision does only
2750 good, but a few programs rely on the precise definition of IEEE floating
2751 point. Use @samp{-ffloat-store} for such programs, after modifying
2752 them to store all pertinent intermediate computations into variables.
2754 @item -fno-default-inline
2755 Do not make member functions inline by default merely because they are
2756 defined inside the class scope (C++ only). Otherwise, when you specify
2757 @w{@samp{-O}}, member functions defined inside class scope are compiled
2758 inline by default; i.e., you don't need to add @samp{inline} in front of
2759 the member function name.
2761 @item -fno-defer-pop
2762 Always pop the arguments to each function call as soon as that function
2763 returns. For machines which must pop arguments after a function call,
2764 the compiler normally lets arguments accumulate on the stack for several
2765 function calls and pops them all at once.
2768 Force memory operands to be copied into registers before doing
2769 arithmetic on them. This produces better code by making all memory
2770 references potential common subexpressions. When they are not common
2771 subexpressions, instruction combination should eliminate the separate
2772 register-load. The @samp{-O2} option turns on this option.
2775 Force memory address constants to be copied into registers before
2776 doing arithmetic on them. This may produce better code just as
2777 @samp{-fforce-mem} may.
2779 @item -fomit-frame-pointer
2780 Don't keep the frame pointer in a register for functions that
2781 don't need one. This avoids the instructions to save, set up and
2782 restore frame pointers; it also makes an extra register available
2783 in many functions. @strong{It also makes debugging impossible on
2787 On some machines, such as the Vax, this flag has no effect, because
2788 the standard calling sequence automatically handles the frame pointer
2789 and nothing is saved by pretending it doesn't exist. The
2790 machine-description macro @code{FRAME_POINTER_REQUIRED} controls
2791 whether a target machine supports this flag. @xref{Registers}.@refill
2794 On some machines, such as the Vax, this flag has no effect, because
2795 the standard calling sequence automatically handles the frame pointer
2796 and nothing is saved by pretending it doesn't exist. The
2797 machine-description macro @code{FRAME_POINTER_REQUIRED} controls
2798 whether a target machine supports this flag. @xref{Registers,,Register
2799 Usage, gcc.info, Using and Porting GCC}.@refill
2802 @item -foptimize-sibling-calls
2803 Optimize sibling and tail recursive calls.
2806 This option generates traps for signed overflow on addition, subtraction,
2807 multiplication operations.
2810 Don't pay attention to the @code{inline} keyword. Normally this option
2811 is used to keep the compiler from expanding any functions inline.
2812 Note that if you are not optimizing, no functions can be expanded inline.
2814 @item -finline-functions
2815 Integrate all simple functions into their callers. The compiler
2816 heuristically decides which functions are simple enough to be worth
2817 integrating in this way.
2819 If all calls to a given function are integrated, and the function is
2820 declared @code{static}, then the function is normally not output as
2821 assembler code in its own right.
2823 @item -finline-limit=@var{n}
2824 By default, gcc limits the size of functions that can be inlined. This flag
2825 allows the control of this limit for functions that are explicitly marked as
2826 inline (ie marked with the inline keyword or defined within the class
2827 definition in c++). @var{n} is the size of functions that can be inlined in
2828 number of pseudo instructions (not counting parameter handling). The default
2829 value of n is 10000. Increasing this value can result in more inlined code at
2830 the cost of compilation time and memory consumption. Decreasing usually makes
2831 the compilation faster and less code will be inlined (which presumably
2832 means slower programs). This option is particularly useful for programs that
2833 use inlining heavily such as those based on recursive templates with c++.
2835 @emph{Note:} pseudo instruction represents, in this particular context, an
2836 abstract measurement of function's size. In no way, it represents a count
2837 of assembly instructions and as such its exact meaning might change from one
2838 release to an another.
2840 @item -fkeep-inline-functions
2841 Even if all calls to a given function are integrated, and the function
2842 is declared @code{static}, nevertheless output a separate run-time
2843 callable version of the function. This switch does not affect
2844 @code{extern inline} functions.
2846 @item -fkeep-static-consts
2847 Emit variables declared @code{static const} when optimization isn't turned
2848 on, even if the variables aren't referenced.
2850 GCC enables this option by default. If you want to force the compiler to
2851 check if the variable was referenced, regardless of whether or not
2852 optimization is turned on, use the @samp{-fno-keep-static-consts} option.
2854 @item -fno-function-cse
2855 Do not put function addresses in registers; make each instruction that
2856 calls a constant function contain the function's address explicitly.
2858 This option results in less efficient code, but some strange hacks
2859 that alter the assembler output may be confused by the optimizations
2860 performed when this option is not used.
2863 This option allows GCC to violate some ISO or IEEE rules and/or
2864 specifications in the interest of optimizing code for speed. For
2865 example, it allows the compiler to assume arguments to the @code{sqrt}
2866 function are non-negative numbers and that no floating-point values
2869 This option should never be turned on by any @samp{-O} option since
2870 it can result in incorrect output for programs which depend on
2871 an exact implementation of IEEE or ISO rules/specifications for
2874 @item -fno-math-errno
2875 Do not set ERRNO after calling math functions that are executed
2876 with a single instruction, e.g., sqrt. A program that relies on
2877 IEEE exceptions for math error handling may want to use this flag
2878 for speed while maintaining IEEE arithmetic compatibility.
2880 The default is @samp{-fmath-errno}. The @samp{-ffast-math} option
2881 sets @samp{-fno-math-errno}.
2884 @c following causes underfulls.. they don't look great, but we deal.
2886 The following options control specific optimizations. The @samp{-O2}
2887 option turns on all of these optimizations except @samp{-funroll-loops}
2888 and @samp{-funroll-all-loops}. On most machines, the @samp{-O} option
2889 turns on the @samp{-fthread-jumps} and @samp{-fdelayed-branch} options,
2890 but specific machines may handle it differently.
2892 You can use the following flags in the rare cases when ``fine-tuning''
2893 of optimizations to be performed is desired.
2896 @item -fstrength-reduce
2897 Perform the optimizations of loop strength reduction and
2898 elimination of iteration variables.
2900 @item -fthread-jumps
2901 Perform optimizations where we check to see if a jump branches to a
2902 location where another comparison subsumed by the first is found. If
2903 so, the first branch is redirected to either the destination of the
2904 second branch or a point immediately following it, depending on whether
2905 the condition is known to be true or false.
2907 @item -fcse-follow-jumps
2908 In common subexpression elimination, scan through jump instructions
2909 when the target of the jump is not reached by any other path. For
2910 example, when CSE encounters an @code{if} statement with an
2911 @code{else} clause, CSE will follow the jump when the condition
2914 @item -fcse-skip-blocks
2915 This is similar to @samp{-fcse-follow-jumps}, but causes CSE to
2916 follow jumps which conditionally skip over blocks. When CSE
2917 encounters a simple @code{if} statement with no else clause,
2918 @samp{-fcse-skip-blocks} causes CSE to follow the jump around the
2919 body of the @code{if}.
2921 @item -frerun-cse-after-loop
2922 Re-run common subexpression elimination after loop optimizations has been
2925 @item -frerun-loop-opt
2926 Run the loop optimizer twice.
2929 Perform a global common subexpression elimination pass.
2930 This pass also performs global constant and copy propagation.
2932 @item -fdelete-null-pointer-checks
2933 Use global dataflow analysis to identify and eliminate useless null
2934 pointer checks. Programs which rely on NULL pointer dereferences @emph{not}
2935 halting the program may not work properly with this option. Use
2936 -fno-delete-null-pointer-checks to disable this optimizing for programs
2937 which depend on that behavior.
2939 @item -fexpensive-optimizations
2940 Perform a number of minor optimizations that are relatively expensive.
2942 @item -foptimize-register-move
2944 Attempt to reassign register numbers in move instructions and as
2945 operands of other simple instructions in order to maximize the amount of
2946 register tying. This is especially helpful on machines with two-operand
2947 instructions. GCC enables this optimization by default with @samp{-O2}
2950 Note @code{-fregmove} and @code{-foptimize-register-move} are the same
2953 @item -fdelayed-branch
2954 If supported for the target machine, attempt to reorder instructions
2955 to exploit instruction slots available after delayed branch
2958 @item -fschedule-insns
2959 If supported for the target machine, attempt to reorder instructions to
2960 eliminate execution stalls due to required data being unavailable. This
2961 helps machines that have slow floating point or memory load instructions
2962 by allowing other instructions to be issued until the result of the load
2963 or floating point instruction is required.
2965 @item -fschedule-insns2
2966 Similar to @samp{-fschedule-insns}, but requests an additional pass of
2967 instruction scheduling after register allocation has been done. This is
2968 especially useful on machines with a relatively small number of
2969 registers and where memory load instructions take more than one cycle.
2971 @item -ffunction-sections
2972 @itemx -fdata-sections
2973 Place each function or data item into its own section in the output
2974 file if the target supports arbitrary sections. The name of the
2975 function or the name of the data item determines the section's name
2978 Use these options on systems where the linker can perform optimizations
2979 to improve locality of reference in the instruction space. HPPA
2980 processors running HP-UX and Sparc processors running Solaris 2 have
2981 linkers with such optimizations. Other systems using the ELF object format
2982 as well as AIX may have these optimizations in the future.
2984 Only use these options when there are significant benefits from doing
2985 so. When you specify these options, the assembler and linker will
2986 create larger object and executable files and will also be slower.
2987 You will not be able to use @code{gprof} on all systems if you
2988 specify this option and you may have problems with debugging if
2989 you specify both this option and @samp{-g}.
2991 @item -fcaller-saves
2992 Enable values to be allocated in registers that will be clobbered by
2993 function calls, by emitting extra instructions to save and restore the
2994 registers around such calls. Such allocation is done only when it
2995 seems to result in better code than would otherwise be produced.
2997 This option is always enabled by default on certain machines, usually
2998 those which have no call-preserved registers to use instead.
3000 For all machines, optimization level 2 and higher enables this flag by
3003 @item -funroll-loops
3004 Perform the optimization of loop unrolling. This is only done for loops
3005 whose number of iterations can be determined at compile time or run time.
3006 @samp{-funroll-loops} implies both @samp{-fstrength-reduce} and
3007 @samp{-frerun-cse-after-loop}.
3009 @item -funroll-all-loops
3010 Perform the optimization of loop unrolling. This is done for all loops
3011 and usually makes programs run more slowly. @samp{-funroll-all-loops}
3012 implies @samp{-fstrength-reduce} as well as @samp{-frerun-cse-after-loop}.
3014 @item -fmove-all-movables
3015 Forces all invariant computations in loops to be moved
3018 @item -freduce-all-givs
3019 Forces all general-induction variables in loops to be
3022 @emph{Note:} When compiling programs written in Fortran,
3023 @samp{-fmove-all-movables} and @samp{-freduce-all-givs} are enabled
3024 by default when you use the optimizer.
3026 These options may generate better or worse code; results are highly
3027 dependent on the structure of loops within the source code.
3029 These two options are intended to be removed someday, once
3030 they have helped determine the efficacy of various
3031 approaches to improving loop optimizations.
3033 Please let us (@email{gcc@@gcc.gnu.org} and @email{fortran@@gnu.org})
3034 know how use of these options affects
3035 the performance of your production code.
3036 We're very interested in code that runs @emph{slower}
3037 when these options are @emph{enabled}.
3040 Disable any machine-specific peephole optimizations.
3042 @item -fbranch-probabilities
3043 After running a program compiled with @samp{-fprofile-arcs}
3044 (@pxref{Debugging Options,, Options for Debugging Your Program or
3045 @code{gcc}}), you can compile it a second time using
3046 @samp{-fbranch-probabilities}, to improve optimizations based on
3047 guessing the path a branch might take.
3050 With @samp{-fbranch-probabilities}, GCC puts a @samp{REG_EXEC_COUNT}
3051 note on the first instruction of each basic block, and a
3052 @samp{REG_BR_PROB} note on each @samp{JUMP_INSN} and @samp{CALL_INSN}.
3053 These can be used to improve optimization. Currently, they are only
3054 used in one place: in @file{reorg.c}, instead of guessing which path a
3055 branch is mostly to take, the @samp{REG_BR_PROB} values are used to
3056 exactly determine which path is taken more often.
3059 @item -fstrict-aliasing
3060 Allows the compiler to assume the strictest aliasing rules applicable to
3061 the language being compiled. For C (and C++), this activates
3062 optimizations based on the type of expressions. In particular, an
3063 object of one type is assumed never to reside at the same address as an
3064 object of a different type, unless the types are almost the same. For
3065 example, an @code{unsigned int} can alias an @code{int}, but not a
3066 @code{void*} or a @code{double}. A character type may alias any other
3069 Pay special attention to code like this:
3082 The practice of reading from a different union member than the one most
3083 recently written to (called ``type-punning'') is common. Even with
3084 @samp{-fstrict-aliasing}, type-punning is allowed, provided the memory
3085 is accessed through the union type. So, the code above will work as
3086 expected. However, this code might not:
3098 Every language that wishes to perform language-specific alias analysis
3099 should define a function that computes, given an @code{tree}
3100 node, an alias set for the node. Nodes in different alias sets are not
3101 allowed to alias. For an example, see the C front-end function
3102 @code{c_get_alias_set}.
3105 @item -falign-functions
3106 @itemx -falign-functions=@var{n}
3107 Align the start of functions to the next power-of-two greater than
3108 @var{n}, skipping up to @var{n} bytes. For instance,
3109 @samp{-falign-functions=32} aligns functions to the next 32-byte
3110 boundary, but @samp{-falign-functions=24} would align to the next
3111 32-byte boundary only if this can be done by skipping 23 bytes or less.
3113 @samp{-fno-align-functions} and @samp{-falign-functions=1} are
3114 equivalent and mean that functions will not be aligned.
3116 Some assemblers only support this flag when @var{n} is a power of two;
3117 in that case, it is rounded up.
3119 If @var{n} is not specified, use a machine-dependent default.
3121 @item -falign-labels
3122 @itemx -falign-labels=@var{n}
3123 Align all branch targets to a power-of-two boundary, skipping up to
3124 @var{n} bytes like @samp{-falign-functions}. This option can easily
3125 make code slower, because it must insert dummy operations for when the
3126 branch target is reached in the usual flow of the code.
3128 If @samp{-falign-loops} or @samp{-falign-jumps} are applicable and
3129 are greater than this value, then their values are used instead.
3131 If @var{n} is not specified, use a machine-dependent default which is
3132 very likely to be @samp{1}, meaning no alignment.
3135 @itemx -falign-loops=@var{n}
3136 Align loops to a power-of-two boundary, skipping up to @var{n} bytes
3137 like @samp{-falign-functions}. The hope is that the loop will be
3138 executed many times, which will make up for any execution of the dummy
3141 If @var{n} is not specified, use a machine-dependent default.
3144 @itemx -falign-jumps=@var{n}
3145 Align branch targets to a power-of-two boundary, for branch targets
3146 where the targets can only be reached by jumping, skipping up to @var{n}
3147 bytes like @samp{-falign-functions}. In this case, no dummy operations
3150 If @var{n} is not specified, use a machine-dependent default.
3153 Perform optimizations in static single assignment form. Each function's
3154 flow graph is translated into SSA form, optimizations are performed, and
3155 the flow graph is translated back from SSA form. User's should not
3156 specify this option, since it is not yet ready for production use.
3159 Perform dead-code elimination in SSA form. Requires @samp{-fssa}. Like
3160 @samp{-fssa}, this is an experimental feature.
3162 @item -fsingle-precision-constant
3163 Treat floating point constant as single precision constant instead of
3164 implicitly converting it to double precision constant.
3166 @item -frename-registers
3167 Attempt to avoid false dependancies in scheduled code by making use
3168 of registers left over after register allocation. This optimization
3169 will most benefit processors with lots of registers. It can, however,
3170 make debugging impossible, since variables will no longer stay in
3171 a ``home register''.
3174 @node Preprocessor Options
3175 @section Options Controlling the Preprocessor
3176 @cindex preprocessor options
3177 @cindex options, preprocessor
3179 These options control the C preprocessor, which is run on each C source
3180 file before actual compilation.
3182 If you use the @samp{-E} option, nothing is done except preprocessing.
3183 Some of these options make sense only together with @samp{-E} because
3184 they cause the preprocessor output to be unsuitable for actual
3188 @item -include @var{file}
3189 Process @var{file} as input before processing the regular input file.
3190 In effect, the contents of @var{file} are compiled first. Any @samp{-D}
3191 and @samp{-U} options on the command line are always processed before
3192 @samp{-include @var{file}}, regardless of the order in which they are
3193 written. All the @samp{-include} and @samp{-imacros} options are
3194 processed in the order in which they are written.
3196 @item -imacros @var{file}
3197 Process @var{file} as input, discarding the resulting output, before
3198 processing the regular input file. Because the output generated from
3199 @var{file} is discarded, the only effect of @samp{-imacros @var{file}}
3200 is to make the macros defined in @var{file} available for use in the
3203 Any @samp{-D} and @samp{-U} options on the command line are always
3204 processed before @samp{-imacros @var{file}}, regardless of the order in
3205 which they are written. All the @samp{-include} and @samp{-imacros}
3206 options are processed in the order in which they are written.
3208 @item -idirafter @var{dir}
3209 @cindex second include path
3210 Add the directory @var{dir} to the second include path. The directories
3211 on the second include path are searched when a header file is not found
3212 in any of the directories in the main include path (the one that
3215 @item -iprefix @var{prefix}
3216 Specify @var{prefix} as the prefix for subsequent @samp{-iwithprefix}
3219 @item -iwithprefix @var{dir}
3220 Add a directory to the second include path. The directory's name is
3221 made by concatenating @var{prefix} and @var{dir}, where @var{prefix} was
3222 specified previously with @samp{-iprefix}. If you have not specified a
3223 prefix yet, the directory containing the installed passes of the
3224 compiler is used as the default.
3226 @item -iwithprefixbefore @var{dir}
3227 Add a directory to the main include path. The directory's name is made
3228 by concatenating @var{prefix} and @var{dir}, as in the case of
3229 @samp{-iwithprefix}.
3231 @item -isystem @var{dir}
3232 Add a directory to the beginning of the second include path, marking it
3233 as a system directory, so that it gets the same special treatment as
3234 is applied to the standard system directories.
3237 Do not search the standard system directories for header files. Only
3238 the directories you have specified with @samp{-I} options (and the
3239 current directory, if appropriate) are searched. @xref{Directory
3240 Options}, for information on @samp{-I}.
3242 By using both @samp{-nostdinc} and @samp{-I-}, you can limit the include-file
3243 search path to only those directories you specify explicitly.
3246 Do not predefine any nonstandard macros. (Including architecture flags).
3249 Run only the C preprocessor. Preprocess all the C source files
3250 specified and output the results to standard output or to the
3251 specified output file.
3254 Tell the preprocessor not to discard comments. Used with the
3258 Tell the preprocessor not to generate @samp{#line} directives.
3259 Used with the @samp{-E} option.
3262 @cindex dependencies, make
3264 Tell the preprocessor to output a rule suitable for @code{make}
3265 describing the dependencies of each object file. For each source file,
3266 the preprocessor outputs one @code{make}-rule whose target is the object
3267 file name for that source file and whose dependencies are all the
3268 @code{#include} header files it uses. This rule may be a single line or
3269 may be continued with @samp{\}-newline if it is long. The list of rules
3270 is printed on standard output instead of the preprocessed C program.
3272 @samp{-M} implies @samp{-E}.
3274 Another way to specify output of a @code{make} rule is by setting
3275 the environment variable @code{DEPENDENCIES_OUTPUT} (@pxref{Environment
3279 Like @samp{-M} but the output mentions only the user header files
3280 included with @samp{#include "@var{file}"}. System header files
3281 included with @samp{#include <@var{file}>} are omitted.
3284 Like @samp{-M} but the dependency information is written to a file made by
3285 replacing ".c" with ".d" at the end of the input file names.
3286 This is in addition to compiling the file as specified---@samp{-MD} does
3287 not inhibit ordinary compilation the way @samp{-M} does.
3289 In Mach, you can use the utility @code{md} to merge multiple dependency
3290 files into a single dependency file suitable for using with the @samp{make}
3294 Like @samp{-MD} except mention only user header files, not system
3298 Treat missing header files as generated files and assume they live in the
3299 same directory as the source file. If you specify @samp{-MG}, you
3300 must also specify either @samp{-M} or @samp{-MM}. @samp{-MG} is not
3301 supported with @samp{-MD} or @samp{-MMD}.
3304 Print the name of each header file used, in addition to other normal
3307 @item -A@var{question}(@var{answer})
3308 Assert the answer @var{answer} for @var{question}, in case it is tested
3309 with a preprocessing conditional such as @samp{#if
3310 #@var{question}(@var{answer})}. @samp{-A-} disables the standard
3311 assertions that normally describe the target machine.
3314 Define macro @var{macro} with the string @samp{1} as its definition.
3316 @item -D@var{macro}=@var{defn}
3317 Define macro @var{macro} as @var{defn}. All instances of @samp{-D} on
3318 the command line are processed before any @samp{-U} options.
3321 Undefine macro @var{macro}. @samp{-U} options are evaluated after all
3322 @samp{-D} options, but before any @samp{-include} and @samp{-imacros}
3326 Tell the preprocessor to output only a list of the macro definitions
3327 that are in effect at the end of preprocessing. Used with the @samp{-E}
3331 Tell the preprocessing to pass all macro definitions into the output, in
3332 their proper sequence in the rest of the output.
3335 Like @samp{-dD} except that the macro arguments and contents are omitted.
3336 Only @samp{#define @var{name}} is included in the output.
3339 Support ISO C trigraphs. The @samp{-ansi} option also has this effect.
3341 @item -Wp,@var{option}
3342 Pass @var{option} as an option to the preprocessor. If @var{option}
3343 contains commas, it is split into multiple options at the commas.
3346 @node Assembler Options
3347 @section Passing Options to the Assembler
3349 @c prevent bad page break with this line
3350 You can pass options to the assembler.
3353 @item -Wa,@var{option}
3354 Pass @var{option} as an option to the assembler. If @var{option}
3355 contains commas, it is split into multiple options at the commas.
3359 @section Options for Linking
3360 @cindex link options
3361 @cindex options, linking
3363 These options come into play when the compiler links object files into
3364 an executable output file. They are meaningless if the compiler is
3365 not doing a link step.
3369 @item @var{object-file-name}
3370 A file name that does not end in a special recognized suffix is
3371 considered to name an object file or library. (Object files are
3372 distinguished from libraries by the linker according to the file
3373 contents.) If linking is done, these object files are used as input
3379 If any of these options is used, then the linker is not run, and
3380 object file names should not be used as arguments. @xref{Overall
3384 @item -l@var{library}
3385 Search the library named @var{library} when linking.
3387 It makes a difference where in the command you write this option; the
3388 linker searches processes libraries and object files in the order they
3389 are specified. Thus, @samp{foo.o -lz bar.o} searches library @samp{z}
3390 after file @file{foo.o} but before @file{bar.o}. If @file{bar.o} refers
3391 to functions in @samp{z}, those functions may not be loaded.
3393 The linker searches a standard list of directories for the library,
3394 which is actually a file named @file{lib@var{library}.a}. The linker
3395 then uses this file as if it had been specified precisely by name.
3397 The directories searched include several standard system directories
3398 plus any that you specify with @samp{-L}.
3400 Normally the files found this way are library files---archive files
3401 whose members are object files. The linker handles an archive file by
3402 scanning through it for members which define symbols that have so far
3403 been referenced but not defined. But if the file that is found is an
3404 ordinary object file, it is linked in the usual fashion. The only
3405 difference between using an @samp{-l} option and specifying a file name
3406 is that @samp{-l} surrounds @var{library} with @samp{lib} and @samp{.a}
3407 and searches several directories.
3410 You need this special case of the @samp{-l} option in order to
3411 link an Objective C program.
3414 Do not use the standard system startup files when linking.
3415 The standard system libraries are used normally, unless @code{-nostdlib}
3416 or @code{-nodefaultlibs} is used.
3418 @item -nodefaultlibs
3419 Do not use the standard system libraries when linking.
3420 Only the libraries you specify will be passed to the linker.
3421 The standard startup files are used normally, unless @code{-nostartfiles}
3422 is used. The compiler may generate calls to memcmp, memset, and memcpy
3423 for System V (and ISO C) environments or to bcopy and bzero for
3424 BSD environments. These entries are usually resolved by entries in
3425 libc. These entry points should be supplied through some other
3426 mechanism when this option is specified.
3429 Do not use the standard system startup files or libraries when linking.
3430 No startup files and only the libraries you specify will be passed to
3431 the linker. The compiler may generate calls to memcmp, memset, and memcpy
3432 for System V (and ISO C) environments or to bcopy and bzero for
3433 BSD environments. These entries are usually resolved by entries in
3434 libc. These entry points should be supplied through some other
3435 mechanism when this option is specified.
3437 @cindex @code{-lgcc}, use with @code{-nostdlib}
3438 @cindex @code{-nostdlib} and unresolved references
3439 @cindex unresolved references and @code{-nostdlib}
3440 @cindex @code{-lgcc}, use with @code{-nodefaultlibs}
3441 @cindex @code{-nodefaultlibs} and unresolved references
3442 @cindex unresolved references and @code{-nodefaultlibs}
3443 One of the standard libraries bypassed by @samp{-nostdlib} and
3444 @samp{-nodefaultlibs} is @file{libgcc.a}, a library of internal subroutines
3445 that GCC uses to overcome shortcomings of particular machines, or special
3446 needs for some languages.
3448 (@xref{Interface,,Interfacing to GCC Output}, for more discussion of
3452 (@xref{Interface,,Interfacing to GCC Output,gcc.info,Porting GCC},
3453 for more discussion of @file{libgcc.a}.)
3455 In most cases, you need @file{libgcc.a} even when you want to avoid
3456 other standard libraries. In other words, when you specify @samp{-nostdlib}
3457 or @samp{-nodefaultlibs} you should usually specify @samp{-lgcc} as well.
3458 This ensures that you have no unresolved references to internal GCC
3459 library subroutines. (For example, @samp{__main}, used to ensure C++
3460 constructors will be called; @pxref{Collect2,,@code{collect2}}.)
3463 Remove all symbol table and relocation information from the executable.
3466 On systems that support dynamic linking, this prevents linking with the shared
3467 libraries. On other systems, this option has no effect.
3470 Produce a shared object which can then be linked with other objects to
3471 form an executable. Not all systems support this option. For predictable
3472 results, you must also specify the same set of options that were used to
3473 generate code (@samp{-fpic}, @samp{-fPIC}, or model suboptions)
3474 when you specify this option.@footnote{On some systems, @code{gcc -shared}
3475 needs to build supplementary stub code for constructors to work. On
3476 multi-libbed systems, @code{gcc -shared} must select the correct support
3477 libraries to link against. Failing to supply the correct flags may lead
3478 to subtle defects. Supplying them in cases where they are not necessary
3482 Bind references to global symbols when building a shared object. Warn
3483 about any unresolved references (unless overridden by the link editor
3484 option @samp{-Xlinker -z -Xlinker defs}). Only a few systems support
3487 @item -Xlinker @var{option}
3488 Pass @var{option} as an option to the linker. You can use this to
3489 supply system-specific linker options which GCC does not know how to
3492 If you want to pass an option that takes an argument, you must use
3493 @samp{-Xlinker} twice, once for the option and once for the argument.
3494 For example, to pass @samp{-assert definitions}, you must write
3495 @samp{-Xlinker -assert -Xlinker definitions}. It does not work to write
3496 @samp{-Xlinker "-assert definitions"}, because this passes the entire
3497 string as a single argument, which is not what the linker expects.
3499 @item -Wl,@var{option}
3500 Pass @var{option} as an option to the linker. If @var{option} contains
3501 commas, it is split into multiple options at the commas.
3503 @item -u @var{symbol}
3504 Pretend the symbol @var{symbol} is undefined, to force linking of
3505 library modules to define it. You can use @samp{-u} multiple times with
3506 different symbols to force loading of additional library modules.
3509 @node Directory Options
3510 @section Options for Directory Search
3511 @cindex directory options
3512 @cindex options, directory search
3515 These options specify directories to search for header files, for
3516 libraries and for parts of the compiler:
3520 Add the directory @var{dir} to the head of the list of directories to be
3521 searched for header files. This can be used to override a system header
3522 file, substituting your own version, since these directories are
3523 searched before the system header file directories. If you use more
3524 than one @samp{-I} option, the directories are scanned in left-to-right
3525 order; the standard system directories come after.
3528 Any directories you specify with @samp{-I} options before the @samp{-I-}
3529 option are searched only for the case of @samp{#include "@var{file}"};
3530 they are not searched for @samp{#include <@var{file}>}.
3532 If additional directories are specified with @samp{-I} options after
3533 the @samp{-I-}, these directories are searched for all @samp{#include}
3534 directives. (Ordinarily @emph{all} @samp{-I} directories are used
3537 In addition, the @samp{-I-} option inhibits the use of the current
3538 directory (where the current input file came from) as the first search
3539 directory for @samp{#include "@var{file}"}. There is no way to
3540 override this effect of @samp{-I-}. With @samp{-I.} you can specify
3541 searching the directory which was current when the compiler was
3542 invoked. That is not exactly the same as what the preprocessor does
3543 by default, but it is often satisfactory.
3545 @samp{-I-} does not inhibit the use of the standard system directories
3546 for header files. Thus, @samp{-I-} and @samp{-nostdinc} are
3550 Add directory @var{dir} to the list of directories to be searched
3553 @item -B@var{prefix}
3554 This option specifies where to find the executables, libraries,
3555 include files, and data files of the compiler itself.
3557 The compiler driver program runs one or more of the subprograms
3558 @file{cpp}, @file{cc1}, @file{as} and @file{ld}. It tries
3559 @var{prefix} as a prefix for each program it tries to run, both with and
3560 without @samp{@var{machine}/@var{version}/} (@pxref{Target Options}).
3562 For each subprogram to be run, the compiler driver first tries the
3563 @samp{-B} prefix, if any. If that name is not found, or if @samp{-B}
3564 was not specified, the driver tries two standard prefixes, which are
3565 @file{/usr/lib/gcc/} and @file{/usr/local/lib/gcc-lib/}. If neither of
3566 those results in a file name that is found, the unmodified program
3567 name is searched for using the directories specified in your
3568 @samp{PATH} environment variable.
3570 @samp{-B} prefixes that effectively specify directory names also apply
3571 to libraries in the linker, because the compiler translates these
3572 options into @samp{-L} options for the linker. They also apply to
3573 includes files in the preprocessor, because the compiler translates these
3574 options into @samp{-isystem} options for the preprocessor. In this case,
3575 the compiler appends @samp{include} to the prefix.
3577 The run-time support file @file{libgcc.a} can also be searched for using
3578 the @samp{-B} prefix, if needed. If it is not found there, the two
3579 standard prefixes above are tried, and that is all. The file is left
3580 out of the link if it is not found by those means.
3582 Another way to specify a prefix much like the @samp{-B} prefix is to use
3583 the environment variable @code{GCC_EXEC_PREFIX}. @xref{Environment
3586 @item -specs=@var{file}
3587 Process @var{file} after the compiler reads in the standard @file{specs}
3588 file, in order to override the defaults that the @file{gcc} driver
3589 program uses when determining what switches to pass to @file{cc1},
3590 @file{cc1plus}, @file{as}, @file{ld}, etc. More than one
3591 @samp{-specs=}@var{file} can be specified on the command line, and they
3592 are processed in order, from left to right.
3598 @section Specifying subprocesses and the switches to pass to them
3600 @code{GCC} is a driver program. It performs its job by invoking a
3601 sequence of other programs to do the work of compiling, assembling and
3602 linking. GCC interprets its command-line parameters and uses these to
3603 deduce which programs it should invoke, and which command-line options
3604 it ought to place on their command lines. This behaviour is controlled
3605 by @dfn{spec strings}. In most cases there is one spec string for each
3606 program that GCC can invoke, but a few programs have multiple spec
3607 strings to control their behaviour. The spec strings built into GCC can
3608 be overridden by using the @samp{-specs=} command-line switch to specify
3611 @dfn{Spec files} are plaintext files that are used to construct spec
3612 strings. They consist of a sequence of directives separated by blank
3613 lines. The type of directive is determined by the first non-whitespace
3614 character on the line and it can be one of the following:
3617 @item %@var{command}
3618 Issues a @var{command} to the spec file processor. The commands that can
3622 @item %include <@var{file}>
3624 Search for @var{file} and insert its text at the current point in the
3627 @item %include_noerr <@var{file}>
3628 @cindex %include_noerr
3629 Just like @samp{%include}, but do not generate an error message if the include
3630 file cannot be found.
3632 @item %rename @var{old_name} @var{new_name}
3634 Rename the spec string @var{old_name} to @var{new_name}.
3638 @item *[@var{spec_name}]:
3639 This tells the compiler to create, override or delete the named spec
3640 string. All lines after this directive up to the next directive or
3641 blank line are considered to be the text for the spec string. If this
3642 results in an empty string then the spec will be deleted. (Or, if the
3643 spec did not exist, then nothing will happened.) Otherwise, if the spec
3644 does not currently exist a new spec will be created. If the spec does
3645 exist then its contents will be overridden by the text of this
3646 directive, unless the first character of that text is the @samp{+}
3647 character, in which case the text will be appended to the spec.
3649 @item [@var{suffix}]:
3650 Creates a new @samp{[@var{suffix}] spec} pair. All lines after this directive
3651 and up to the next directive or blank line are considered to make up the
3652 spec string for the indicated suffix. When the compiler encounters an
3653 input file with the named suffix, it will processes the spec string in
3654 order to work out how to compile that file. For example:
3661 This says that any input file whose name ends in @samp{.ZZ} should be
3662 passed to the program @samp{z-compile}, which should be invoked with the
3663 command-line switch @samp{-input} and with the result of performing the
3664 @samp{%i} substitution. (See below.)
3666 As an alternative to providing a spec string, the text that follows a
3667 suffix directive can be one of the following:
3670 @item @@@var{language}
3671 This says that the suffix is an alias for a known @var{language}. This is
3672 similar to using the @code{-x} command-line switch to GCC to specify a
3673 language explicitly. For example:
3680 Says that .ZZ files are, in fact, C++ source files.
3683 This causes an error messages saying:
3686 @var{name} compiler not installed on this system.
3690 GCC already has an extensive list of suffixes built into it.
3691 This directive will add an entry to the end of the list of suffixes, but
3692 since the list is searched from the end backwards, it is effectively
3693 possible to override earlier entries using this technique.
3697 GCC has the following spec strings built into it. Spec files can
3698 override these strings or create their own. Note that individual
3699 targets can also add their own spec strings to this list.
3702 asm Options to pass to the assembler
3703 asm_final Options to pass to the assembler post-processor
3704 cpp Options to pass to the C preprocessor
3705 cc1 Options to pass to the C compiler
3706 cc1plus Options to pass to the C++ compiler
3707 endfile Object files to include at the end of the link
3708 link Options to pass to the linker
3709 lib Libraries to include on the command line to the linker
3710 libgcc Decides which GCC support library to pass to the linker
3711 linker Sets the name of the linker
3712 predefines Defines to be passed to the C preprocessor
3713 signed_char Defines to pass to CPP to say whether @code{char} is signed by default
3714 startfile Object files to include at the start of the link
3717 Here is a small example of a spec file:
3723 --start-group -lgcc -lc -leval1 --end-group %(old_lib)
3726 This example renames the spec called @samp{lib} to @samp{old_lib} and
3727 then overrides the previous definition of @samp{lib} with a new one.
3728 The new definition adds in some extra command-line options before
3729 including the text of the old definition.
3731 @dfn{Spec strings} are a list of command-line options to be passed to their
3732 corresponding program. In addition, the spec strings can contain
3733 @samp{%}-prefixed sequences to substitute variable text or to
3734 conditionally insert text into the command line. Using these constructs
3735 it is possible to generate quite complex command lines.
3737 Here is a table of all defined @samp{%}-sequences for spec
3738 strings. Note that spaces are not generated automatically around the
3739 results of expanding these sequences. Therefore you can concatenate them
3740 together or combine them with constant text in a single argument.
3744 Substitute one @samp{%} into the program name or argument.
3747 Substitute the name of the input file being processed.
3750 Substitute the basename of the input file being processed.
3751 This is the substring up to (and not including) the last period
3752 and not including the directory.
3755 Marks the argument containing or following the @samp{%d} as a
3756 temporary file name, so that that file will be deleted if GCC exits
3757 successfully. Unlike @samp{%g}, this contributes no text to the
3760 @item %g@var{suffix}
3761 Substitute a file name that has suffix @var{suffix} and is chosen
3762 once per compilation, and mark the argument in the same way as
3763 @samp{%d}. To reduce exposure to denial-of-service attacks, the file
3764 name is now chosen in a way that is hard to predict even when previously
3765 chosen file names are known. For example, @samp{%g.s ... %g.o ... %g.s}
3766 might turn into @samp{ccUVUUAU.s ccXYAXZ12.o ccUVUUAU.s}. @var{suffix} matches
3767 the regexp @samp{[.A-Za-z]*} or the special string @samp{%O}, which is
3768 treated exactly as if @samp{%O} had been preprocessed. Previously, @samp{%g}
3769 was simply substituted with a file name chosen once per compilation,
3770 without regard to any appended suffix (which was therefore treated
3771 just like ordinary text), making such attacks more likely to succeed.
3773 @item %u@var{suffix}
3774 Like @samp{%g}, but generates a new temporary file name even if
3775 @samp{%u@var{suffix}} was already seen.
3777 @item %U@var{suffix}
3778 Substitutes the last file name generated with @samp{%u@var{suffix}}, generating a
3779 new one if there is no such last file name. In the absence of any
3780 @samp{%u@var{suffix}}, this is just like @samp{%g@var{suffix}}, except they don't share
3781 the same suffix @emph{space}, so @samp{%g.s ... %U.s ... %g.s ... %U.s}
3782 would involve the generation of two distinct file names, one
3783 for each @samp{%g.s} and another for each @samp{%U.s}. Previously, @samp{%U} was
3784 simply substituted with a file name chosen for the previous @samp{%u},
3785 without regard to any appended suffix.
3788 Marks the argument containing or following the @samp{%w} as the
3789 designated output file of this compilation. This puts the argument
3790 into the sequence of arguments that @samp{%o} will substitute later.
3793 Substitutes the names of all the output files, with spaces
3794 automatically placed around them. You should write spaces
3795 around the @samp{%o} as well or the results are undefined.
3796 @samp{%o} is for use in the specs for running the linker.
3797 Input files whose names have no recognized suffix are not compiled
3798 at all, but they are included among the output files, so they will
3802 Substitutes the suffix for object files. Note that this is
3803 handled specially when it immediately follows @samp{%g, %u, or %U},
3804 because of the need for those to form complete file names. The
3805 handling is such that @samp{%O} is treated exactly as if it had already
3806 been substituted, except that @samp{%g, %u, and %U} do not currently
3807 support additional @var{suffix} characters following @samp{%O} as they would
3808 following, for example, @samp{.o}.
3811 Substitutes the standard macro predefinitions for the
3812 current target machine. Use this when running @code{cpp}.
3815 Like @samp{%p}, but puts @samp{__} before and after the name of each
3816 predefined macro, except for macros that start with @samp{__} or with
3817 @samp{_@var{L}}, where @var{L} is an uppercase letter. This is for ISO
3821 Substitute a @samp{-iprefix} option made from GCC_EXEC_PREFIX.
3824 Current argument is the name of a library or startup file of some sort.
3825 Search for that file in a standard list of directories and substitute
3826 the full name found.
3829 Print @var{str} as an error message. @var{str} is terminated by a newline.
3830 Use this when inconsistent options are detected.
3833 Output @samp{-} if the input for the current command is coming from a pipe.
3836 Substitute the contents of spec string @var{name} at this point.
3839 Like @samp{%(...)} but put @samp{__} around @samp{-D} arguments.
3841 @item %x@{@var{option}@}
3842 Accumulate an option for @samp{%X}.
3845 Output the accumulated linker options specified by @samp{-Wl} or a @samp{%x}
3849 Output the accumulated assembler options specified by @samp{-Wa}.
3852 Output the accumulated preprocessor options specified by @samp{-Wp}.
3855 Substitute the major version number of GCC.
3856 (For version 2.9.5, this is 2.)
3859 Substitute the minor version number of GCC.
3860 (For version 2.9.5, this is 9.)
3863 Process the @code{asm} spec. This is used to compute the
3864 switches to be passed to the assembler.
3867 Process the @code{asm_final} spec. This is a spec string for
3868 passing switches to an assembler post-processor, if such a program is
3872 Process the @code{link} spec. This is the spec for computing the
3873 command line passed to the linker. Typically it will make use of the
3874 @samp{%L %G %S %D and %E} sequences.
3877 Dump out a @samp{-L} option for each directory that GCC believes might
3878 contain startup files. If the target supports multilibs then the
3879 current multilib directory will be prepended to each of these paths.
3882 Process the @code{lib} spec. This is a spec string for deciding which
3883 libraries should be included on the command line to the linker.
3886 Process the @code{libgcc} spec. This is a spec string for deciding
3887 which GCC support library should be included on the command line to the linker.
3890 Process the @code{startfile} spec. This is a spec for deciding which
3891 object files should be the first ones passed to the linker. Typically
3892 this might be a file named @file{crt0.o}.
3895 Process the @code{endfile} spec. This is a spec string that specifies
3896 the last object files that will be passed to the linker.
3899 Process the @code{cpp} spec. This is used to construct the arguments
3900 to be passed to the C preprocessor.
3903 Process the @code{signed_char} spec. This is intended to be used
3904 to tell cpp whether a char is signed. It typically has the definition:
3906 %@{funsigned-char:-D__CHAR_UNSIGNED__@}
3910 Process the @code{cc1} spec. This is used to construct the options to be
3911 passed to the actual C compiler (@samp{cc1}).
3914 Process the @code{cc1plus} spec. This is used to construct the options to be
3915 passed to the actual C++ compiler (@samp{cc1plus}).
3918 Substitute the variable part of a matched option. See below.
3919 Note that each comma in the substituted string is replaced by
3923 Substitutes the @code{-S} switch, if that switch was given to GCC.
3924 If that switch was not specified, this substitutes nothing. Note that
3925 the leading dash is omitted when specifying this option, and it is
3926 automatically inserted if the substitution is performed. Thus the spec
3927 string @samp{%@{foo@}} would match the command-line option @samp{-foo}
3928 and would output the command line option @samp{-foo}.
3930 @item %W@{@code{S}@}
3931 Like %@{@code{S}@} but mark last argument supplied within as a file to be
3934 @item %@{@code{S}*@}
3935 Substitutes all the switches specified to GCC whose names start
3936 with @code{-S}, but which also take an argument. This is used for
3937 switches like @samp{-o, -D, -I}, etc. GCC considers @samp{-o foo} as being
3938 one switch whose names starts with @samp{o}. %@{o*@} would substitute this
3939 text, including the space. Thus two arguments would be generated.
3941 @item %@{^@code{S}*@}
3942 Like %@{@code{S}*@}, but don't put a blank between a switch and its
3943 argument. Thus %@{^o*@} would only generate one argument, not two.
3945 @item %@{<@code{S}@}
3946 Remove all occurrences of @code{-S} from the command line. Note - this
3947 command is position dependent. @samp{%} commands in the spec string
3948 before this option will see @code{-S}, @samp{%} commands in the spec
3949 string after this option will not.
3951 @item %@{@code{S}*:@code{X}@}
3952 Substitutes @code{X} if one or more switches whose names start with
3953 @code{-S} are specified to GCC. Note that the tail part of the
3954 @code{-S} option (i.e. the part matched by the @samp{*}) will be substituted
3955 for each occurrence of @samp{%*} within @code{X}.
3957 @item %@{@code{S}:@code{X}@}
3958 Substitutes @code{X}, but only if the @samp{-S} switch was given to GCC.
3960 @item %@{!@code{S}:@code{X}@}
3961 Substitutes @code{X}, but only if the @samp{-S} switch was @emph{not} given to GCC.
3963 @item %@{|@code{S}:@code{X}@}
3964 Like %@{@code{S}:@code{X}@}, but if no @code{S} switch, substitute @samp{-}.
3966 @item %@{|!@code{S}:@code{X}@}
3967 Like %@{!@code{S}:@code{X}@}, but if there is an @code{S} switch, substitute @samp{-}.
3969 @item %@{.@code{S}:@code{X}@}
3970 Substitutes @code{X}, but only if processing a file with suffix @code{S}.
3972 @item %@{!.@code{S}:@code{X}@}
3973 Substitutes @code{X}, but only if @emph{not} processing a file with suffix @code{S}.
3975 @item %@{@code{S}|@code{P}:@code{X}@}
3976 Substitutes @code{X} if either @code{-S} or @code{-P} was given to GCC. This may be
3977 combined with @samp{!} and @samp{.} sequences as well, although they
3978 have a stronger binding than the @samp{|}. For example a spec string
3982 %@{.c:-foo@} %@{!.c:-bar@} %@{.c|d:-baz@} %@{!.c|d:-boggle@}
3985 will output the following command-line options from the following input
3986 command-line options:
3991 -d fred.c -foo -baz -boggle
3992 -d jim.d -bar -baz -boggle
3997 The conditional text @code{X} in a %@{@code{S}:@code{X}@} or
3998 %@{!@code{S}:@code{X}@} construct may contain other nested @samp{%} constructs
3999 or spaces, or even newlines. They are processed as usual, as described
4002 The @samp{-O, -f, -m, and -W} switches are handled specifically in these
4003 constructs. If another value of @samp{-O} or the negated form of a @samp{-f, -m, or
4004 -W} switch is found later in the command line, the earlier switch
4005 value is ignored, except with @{@code{S}*@} where @code{S} is just one
4006 letter, which passes all matching options.
4008 The character @samp{|} at the beginning of the predicate text is used to indicate
4009 that a command should be piped to the following command, but only if @samp{-pipe}
4012 It is built into GCC which switches take arguments and which do not.
4013 (You might think it would be useful to generalize this to allow each
4014 compiler's spec to say which switches take arguments. But this cannot
4015 be done in a consistent fashion. GCC cannot even decide which input
4016 files have been specified without knowing which switches take arguments,
4017 and it must know which input files to compile in order to tell which
4020 GCC also knows implicitly that arguments starting in @samp{-l} are to be
4021 treated as compiler output files, and passed to the linker in their
4022 proper position among the other output files.
4024 @c man begin OPTIONS
4026 @node Target Options
4027 @section Specifying Target Machine and Compiler Version
4028 @cindex target options
4029 @cindex cross compiling
4030 @cindex specifying machine version
4031 @cindex specifying compiler version and target machine
4032 @cindex compiler version, specifying
4033 @cindex target machine, specifying
4035 By default, GCC compiles code for the same type of machine that you
4036 are using. However, it can also be installed as a cross-compiler, to
4037 compile for some other type of machine. In fact, several different
4038 configurations of GCC, for different target machines, can be
4039 installed side by side. Then you specify which one to use with the
4042 In addition, older and newer versions of GCC can be installed side
4043 by side. One of them (probably the newest) will be the default, but
4044 you may sometimes wish to use another.
4047 @item -b @var{machine}
4048 The argument @var{machine} specifies the target machine for compilation.
4049 This is useful when you have installed GCC as a cross-compiler.
4051 The value to use for @var{machine} is the same as was specified as the
4052 machine type when configuring GCC as a cross-compiler. For
4053 example, if a cross-compiler was configured with @samp{configure
4054 i386v}, meaning to compile for an 80386 running System V, then you
4055 would specify @samp{-b i386v} to run that cross compiler.
4057 When you do not specify @samp{-b}, it normally means to compile for
4058 the same type of machine that you are using.
4060 @item -V @var{version}
4061 The argument @var{version} specifies which version of GCC to run.
4062 This is useful when multiple versions are installed. For example,
4063 @var{version} might be @samp{2.0}, meaning to run GCC version 2.0.
4065 The default version, when you do not specify @samp{-V}, is the last
4066 version of GCC that you installed.
4069 The @samp{-b} and @samp{-V} options actually work by controlling part of
4070 the file name used for the executable files and libraries used for
4071 compilation. A given version of GCC, for a given target machine, is
4072 normally kept in the directory @file{/usr/local/lib/gcc-lib/@var{machine}/@var{version}}.@refill
4074 Thus, sites can customize the effect of @samp{-b} or @samp{-V} either by
4075 changing the names of these directories or adding alternate names (or
4076 symbolic links). If in directory @file{/usr/local/lib/gcc-lib/} the
4077 file @file{80386} is a link to the file @file{i386v}, then @samp{-b
4078 80386} becomes an alias for @samp{-b i386v}.
4080 In one respect, the @samp{-b} or @samp{-V} do not completely change
4081 to a different compiler: the top-level driver program @code{gcc}
4082 that you originally invoked continues to run and invoke the other
4083 executables (preprocessor, compiler per se, assembler and linker)
4084 that do the real work. However, since no real work is done in the
4085 driver program, it usually does not matter that the driver program
4086 in use is not the one for the specified target. It is common for the
4087 interface to the other executables to change incompatibly between
4088 compiler versions, so unless the version specified is very close to that
4089 of the driver (for example, @samp{-V 3.0} with a driver program from GCC
4090 version 3.0.1), use of @samp{-V} may not work; for example, using
4091 @samp{-V 2.95.2} will not work with a driver program from GCC 3.0.
4093 The only way that the driver program depends on the target machine is
4094 in the parsing and handling of special machine-specific options.
4095 However, this is controlled by a file which is found, along with the
4096 other executables, in the directory for the specified version and
4097 target machine. As a result, a single installed driver program adapts
4098 to any specified target machine, and sufficiently similar compiler
4101 The driver program executable does control one significant thing,
4102 however: the default version and target machine. Therefore, you can
4103 install different instances of the driver program, compiled for
4104 different targets or versions, under different names.
4106 For example, if the driver for version 2.0 is installed as @code{ogcc}
4107 and that for version 2.1 is installed as @code{gcc}, then the command
4108 @code{gcc} will use version 2.1 by default, while @code{ogcc} will use
4109 2.0 by default. However, you can choose either version with either
4110 command with the @samp{-V} option.
4112 @node Submodel Options
4113 @section Hardware Models and Configurations
4114 @cindex submodel options
4115 @cindex specifying hardware config
4116 @cindex hardware models and configurations, specifying
4117 @cindex machine dependent options
4119 Earlier we discussed the standard option @samp{-b} which chooses among
4120 different installed compilers for completely different target
4121 machines, such as Vax vs. 68000 vs. 80386.
4123 In addition, each of these target machine types can have its own
4124 special options, starting with @samp{-m}, to choose among various
4125 hardware models or configurations---for example, 68010 vs 68020,
4126 floating coprocessor or none. A single installed version of the
4127 compiler can compile for any model or configuration, according to the
4130 Some configurations of the compiler also support additional special
4131 options, usually for compatibility with other compilers on the same
4135 These options are defined by the macro @code{TARGET_SWITCHES} in the
4136 machine description. The default for the options is also defined by
4137 that macro, which enables you to change the defaults.
4153 * RS/6000 and PowerPC Options::
4158 * Intel 960 Options::
4159 * DEC Alpha Options::
4163 * System V Options::
4164 * TMS320C3x/C4x Options::
4173 @node M680x0 Options
4174 @subsection M680x0 Options
4175 @cindex M680x0 options
4177 These are the @samp{-m} options defined for the 68000 series. The default
4178 values for these options depends on which style of 68000 was selected when
4179 the compiler was configured; the defaults for the most common choices are
4185 Generate output for a 68000. This is the default
4186 when the compiler is configured for 68000-based systems.
4188 Use this option for microcontrollers with a 68000 or EC000 core,
4189 including the 68008, 68302, 68306, 68307, 68322, 68328 and 68356.
4193 Generate output for a 68020. This is the default
4194 when the compiler is configured for 68020-based systems.
4197 Generate output containing 68881 instructions for floating point.
4198 This is the default for most 68020 systems unless @samp{-nfp} was
4199 specified when the compiler was configured.
4202 Generate output for a 68030. This is the default when the compiler is
4203 configured for 68030-based systems.
4206 Generate output for a 68040. This is the default when the compiler is
4207 configured for 68040-based systems.
4209 This option inhibits the use of 68881/68882 instructions that have to be
4210 emulated by software on the 68040. Use this option if your 68040 does not
4211 have code to emulate those instructions.
4214 Generate output for a 68060. This is the default when the compiler is
4215 configured for 68060-based systems.
4217 This option inhibits the use of 68020 and 68881/68882 instructions that
4218 have to be emulated by software on the 68060. Use this option if your 68060
4219 does not have code to emulate those instructions.
4222 Generate output for a CPU32. This is the default
4223 when the compiler is configured for CPU32-based systems.
4225 Use this option for microcontrollers with a
4226 CPU32 or CPU32+ core, including the 68330, 68331, 68332, 68333, 68334,
4227 68336, 68340, 68341, 68349 and 68360.
4230 Generate output for a 520X "coldfire" family cpu. This is the default
4231 when the compiler is configured for 520X-based systems.
4233 Use this option for microcontroller with a 5200 core, including
4234 the MCF5202, MCF5203, MCF5204 and MCF5202.
4238 Generate output for a 68040, without using any of the new instructions.
4239 This results in code which can run relatively efficiently on either a
4240 68020/68881 or a 68030 or a 68040. The generated code does use the
4241 68881 instructions that are emulated on the 68040.
4244 Generate output for a 68060, without using any of the new instructions.
4245 This results in code which can run relatively efficiently on either a
4246 68020/68881 or a 68030 or a 68040. The generated code does use the
4247 68881 instructions that are emulated on the 68060.
4250 Generate output containing Sun FPA instructions for floating point.
4253 Generate output containing library calls for floating point.
4254 @strong{Warning:} the requisite libraries are not available for all m68k
4255 targets. Normally the facilities of the machine's usual C compiler are
4256 used, but this can't be done directly in cross-compilation. You must
4257 make your own arrangements to provide suitable library functions for
4258 cross-compilation. The embedded targets @samp{m68k-*-aout} and
4259 @samp{m68k-*-coff} do provide software floating point support.
4262 Consider type @code{int} to be 16 bits wide, like @code{short int}.
4265 Do not use the bit-field instructions. The @samp{-m68000}, @samp{-mcpu32}
4266 and @samp{-m5200} options imply @w{@samp{-mnobitfield}}.
4269 Do use the bit-field instructions. The @samp{-m68020} option implies
4270 @samp{-mbitfield}. This is the default if you use a configuration
4271 designed for a 68020.
4274 Use a different function-calling convention, in which functions
4275 that take a fixed number of arguments return with the @code{rtd}
4276 instruction, which pops their arguments while returning. This
4277 saves one instruction in the caller since there is no need to pop
4278 the arguments there.
4280 This calling convention is incompatible with the one normally
4281 used on Unix, so you cannot use it if you need to call libraries
4282 compiled with the Unix compiler.
4284 Also, you must provide function prototypes for all functions that
4285 take variable numbers of arguments (including @code{printf});
4286 otherwise incorrect code will be generated for calls to those
4289 In addition, seriously incorrect code will result if you call a
4290 function with too many arguments. (Normally, extra arguments are
4291 harmlessly ignored.)
4293 The @code{rtd} instruction is supported by the 68010, 68020, 68030,
4294 68040, 68060 and CPU32 processors, but not by the 68000 or 5200.
4297 @itemx -mno-align-int
4298 Control whether GCC aligns @code{int}, @code{long}, @code{long long},
4299 @code{float}, @code{double}, and @code{long double} variables on a 32-bit
4300 boundary (@samp{-malign-int}) or a 16-bit boundary (@samp{-mno-align-int}).
4301 Aligning variables on 32-bit boundaries produces code that runs somewhat
4302 faster on processors with 32-bit busses at the expense of more memory.
4304 @strong{Warning:} if you use the @samp{-malign-int} switch, GCC will
4305 align structures containing the above types differently than
4306 most published application binary interface specifications for the m68k.
4309 Use the pc-relative addressing mode of the 68000 directly, instead of
4310 using a global offset table. At present, this option implies -fpic,
4311 allowing at most a 16-bit offset for pc-relative addressing. -fPIC is
4312 not presently supported with -mpcrel, though this could be supported for
4313 68020 and higher processors.
4315 @item -mno-strict-align
4316 @itemx -mstrict-align
4317 @kindex -mstrict-align
4318 Do not (do) assume that unaligned memory references will be handled by
4323 @node M68hc1x Options
4324 @subsection M68hc1x Options
4325 @cindex M68hc1x options
4327 These are the @samp{-m} options defined for the 68hc11 and 68hc12
4328 microcontrollers. The default values for these options depends on
4329 which style of microcontroller was selected when the compiler was configured;
4330 the defaults for the most common choices are given below.
4335 Generate output for a 68HC11. This is the default
4336 when the compiler is configured for 68HC11-based systems.
4340 Generate output for a 68HC12. This is the default
4341 when the compiler is configured for 68HC12-based systems.
4344 Enable the use of 68HC12 pre and post auto-increment and auto-decrement
4348 Consider type @code{int} to be 16 bits wide, like @code{short int}.
4350 @item -msoft-reg-count=@var{count}
4351 Specify the number of pseudo-soft registers which are used for the
4352 code generation. The maximum number is 32. Using more pseudo-soft
4353 register may or may not result in better code depending on the program.
4354 The default is 4 for 68HC11 and 2 for 68HC12.
4359 @subsection VAX Options
4362 These @samp{-m} options are defined for the Vax:
4366 Do not output certain jump instructions (@code{aobleq} and so on)
4367 that the Unix assembler for the Vax cannot handle across long
4371 Do output those jump instructions, on the assumption that you
4372 will assemble with the GNU assembler.
4375 Output code for g-format floating point numbers instead of d-format.
4379 @subsection SPARC Options
4380 @cindex SPARC options
4382 These @samp{-m} switches are supported on the SPARC:
4387 Specify @samp{-mapp-regs} to generate output using the global registers
4388 2 through 4, which the SPARC SVR4 ABI reserves for applications. This
4391 To be fully SVR4 ABI compliant at the cost of some performance loss,
4392 specify @samp{-mno-app-regs}. You should compile libraries and system
4393 software with this option.
4397 Generate output containing floating point instructions. This is the
4402 Generate output containing library calls for floating point.
4403 @strong{Warning:} the requisite libraries are not available for all SPARC
4404 targets. Normally the facilities of the machine's usual C compiler are
4405 used, but this cannot be done directly in cross-compilation. You must make
4406 your own arrangements to provide suitable library functions for
4407 cross-compilation. The embedded targets @samp{sparc-*-aout} and
4408 @samp{sparclite-*-*} do provide software floating point support.
4410 @samp{-msoft-float} changes the calling convention in the output file;
4411 therefore, it is only useful if you compile @emph{all} of a program with
4412 this option. In particular, you need to compile @file{libgcc.a}, the
4413 library that comes with GCC, with @samp{-msoft-float} in order for
4416 @item -mhard-quad-float
4417 Generate output containing quad-word (long double) floating point
4420 @item -msoft-quad-float
4421 Generate output containing library calls for quad-word (long double)
4422 floating point instructions. The functions called are those specified
4423 in the SPARC ABI. This is the default.
4425 As of this writing, there are no sparc implementations that have hardware
4426 support for the quad-word floating point instructions. They all invoke
4427 a trap handler for one of these instructions, and then the trap handler
4428 emulates the effect of the instruction. Because of the trap handler overhead,
4429 this is much slower than calling the ABI library routines. Thus the
4430 @samp{-msoft-quad-float} option is the default.
4434 With @samp{-mepilogue} (the default), the compiler always emits code for
4435 function exit at the end of each function. Any function exit in
4436 the middle of the function (such as a return statement in C) will
4437 generate a jump to the exit code at the end of the function.
4439 With @samp{-mno-epilogue}, the compiler tries to emit exit code inline
4440 at every function exit.
4444 With @samp{-mflat}, the compiler does not generate save/restore instructions
4445 and will use a "flat" or single register window calling convention.
4446 This model uses %i7 as the frame pointer and is compatible with the normal
4447 register window model. Code from either may be intermixed.
4448 The local registers and the input registers (0-5) are still treated as
4449 "call saved" registers and will be saved on the stack as necessary.
4451 With @samp{-mno-flat} (the default), the compiler emits save/restore
4452 instructions (except for leaf functions) and is the normal mode of operation.
4454 @item -mno-unaligned-doubles
4455 @itemx -munaligned-doubles
4456 Assume that doubles have 8 byte alignment. This is the default.
4458 With @samp{-munaligned-doubles}, GCC assumes that doubles have 8 byte
4459 alignment only if they are contained in another type, or if they have an
4460 absolute address. Otherwise, it assumes they have 4 byte alignment.
4461 Specifying this option avoids some rare compatibility problems with code
4462 generated by other compilers. It is not the default because it results
4463 in a performance loss, especially for floating point code.
4465 @item -mno-faster-structs
4466 @itemx -mfaster-structs
4467 With @samp{-mfaster-structs}, the compiler assumes that structures
4468 should have 8 byte alignment. This enables the use of pairs of
4469 @code{ldd} and @code{std} instructions for copies in structure
4470 assignment, in place of twice as many @code{ld} and @code{st} pairs.
4471 However, the use of this changed alignment directly violates the Sparc
4472 ABI. Thus, it's intended only for use on targets where the developer
4473 acknowledges that their resulting code will not be directly in line with
4474 the rules of the ABI.
4478 These two options select variations on the SPARC architecture.
4480 By default (unless specifically configured for the Fujitsu SPARClite),
4481 GCC generates code for the v7 variant of the SPARC architecture.
4483 @samp{-mv8} will give you SPARC v8 code. The only difference from v7
4484 code is that the compiler emits the integer multiply and integer
4485 divide instructions which exist in SPARC v8 but not in SPARC v7.
4487 @samp{-msparclite} will give you SPARClite code. This adds the integer
4488 multiply, integer divide step and scan (@code{ffs}) instructions which
4489 exist in SPARClite but not in SPARC v7.
4491 These options are deprecated and will be deleted in a future GCC release.
4492 They have been replaced with @samp{-mcpu=xxx}.
4496 These two options select the processor for which the code is optimised.
4498 With @samp{-mcypress} (the default), the compiler optimizes code for the
4499 Cypress CY7C602 chip, as used in the SparcStation/SparcServer 3xx series.
4500 This is also appropriate for the older SparcStation 1, 2, IPX etc.
4502 With @samp{-msupersparc} the compiler optimizes code for the SuperSparc cpu, as
4503 used in the SparcStation 10, 1000 and 2000 series. This flag also enables use
4504 of the full SPARC v8 instruction set.
4506 These options are deprecated and will be deleted in a future GCC release.
4507 They have been replaced with @samp{-mcpu=xxx}.
4509 @item -mcpu=@var{cpu_type}
4510 Set the instruction set, register set, and instruction scheduling parameters
4511 for machine type @var{cpu_type}. Supported values for @var{cpu_type} are
4512 @samp{v7}, @samp{cypress}, @samp{v8}, @samp{supersparc}, @samp{sparclite},
4513 @samp{hypersparc}, @samp{sparclite86x}, @samp{f930}, @samp{f934},
4514 @samp{sparclet}, @samp{tsc701}, @samp{v9}, and @samp{ultrasparc}.
4516 Default instruction scheduling parameters are used for values that select
4517 an architecture and not an implementation. These are @samp{v7}, @samp{v8},
4518 @samp{sparclite}, @samp{sparclet}, @samp{v9}.
4520 Here is a list of each supported architecture and their supported
4525 v8: supersparc, hypersparc
4526 sparclite: f930, f934, sparclite86x
4531 @item -mtune=@var{cpu_type}
4532 Set the instruction scheduling parameters for machine type
4533 @var{cpu_type}, but do not set the instruction set or register set that the
4534 option @samp{-mcpu=}@var{cpu_type} would.
4536 The same values for @samp{-mcpu=}@var{cpu_type} are used for
4537 @samp{-mtune=}@*@var{cpu_type}, though the only useful values are those that
4538 select a particular cpu implementation: @samp{cypress}, @samp{supersparc},
4539 @samp{hypersparc}, @samp{f930}, @samp{f934}, @samp{sparclite86x},
4540 @samp{tsc701}, @samp{ultrasparc}.
4544 These @samp{-m} switches are supported in addition to the above
4545 on the SPARCLET processor.
4548 @item -mlittle-endian
4549 Generate code for a processor running in little-endian mode.
4552 Treat register @code{%g0} as a normal register.
4553 GCC will continue to clobber it as necessary but will not assume
4554 it always reads as 0.
4556 @item -mbroken-saverestore
4557 Generate code that does not use non-trivial forms of the @code{save} and
4558 @code{restore} instructions. Early versions of the SPARCLET processor do
4559 not correctly handle @code{save} and @code{restore} instructions used with
4560 arguments. They correctly handle them used without arguments. A @code{save}
4561 instruction used without arguments increments the current window pointer
4562 but does not allocate a new stack frame. It is assumed that the window
4563 overflow trap handler will properly handle this case as will interrupt
4567 These @samp{-m} switches are supported in addition to the above
4568 on SPARC V9 processors in 64 bit environments.
4571 @item -mlittle-endian
4572 Generate code for a processor running in little-endian mode.
4576 Generate code for a 32 bit or 64 bit environment.
4577 The 32 bit environment sets int, long and pointer to 32 bits.
4578 The 64 bit environment sets int to 32 bits and long and pointer
4581 @item -mcmodel=medlow
4582 Generate code for the Medium/Low code model: the program must be linked
4583 in the low 32 bits of the address space. Pointers are 64 bits.
4584 Programs can be statically or dynamically linked.
4586 @item -mcmodel=medmid
4587 Generate code for the Medium/Middle code model: the program must be linked
4588 in the low 44 bits of the address space, the text segment must be less than
4589 2G bytes, and data segment must be within 2G of the text segment.
4590 Pointers are 64 bits.
4592 @item -mcmodel=medany
4593 Generate code for the Medium/Anywhere code model: the program may be linked
4594 anywhere in the address space, the text segment must be less than
4595 2G bytes, and data segment must be within 2G of the text segment.
4596 Pointers are 64 bits.
4598 @item -mcmodel=embmedany
4599 Generate code for the Medium/Anywhere code model for embedded systems:
4600 assume a 32 bit text and a 32 bit data segment, both starting anywhere
4601 (determined at link time). Register %g4 points to the base of the
4602 data segment. Pointers still 64 bits.
4603 Programs are statically linked, PIC is not supported.
4606 @itemx -mno-stack-bias
4607 With @samp{-mstack-bias}, GCC assumes that the stack pointer, and
4608 frame pointer if present, are offset by -2047 which must be added back
4609 when making stack frame references.
4610 Otherwise, assume no such offset is present.
4613 @node Convex Options
4614 @subsection Convex Options
4615 @cindex Convex options
4617 These @samp{-m} options are defined for Convex:
4621 Generate output for C1. The code will run on any Convex machine.
4622 The preprocessor symbol @code{__convex__c1__} is defined.
4625 Generate output for C2. Uses instructions not available on C1.
4626 Scheduling and other optimizations are chosen for max performance on C2.
4627 The preprocessor symbol @code{__convex_c2__} is defined.
4630 Generate output for C32xx. Uses instructions not available on C1.
4631 Scheduling and other optimizations are chosen for max performance on C32.
4632 The preprocessor symbol @code{__convex_c32__} is defined.
4635 Generate output for C34xx. Uses instructions not available on C1.
4636 Scheduling and other optimizations are chosen for max performance on C34.
4637 The preprocessor symbol @code{__convex_c34__} is defined.
4640 Generate output for C38xx. Uses instructions not available on C1.
4641 Scheduling and other optimizations are chosen for max performance on C38.
4642 The preprocessor symbol @code{__convex_c38__} is defined.
4645 Generate code which puts an argument count in the word preceding each
4646 argument list. This is compatible with regular CC, and a few programs
4647 may need the argument count word. GDB and other source-level debuggers
4648 do not need it; this info is in the symbol table.
4651 Omit the argument count word. This is the default.
4653 @item -mvolatile-cache
4654 Allow volatile references to be cached. This is the default.
4656 @item -mvolatile-nocache
4657 Volatile references bypass the data cache, going all the way to memory.
4658 This is only needed for multi-processor code that does not use standard
4659 synchronization instructions. Making non-volatile references to volatile
4660 locations will not necessarily work.
4663 Type long is 32 bits, the same as type int. This is the default.
4666 Type long is 64 bits, the same as type long long. This option is useless,
4667 because no library support exists for it.
4670 @node AMD29K Options
4671 @subsection AMD29K Options
4672 @cindex AMD29K options
4674 These @samp{-m} options are defined for the AMD Am29000:
4679 @cindex DW bit (29k)
4680 Generate code that assumes the @code{DW} bit is set, i.e., that byte and
4681 halfword operations are directly supported by the hardware. This is the
4686 Generate code that assumes the @code{DW} bit is not set.
4690 @cindex byte writes (29k)
4691 Generate code that assumes the system supports byte and halfword write
4692 operations. This is the default.
4696 Generate code that assumes the systems does not support byte and
4697 halfword write operations. @samp{-mnbw} implies @samp{-mndw}.
4701 @cindex memory model (29k)
4702 Use a small memory model that assumes that all function addresses are
4703 either within a single 256 KB segment or at an absolute address of less
4704 than 256k. This allows the @code{call} instruction to be used instead
4705 of a @code{const}, @code{consth}, @code{calli} sequence.
4709 Use the normal memory model: Generate @code{call} instructions only when
4710 calling functions in the same file and @code{calli} instructions
4711 otherwise. This works if each file occupies less than 256 KB but allows
4712 the entire executable to be larger than 256 KB. This is the default.
4715 Always use @code{calli} instructions. Specify this option if you expect
4716 a single file to compile into more than 256 KB of code.
4720 @cindex processor selection (29k)
4721 Generate code for the Am29050.
4725 Generate code for the Am29000. This is the default.
4727 @item -mkernel-registers
4728 @kindex -mkernel-registers
4729 @cindex kernel and user registers (29k)
4730 Generate references to registers @code{gr64-gr95} instead of to
4731 registers @code{gr96-gr127}. This option can be used when compiling
4732 kernel code that wants a set of global registers disjoint from that used
4735 Note that when this option is used, register names in @samp{-f} flags
4736 must use the normal, user-mode, names.
4738 @item -muser-registers
4739 @kindex -muser-registers
4740 Use the normal set of global registers, @code{gr96-gr127}. This is the
4744 @itemx -mno-stack-check
4745 @kindex -mstack-check
4746 @cindex stack checks (29k)
4747 Insert (or do not insert) a call to @code{__msp_check} after each stack
4748 adjustment. This is often used for kernel code.
4751 @itemx -mno-storem-bug
4752 @kindex -mstorem-bug
4753 @cindex storem bug (29k)
4754 @samp{-mstorem-bug} handles 29k processors which cannot handle the
4755 separation of a mtsrim insn and a storem instruction (most 29000 chips
4756 to date, but not the 29050).
4758 @item -mno-reuse-arg-regs
4759 @itemx -mreuse-arg-regs
4760 @kindex -mreuse-arg-regs
4761 @samp{-mno-reuse-arg-regs} tells the compiler to only use incoming argument
4762 registers for copying out arguments. This helps detect calling a function
4763 with fewer arguments than it was declared with.
4765 @item -mno-impure-text
4766 @itemx -mimpure-text
4767 @kindex -mimpure-text
4768 @samp{-mimpure-text}, used in addition to @samp{-shared}, tells the compiler to
4769 not pass @samp{-assert pure-text} to the linker when linking a shared object.
4772 @kindex -msoft-float
4773 Generate output containing library calls for floating point.
4774 @strong{Warning:} the requisite libraries are not part of GCC.
4775 Normally the facilities of the machine's usual C compiler are used, but
4776 this can't be done directly in cross-compilation. You must make your
4777 own arrangements to provide suitable library functions for
4782 Do not generate multm or multmu instructions. This is useful for some embedded
4783 systems which do not have trap handlers for these instructions.
4787 @subsection ARM Options
4790 These @samp{-m} options are defined for Advanced RISC Machines (ARM)
4795 @kindex -mapcs-frame
4796 Generate a stack frame that is compliant with the ARM Procedure Call
4797 Standard for all functions, even if this is not strictly necessary for
4798 correct execution of the code. Specifying @samp{-fomit-frame-pointer}
4799 with this option will cause the stack frames not to be generated for
4800 leaf functions. The default is @samp{-mno-apcs-frame}.
4804 This is a synonym for @samp{-mapcs-frame}.
4808 Generate code for a processor running with a 26-bit program counter,
4809 and conforming to the function calling standards for the APCS 26-bit
4810 option. This option replaces the @samp{-m2} and @samp{-m3} options
4811 of previous releases of the compiler.
4815 Generate code for a processor running with a 32-bit program counter,
4816 and conforming to the function calling standards for the APCS 32-bit
4817 option. This option replaces the @samp{-m6} option of previous releases
4820 @item -mapcs-stack-check
4821 @kindex -mapcs-stack-check
4822 @kindex -mno-apcs-stack-check
4823 Generate code to check the amount of stack space available upon entry to
4824 every function (that actually uses some stack space). If there is
4825 insufficient space available then either the function
4826 @samp{__rt_stkovf_split_small} or @samp{__rt_stkovf_split_big} will be
4827 called, depending upon the amount of stack space required. The run time
4828 system is required to provide these functions. The default is
4829 @samp{-mno-apcs-stack-check}, since this produces smaller code.
4832 @kindex -mapcs-float
4833 @kindex -mno-apcs-float
4834 Pass floating point arguments using the float point registers. This is
4835 one of the variants of the APCS. This option is recommended if the
4836 target hardware has a floating point unit or if a lot of floating point
4837 arithmetic is going to be performed by the code. The default is
4838 @samp{-mno-apcs-float}, since integer only code is slightly increased in
4839 size if @samp{-mapcs-float} is used.
4841 @item -mapcs-reentrant
4842 @kindex -mapcs-reentrant
4843 @kindex -mno-apcs-reentrant
4844 Generate reentrant, position independent code. This is the equivalent
4845 to specifying the @samp{-fpic} option. The default is
4846 @samp{-mno-apcs-reentrant}.
4848 @item -mthumb-interwork
4849 @kindex -mthumb-interwork
4850 @kindex -mno-thumb-interwork
4851 Generate code which supports calling between the ARM and THUMB
4852 instruction sets. Without this option the two instruction sets cannot
4853 be reliably used inside one program. The default is
4854 @samp{-mno-thumb-interwork}, since slightly larger code is generated
4855 when @samp{-mthumb-interwork} is specified.
4857 @item -mno-sched-prolog
4858 @kindex -mno-sched-prolog
4859 @kindex -msched-prolog
4860 Prevent the reordering of instructions in the function prolog, or the
4861 merging of those instruction with the instructions in the function's
4862 body. This means that all functions will start with a recognizable set
4863 of instructions (or in fact one of a choice from a small set of
4864 different function prologues), and this information can be used to
4865 locate the start if functions inside an executable piece of code. The
4866 default is @samp{-msched-prolog}.
4869 Generate output containing floating point instructions. This is the
4873 Generate output containing library calls for floating point.
4874 @strong{Warning:} the requisite libraries are not available for all ARM
4875 targets. Normally the facilities of the machine's usual C compiler are
4876 used, but this cannot be done directly in cross-compilation. You must make
4877 your own arrangements to provide suitable library functions for
4880 @samp{-msoft-float} changes the calling convention in the output file;
4881 therefore, it is only useful if you compile @emph{all} of a program with
4882 this option. In particular, you need to compile @file{libgcc.a}, the
4883 library that comes with GCC, with @samp{-msoft-float} in order for
4886 @item -mlittle-endian
4887 Generate code for a processor running in little-endian mode. This is
4888 the default for all standard configurations.
4891 Generate code for a processor running in big-endian mode; the default is
4892 to compile code for a little-endian processor.
4894 @item -mwords-little-endian
4895 This option only applies when generating code for big-endian processors.
4896 Generate code for a little-endian word order but a big-endian byte
4897 order. That is, a byte order of the form @samp{32107654}. Note: this
4898 option should only be used if you require compatibility with code for
4899 big-endian ARM processors generated by versions of the compiler prior to
4902 @item -malignment-traps
4903 @kindex -malignment-traps
4904 Generate code that will not trap if the MMU has alignment traps enabled.
4905 On ARM architectures prior to ARMv4, there were no instructions to
4906 access half-word objects stored in memory. However, when reading from
4907 memory a feature of the ARM architecture allows a word load to be used,
4908 even if the address is unaligned, and the processor core will rotate the
4909 data as it is being loaded. This option tells the compiler that such
4910 misaligned accesses will cause a MMU trap and that it should instead
4911 synthesise the access as a series of byte accesses. The compiler can
4912 still use word accesses to load half-word data if it knows that the
4913 address is aligned to a word boundary.
4915 This option is ignored when compiling for ARM architecture 4 or later,
4916 since these processors have instructions to directly access half-word
4919 @item -mno-alignment-traps
4920 @kindex -mno-alignment-traps
4921 Generate code that assumes that the MMU will not trap unaligned
4922 accesses. This produces better code when the target instruction set
4923 does not have half-word memory operations (implementations prior to
4926 Note that you cannot use this option to access unaligned word objects,
4927 since the processor will only fetch one 32-bit aligned object from
4930 The default setting for most targets is -mno-alignment-traps, since
4931 this produces better code when there are no half-word memory
4932 instructions available.
4934 @item -mshort-load-bytes
4935 @kindex -mshort-load-bytes
4936 This is a deprecated alias for @samp{-malignment-traps}.
4938 @item -mno-short-load-bytes
4939 @kindex -mno-short-load-bytes
4940 This is a deprecated alias for @samp{-mno-alignment-traps}.
4942 @item -mshort-load-words
4943 @kindex -mshort-load-words
4944 This is a deprecated alias for @samp{-mno-alignment-traps}.
4946 @item -mno-short-load-words
4947 @kindex -mno-short-load-words
4948 This is a deprecated alias for @samp{-malignment-traps}.
4952 This option only applies to RISC iX. Emulate the native BSD-mode
4953 compiler. This is the default if @samp{-ansi} is not specified.
4957 This option only applies to RISC iX. Emulate the native X/Open-mode
4960 @item -mno-symrename
4961 @kindex -mno-symrename
4962 This option only applies to RISC iX. Do not run the assembler
4963 post-processor, @samp{symrename}, after code has been assembled.
4964 Normally it is necessary to modify some of the standard symbols in
4965 preparation for linking with the RISC iX C library; this option
4966 suppresses this pass. The post-processor is never run when the
4967 compiler is built for cross-compilation.
4971 This specifies the name of the target ARM processor. GCC uses this name
4972 to determine what kind of instructions it can use when generating
4973 assembly code. Permissible names are: arm2, arm250, arm3, arm6, arm60,
4974 arm600, arm610, arm620, arm7, arm7m, arm7d, arm7dm, arm7di, arm7dmi,
4975 arm70, arm700, arm700i, arm710, arm710c, arm7100, arm7500, arm7500fe,
4976 arm7tdmi, arm8, strongarm, strongarm110, strongarm1100, arm8, arm810,
4977 arm9, arm920, arm920t, arm9tdmi.
4979 @itemx -mtune=<name>
4981 This option is very similar to the @samp{-mcpu=} option, except that
4982 instead of specifying the actual target processor type, and hence
4983 restricting which instructions can be used, it specifies that GCC should
4984 tune the performance of the code as if the target were of the type
4985 specified in this option, but still choosing the instructions that it
4986 will generate based on the cpu specified by a @samp{-mcpu=} option.
4987 For some arm implementations better performance can be obtained by using
4992 This specifies the name of the target ARM architecture. GCC uses this
4993 name to determine what kind of instructions it can use when generating
4994 assembly code. This option can be used in conjunction with or instead
4995 of the @samp{-mcpu=} option. Permissible names are: armv2, armv2a,
4996 armv3, armv3m, armv4, armv4t, armv5.
4998 @item -mfpe=<number>
4999 @itemx -mfp=<number>
5002 This specifies the version of the floating point emulation available on
5003 the target. Permissible values are 2 and 3. @samp{-mfp=} is a synonym
5004 for @samp{-mfpe=} to support older versions of GCC.
5006 @item -mstructure-size-boundary=<n>
5007 @kindex -mstructure-size-boundary
5008 The size of all structures and unions will be rounded up to a multiple
5009 of the number of bits set by this option. Permissible values are 8 and
5010 32. The default value varies for different toolchains. For the COFF
5011 targeted toolchain the default value is 8. Specifying the larger number
5012 can produce faster, more efficient code, but can also increase the size
5013 of the program. The two values are potentially incompatible. Code
5014 compiled with one value cannot necessarily expect to work with code or
5015 libraries compiled with the other value, if they exchange information
5016 using structures or unions. Programmers are encouraged to use the 32
5017 value as future versions of the toolchain may default to this value.
5019 @item -mabort-on-noreturn
5020 @kindex -mabort-on-noreturn
5021 @kindex -mnoabort-on-noreturn
5022 Generate a call to the function abort at the end of a noreturn function.
5023 It will be executed if the function tries to return.
5026 @itemx -mno-long-calls
5027 Tells the compiler to perform function calls by first loading the
5028 address of the function into a register and then performing a subroutine
5029 call on this register. This switch is needed if the target function
5030 will lie outside of the 64 megabyte addressing range of the offset based
5031 version of subroutine call instruction.
5033 Even if this switch is enabled, not all function calls will be turned
5034 into long calls. The heuristic is that static functions, functions
5035 which have the @samp{short-call} attribute, functions that are inside
5036 the scope of a @samp{#pragma no_long_calls} directive and functions whose
5037 definitions have already been compiled within the current compilation
5038 unit, will not be turned into long calls. The exception to this rule is
5039 that weak function definitions, functions with the @samp{long-call}
5040 attribute or the @samp{section} attribute, and functions that are within
5041 the scope of a @samp{#pragma long_calls} directive, will always be
5042 turned into long calls.
5044 This feature is not enabled by default. Specifying
5045 @samp{--no-long-calls} will restore the default behaviour, as will
5046 placing the function calls within the scope of a @samp{#pragma
5047 long_calls_off} directive. Note these switches have no effect on how
5048 the compiler generates code to handle function calls via function
5051 @item -mnop-fun-dllimport
5052 @kindex -mnop-fun-dllimport
5053 Disable the support for the @emph{dllimport} attribute.
5055 @item -msingle-pic-base
5056 @kindex -msingle-pic-base
5057 Treat the register used for PIC addressing as read-only, rather than
5058 loading it in the prologue for each function. The run-time system is
5059 responsible for initialising this register with an appropriate value
5060 before execution begins.
5062 @item -mpic-register=<reg>
5063 @kindex -mpic-register=
5064 Specify the register to be used for PIC addressing. The default is R10
5065 unless stack-checking is enabled, when R9 is used.
5070 @subsection Thumb Options
5071 @cindex Thumb Options
5075 @item -mthumb-interwork
5076 @kindex -mthumb-interwork
5077 @kindex -mno-thumb-interwork
5078 Generate code which supports calling between the THUMB and ARM
5079 instruction sets. Without this option the two instruction sets cannot
5080 be reliably used inside one program. The default is
5081 @samp{-mno-thumb-interwork}, since slightly smaller code is generated
5085 @kindex -mtpcs-frame
5086 @kindex -mno-tpcs-frame
5087 Generate a stack frame that is compliant with the Thumb Procedure Call
5088 Standard for all non-leaf functions. (A leaf function is one that does
5089 not call any other functions). The default is @samp{-mno-apcs-frame}.
5091 @item -mtpcs-leaf-frame
5092 @kindex -mtpcs-leaf-frame
5093 @kindex -mno-tpcs-leaf-frame
5094 Generate a stack frame that is compliant with the Thumb Procedure Call
5095 Standard for all leaf functions. (A leaf function is one that does
5096 not call any other functions). The default is @samp{-mno-apcs-leaf-frame}.
5098 @item -mlittle-endian
5099 @kindex -mlittle-endian
5100 Generate code for a processor running in little-endian mode. This is
5101 the default for all standard configurations.
5104 @kindex -mbig-endian
5105 Generate code for a processor running in big-endian mode.
5107 @item -mstructure-size-boundary=<n>
5108 @kindex -mstructure-size-boundary
5109 The size of all structures and unions will be rounded up to a multiple
5110 of the number of bits set by this option. Permissible values are 8 and
5111 32. The default value varies for different toolchains. For the COFF
5112 targeted toolchain the default value is 8. Specifying the larger number
5113 can produced faster, more efficient code, but can also increase the size
5114 of the program. The two values are potentially incompatible. Code
5115 compiled with one value cannot necessarily expect to work with code or
5116 libraries compiled with the other value, if they exchange information
5117 using structures or unions. Programmers are encouraged to use the 32
5118 value as future versions of the toolchain may default to this value.
5120 @item -mnop-fun-dllimport
5121 @kindex -mnop-fun-dllimport
5122 Disable the support for the @emph{dllimport} attribute.
5124 @item -mcallee-super-interworking
5125 @kindex -mcallee-super-interworking
5126 Gives all externally visible functions in the file being compiled an ARM
5127 instruction set header which switches to Thumb mode before executing the
5128 rest of the function. This allows these functions to be called from
5129 non-interworking code.
5131 @item -mcaller-super-interworking
5132 @kindex -mcaller-super-interworking
5133 Allows calls via function pointers (including virtual functions) to
5134 execute correctly regardless of whether the target code has been
5135 compiled for interworking or not. There is a small overhead in the cost
5136 of executing a function pointer if this option is enabled.
5138 @item -msingle-pic-base
5139 @kindex -msingle-pic-base
5140 Treat the register used for PIC addressing as read-only, rather than
5141 loading it in the prologue for each function. The run-time system is
5142 responsible for initialising this register with an appropriate value
5143 before execution begins.
5145 @item -mpic-register=<reg>
5146 @kindex -mpic-register=
5147 Specify the register to be used for PIC addressing. The default is R10.
5151 @node MN10200 Options
5152 @subsection MN10200 Options
5153 @cindex MN10200 options
5154 These @samp{-m} options are defined for Matsushita MN10200 architectures:
5158 Indicate to the linker that it should perform a relaxation optimization pass
5159 to shorten branches, calls and absolute memory addresses. This option only
5160 has an effect when used on the command line for the final link step.
5162 This option makes symbolic debugging impossible.
5165 @node MN10300 Options
5166 @subsection MN10300 Options
5167 @cindex MN10300 options
5168 These @samp{-m} options are defined for Matsushita MN10300 architectures:
5172 Generate code to avoid bugs in the multiply instructions for the MN10300
5173 processors. This is the default.
5176 Do not generate code to avoid bugs in the multiply instructions for the
5180 Generate code which uses features specific to the AM33 processor.
5183 Do not generate code which uses features specific to the AM33 processor. This
5187 Indicate to the linker that it should perform a relaxation optimization pass
5188 to shorten branches, calls and absolute memory addresses. This option only
5189 has an effect when used on the command line for the final link step.
5191 This option makes symbolic debugging impossible.
5195 @node M32R/D Options
5196 @subsection M32R/D Options
5197 @cindex M32R/D options
5199 These @samp{-m} options are defined for Mitsubishi M32R/D architectures:
5202 @item -mcode-model=small
5203 Assume all objects live in the lower 16MB of memory (so that their addresses
5204 can be loaded with the @code{ld24} instruction), and assume all subroutines
5205 are reachable with the @code{bl} instruction.
5206 This is the default.
5208 The addressability of a particular object can be set with the
5209 @code{model} attribute.
5211 @item -mcode-model=medium
5212 Assume objects may be anywhere in the 32 bit address space (the compiler
5213 will generate @code{seth/add3} instructions to load their addresses), and
5214 assume all subroutines are reachable with the @code{bl} instruction.
5216 @item -mcode-model=large
5217 Assume objects may be anywhere in the 32 bit address space (the compiler
5218 will generate @code{seth/add3} instructions to load their addresses), and
5219 assume subroutines may not be reachable with the @code{bl} instruction
5220 (the compiler will generate the much slower @code{seth/add3/jl}
5221 instruction sequence).
5224 Disable use of the small data area. Variables will be put into
5225 one of @samp{.data}, @samp{bss}, or @samp{.rodata} (unless the
5226 @code{section} attribute has been specified).
5227 This is the default.
5229 The small data area consists of sections @samp{.sdata} and @samp{.sbss}.
5230 Objects may be explicitly put in the small data area with the
5231 @code{section} attribute using one of these sections.
5234 Put small global and static data in the small data area, but do not
5235 generate special code to reference them.
5238 Put small global and static data in the small data area, and generate
5239 special instructions to reference them.
5242 @cindex smaller data references
5243 Put global and static objects less than or equal to @var{num} bytes
5244 into the small data or bss sections instead of the normal data or bss
5245 sections. The default value of @var{num} is 8.
5246 The @samp{-msdata} option must be set to one of @samp{sdata} or @samp{use}
5247 for this option to have any effect.
5249 All modules should be compiled with the same @samp{-G @var{num}} value.
5250 Compiling with different values of @var{num} may or may not work; if it
5251 doesn't the linker will give an error message - incorrect code will not be
5257 @subsection M88K Options
5258 @cindex M88k options
5260 These @samp{-m} options are defined for Motorola 88k architectures:
5265 Generate code that works well on both the m88100 and the
5270 Generate code that works best for the m88100, but that also
5275 Generate code that works best for the m88110, and may not run
5280 Obsolete option to be removed from the next revision.
5283 @item -midentify-revision
5284 @kindex -midentify-revision
5286 @cindex identifying source, compiler (88k)
5287 Include an @code{ident} directive in the assembler output recording the
5288 source file name, compiler name and version, timestamp, and compilation
5291 @item -mno-underscores
5292 @kindex -mno-underscores
5293 @cindex underscores, avoiding (88k)
5294 In assembler output, emit symbol names without adding an underscore
5295 character at the beginning of each name. The default is to use an
5296 underscore as prefix on each name.
5298 @item -mocs-debug-info
5299 @itemx -mno-ocs-debug-info
5300 @kindex -mocs-debug-info
5301 @kindex -mno-ocs-debug-info
5303 @cindex debugging, 88k OCS
5304 Include (or omit) additional debugging information (about registers used
5305 in each stack frame) as specified in the 88open Object Compatibility
5306 Standard, ``OCS''. This extra information allows debugging of code that
5307 has had the frame pointer eliminated. The default for DG/UX, SVr4, and
5308 Delta 88 SVr3.2 is to include this information; other 88k configurations
5309 omit this information by default.
5311 @item -mocs-frame-position
5312 @kindex -mocs-frame-position
5313 @cindex register positions in frame (88k)
5314 When emitting COFF debugging information for automatic variables and
5315 parameters stored on the stack, use the offset from the canonical frame
5316 address, which is the stack pointer (register 31) on entry to the
5317 function. The DG/UX, SVr4, Delta88 SVr3.2, and BCS configurations use
5318 @samp{-mocs-frame-position}; other 88k configurations have the default
5319 @samp{-mno-ocs-frame-position}.
5321 @item -mno-ocs-frame-position
5322 @kindex -mno-ocs-frame-position
5323 @cindex register positions in frame (88k)
5324 When emitting COFF debugging information for automatic variables and
5325 parameters stored on the stack, use the offset from the frame pointer
5326 register (register 30). When this option is in effect, the frame
5327 pointer is not eliminated when debugging information is selected by the
5330 @item -moptimize-arg-area
5331 @itemx -mno-optimize-arg-area
5332 @kindex -moptimize-arg-area
5333 @kindex -mno-optimize-arg-area
5334 @cindex arguments in frame (88k)
5335 Control how function arguments are stored in stack frames.
5336 @samp{-moptimize-arg-area} saves space by optimizing them, but this
5337 conflicts with the 88open specifications. The opposite alternative,
5338 @samp{-mno-optimize-arg-area}, agrees with 88open standards. By default
5339 GCC does not optimize the argument area.
5341 @item -mshort-data-@var{num}
5342 @kindex -mshort-data-@var{num}
5343 @cindex smaller data references (88k)
5344 @cindex r0-relative references (88k)
5345 Generate smaller data references by making them relative to @code{r0},
5346 which allows loading a value using a single instruction (rather than the
5347 usual two). You control which data references are affected by
5348 specifying @var{num} with this option. For example, if you specify
5349 @samp{-mshort-data-512}, then the data references affected are those
5350 involving displacements of less than 512 bytes.
5351 @samp{-mshort-data-@var{num}} is not effective for @var{num} greater
5354 @item -mserialize-volatile
5355 @kindex -mserialize-volatile
5356 @itemx -mno-serialize-volatile
5357 @kindex -mno-serialize-volatile
5358 @cindex sequential consistency on 88k
5359 Do, or don't, generate code to guarantee sequential consistency
5360 of volatile memory references. By default, consistency is
5363 The order of memory references made by the MC88110 processor does
5364 not always match the order of the instructions requesting those
5365 references. In particular, a load instruction may execute before
5366 a preceding store instruction. Such reordering violates
5367 sequential consistency of volatile memory references, when there
5368 are multiple processors. When consistency must be guaranteed,
5369 GNU C generates special instructions, as needed, to force
5370 execution in the proper order.
5372 The MC88100 processor does not reorder memory references and so
5373 always provides sequential consistency. However, by default, GNU
5374 C generates the special instructions to guarantee consistency
5375 even when you use @samp{-m88100}, so that the code may be run on an
5376 MC88110 processor. If you intend to run your code only on the
5377 MC88100 processor, you may use @samp{-mno-serialize-volatile}.
5379 The extra code generated to guarantee consistency may affect the
5380 performance of your application. If you know that you can safely
5381 forgo this guarantee, you may use @samp{-mno-serialize-volatile}.
5387 @cindex assembler syntax, 88k
5389 Turn on (@samp{-msvr4}) or off (@samp{-msvr3}) compiler extensions
5390 related to System V release 4 (SVr4). This controls the following:
5394 Which variant of the assembler syntax to emit.
5396 @samp{-msvr4} makes the C preprocessor recognize @samp{#pragma weak}
5397 that is used on System V release 4.
5399 @samp{-msvr4} makes GCC issue additional declaration directives used in
5403 @samp{-msvr4} is the default for the m88k-motorola-sysv4 and
5404 m88k-dg-dgux m88k configurations. @samp{-msvr3} is the default for all
5405 other m88k configurations.
5407 @item -mversion-03.00
5408 @kindex -mversion-03.00
5409 This option is obsolete, and is ignored.
5410 @c ??? which asm syntax better for GAS? option there too?
5412 @item -mno-check-zero-division
5413 @itemx -mcheck-zero-division
5414 @kindex -mno-check-zero-division
5415 @kindex -mcheck-zero-division
5416 @cindex zero division on 88k
5417 Do, or don't, generate code to guarantee that integer division by
5418 zero will be detected. By default, detection is guaranteed.
5420 Some models of the MC88100 processor fail to trap upon integer
5421 division by zero under certain conditions. By default, when
5422 compiling code that might be run on such a processor, GNU C
5423 generates code that explicitly checks for zero-valued divisors
5424 and traps with exception number 503 when one is detected. Use of
5425 mno-check-zero-division suppresses such checking for code
5426 generated to run on an MC88100 processor.
5428 GNU C assumes that the MC88110 processor correctly detects all
5429 instances of integer division by zero. When @samp{-m88110} is
5430 specified, both @samp{-mcheck-zero-division} and
5431 @samp{-mno-check-zero-division} are ignored, and no explicit checks for
5432 zero-valued divisors are generated.
5434 @item -muse-div-instruction
5435 @kindex -muse-div-instruction
5436 @cindex divide instruction, 88k
5437 Use the div instruction for signed integer division on the
5438 MC88100 processor. By default, the div instruction is not used.
5440 On the MC88100 processor the signed integer division instruction
5441 div) traps to the operating system on a negative operand. The
5442 operating system transparently completes the operation, but at a
5443 large cost in execution time. By default, when compiling code
5444 that might be run on an MC88100 processor, GNU C emulates signed
5445 integer division using the unsigned integer division instruction
5446 divu), thereby avoiding the large penalty of a trap to the
5447 operating system. Such emulation has its own, smaller, execution
5448 cost in both time and space. To the extent that your code's
5449 important signed integer division operations are performed on two
5450 nonnegative operands, it may be desirable to use the div
5451 instruction directly.
5453 On the MC88110 processor the div instruction (also known as the
5454 divs instruction) processes negative operands without trapping to
5455 the operating system. When @samp{-m88110} is specified,
5456 @samp{-muse-div-instruction} is ignored, and the div instruction is used
5457 for signed integer division.
5459 Note that the result of dividing INT_MIN by -1 is undefined. In
5460 particular, the behavior of such a division with and without
5461 @samp{-muse-div-instruction} may differ.
5463 @item -mtrap-large-shift
5464 @itemx -mhandle-large-shift
5465 @kindex -mtrap-large-shift
5466 @kindex -mhandle-large-shift
5467 @cindex bit shift overflow (88k)
5468 @cindex large bit shifts (88k)
5469 Include code to detect bit-shifts of more than 31 bits; respectively,
5470 trap such shifts or emit code to handle them properly. By default GCC
5471 makes no special provision for large bit shifts.
5473 @item -mwarn-passed-structs
5474 @kindex -mwarn-passed-structs
5475 @cindex structure passing (88k)
5476 Warn when a function passes a struct as an argument or result.
5477 Structure-passing conventions have changed during the evolution of the C
5478 language, and are often the source of portability problems. By default,
5479 GCC issues no such warning.
5482 @node RS/6000 and PowerPC Options
5483 @subsection IBM RS/6000 and PowerPC Options
5484 @cindex RS/6000 and PowerPC Options
5485 @cindex IBM RS/6000 and PowerPC Options
5487 These @samp{-m} options are defined for the IBM RS/6000 and PowerPC:
5495 @itemx -mpowerpc-gpopt
5496 @itemx -mno-powerpc-gpopt
5497 @itemx -mpowerpc-gfxopt
5498 @itemx -mno-powerpc-gfxopt
5500 @itemx -mno-powerpc64
5504 @kindex -mpowerpc-gpopt
5505 @kindex -mpowerpc-gfxopt
5507 GCC supports two related instruction set architectures for the
5508 RS/6000 and PowerPC. The @dfn{POWER} instruction set are those
5509 instructions supported by the @samp{rios} chip set used in the original
5510 RS/6000 systems and the @dfn{PowerPC} instruction set is the
5511 architecture of the Motorola MPC5xx, MPC6xx, MPC8xx microprocessors, and
5512 the IBM 4xx microprocessors.
5514 Neither architecture is a subset of the other. However there is a
5515 large common subset of instructions supported by both. An MQ
5516 register is included in processors supporting the POWER architecture.
5518 You use these options to specify which instructions are available on the
5519 processor you are using. The default value of these options is
5520 determined when configuring GCC. Specifying the
5521 @samp{-mcpu=@var{cpu_type}} overrides the specification of these
5522 options. We recommend you use the @samp{-mcpu=@var{cpu_type}} option
5523 rather than the options listed above.
5525 The @samp{-mpower} option allows GCC to generate instructions that
5526 are found only in the POWER architecture and to use the MQ register.
5527 Specifying @samp{-mpower2} implies @samp{-power} and also allows GCC
5528 to generate instructions that are present in the POWER2 architecture but
5529 not the original POWER architecture.
5531 The @samp{-mpowerpc} option allows GCC to generate instructions that
5532 are found only in the 32-bit subset of the PowerPC architecture.
5533 Specifying @samp{-mpowerpc-gpopt} implies @samp{-mpowerpc} and also allows
5534 GCC to use the optional PowerPC architecture instructions in the
5535 General Purpose group, including floating-point square root. Specifying
5536 @samp{-mpowerpc-gfxopt} implies @samp{-mpowerpc} and also allows GCC to
5537 use the optional PowerPC architecture instructions in the Graphics
5538 group, including floating-point select.
5540 The @samp{-mpowerpc64} option allows GCC to generate the additional
5541 64-bit instructions that are found in the full PowerPC64 architecture
5542 and to treat GPRs as 64-bit, doubleword quantities. GCC defaults to
5543 @samp{-mno-powerpc64}.
5545 If you specify both @samp{-mno-power} and @samp{-mno-powerpc}, GCC
5546 will use only the instructions in the common subset of both
5547 architectures plus some special AIX common-mode calls, and will not use
5548 the MQ register. Specifying both @samp{-mpower} and @samp{-mpowerpc}
5549 permits GCC to use any instruction from either architecture and to
5550 allow use of the MQ register; specify this for the Motorola MPC601.
5552 @item -mnew-mnemonics
5553 @itemx -mold-mnemonics
5554 @kindex -mnew-mnemonics
5555 @kindex -mold-mnemonics
5556 Select which mnemonics to use in the generated assembler code.
5557 @samp{-mnew-mnemonics} requests output that uses the assembler mnemonics
5558 defined for the PowerPC architecture, while @samp{-mold-mnemonics}
5559 requests the assembler mnemonics defined for the POWER architecture.
5560 Instructions defined in only one architecture have only one mnemonic;
5561 GCC uses that mnemonic irrespective of which of these options is
5564 GCC defaults to the mnemonics appropriate for the architecture in
5565 use. Specifying @samp{-mcpu=@var{cpu_type}} sometimes overrides the
5566 value of these option. Unless you are building a cross-compiler, you
5567 should normally not specify either @samp{-mnew-mnemonics} or
5568 @samp{-mold-mnemonics}, but should instead accept the default.
5570 @item -mcpu=@var{cpu_type}
5572 Set architecture type, register usage, choice of mnemonics, and
5573 instruction scheduling parameters for machine type @var{cpu_type}.
5574 Supported values for @var{cpu_type} are @samp{rios}, @samp{rios1},
5575 @samp{rsc}, @samp{rios2}, @samp{rs64a}, @samp{601}, @samp{602},
5576 @samp{603}, @samp{603e}, @samp{604}, @samp{604e}, @samp{620},
5577 @samp{630}, @samp{740}, @samp{750}, @samp{power}, @samp{power2},
5578 @samp{powerpc}, @samp{403}, @samp{505}, @samp{801}, @samp{821},
5579 @samp{823}, and @samp{860} and @samp{common}. @samp{-mcpu=power},
5580 @samp{-mcpu=power2}, @samp{-mcpu=powerpc}, and @samp{-mcpu=powerpc64}
5581 specify generic POWER, POWER2, pure 32-bit PowerPC (i.e., not MPC601),
5582 and 64-bit PowerPC architecture machine types, with an appropriate,
5583 generic processor model assumed for scheduling purposes.@refill
5585 Specifying any of the following options:
5586 @samp{-mcpu=rios1}, @samp{-mcpu=rios2}, @samp{-mcpu=rsc},
5587 @samp{-mcpu=power}, or @samp{-mcpu=power2}
5588 enables the @samp{-mpower} option and disables the @samp{-mpowerpc} option;
5589 @samp{-mcpu=601} enables both the @samp{-mpower} and @samp{-mpowerpc} options.
5590 All of @samp{-mcpu=rs64a}, @samp{-mcpu=602}, @samp{-mcpu=603},
5591 @samp{-mcpu=603e}, @samp{-mcpu=604}, @samp{-mcpu=620}, @samp{-mcpu=630},
5592 @samp{-mcpu=740}, and @samp{-mcpu=750}
5593 enable the @samp{-mpowerpc} option and disable the @samp{-mpower} option.
5594 Exactly similarly, all of @samp{-mcpu=403},
5595 @samp{-mcpu=505}, @samp{-mcpu=821}, @samp{-mcpu=860} and @samp{-mcpu=powerpc}
5596 enable the @samp{-mpowerpc} option and disable the @samp{-mpower} option.
5597 @samp{-mcpu=common} disables both the
5598 @samp{-mpower} and @samp{-mpowerpc} options.@refill
5600 AIX versions 4 or greater selects @samp{-mcpu=common} by default, so
5601 that code will operate on all members of the RS/6000 POWER and PowerPC
5602 families. In that case, GCC will use only the instructions in the
5603 common subset of both architectures plus some special AIX common-mode
5604 calls, and will not use the MQ register. GCC assumes a generic
5605 processor model for scheduling purposes.
5607 Specifying any of the options @samp{-mcpu=rios1}, @samp{-mcpu=rios2},
5608 @samp{-mcpu=rsc}, @samp{-mcpu=power}, or @samp{-mcpu=power2} also
5609 disables the @samp{new-mnemonics} option. Specifying @samp{-mcpu=601},
5610 @samp{-mcpu=602}, @samp{-mcpu=603}, @samp{-mcpu=603e}, @samp{-mcpu=604},
5611 @samp{-mcpu=620}, @samp{-mcpu=630}, @samp{-mcpu=403}, @samp{-mcpu=505},
5612 @samp{-mcpu=821}, @samp{-mcpu=860} or @samp{-mcpu=powerpc} also enables
5613 the @samp{new-mnemonics} option.@refill
5615 Specifying @samp{-mcpu=403}, @samp{-mcpu=821}, or @samp{-mcpu=860} also
5616 enables the @samp{-msoft-float} option.
5618 @item -mtune=@var{cpu_type}
5619 Set the instruction scheduling parameters for machine type
5620 @var{cpu_type}, but do not set the architecture type, register usage,
5621 choice of mnemonics like @samp{-mcpu=}@var{cpu_type} would. The same
5622 values for @var{cpu_type} are used for @samp{-mtune=}@var{cpu_type} as
5623 for @samp{-mcpu=}@var{cpu_type}. The @samp{-mtune=}@var{cpu_type}
5624 option overrides the @samp{-mcpu=}@var{cpu_type} option in terms of
5625 instruction scheduling parameters.
5628 @itemx -mno-fp-in-toc
5629 @itemx -mno-sum-in-toc
5630 @itemx -mminimal-toc
5631 @kindex -mminimal-toc
5632 Modify generation of the TOC (Table Of Contents), which is created for
5633 every executable file. The @samp{-mfull-toc} option is selected by
5634 default. In that case, GCC will allocate at least one TOC entry for
5635 each unique non-automatic variable reference in your program. GCC
5636 will also place floating-point constants in the TOC. However, only
5637 16,384 entries are available in the TOC.
5639 If you receive a linker error message that saying you have overflowed
5640 the available TOC space, you can reduce the amount of TOC space used
5641 with the @samp{-mno-fp-in-toc} and @samp{-mno-sum-in-toc} options.
5642 @samp{-mno-fp-in-toc} prevents GCC from putting floating-point
5643 constants in the TOC and @samp{-mno-sum-in-toc} forces GCC to
5644 generate code to calculate the sum of an address and a constant at
5645 run-time instead of putting that sum into the TOC. You may specify one
5646 or both of these options. Each causes GCC to produce very slightly
5647 slower and larger code at the expense of conserving TOC space.
5649 If you still run out of space in the TOC even when you specify both of
5650 these options, specify @samp{-mminimal-toc} instead. This option causes
5651 GCC to make only one TOC entry for every file. When you specify this
5652 option, GCC will produce code that is slower and larger but which
5653 uses extremely little TOC space. You may wish to use this option
5654 only on files that contain less frequently executed code. @refill
5660 Enable 64-bit AIX ABI and calling convention: 64-bit pointers, 64-bit
5661 @code{long} type, and the infrastructure needed to support them.
5662 Specifying @samp{-maix64} implies @samp{-mpowerpc64} and
5663 @samp{-mpowerpc}, while @samp{-maix32} disables the 64-bit ABI and
5664 implies @samp{-mno-powerpc64}. GCC defaults to @samp{-maix32}.
5669 On AIX, pass floating-point arguments to prototyped functions beyond the
5670 register save area (RSA) on the stack in addition to argument FPRs. The
5671 AIX calling convention was extended but not initially documented to
5672 handle an obscure K&R C case of calling a function that takes the
5673 address of its arguments with fewer arguments than declared. AIX XL
5674 compilers access floating point arguments which do not fit in the
5675 RSA from the stack when a subroutine is compiled without
5676 optimization. Because always storing floating-point arguments on the
5677 stack is inefficient and rarely needed, this option is not enabled by
5678 default and only is necessary when calling subroutines compiled by AIX
5679 XL compilers without optimization.
5683 Support @dfn{AIX Threads}. Link an application written to use
5684 @dfn{pthreads} with special libraries and startup code to enable the
5689 Support @dfn{IBM RS/6000 SP} @dfn{Parallel Environment} (PE). Link an
5690 application written to use message passing with special startup code to
5691 enable the application to run. The system must have PE installed in the
5692 standard location (@file{/usr/lpp/ppe.poe/}), or the @file{specs} file
5693 must be overridden with the @samp{-specs=} option to specify the
5694 appropriate directory location. The Parallel Environment does not
5695 support threads, so the @samp{-mpe} option and the @samp{-mthreads}
5696 option are incompatible.
5700 @kindex -msoft-float
5701 Generate code that does not use (uses) the floating-point register set.
5702 Software floating point emulation is provided if you use the
5703 @samp{-msoft-float} option, and pass the option to GCC when linking.
5706 @itemx -mno-multiple
5707 Generate code that uses (does not use) the load multiple word
5708 instructions and the store multiple word instructions. These
5709 instructions are generated by default on POWER systems, and not
5710 generated on PowerPC systems. Do not use @samp{-mmultiple} on little
5711 endian PowerPC systems, since those instructions do not work when the
5712 processor is in little endian mode. The exceptions are PPC740 and
5713 PPC750 which permit the instructions usage in little endian mode.
5718 Generate code that uses (does not use) the load string instructions
5719 and the store string word instructions to save multiple registers and
5720 do small block moves. These instructions are generated by default on
5721 POWER systems, and not generated on PowerPC systems. Do not use
5722 @samp{-mstring} on little endian PowerPC systems, since those
5723 instructions do not work when the processor is in little endian mode.
5724 The exceptions are PPC740 and PPC750 which permit the instructions
5725 usage in little endian mode.
5730 Generate code that uses (does not use) the load or store instructions
5731 that update the base register to the address of the calculated memory
5732 location. These instructions are generated by default. If you use
5733 @samp{-mno-update}, there is a small window between the time that the
5734 stack pointer is updated and the address of the previous frame is
5735 stored, which means code that walks the stack frame across interrupts or
5736 signals may get corrupted data.
5739 @itemx -mno-fused-madd
5740 @kindex -mfused-madd
5741 Generate code that uses (does not use) the floating point multiply and
5742 accumulate instructions. These instructions are generated by default if
5743 hardware floating is used.
5745 @item -mno-bit-align
5748 On System V.4 and embedded PowerPC systems do not (do) force structures
5749 and unions that contain bit fields to be aligned to the base type of the
5752 For example, by default a structure containing nothing but 8
5753 @code{unsigned} bitfields of length 1 would be aligned to a 4 byte
5754 boundary and have a size of 4 bytes. By using @samp{-mno-bit-align},
5755 the structure would be aligned to a 1 byte boundary and be one byte in
5758 @item -mno-strict-align
5759 @itemx -mstrict-align
5760 @kindex -mstrict-align
5761 On System V.4 and embedded PowerPC systems do not (do) assume that
5762 unaligned memory references will be handled by the system.
5765 @itemx -mno-relocatable
5766 @kindex -mrelocatable
5767 On embedded PowerPC systems generate code that allows (does not allow)
5768 the program to be relocated to a different address at runtime. If you
5769 use @samp{-mrelocatable} on any module, all objects linked together must
5770 be compiled with @samp{-mrelocatable} or @samp{-mrelocatable-lib}.
5772 @item -mrelocatable-lib
5773 @itemx -mno-relocatable-lib
5774 On embedded PowerPC systems generate code that allows (does not allow)
5775 the program to be relocated to a different address at runtime. Modules
5776 compiled with @samp{-mrelocatable-lib} can be linked with either modules
5777 compiled without @samp{-mrelocatable} and @samp{-mrelocatable-lib} or
5778 with modules compiled with the @samp{-mrelocatable} options.
5782 On System V.4 and embedded PowerPC systems do not (do) assume that
5783 register 2 contains a pointer to a global area pointing to the addresses
5784 used in the program.
5787 @itemx -mlittle-endian
5788 On System V.4 and embedded PowerPC systems compile code for the
5789 processor in little endian mode. The @samp{-mlittle-endian} option is
5790 the same as @samp{-mlittle}.
5794 On System V.4 and embedded PowerPC systems compile code for the
5795 processor in big endian mode. The @samp{-mbig-endian} option is
5796 the same as @samp{-mbig}.
5799 On System V.4 and embedded PowerPC systems compile code using calling
5800 conventions that adheres to the March 1995 draft of the System V
5801 Application Binary Interface, PowerPC processor supplement. This is the
5802 default unless you configured GCC using @samp{powerpc-*-eabiaix}.
5804 @item -mcall-sysv-eabi
5805 Specify both @samp{-mcall-sysv} and @samp{-meabi} options.
5807 @item -mcall-sysv-noeabi
5808 Specify both @samp{-mcall-sysv} and @samp{-mno-eabi} options.
5811 On System V.4 and embedded PowerPC systems compile code using calling
5812 conventions that are similar to those used on AIX. This is the
5813 default if you configured GCC using @samp{powerpc-*-eabiaix}.
5815 @item -mcall-solaris
5816 On System V.4 and embedded PowerPC systems compile code for the Solaris
5820 On System V.4 and embedded PowerPC systems compile code for the
5821 Linux-based GNU system.
5824 @itemx -mno-prototype
5825 On System V.4 and embedded PowerPC systems assume that all calls to
5826 variable argument functions are properly prototyped. Otherwise, the
5827 compiler must insert an instruction before every non prototyped call to
5828 set or clear bit 6 of the condition code register (@var{CR}) to
5829 indicate whether floating point values were passed in the floating point
5830 registers in case the function takes a variable arguments. With
5831 @samp{-mprototype}, only calls to prototyped variable argument functions
5832 will set or clear the bit.
5835 On embedded PowerPC systems, assume that the startup module is called
5836 @file{sim-crt0.o} and that the standard C libraries are @file{libsim.a} and
5837 @file{libc.a}. This is the default for @samp{powerpc-*-eabisim}.
5841 On embedded PowerPC systems, assume that the startup module is called
5842 @file{crt0.o} and the standard C libraries are @file{libmvme.a} and
5846 On embedded PowerPC systems, assume that the startup module is called
5847 @file{crt0.o} and the standard C libraries are @file{libads.a} and
5851 On embedded PowerPC systems, assume that the startup module is called
5852 @file{crt0.o} and the standard C libraries are @file{libyk.a} and
5856 On System V.4 and embedded PowerPC systems, specify that you are
5857 compiling for a VxWorks system.
5860 On embedded PowerPC systems, set the @var{PPC_EMB} bit in the ELF flags
5861 header to indicate that @samp{eabi} extended relocations are used.
5865 On System V.4 and embedded PowerPC systems do (do not) adhere to the
5866 Embedded Applications Binary Interface (eabi) which is a set of
5867 modifications to the System V.4 specifications. Selecting @code{-meabi}
5868 means that the stack is aligned to an 8 byte boundary, a function
5869 @code{__eabi} is called to from @code{main} to set up the eabi
5870 environment, and the @samp{-msdata} option can use both @code{r2} and
5871 @code{r13} to point to two separate small data areas. Selecting
5872 @code{-mno-eabi} means that the stack is aligned to a 16 byte boundary,
5873 do not call an initialization function from @code{main}, and the
5874 @samp{-msdata} option will only use @code{r13} to point to a single
5875 small data area. The @samp{-meabi} option is on by default if you
5876 configured GCC using one of the @samp{powerpc*-*-eabi*} options.
5879 On System V.4 and embedded PowerPC systems, put small initialized
5880 @code{const} global and static data in the @samp{.sdata2} section, which
5881 is pointed to by register @code{r2}. Put small initialized
5882 non-@code{const} global and static data in the @samp{.sdata} section,
5883 which is pointed to by register @code{r13}. Put small uninitialized
5884 global and static data in the @samp{.sbss} section, which is adjacent to
5885 the @samp{.sdata} section. The @samp{-msdata=eabi} option is
5886 incompatible with the @samp{-mrelocatable} option. The
5887 @samp{-msdata=eabi} option also sets the @samp{-memb} option.
5890 On System V.4 and embedded PowerPC systems, put small global and static
5891 data in the @samp{.sdata} section, which is pointed to by register
5892 @code{r13}. Put small uninitialized global and static data in the
5893 @samp{.sbss} section, which is adjacent to the @samp{.sdata} section.
5894 The @samp{-msdata=sysv} option is incompatible with the
5895 @samp{-mrelocatable} option.
5897 @item -msdata=default
5899 On System V.4 and embedded PowerPC systems, if @samp{-meabi} is used,
5900 compile code the same as @samp{-msdata=eabi}, otherwise compile code the
5901 same as @samp{-msdata=sysv}.
5904 On System V.4 and embedded PowerPC systems, put small global and static
5905 data in the @samp{.sdata} section. Put small uninitialized global and
5906 static data in the @samp{.sbss} section. Do not use register @code{r13}
5907 to address small data however. This is the default behavior unless
5908 other @samp{-msdata} options are used.
5912 On embedded PowerPC systems, put all initialized global and static data
5913 in the @samp{.data} section, and all uninitialized data in the
5914 @samp{.bss} section.
5917 @cindex smaller data references (PowerPC)
5918 @cindex .sdata/.sdata2 references (PowerPC)
5919 On embedded PowerPC systems, put global and static items less than or
5920 equal to @var{num} bytes into the small data or bss sections instead of
5921 the normal data or bss section. By default, @var{num} is 8. The
5922 @samp{-G @var{num}} switch is also passed to the linker.
5923 All modules should be compiled with the same @samp{-G @var{num}} value.
5926 @itemx -mno-regnames
5927 On System V.4 and embedded PowerPC systems do (do not) emit register
5928 names in the assembly language output using symbolic forms.
5933 @subsection IBM RT Options
5935 @cindex IBM RT options
5937 These @samp{-m} options are defined for the IBM RT PC:
5941 Use an in-line code sequence for integer multiplies. This is the
5944 @item -mcall-lib-mul
5945 Call @code{lmul$$} for integer multiples.
5947 @item -mfull-fp-blocks
5948 Generate full-size floating point data blocks, including the minimum
5949 amount of scratch space recommended by IBM. This is the default.
5951 @item -mminimum-fp-blocks
5952 Do not include extra scratch space in floating point data blocks. This
5953 results in smaller code, but slower execution, since scratch space must
5954 be allocated dynamically.
5956 @cindex @file{varargs.h} and RT PC
5957 @cindex @file{stdarg.h} and RT PC
5958 @item -mfp-arg-in-fpregs
5959 Use a calling sequence incompatible with the IBM calling convention in
5960 which floating point arguments are passed in floating point registers.
5961 Note that @code{varargs.h} and @code{stdargs.h} will not work with
5962 floating point operands if this option is specified.
5964 @item -mfp-arg-in-gregs
5965 Use the normal calling convention for floating point arguments. This is
5968 @item -mhc-struct-return
5969 Return structures of more than one word in memory, rather than in a
5970 register. This provides compatibility with the MetaWare HighC (hc)
5971 compiler. Use the option @samp{-fpcc-struct-return} for compatibility
5972 with the Portable C Compiler (pcc).
5974 @item -mnohc-struct-return
5975 Return some structures of more than one word in registers, when
5976 convenient. This is the default. For compatibility with the
5977 IBM-supplied compilers, use the option @samp{-fpcc-struct-return} or the
5978 option @samp{-mhc-struct-return}.
5982 @subsection MIPS Options
5983 @cindex MIPS options
5985 These @samp{-m} options are defined for the MIPS family of computers:
5988 @item -mcpu=@var{cpu type}
5989 Assume the defaults for the machine type @var{cpu type} when scheduling
5990 instructions. The choices for @var{cpu type} are @samp{r2000}, @samp{r3000},
5991 @samp{r3900}, @samp{r4000}, @samp{r4100}, @samp{r4300}, @samp{r4400},
5992 @samp{r4600}, @samp{r4650}, @samp{r5000}, @samp{r6000}, @samp{r8000},
5993 and @samp{orion}. Additionally, the @samp{r2000}, @samp{r3000},
5994 @samp{r4000}, @samp{r5000}, and @samp{r6000} can be abbreviated as
5995 @samp{r2k} (or @samp{r2K}), @samp{r3k}, etc. While picking a specific
5996 @var{cpu type} will schedule things appropriately for that particular
5997 chip, the compiler will not generate any code that does not meet level 1
5998 of the MIPS ISA (instruction set architecture) without a @samp{-mipsX}
5999 or @samp{-mabi} switch being used.
6002 Issue instructions from level 1 of the MIPS ISA. This is the default.
6003 @samp{r3000} is the default @var{cpu type} at this ISA level.
6006 Issue instructions from level 2 of the MIPS ISA (branch likely, square
6007 root instructions). @samp{r6000} is the default @var{cpu type} at this
6011 Issue instructions from level 3 of the MIPS ISA (64 bit instructions).
6012 @samp{r4000} is the default @var{cpu type} at this ISA level.
6015 Issue instructions from level 4 of the MIPS ISA (conditional move,
6016 prefetch, enhanced FPU instructions). @samp{r8000} is the default
6017 @var{cpu type} at this ISA level.
6020 Assume that 32 32-bit floating point registers are available. This is
6024 Assume that 32 64-bit floating point registers are available. This is
6025 the default when the @samp{-mips3} option is used.
6028 Assume that 32 32-bit general purpose registers are available. This is
6032 Assume that 32 64-bit general purpose registers are available. This is
6033 the default when the @samp{-mips3} option is used.
6036 Force int and long types to be 64 bits wide. See @samp{-mlong32} for an
6037 explanation of the default, and the width of pointers.
6040 Force long types to be 64 bits wide. See @samp{-mlong32} for an
6041 explanation of the default, and the width of pointers.
6044 Force long, int, and pointer types to be 32 bits wide.
6046 If none of @samp{-mlong32}, @samp{-mlong64}, or @samp{-mint64} are set,
6047 the size of ints, longs, and pointers depends on the ABI and ISA chosen.
6048 For @samp{-mabi=32}, and @samp{-mabi=n32}, ints and longs are 32 bits
6049 wide. For @samp{-mabi=64}, ints are 32 bits, and longs are 64 bits wide.
6050 For @samp{-mabi=eabi} and either @samp{-mips1} or @samp{-mips2}, ints
6051 and longs are 32 bits wide. For @samp{-mabi=eabi} and higher ISAs, ints
6052 are 32 bits, and longs are 64 bits wide. The width of pointer types is
6053 the smaller of the width of longs or the width of general purpose
6054 registers (which in turn depends on the ISA).
6061 Generate code for the indicated ABI. The default instruction level is
6062 @samp{-mips1} for @samp{32}, @samp{-mips3} for @samp{n32}, and
6063 @samp{-mips4} otherwise. Conversely, with @samp{-mips1} or
6064 @samp{-mips2}, the default ABI is @samp{32}; otherwise, the default ABI
6068 Generate code for the MIPS assembler, and invoke @file{mips-tfile} to
6069 add normal debug information. This is the default for all
6070 platforms except for the OSF/1 reference platform, using the OSF/rose
6071 object format. If the either of the @samp{-gstabs} or @samp{-gstabs+}
6072 switches are used, the @file{mips-tfile} program will encapsulate the
6073 stabs within MIPS ECOFF.
6076 Generate code for the GNU assembler. This is the default on the OSF/1
6077 reference platform, using the OSF/rose object format. Also, this is
6078 the default if the configure option @samp{--with-gnu-as} is used.
6080 @item -msplit-addresses
6081 @itemx -mno-split-addresses
6082 Generate code to load the high and low parts of address constants separately.
6083 This allows @code{gcc} to optimize away redundant loads of the high order
6084 bits of addresses. This optimization requires GNU as and GNU ld.
6085 This optimization is enabled by default for some embedded targets where
6086 GNU as and GNU ld are standard.
6090 The @samp{-mrnames} switch says to output code using the MIPS software
6091 names for the registers, instead of the hardware names (ie, @var{a0}
6092 instead of @var{$4}). The only known assembler that supports this option
6093 is the Algorithmics assembler.
6097 The @samp{-mgpopt} switch says to write all of the data declarations
6098 before the instructions in the text section, this allows the MIPS
6099 assembler to generate one word memory references instead of using two
6100 words for short global or static data items. This is on by default if
6101 optimization is selected.
6105 For each non-inline function processed, the @samp{-mstats} switch
6106 causes the compiler to emit one line to the standard error file to
6107 print statistics about the program (number of registers saved, stack
6112 The @samp{-mmemcpy} switch makes all block moves call the appropriate
6113 string function (@samp{memcpy} or @samp{bcopy}) instead of possibly
6114 generating inline code.
6117 @itemx -mno-mips-tfile
6118 The @samp{-mno-mips-tfile} switch causes the compiler not
6119 postprocess the object file with the @file{mips-tfile} program,
6120 after the MIPS assembler has generated it to add debug support. If
6121 @file{mips-tfile} is not run, then no local variables will be
6122 available to the debugger. In addition, @file{stage2} and
6123 @file{stage3} objects will have the temporary file names passed to the
6124 assembler embedded in the object file, which means the objects will
6125 not compare the same. The @samp{-mno-mips-tfile} switch should only
6126 be used when there are bugs in the @file{mips-tfile} program that
6127 prevents compilation.
6130 Generate output containing library calls for floating point.
6131 @strong{Warning:} the requisite libraries are not part of GCC.
6132 Normally the facilities of the machine's usual C compiler are used, but
6133 this can't be done directly in cross-compilation. You must make your
6134 own arrangements to provide suitable library functions for
6138 Generate output containing floating point instructions. This is the
6139 default if you use the unmodified sources.
6142 @itemx -mno-abicalls
6143 Emit (or do not emit) the pseudo operations @samp{.abicalls},
6144 @samp{.cpload}, and @samp{.cprestore} that some System V.4 ports use for
6145 position independent code.
6148 @itemx -mno-long-calls
6149 Do all calls with the @samp{JALR} instruction, which requires
6150 loading up a function's address into a register before the call.
6151 You need to use this switch, if you call outside of the current
6152 512 megabyte segment to functions that are not through pointers.
6155 @itemx -mno-half-pic
6156 Put pointers to extern references into the data section and load them
6157 up, rather than put the references in the text section.
6159 @item -membedded-pic
6160 @itemx -mno-embedded-pic
6161 Generate PIC code suitable for some embedded systems. All calls are
6162 made using PC relative address, and all data is addressed using the $gp
6163 register. No more than 65536 bytes of global data may be used. This
6164 requires GNU as and GNU ld which do most of the work. This currently
6165 only works on targets which use ECOFF; it does not work with ELF.
6167 @item -membedded-data
6168 @itemx -mno-embedded-data
6169 Allocate variables to the read-only data section first if possible, then
6170 next in the small data section if possible, otherwise in data. This gives
6171 slightly slower code than the default, but reduces the amount of RAM required
6172 when executing, and thus may be preferred for some embedded systems.
6174 @item -muninit-const-in-rodata
6175 @itemx -mno-uninit-const-in-rodata
6176 When used together with -membedded-data, it will always store uninitialized
6177 const variables in the read-only data section.
6179 @item -msingle-float
6180 @itemx -mdouble-float
6181 The @samp{-msingle-float} switch tells gcc to assume that the floating
6182 point coprocessor only supports single precision operations, as on the
6183 @samp{r4650} chip. The @samp{-mdouble-float} switch permits gcc to use
6184 double precision operations. This is the default.
6188 Permit use of the @samp{mad}, @samp{madu} and @samp{mul} instructions,
6189 as on the @samp{r4650} chip.
6192 Turns on @samp{-msingle-float}, @samp{-mmad}, and, at least for now,
6197 Enable 16-bit instructions.
6200 Use the entry and exit pseudo ops. This option can only be used with
6204 Compile code for the processor in little endian mode.
6205 The requisite libraries are assumed to exist.
6208 Compile code for the processor in big endian mode.
6209 The requisite libraries are assumed to exist.
6212 @cindex smaller data references (MIPS)
6213 @cindex gp-relative references (MIPS)
6214 Put global and static items less than or equal to @var{num} bytes into
6215 the small data or bss sections instead of the normal data or bss
6216 section. This allows the assembler to emit one word memory reference
6217 instructions based on the global pointer (@var{gp} or @var{$28}),
6218 instead of the normal two words used. By default, @var{num} is 8 when
6219 the MIPS assembler is used, and 0 when the GNU assembler is used. The
6220 @samp{-G @var{num}} switch is also passed to the assembler and linker.
6221 All modules should be compiled with the same @samp{-G @var{num}}
6225 Tell the MIPS assembler to not run its preprocessor over user
6226 assembler files (with a @samp{.s} suffix) when assembling them.
6229 Pass an option to gas which will cause nops to be inserted if
6230 the read of the destination register of an mfhi or mflo instruction
6231 occurs in the following two instructions.
6234 Do not include the default crt0.
6238 These options are defined by the macro
6239 @code{TARGET_SWITCHES} in the machine description. The default for the
6240 options is also defined by that macro, which enables you to change the
6245 @subsection Intel 386 Options
6246 @cindex i386 Options
6247 @cindex Intel 386 Options
6249 These @samp{-m} options are defined for the i386 family of computers:
6252 @item -mcpu=@var{cpu type}
6253 Assume the defaults for the machine type @var{cpu type} when scheduling
6254 instructions. The choices for @var{cpu type} are @samp{i386},
6255 @samp{i486}, @samp{i586}, @samp{i686}, @samp{pentium},
6256 @samp{pentiumpro}, @samp{k6}, and @samp{athlon}
6258 While picking a specific @var{cpu type} will schedule things appropriately
6259 for that particular chip, the compiler will not generate any code that
6260 does not run on the i386 without the @samp{-march=@var{cpu type}} option
6261 being used. @samp{i586} is equivalent to @samp{pentium} and @samp{i686}
6262 is equivalent to @samp{pentiumpro}. @samp{k6} is the AMD chip as
6263 opposed to the Intel ones.
6265 @item -march=@var{cpu type}
6266 Generate instructions for the machine type @var{cpu type}. The choices
6267 for @var{cpu type} are the same as for @samp{-mcpu}. Moreover,
6268 specifying @samp{-march=@var{cpu type}} implies @samp{-mcpu=@var{cpu type}}.
6274 Synonyms for -mcpu=i386, -mcpu=i486, -mcpu=pentium, and -mcpu=pentiumpro
6275 respectively. These synonyms are deprecated.
6277 @item -mintel-syntax
6278 Emit assembly using Intel syntax opcodes instead of AT&T syntax.
6282 Control whether or not the compiler uses IEEE floating point
6283 comparisons. These handle correctly the case where the result of a
6284 comparison is unordered.
6287 Generate output containing library calls for floating point.
6288 @strong{Warning:} the requisite libraries are not part of GCC.
6289 Normally the facilities of the machine's usual C compiler are used, but
6290 this can't be done directly in cross-compilation. You must make your
6291 own arrangements to provide suitable library functions for
6294 On machines where a function returns floating point results in the 80387
6295 register stack, some floating point opcodes may be emitted even if
6296 @samp{-msoft-float} is used.
6298 @item -mno-fp-ret-in-387
6299 Do not use the FPU registers for return values of functions.
6301 The usual calling convention has functions return values of types
6302 @code{float} and @code{double} in an FPU register, even if there
6303 is no FPU. The idea is that the operating system should emulate
6306 The option @samp{-mno-fp-ret-in-387} causes such values to be returned
6307 in ordinary CPU registers instead.
6309 @item -mno-fancy-math-387
6310 Some 387 emulators do not support the @code{sin}, @code{cos} and
6311 @code{sqrt} instructions for the 387. Specify this option to avoid
6312 generating those instructions. This option is the default on FreeBSD.
6313 As of revision 2.6.1, these instructions are not generated unless you
6314 also use the @samp{-ffast-math} switch.
6316 @item -malign-double
6317 @itemx -mno-align-double
6318 Control whether GCC aligns @code{double}, @code{long double}, and
6319 @code{long long} variables on a two word boundary or a one word
6320 boundary. Aligning @code{double} variables on a two word boundary will
6321 produce code that runs somewhat faster on a @samp{Pentium} at the
6322 expense of more memory.
6324 @strong{Warning:} if you use the @samp{-malign-double} switch,
6325 structures containing the above types will be aligned differently than
6326 the published application binary interface specifications for the 386.
6329 @itemx -mno-svr3-shlib
6330 Control whether GCC places uninitialized locals into @code{bss} or
6331 @code{data}. @samp{-msvr3-shlib} places these locals into @code{bss}.
6332 These options are meaningful only on System V Release 3.
6334 @item -mno-wide-multiply
6335 @itemx -mwide-multiply
6336 Control whether GCC uses the @code{mul} and @code{imul} that produce
6337 64 bit results in @code{eax:edx} from 32 bit operands to do @code{long
6338 long} multiplies and 32-bit division by constants.
6341 Use a different function-calling convention, in which functions that
6342 take a fixed number of arguments return with the @code{ret} @var{num}
6343 instruction, which pops their arguments while returning. This saves one
6344 instruction in the caller since there is no need to pop the arguments
6347 You can specify that an individual function is called with this calling
6348 sequence with the function attribute @samp{stdcall}. You can also
6349 override the @samp{-mrtd} option by using the function attribute
6350 @samp{cdecl}. @xref{Function Attributes}.
6352 @strong{Warning:} this calling convention is incompatible with the one
6353 normally used on Unix, so you cannot use it if you need to call
6354 libraries compiled with the Unix compiler.
6356 Also, you must provide function prototypes for all functions that
6357 take variable numbers of arguments (including @code{printf});
6358 otherwise incorrect code will be generated for calls to those
6361 In addition, seriously incorrect code will result if you call a
6362 function with too many arguments. (Normally, extra arguments are
6363 harmlessly ignored.)
6365 @item -mreg-alloc=@var{regs}
6366 Control the default allocation order of integer registers. The
6367 string @var{regs} is a series of letters specifying a register. The
6368 supported letters are: @code{a} allocate EAX; @code{b} allocate EBX;
6369 @code{c} allocate ECX; @code{d} allocate EDX; @code{S} allocate ESI;
6370 @code{D} allocate EDI; @code{B} allocate EBP.
6372 @item -mregparm=@var{num}
6373 Control how many registers are used to pass integer arguments. By
6374 default, no registers are used to pass arguments, and at most 3
6375 registers can be used. You can control this behavior for a specific
6376 function by using the function attribute @samp{regparm}.
6377 @xref{Function Attributes}.
6379 @strong{Warning:} if you use this switch, and
6380 @var{num} is nonzero, then you must build all modules with the same
6381 value, including any libraries. This includes the system libraries and
6384 @item -malign-loops=@var{num}
6385 Align loops to a 2 raised to a @var{num} byte boundary. If
6386 @samp{-malign-loops} is not specified, the default is 2 unless
6387 gas 2.8 (or later) is being used in which case the default is
6388 to align the loop on a 16 byte boundary if it is less than 8
6391 @item -malign-jumps=@var{num}
6392 Align instructions that are only jumped to to a 2 raised to a @var{num}
6393 byte boundary. If @samp{-malign-jumps} is not specified, the default is
6394 2 if optimizing for a 386, and 4 if optimizing for a 486 unless
6395 gas 2.8 (or later) is being used in which case the default is
6396 to align the instruction on a 16 byte boundary if it is less
6399 @item -malign-functions=@var{num}
6400 Align the start of functions to a 2 raised to @var{num} byte boundary.
6401 If @samp{-malign-functions} is not specified, the default is 2 if optimizing
6402 for a 386, and 4 if optimizing for a 486.
6404 @item -mpreferred-stack-boundary=@var{num}
6405 Attempt to keep the stack boundary aligned to a 2 raised to @var{num}
6406 byte boundary. If @samp{-mpreferred-stack-boundary} is not specified,
6407 the default is 4 (16 bytes or 128 bits).
6409 The stack is required to be aligned on a 4 byte boundary. On Pentium
6410 and PentiumPro, @code{double} and @code{long double} values should be
6411 aligned to an 8 byte boundary (see @samp{-malign-double}) or suffer
6412 significant run time performance penalties. On Pentium III, the
6413 Streaming SIMD Extension (SSE) data type @code{__m128} suffers similar
6414 penalties if it is not 16 byte aligned.
6416 To ensure proper alignment of this values on the stack, the stack boundary
6417 must be as aligned as that required by any value stored on the stack.
6418 Further, every function must be generated such that it keeps the stack
6419 aligned. Thus calling a function compiled with a higher preferred
6420 stack boundary from a function compiled with a lower preferred stack
6421 boundary will most likely misalign the stack. It is recommended that
6422 libraries that use callbacks always use the default setting.
6424 This extra alignment does consume extra stack space. Code that is sensitive
6425 to stack space usage, such as embedded systems and operating system kernels,
6426 may want to reduce the preferred alignment to
6427 @samp{-mpreferred-stack-boundary=2}.
6431 Use PUSH operations to store outgoing parameters. This method is shorter
6432 and usually equally fast as method using SUB/MOV operations and is enabled
6433 by default. In some cases disabling it may improve performance because of
6434 improved scheduling and reduced dependencies.
6436 @item -maccumulate-outgoing-args
6437 @kindex -maccumulate-outgoing-args
6438 If enabled, the maximum amount of space required for outgoing arguments will be
6439 computed in the function prologue. This in faster on most modern CPUs
6440 because of reduced dependencies, improved scheduling and reduced stack usage
6441 when preferred stack boundary is not equal to 2. The drawback is a notable
6442 increase in code size. This switch implies -mno-push-args.
6446 Support thread-safe exception handling on @samp{Mingw32}. Code that relies
6447 on thread-safe exception handling must compile and link all code with the
6448 @samp{-mthreads} option. When compiling, @samp{-mthreads} defines
6449 @samp{-D_MT}; when linking, it links in a special thread helper library
6450 @samp{-lmingwthrd} which cleans up per thread exception handling data.
6452 @item -mno-align-stringops
6453 @kindex -mno-align-stringops
6454 Do not align destination of inlined string operations. This switch reduces
6455 code size and improves performance in case the destination is already aligned,
6456 but gcc don't know about it.
6458 @item -minline-all-stringops
6459 @kindex -minline-all-stringops
6460 By default GCC inlines string operations only when destination is known to be
6461 aligned at least to 4 byte boundary. This enables more inlining, increase code
6462 size, but may improve performance of code that depends on fast memcpy, strlen
6463 and memset for short lengths.
6467 @subsection HPPA Options
6468 @cindex HPPA Options
6470 These @samp{-m} options are defined for the HPPA family of computers:
6473 @item -march=@var{architecture type}
6474 Generate code for the specified architecture. The choices for
6475 @var{architecture type} are @samp{1.0} for PA 1.0, @samp{1.1} for PA
6476 1.1, and @samp{2.0} for PA 2.0 processors. Refer to
6477 @file{/usr/lib/sched.models} on an HP-UX system to determine the proper
6478 architecture option for your machine. Code compiled for lower numbered
6479 architectures will run on higher numbered architectures, but not the
6482 PA 2.0 support currently requires gas snapshot 19990413 or later. The
6483 next release of binutils (current is 2.9.1) will probably contain PA 2.0
6487 @itemx -mpa-risc-1-1
6488 @itemx -mpa-risc-2-0
6489 Synonyms for -march=1.0, -march=1.1, and -march=2.0 respectively.
6492 Generate code suitable for big switch tables. Use this option only if
6493 the assembler/linker complain about out of range branches within a switch
6496 @item -mjump-in-delay
6497 Fill delay slots of function calls with unconditional jump instructions
6498 by modifying the return pointer for the function call to be the target
6499 of the conditional jump.
6501 @item -mdisable-fpregs
6502 Prevent floating point registers from being used in any manner. This is
6503 necessary for compiling kernels which perform lazy context switching of
6504 floating point registers. If you use this option and attempt to perform
6505 floating point operations, the compiler will abort.
6507 @item -mdisable-indexing
6508 Prevent the compiler from using indexing address modes. This avoids some
6509 rather obscure problems when compiling MIG generated code under MACH.
6511 @item -mno-space-regs
6512 Generate code that assumes the target has no space registers. This allows
6513 GCC to generate faster indirect calls and use unscaled index address modes.
6515 Such code is suitable for level 0 PA systems and kernels.
6517 @item -mfast-indirect-calls
6518 Generate code that assumes calls never cross space boundaries. This
6519 allows GCC to emit code which performs faster indirect calls.
6521 This option will not work in the presence of shared libraries or nested
6524 @item -mlong-load-store
6525 Generate 3-instruction load and store sequences as sometimes required by
6526 the HP-UX 10 linker. This is equivalent to the @samp{+k} option to
6529 @item -mportable-runtime
6530 Use the portable calling conventions proposed by HP for ELF systems.
6533 Enable the use of assembler directives only GAS understands.
6535 @item -mschedule=@var{cpu type}
6536 Schedule code according to the constraints for the machine type
6537 @var{cpu type}. The choices for @var{cpu type} are @samp{700}
6538 @samp{7100}, @samp{7100LC}, @samp{7200}, and @samp{8000}. Refer to
6539 @file{/usr/lib/sched.models} on an HP-UX system to determine the
6540 proper scheduling option for your machine.
6543 Enable the optimization pass in the HPUX linker. Note this makes symbolic
6544 debugging impossible. It also triggers a bug in the HPUX 8 and HPUX 9 linkers
6545 in which they give bogus error messages when linking some programs.
6548 Generate output containing library calls for floating point.
6549 @strong{Warning:} the requisite libraries are not available for all HPPA
6550 targets. Normally the facilities of the machine's usual C compiler are
6551 used, but this cannot be done directly in cross-compilation. You must make
6552 your own arrangements to provide suitable library functions for
6553 cross-compilation. The embedded target @samp{hppa1.1-*-pro}
6554 does provide software floating point support.
6556 @samp{-msoft-float} changes the calling convention in the output file;
6557 therefore, it is only useful if you compile @emph{all} of a program with
6558 this option. In particular, you need to compile @file{libgcc.a}, the
6559 library that comes with GCC, with @samp{-msoft-float} in order for
6563 @node Intel 960 Options
6564 @subsection Intel 960 Options
6566 These @samp{-m} options are defined for the Intel 960 implementations:
6569 @item -m@var{cpu type}
6570 Assume the defaults for the machine type @var{cpu type} for some of
6571 the other options, including instruction scheduling, floating point
6572 support, and addressing modes. The choices for @var{cpu type} are
6573 @samp{ka}, @samp{kb}, @samp{mc}, @samp{ca}, @samp{cf},
6574 @samp{sa}, and @samp{sb}.
6580 The @samp{-mnumerics} option indicates that the processor does support
6581 floating-point instructions. The @samp{-msoft-float} option indicates
6582 that floating-point support should not be assumed.
6584 @item -mleaf-procedures
6585 @itemx -mno-leaf-procedures
6586 Do (or do not) attempt to alter leaf procedures to be callable with the
6587 @code{bal} instruction as well as @code{call}. This will result in more
6588 efficient code for explicit calls when the @code{bal} instruction can be
6589 substituted by the assembler or linker, but less efficient code in other
6590 cases, such as calls via function pointers, or using a linker that doesn't
6591 support this optimization.
6594 @itemx -mno-tail-call
6595 Do (or do not) make additional attempts (beyond those of the
6596 machine-independent portions of the compiler) to optimize tail-recursive
6597 calls into branches. You may not want to do this because the detection of
6598 cases where this is not valid is not totally complete. The default is
6599 @samp{-mno-tail-call}.
6601 @item -mcomplex-addr
6602 @itemx -mno-complex-addr
6603 Assume (or do not assume) that the use of a complex addressing mode is a
6604 win on this implementation of the i960. Complex addressing modes may not
6605 be worthwhile on the K-series, but they definitely are on the C-series.
6606 The default is currently @samp{-mcomplex-addr} for all processors except
6610 @itemx -mno-code-align
6611 Align code to 8-byte boundaries for faster fetching (or don't bother).
6612 Currently turned on by default for C-series implementations only.
6615 @item -mclean-linkage
6616 @itemx -mno-clean-linkage
6617 These options are not fully implemented.
6621 @itemx -mic2.0-compat
6622 @itemx -mic3.0-compat
6623 Enable compatibility with iC960 v2.0 or v3.0.
6627 Enable compatibility with the iC960 assembler.
6629 @item -mstrict-align
6630 @itemx -mno-strict-align
6631 Do not permit (do permit) unaligned accesses.
6634 Enable structure-alignment compatibility with Intel's gcc release version
6635 1.3 (based on gcc 1.37). This option implies @samp{-mstrict-align}.
6637 @item -mlong-double-64
6638 Implement type @samp{long double} as 64-bit floating point numbers.
6639 Without the option @samp{long double} is implemented by 80-bit
6640 floating point numbers. The only reason we have it because there is
6641 no 128-bit @samp{long double} support in @samp{fp-bit.c} yet. So it
6642 is only useful for people using soft-float targets. Otherwise, we
6643 should recommend against use of it.
6647 @node DEC Alpha Options
6648 @subsection DEC Alpha Options
6650 These @samp{-m} options are defined for the DEC Alpha implementations:
6653 @item -mno-soft-float
6655 Use (do not use) the hardware floating-point instructions for
6656 floating-point operations. When @code{-msoft-float} is specified,
6657 functions in @file{libgcc1.c} will be used to perform floating-point
6658 operations. Unless they are replaced by routines that emulate the
6659 floating-point operations, or compiled in such a way as to call such
6660 emulations routines, these routines will issue floating-point
6661 operations. If you are compiling for an Alpha without floating-point
6662 operations, you must ensure that the library is built so as not to call
6665 Note that Alpha implementations without floating-point operations are
6666 required to have floating-point registers.
6670 Generate code that uses (does not use) the floating-point register set.
6671 @code{-mno-fp-regs} implies @code{-msoft-float}. If the floating-point
6672 register set is not used, floating point operands are passed in integer
6673 registers as if they were integers and floating-point results are passed
6674 in $0 instead of $f0. This is a non-standard calling sequence, so any
6675 function with a floating-point argument or return value called by code
6676 compiled with @code{-mno-fp-regs} must also be compiled with that
6679 A typical use of this option is building a kernel that does not use,
6680 and hence need not save and restore, any floating-point registers.
6683 The Alpha architecture implements floating-point hardware optimized for
6684 maximum performance. It is mostly compliant with the IEEE floating
6685 point standard. However, for full compliance, software assistance is
6686 required. This option generates code fully IEEE compliant code
6687 @emph{except} that the @var{inexact flag} is not maintained (see below).
6688 If this option is turned on, the CPP macro @code{_IEEE_FP} is defined
6689 during compilation. The option is a shorthand for: @samp{-D_IEEE_FP
6690 -mfp-trap-mode=su -mtrap-precision=i -mieee-conformant}. The resulting
6691 code is less efficient but is able to correctly support denormalized
6692 numbers and exceptional IEEE values such as not-a-number and plus/minus
6693 infinity. Other Alpha compilers call this option
6694 @code{-ieee_with_no_inexact}.
6696 @item -mieee-with-inexact
6697 @c overfull hbox here --bob 22 jul96
6698 @c original text between ignore ... end ignore
6700 This is like @samp{-mieee} except the generated code also maintains the
6701 IEEE @var{inexact flag}. Turning on this option causes the generated
6702 code to implement fully-compliant IEEE math. The option is a shorthand
6703 for @samp{-D_IEEE_FP -D_IEEE_FP_INEXACT} plus @samp{-mieee-conformant},
6704 @samp{-mfp-trap-mode=sui}, and @samp{-mtrap-precision=i}. On some Alpha
6705 implementations the resulting code may execute significantly slower than
6706 the code generated by default. Since there is very little code that
6707 depends on the @var{inexact flag}, you should normally not specify this
6708 option. Other Alpha compilers call this option
6709 @samp{-ieee_with_inexact}.
6711 @c changed paragraph
6712 This is like @samp{-mieee} except the generated code also maintains the
6713 IEEE @var{inexact flag}. Turning on this option causes the generated
6714 code to implement fully-compliant IEEE math. The option is a shorthand
6715 for @samp{-D_IEEE_FP -D_IEEE_FP_INEXACT} plus the three following:
6716 @samp{-mieee-conformant},
6717 @samp{-mfp-trap-mode=sui},
6718 and @samp{-mtrap-precision=i}.
6719 On some Alpha implementations the resulting code may execute
6720 significantly slower than the code generated by default. Since there
6721 is very little code that depends on the @var{inexact flag}, you should
6722 normally not specify this option. Other Alpha compilers call this
6723 option @samp{-ieee_with_inexact}.
6724 @c end changes to prevent overfull hboxes
6726 @item -mfp-trap-mode=@var{trap mode}
6727 This option controls what floating-point related traps are enabled.
6728 Other Alpha compilers call this option @samp{-fptm }@var{trap mode}.
6729 The trap mode can be set to one of four values:
6733 This is the default (normal) setting. The only traps that are enabled
6734 are the ones that cannot be disabled in software (e.g., division by zero
6738 In addition to the traps enabled by @samp{n}, underflow traps are enabled
6742 Like @samp{su}, but the instructions are marked to be safe for software
6743 completion (see Alpha architecture manual for details).
6746 Like @samp{su}, but inexact traps are enabled as well.
6749 @item -mfp-rounding-mode=@var{rounding mode}
6750 Selects the IEEE rounding mode. Other Alpha compilers call this option
6751 @samp{-fprm }@var{rounding mode}. The @var{rounding mode} can be one
6756 Normal IEEE rounding mode. Floating point numbers are rounded towards
6757 the nearest machine number or towards the even machine number in case
6761 Round towards minus infinity.
6764 Chopped rounding mode. Floating point numbers are rounded towards zero.
6767 Dynamic rounding mode. A field in the floating point control register
6768 (@var{fpcr}, see Alpha architecture reference manual) controls the
6769 rounding mode in effect. The C library initializes this register for
6770 rounding towards plus infinity. Thus, unless your program modifies the
6771 @var{fpcr}, @samp{d} corresponds to round towards plus infinity.
6774 @item -mtrap-precision=@var{trap precision}
6775 In the Alpha architecture, floating point traps are imprecise. This
6776 means without software assistance it is impossible to recover from a
6777 floating trap and program execution normally needs to be terminated.
6778 GCC can generate code that can assist operating system trap handlers
6779 in determining the exact location that caused a floating point trap.
6780 Depending on the requirements of an application, different levels of
6781 precisions can be selected:
6785 Program precision. This option is the default and means a trap handler
6786 can only identify which program caused a floating point exception.
6789 Function precision. The trap handler can determine the function that
6790 caused a floating point exception.
6793 Instruction precision. The trap handler can determine the exact
6794 instruction that caused a floating point exception.
6797 Other Alpha compilers provide the equivalent options called
6798 @samp{-scope_safe} and @samp{-resumption_safe}.
6800 @item -mieee-conformant
6801 This option marks the generated code as IEEE conformant. You must not
6802 use this option unless you also specify @samp{-mtrap-precision=i} and either
6803 @samp{-mfp-trap-mode=su} or @samp{-mfp-trap-mode=sui}. Its only effect
6804 is to emit the line @samp{.eflag 48} in the function prologue of the
6805 generated assembly file. Under DEC Unix, this has the effect that
6806 IEEE-conformant math library routines will be linked in.
6808 @item -mbuild-constants
6809 Normally GCC examines a 32- or 64-bit integer constant to
6810 see if it can construct it from smaller constants in two or three
6811 instructions. If it cannot, it will output the constant as a literal and
6812 generate code to load it from the data segment at runtime.
6814 Use this option to require GCC to construct @emph{all} integer constants
6815 using code, even if it takes more instructions (the maximum is six).
6817 You would typically use this option to build a shared library dynamic
6818 loader. Itself a shared library, it must relocate itself in memory
6819 before it can find the variables and constants in its own data segment.
6823 Select whether to generate code to be assembled by the vendor-supplied
6824 assembler (@samp{-malpha-as}) or by the GNU assembler @samp{-mgas}.
6832 Indicate whether GCC should generate code to use the optional BWX,
6833 CIX, and MAX instruction sets. The default is to use the instruction sets
6834 supported by the CPU type specified via @samp{-mcpu=} option or that
6835 of the CPU on which GCC was built if none was specified.
6837 @item -mcpu=@var{cpu_type}
6838 Set the instruction set, register set, and instruction scheduling
6839 parameters for machine type @var{cpu_type}. You can specify either the
6840 @samp{EV} style name or the corresponding chip number. GCC
6841 supports scheduling parameters for the EV4 and EV5 family of processors
6842 and will choose the default values for the instruction set from
6843 the processor you specify. If you do not specify a processor type,
6844 GCC will default to the processor on which the compiler was built.
6846 Supported values for @var{cpu_type} are
6851 Schedules as an EV4 and has no instruction set extensions.
6855 Schedules as an EV5 and has no instruction set extensions.
6859 Schedules as an EV5 and supports the BWX extension.
6864 Schedules as an EV5 and supports the BWX and MAX extensions.
6868 Schedules as an EV5 (until Digital releases the scheduling parameters
6869 for the EV6) and supports the BWX, CIX, and MAX extensions.
6872 @item -mmemory-latency=@var{time}
6873 Sets the latency the scheduler should assume for typical memory
6874 references as seen by the application. This number is highly
6875 dependent on the memory access patterns used by the application
6876 and the size of the external cache on the machine.
6878 Valid options for @var{time} are
6882 A decimal number representing clock cycles.
6888 The compiler contains estimates of the number of clock cycles for
6889 ``typical'' EV4 & EV5 hardware for the Level 1, 2 & 3 caches
6890 (also called Dcache, Scache, and Bcache), as well as to main memory.
6891 Note that L3 is only valid for EV5.
6896 @node Clipper Options
6897 @subsection Clipper Options
6899 These @samp{-m} options are defined for the Clipper implementations:
6903 Produce code for a C300 Clipper processor. This is the default.
6906 Produce code for a C400 Clipper processor i.e. use floating point
6910 @node H8/300 Options
6911 @subsection H8/300 Options
6913 These @samp{-m} options are defined for the H8/300 implementations:
6917 Shorten some address references at link time, when possible; uses the
6918 linker option @samp{-relax}. @xref{H8/300,, @code{ld} and the H8/300,
6919 ld.info, Using ld}, for a fuller description.
6922 Generate code for the H8/300H.
6925 Generate code for the H8/S.
6928 Generate code for the H8/S2600. This switch must be used with -ms.
6931 Make @code{int} data 32 bits by default.
6934 On the H8/300H and H8/S, use the same alignment rules as for the H8/300.
6935 The default for the H8/300H and H8/S is to align longs and floats on 4
6937 @samp{-malign-300} causes them to be aligned on 2 byte boundaries.
6938 This option has no effect on the H8/300.
6942 @subsection SH Options
6944 These @samp{-m} options are defined for the SH implementations:
6948 Generate code for the SH1.
6951 Generate code for the SH2.
6954 Generate code for the SH3.
6957 Generate code for the SH3e.
6960 Generate code for the SH4 without a floating-point unit.
6962 @item -m4-single-only
6963 Generate code for the SH4 with a floating-point unit that only
6964 supports single-precision arithmentic.
6967 Generate code for the SH4 assuming the floating-point unit is in
6968 single-precision mode by default.
6971 Generate code for the SH4.
6974 Compile code for the processor in big endian mode.
6977 Compile code for the processor in little endian mode.
6980 Align doubles at 64 bit boundaries. Note that this changes the calling
6981 conventions, and thus some functions from the standard C library will
6982 not work unless you recompile it first with -mdalign.
6985 Shorten some address references at link time, when possible; uses the
6986 linker option @samp{-relax}.
6989 Use 32-bit offsets in @code{switch} tables. The default is to use
6993 Enable the use of the instruction @code{fmovd}.
6996 Comply with the calling conventions defined by Hitachi.
6999 Mark the @code{MAC} register as call-clobbered, even if
7000 @code{-mhitachi} is given.
7003 Dump instruction size and location in the assembly code.
7006 This option is deprecated. It pads structures to multiple of 4 bytes,
7007 which is incompatible with the SH ABI.
7010 Optimize for space instead of speed. Implied by @code{-Os}.
7013 When generating position-independent code, emit function calls using
7014 the Global Offset Table instead of the Procedure Linkage Table.
7017 Generate a library function call to invalidate instruction cache
7018 entries, after fixing up a trampoline. This library function call
7019 doesn't assume it can write to the whole memory address space. This
7020 is the default when the target is @code{sh-*-linux*}.
7023 @node System V Options
7024 @subsection Options for System V
7026 These additional options are available on System V Release 4 for
7027 compatibility with other compilers on those systems:
7031 Create a shared object.
7032 It is recommended that @samp{-symbolic} or @samp{-shared} be used instead.
7035 Identify the versions of each tool used by the compiler, in a
7036 @code{.ident} assembler directive in the output.
7039 Refrain from adding @code{.ident} directives to the output file (this is
7042 @item -YP,@var{dirs}
7043 Search the directories @var{dirs}, and no others, for libraries
7044 specified with @samp{-l}.
7047 Look in the directory @var{dir} to find the M4 preprocessor.
7048 The assembler uses this option.
7049 @c This is supposed to go with a -Yd for predefined M4 macro files, but
7050 @c the generic assembler that comes with Solaris takes just -Ym.
7053 @node TMS320C3x/C4x Options
7054 @subsection TMS320C3x/C4x Options
7055 @cindex TMS320C3x/C4x Options
7057 These @samp{-m} options are defined for TMS320C3x/C4x implementations:
7061 @item -mcpu=@var{cpu_type}
7062 Set the instruction set, register set, and instruction scheduling
7063 parameters for machine type @var{cpu_type}. Supported values for
7064 @var{cpu_type} are @samp{c30}, @samp{c31}, @samp{c32}, @samp{c40}, and
7065 @samp{c44}. The default is @samp{c40} to generate code for the
7070 @itemx -msmall-memory
7072 Generates code for the big or small memory model. The small memory
7073 model assumed that all data fits into one 64K word page. At run-time
7074 the data page (DP) register must be set to point to the 64K page
7075 containing the .bss and .data program sections. The big memory model is
7076 the default and requires reloading of the DP register for every direct
7081 Allow (disallow) allocation of general integer operands into the block
7086 Enable (disable) generation of code using decrement and branch,
7087 DBcond(D), instructions. This is enabled by default for the C4x. To be
7088 on the safe side, this is disabled for the C3x, since the maximum
7089 iteration count on the C3x is 2^23 + 1 (but who iterates loops more than
7090 2^23 times on the C3x?). Note that GCC will try to reverse a loop so
7091 that it can utilise the decrement and branch instruction, but will give
7092 up if there is more than one memory reference in the loop. Thus a loop
7093 where the loop counter is decremented can generate slightly more
7094 efficient code, in cases where the RPTB instruction cannot be utilised.
7096 @item -mdp-isr-reload
7098 Force the DP register to be saved on entry to an interrupt service
7099 routine (ISR), reloaded to point to the data section, and restored on
7100 exit from the ISR. This should not be required unless someone has
7101 violated the small memory model by modifying the DP register, say within
7106 For the C3x use the 24-bit MPYI instruction for integer multiplies
7107 instead of a library call to guarantee 32-bit results. Note that if one
7108 of the operands is a constant, then the multiplication will be performed
7109 using shifts and adds. If the -mmpyi option is not specified for the C3x,
7110 then squaring operations are performed inline instead of a library call.
7113 @itemx -mno-fast-fix
7114 The C3x/C4x FIX instruction to convert a floating point value to an
7115 integer value chooses the nearest integer less than or equal to the
7116 floating point value rather than to the nearest integer. Thus if the
7117 floating point number is negative, the result will be incorrectly
7118 truncated an additional code is necessary to detect and correct this
7119 case. This option can be used to disable generation of the additional
7120 code required to correct the result.
7124 Enable (disable) generation of repeat block sequences using the RPTB
7125 instruction for zero overhead looping. The RPTB construct is only used
7126 for innermost loops that do not call functions or jump across the loop
7127 boundaries. There is no advantage having nested RPTB loops due to the
7128 overhead required to save and restore the RC, RS, and RE registers.
7129 This is enabled by default with -O2.
7131 @item -mrpts=@var{count}
7133 Enable (disable) the use of the single instruction repeat instruction
7134 RPTS. If a repeat block contains a single instruction, and the loop
7135 count can be guaranteed to be less than the value @var{count}, GCC will
7136 emit a RPTS instruction instead of a RPTB. If no value is specified,
7137 then a RPTS will be emitted even if the loop count cannot be determined
7138 at compile time. Note that the repeated instruction following RPTS does
7139 not have to be reloaded from memory each iteration, thus freeing up the
7140 CPU buses for operands. However, since interrupts are blocked by this
7141 instruction, it is disabled by default.
7143 @item -mloop-unsigned
7144 @itemx -mno-loop-unsigned
7145 The maximum iteration count when using RPTS and RPTB (and DB on the C40)
7146 is 2^31 + 1 since these instructions test if the iteration count is
7147 negative to terminate the loop. If the iteration count is unsigned
7148 there is a possibility than the 2^31 + 1 maximum iteration count may be
7149 exceeded. This switch allows an unsigned iteration count.
7152 Try to emit an assembler syntax that the TI assembler (asm30) is happy
7153 with. This also enforces compatibility with the API employed by the TI
7154 C3x C compiler. For example, long doubles are passed as structures
7155 rather than in floating point registers.
7159 Generate code that uses registers (stack) for passing arguments to functions.
7160 By default, arguments are passed in registers where possible rather
7161 than by pushing arguments on to the stack.
7163 @item -mparallel-insns
7164 @itemx -mno-parallel-insns
7165 Allow the generation of parallel instructions. This is enabled by
7168 @item -mparallel-mpy
7169 @itemx -mno-parallel-mpy
7170 Allow the generation of MPY||ADD and MPY||SUB parallel instructions,
7171 provided -mparallel-insns is also specified. These instructions have
7172 tight register constraints which can pessimize the code generation
7178 @subsection V850 Options
7179 @cindex V850 Options
7181 These @samp{-m} options are defined for V850 implementations:
7185 @itemx -mno-long-calls
7186 Treat all calls as being far away (near). If calls are assumed to be
7187 far away, the compiler will always load the functions address up into a
7188 register, and call indirect through the pointer.
7192 Do not optimize (do optimize) basic blocks that use the same index
7193 pointer 4 or more times to copy pointer into the @code{ep} register, and
7194 use the shorter @code{sld} and @code{sst} instructions. The @samp{-mep}
7195 option is on by default if you optimize.
7197 @item -mno-prolog-function
7198 @itemx -mprolog-function
7199 Do not use (do use) external functions to save and restore registers at
7200 the prolog and epilog of a function. The external functions are slower,
7201 but use less code space if more than one function saves the same number
7202 of registers. The @samp{-mprolog-function} option is on by default if
7206 Try to make the code as small as possible. At present, this just turns
7207 on the @samp{-mep} and @samp{-mprolog-function} options.
7210 Put static or global variables whose size is @var{n} bytes or less into
7211 the tiny data area that register @code{ep} points to. The tiny data
7212 area can hold up to 256 bytes in total (128 bytes for byte references).
7215 Put static or global variables whose size is @var{n} bytes or less into
7216 the small data area that register @code{gp} points to. The small data
7217 area can hold up to 64 kilobytes.
7220 Put static or global variables whose size is @var{n} bytes or less into
7221 the first 32 kilobytes of memory.
7224 Specify that the target processor is the V850.
7227 Generate code suitable for big switch tables. Use this option only if
7228 the assembler/linker complain about out of range branches within a switch
7233 @subsection ARC Options
7236 These options are defined for ARC implementations:
7240 Compile code for little endian mode. This is the default.
7243 Compile code for big endian mode.
7246 Prepend the name of the cpu to all public symbol names.
7247 In multiple-processor systems, there are many ARC variants with different
7248 instruction and register set characteristics. This flag prevents code
7249 compiled for one cpu to be linked with code compiled for another.
7250 No facility exists for handling variants that are "almost identical".
7251 This is an all or nothing option.
7253 @item -mcpu=@var{cpu}
7254 Compile code for ARC variant @var{cpu}.
7255 Which variants are supported depend on the configuration.
7256 All variants support @samp{-mcpu=base}, this is the default.
7258 @item -mtext=@var{text section}
7259 @itemx -mdata=@var{data section}
7260 @itemx -mrodata=@var{readonly data section}
7261 Put functions, data, and readonly data in @var{text section},
7262 @var{data section}, and @var{readonly data section} respectively
7263 by default. This can be overridden with the @code{section} attribute.
7264 @xref{Variable Attributes}.
7269 @subsection NS32K Options
7270 @cindex NS32K options
7272 These are the @samp{-m} options defined for the 32000 series. The default
7273 values for these options depends on which style of 32000 was selected when
7274 the compiler was configured; the defaults for the most common choices are
7280 Generate output for a 32032. This is the default
7281 when the compiler is configured for 32032 and 32016 based systems.
7285 Generate output for a 32332. This is the default
7286 when the compiler is configured for 32332-based systems.
7290 Generate output for a 32532. This is the default
7291 when the compiler is configured for 32532-based systems.
7294 Generate output containing 32081 instructions for floating point.
7295 This is the default for all systems.
7298 Generate output containing 32381 instructions for floating point. This
7299 also implies @samp{-m32081}. The 32381 is only compatible with the 32332
7300 and 32532 cpus. This is the default for the pc532-netbsd configuration.
7303 Try and generate multiply-add floating point instructions @code{polyF}
7304 and @code{dotF}. This option is only available if the @samp{-m32381}
7305 option is in effect. Using these instructions requires changes to to
7306 register allocation which generally has a negative impact on
7307 performance. This option should only be enabled when compiling code
7308 particularly likely to make heavy use of multiply-add instructions.
7311 Do not try and generate multiply-add floating point instructions
7312 @code{polyF} and @code{dotF}. This is the default on all platforms.
7315 Generate output containing library calls for floating point.
7316 @strong{Warning:} the requisite libraries may not be available.
7319 Do not use the bit-field instructions. On some machines it is faster to
7320 use shifting and masking operations. This is the default for the pc532.
7323 Do use the bit-field instructions. This is the default for all platforms
7327 Use a different function-calling convention, in which functions
7328 that take a fixed number of arguments return pop their
7329 arguments on return with the @code{ret} instruction.
7331 This calling convention is incompatible with the one normally
7332 used on Unix, so you cannot use it if you need to call libraries
7333 compiled with the Unix compiler.
7335 Also, you must provide function prototypes for all functions that
7336 take variable numbers of arguments (including @code{printf});
7337 otherwise incorrect code will be generated for calls to those
7340 In addition, seriously incorrect code will result if you call a
7341 function with too many arguments. (Normally, extra arguments are
7342 harmlessly ignored.)
7344 This option takes its name from the 680x0 @code{rtd} instruction.
7348 Use a different function-calling convention where the first two arguments
7349 are passed in registers.
7351 This calling convention is incompatible with the one normally
7352 used on Unix, so you cannot use it if you need to call libraries
7353 compiled with the Unix compiler.
7356 Do not pass any arguments in registers. This is the default for all
7360 It is OK to use the sb as an index register which is always loaded with
7361 zero. This is the default for the pc532-netbsd target.
7364 The sb register is not available for use or has not been initialized to
7365 zero by the run time system. This is the default for all targets except
7366 the pc532-netbsd. It is also implied whenever @samp{-mhimem} or
7367 @samp{-fpic} is set.
7370 Many ns32000 series addressing modes use displacements of up to 512MB.
7371 If an address is above 512MB then displacements from zero can not be used.
7372 This option causes code to be generated which can be loaded above 512MB.
7373 This may be useful for operating systems or ROM code.
7376 Assume code will be loaded in the first 512MB of virtual address space.
7377 This is the default for all platforms.
7383 @subsection AVR Options
7386 These options are defined for AVR implementations:
7389 @item -mmcu=@var{mcu}
7390 Specify ATMEL AVR instruction set or MCU type.
7392 Instruction set avr1 is for the minimal AVR core, not supported by the C
7393 compiler, only for assembler programs (MCU types: at90s1200, attiny10,
7394 attiny11, attiny12, attiny15, attiny28).
7396 Instruction set avr2 (default) is for the classic AVR core with up to
7397 8K program memory space (MCU types: at90s2313, at90s2323, attiny22,
7398 at90s2333, at90s2343, at90s4414, at90s4433, at90s4434, at90s8515,
7399 at90c8534, at90s8535).
7401 Instruction set avr3 is for the classic AVR core with up to 128K program
7402 memory space (MCU types: atmega103, atmega603).
7404 Instruction set avr4 is for the enhanced AVR core with up to 8K program
7405 memory space (MCU types: atmega83, atmega85).
7407 Instruction set avr5 is for the enhanced AVR core with up to 128K program
7408 memory space (MCU types: atmega161, atmega163, atmega32, at94k).
7411 Output instruction sizes to the asm file.
7413 @item -minit-stack=@var{N}
7414 Specify the initial stack address, which may be a symbol or numeric value,
7415 __stack is the default.
7417 @item -mno-interrupts
7418 Generated code is not compatible with hardware interrupts.
7419 Code size will be smaller.
7421 @item -mcall-prologues
7422 Functions prologues/epilogues expanded as call to appropriate
7423 subroutines. Code size will be smaller.
7425 @item -mno-tablejump
7426 Do not generate tablejump insns which sometimes increase code size.
7429 Change only the low 8 bits of the stack pointer.
7433 @subsection MCore Options
7434 @cindex MCore options
7436 These are the @samp{-m} options defined for the Motorola M*Core
7444 Inline constants into the code stream if it can be done in two
7445 instructions or less.
7450 Use the divide instruction. (Enabled by default).
7452 @item -mrelax-immediate
7453 @itemx -mrelax-immediate
7454 @itemx -mno-relax-immediate
7455 Allow arbitrary sized immediates in bit operations.
7457 @item -mwide-bitfields
7458 @itemx -mwide-bitfields
7459 @itemx -mno-wide-bitfields
7460 Always treat bitfields as int-sized.
7462 @item -m4byte-functions
7463 @itemx -m4byte-functions
7464 @itemx -mno-4byte-functions
7465 Force all functions to be aligned to a four byte boundary.
7467 @item -mcallgraph-data
7468 @itemx -mcallgraph-data
7469 @itemx -mno-callgraph-data
7470 Emit callgraph information.
7474 @itemx -mno-slow-bytes
7475 Prefer word access when reading byte quantities.
7477 @item -mlittle-endian
7478 @itemx -mlittle-endian
7480 Generate code for a little endian target.
7485 Generate code for the 210 processor.
7489 @subsection D30V Options
7490 @cindex D30V Options
7492 These @samp{-m} options are defined for D30V implementations:
7496 Link the @samp{.text}, @samp{.data}, @samp{.bss}, @samp{.strings},
7497 @samp{.rodata}, @samp{.rodata1}, @samp{.data1} sections into external
7498 memory, which starts at location @code{0x80000000}.
7501 Same as the @samp{-mextmem} switch.
7504 Link the @samp{.text} section into onchip text memory, which starts at
7505 location @code{0x0}. Also link @samp{.data}, @samp{.bss},
7506 @samp{.strings}, @samp{.rodata}, @samp{.rodata1}, @samp{.data1} sections
7507 into onchip data memory, which starts at location @code{0x20000000}.
7509 @item -mno-asm-optimize
7510 @itemx -masm-optimize
7511 Disable (enable) passing @samp{-O} to the assembler when optimizing.
7512 The assembler uses the @samp{-O} option to automatically parallelize
7513 adjacent short instructions where possible.
7515 @item -mbranch-cost=@var{n}
7516 Increase the internal costs of branches to @var{n}. Higher costs means
7517 that the compiler will issue more instructions to avoid doing a branch.
7520 @item -mcond-exec=@var{n}
7521 Specify the maximum number of conditionally executed instructions that
7522 replace a branch. The default is 4.
7525 @node Code Gen Options
7526 @section Options for Code Generation Conventions
7527 @cindex code generation conventions
7528 @cindex options, code generation
7529 @cindex run-time options
7531 These machine-independent options control the interface conventions
7532 used in code generation.
7534 Most of them have both positive and negative forms; the negative form
7535 of @samp{-ffoo} would be @samp{-fno-foo}. In the table below, only
7536 one of the forms is listed---the one which is not the default. You
7537 can figure out the other form by either removing @samp{no-} or adding
7542 Enable exception handling. Generates extra code needed to propagate
7543 exceptions. For some targets, this implies GNU CC will generate frame
7544 unwind information for all functions, which can produce significant data
7545 size overhead, although it does not affect execution. If you do not
7546 specify this option, GNU CC will enable it by default for languages like
7547 C++ which normally require exception handling, and disable itfor
7548 languages like C that do not normally require it. However, you may need
7549 to enable this option when compiling C code that needs to interoperate
7550 properly with exception handlers written in C++. You may also wish to
7551 disable this option if you are compiling older C++ programs that don't
7552 use exception handling.
7554 @item -funwind-tables
7555 Similar to @code{-fexceptions}, except that it will just generate any needed
7556 static data, but will not affect the generated code in any other way.
7557 You will normally not enable this option; instead, a language processor
7558 that needs this handling would enable it on your behalf.
7560 @item -fpcc-struct-return
7561 Return ``short'' @code{struct} and @code{union} values in memory like
7562 longer ones, rather than in registers. This convention is less
7563 efficient, but it has the advantage of allowing intercallability between
7564 GCC-compiled files and files compiled with other compilers.
7566 The precise convention for returning structures in memory depends
7567 on the target configuration macros.
7569 Short structures and unions are those whose size and alignment match
7570 that of some integer type.
7572 @item -freg-struct-return
7573 Use the convention that @code{struct} and @code{union} values are
7574 returned in registers when possible. This is more efficient for small
7575 structures than @samp{-fpcc-struct-return}.
7577 If you specify neither @samp{-fpcc-struct-return} nor its contrary
7578 @samp{-freg-struct-return}, GCC defaults to whichever convention is
7579 standard for the target. If there is no standard convention, GCC
7580 defaults to @samp{-fpcc-struct-return}, except on targets where GCC
7581 is the principal compiler. In those cases, we can choose the standard,
7582 and we chose the more efficient register return alternative.
7585 Allocate to an @code{enum} type only as many bytes as it needs for the
7586 declared range of possible values. Specifically, the @code{enum} type
7587 will be equivalent to the smallest integer type which has enough room.
7589 @item -fshort-double
7590 Use the same size for @code{double} as for @code{float}.
7593 Requests that the data and non-@code{const} variables of this
7594 compilation be shared data rather than private data. The distinction
7595 makes sense only on certain operating systems, where shared data is
7596 shared between processes running the same program, while private data
7597 exists in one copy per process.
7600 Allocate even uninitialized global variables in the data section of the
7601 object file, rather than generating them as common blocks. This has the
7602 effect that if the same variable is declared (without @code{extern}) in
7603 two different compilations, you will get an error when you link them.
7604 The only reason this might be useful is if you wish to verify that the
7605 program will work on other systems which always work this way.
7608 Ignore the @samp{#ident} directive.
7610 @item -fno-gnu-linker
7611 Do not output global initializations (such as C++ constructors and
7612 destructors) in the form used by the GNU linker (on systems where the GNU
7613 linker is the standard method of handling them). Use this option when
7614 you want to use a non-GNU linker, which also requires using the
7615 @code{collect2} program to make sure the system linker includes
7616 constructors and destructors. (@code{collect2} is included in the GCC
7617 distribution.) For systems which @emph{must} use @code{collect2}, the
7618 compiler driver @code{gcc} is configured to do this automatically.
7620 @item -finhibit-size-directive
7621 Don't output a @code{.size} assembler directive, or anything else that
7622 would cause trouble if the function is split in the middle, and the
7623 two halves are placed at locations far apart in memory. This option is
7624 used when compiling @file{crtstuff.c}; you should not need to use it
7628 Put extra commentary information in the generated assembly code to
7629 make it more readable. This option is generally only of use to those
7630 who actually need to read the generated assembly code (perhaps while
7631 debugging the compiler itself).
7633 @samp{-fno-verbose-asm}, the default, causes the
7634 extra information to be omitted and is useful when comparing two assembler
7638 Consider all memory references through pointers to be volatile.
7640 @item -fvolatile-global
7641 Consider all memory references to extern and global data items to
7642 be volatile. GCC does not consider static data items to be volatile
7643 because of this switch.
7645 @item -fvolatile-static
7646 Consider all memory references to static data to be volatile.
7649 @cindex global offset table
7651 Generate position-independent code (PIC) suitable for use in a shared
7652 library, if supported for the target machine. Such code accesses all
7653 constant addresses through a global offset table (GOT). The dynamic
7654 loader resolves the GOT entries when the program starts (the dynamic
7655 loader is not part of GCC; it is part of the operating system). If
7656 the GOT size for the linked executable exceeds a machine-specific
7657 maximum size, you get an error message from the linker indicating that
7658 @samp{-fpic} does not work; in that case, recompile with @samp{-fPIC}
7659 instead. (These maximums are 16k on the m88k, 8k on the Sparc, and 32k
7660 on the m68k and RS/6000. The 386 has no such limit.)
7662 Position-independent code requires special support, and therefore works
7663 only on certain machines. For the 386, GCC supports PIC for System V
7664 but not for the Sun 386i. Code generated for the IBM RS/6000 is always
7665 position-independent.
7668 If supported for the target machine, emit position-independent code,
7669 suitable for dynamic linking and avoiding any limit on the size of the
7670 global offset table. This option makes a difference on the m68k, m88k,
7673 Position-independent code requires special support, and therefore works
7674 only on certain machines.
7676 @item -ffixed-@var{reg}
7677 Treat the register named @var{reg} as a fixed register; generated code
7678 should never refer to it (except perhaps as a stack pointer, frame
7679 pointer or in some other fixed role).
7681 @var{reg} must be the name of a register. The register names accepted
7682 are machine-specific and are defined in the @code{REGISTER_NAMES}
7683 macro in the machine description macro file.
7685 This flag does not have a negative form, because it specifies a
7688 @item -fcall-used-@var{reg}
7689 Treat the register named @var{reg} as an allocable register that is
7690 clobbered by function calls. It may be allocated for temporaries or
7691 variables that do not live across a call. Functions compiled this way
7692 will not save and restore the register @var{reg}.
7694 It is an error to used this flag with the frame pointer or stack pointer.
7695 Use of this flag for other registers that have fixed pervasive roles in
7696 the machine's execution model will produce disastrous results.
7698 This flag does not have a negative form, because it specifies a
7701 @item -fcall-saved-@var{reg}
7702 Treat the register named @var{reg} as an allocable register saved by
7703 functions. It may be allocated even for temporaries or variables that
7704 live across a call. Functions compiled this way will save and restore
7705 the register @var{reg} if they use it.
7707 It is an error to used this flag with the frame pointer or stack pointer.
7708 Use of this flag for other registers that have fixed pervasive roles in
7709 the machine's execution model will produce disastrous results.
7711 A different sort of disaster will result from the use of this flag for
7712 a register in which function values may be returned.
7714 This flag does not have a negative form, because it specifies a
7718 Pack all structure members together without holes. Usually you would
7719 not want to use this option, since it makes the code suboptimal, and
7720 the offsets of structure members won't agree with system libraries.
7722 @item -fcheck-memory-usage
7723 Generate extra code to check each memory access. GCC will generate
7724 code that is suitable for a detector of bad memory accesses such as
7727 Normally, you should compile all, or none, of your code with this option.
7729 If you do mix code compiled with and without this option,
7730 you must ensure that all code that has side effects
7731 and that is called by code compiled with this option
7732 is, itself, compiled with this option.
7733 If you do not, you might get erroneous messages from the detector.
7735 If you use functions from a library that have side-effects (such as
7736 @code{read}), you might not be able to recompile the library and
7737 specify this option. In that case, you can enable the
7738 @samp{-fprefix-function-name} option, which requests GCC to encapsulate
7739 your code and make other functions look as if they were compiled with
7740 @samp{-fcheck-memory-usage}. This is done by calling ``stubs'',
7741 which are provided by the detector. If you cannot find or build
7742 stubs for every function you call, you might have to specify
7743 @samp{-fcheck-memory-usage} without @samp{-fprefix-function-name}.
7745 If you specify this option, you can not use the @code{asm} or
7746 @code{__asm__} keywords in functions with memory checking enabled. GNU
7747 CC cannot understand what the @code{asm} statement may do, and therefore
7748 cannot generate the appropriate code, so it will reject it. However, if
7749 you specify the function attribute @code{no_check_memory_usage}
7750 (@pxref{Function Attributes}), GNU CC will disable memory checking within a
7751 function; you may use @code{asm} statements inside such functions. You
7752 may have an inline expansion of a non-checked function within a checked
7753 function; in that case GNU CC will not generate checks for the inlined
7754 function's memory accesses.
7756 If you move your @code{asm} statements to non-checked inline functions
7757 and they do access memory, you can add calls to the support code in your
7758 inline function, to indicate any reads, writes, or copies being done.
7759 These calls would be similar to those done in the stubs described above.
7761 @item -fprefix-function-name
7762 Request GCC to add a prefix to the symbols generated for function names.
7763 GCC adds a prefix to the names of functions defined as well as
7764 functions called. Code compiled with this option and code compiled
7765 without the option can't be linked together, unless stubs are used.
7767 If you compile the following code with @samp{-fprefix-function-name}
7769 extern void bar (int);
7778 GCC will compile the code as if it was written:
7780 extern void prefix_bar (int);
7784 return prefix_bar (a + 5);
7787 This option is designed to be used with @samp{-fcheck-memory-usage}.
7789 @item -finstrument-functions
7790 Generate instrumentation calls for entry and exit to functions. Just
7791 after function entry and just before function exit, the following
7792 profiling functions will be called with the address of the current
7793 function and its call site. (On some platforms,
7794 @code{__builtin_return_address} does not work beyond the current
7795 function, so the call site information may not be available to the
7796 profiling functions otherwise.)
7799 void __cyg_profile_func_enter (void *this_fn, void *call_site);
7800 void __cyg_profile_func_exit (void *this_fn, void *call_site);
7803 The first argument is the address of the start of the current function,
7804 which may be looked up exactly in the symbol table.
7806 This instrumentation is also done for functions expanded inline in other
7807 functions. The profiling calls will indicate where, conceptually, the
7808 inline function is entered and exited. This means that addressable
7809 versions of such functions must be available. If all your uses of a
7810 function are expanded inline, this may mean an additional expansion of
7811 code size. If you use @samp{extern inline} in your C code, an
7812 addressable version of such functions must be provided. (This is
7813 normally the case anyways, but if you get lucky and the optimizer always
7814 expands the functions inline, you might have gotten away without
7815 providing static copies.)
7817 A function may be given the attribute @code{no_instrument_function}, in
7818 which case this instrumentation will not be done. This can be used, for
7819 example, for the profiling functions listed above, high-priority
7820 interrupt routines, and any functions from which the profiling functions
7821 cannot safely be called (perhaps signal handlers, if the profiling
7822 routines generate output or allocate memory).
7825 Generate code to verify that you do not go beyond the boundary of the
7826 stack. You should specify this flag if you are running in an
7827 environment with multiple threads, but only rarely need to specify it in
7828 a single-threaded environment since stack overflow is automatically
7829 detected on nearly all systems if there is only one stack.
7831 Note that this switch does not actually cause checking to be done; the
7832 operating system must do that. The switch causes generation of code
7833 to ensure that the operating system sees the stack being extended.
7835 @item -fstack-limit-register=@var{reg}
7836 @itemx -fstack-limit-symbol=@var{sym}
7837 @itemx -fno-stack-limit
7838 Generate code to ensure that the stack does not grow beyond a certain value,
7839 either the value of a register or the address of a symbol. If the stack
7840 would grow beyond the value, a signal is raised. For most targets,
7841 the signal is raised before the stack overruns the boundary, so
7842 it is possible to catch the signal without taking special precautions.
7844 For instance, if the stack starts at address @samp{0x80000000} and grows
7845 downwards you can use the flags
7846 @samp{-fstack-limit-symbol=__stack_limit}
7847 @samp{-Wl,--defsym,__stack_limit=0x7ffe0000} which will enforce a stack
7850 @cindex aliasing of parameters
7851 @cindex parameters, aliased
7852 @item -fargument-alias
7853 @itemx -fargument-noalias
7854 @itemx -fargument-noalias-global
7855 Specify the possible relationships among parameters and between
7856 parameters and global data.
7858 @samp{-fargument-alias} specifies that arguments (parameters) may
7859 alias each other and may alias global storage.
7860 @samp{-fargument-noalias} specifies that arguments do not alias
7861 each other, but may alias global storage.
7862 @samp{-fargument-noalias-global} specifies that arguments do not
7863 alias each other and do not alias global storage.
7865 Each language will automatically use whatever option is required by
7866 the language standard. You should not need to use these options yourself.
7868 @item -fleading-underscore
7869 This option and its counterpart, -fno-leading-underscore, forcibly
7870 change the way C symbols are represented in the object file. One use
7871 is to help link with legacy assembly code.
7873 Be warned that you should know what you are doing when invoking this
7874 option, and that not all targets provide complete support for it.
7879 @node Environment Variables
7880 @section Environment Variables Affecting GCC
7881 @cindex environment variables
7883 @c man begin ENVIRONMENT
7885 This section describes several environment variables that affect how GCC
7886 operates. Some of them work by specifying directories or prefixes to use
7887 when searching for various kinds of files. Some are used to specify other
7888 aspects of the compilation environment.
7891 Note that you can also specify places to search using options such as
7892 @samp{-B}, @samp{-I} and @samp{-L} (@pxref{Directory Options}). These
7893 take precedence over places specified using environment variables, which
7894 in turn take precedence over those specified by the configuration of GCC.
7898 Note that you can also specify places to search using options such as
7899 @samp{-B}, @samp{-I} and @samp{-L} (@pxref{Directory Options}). These
7900 take precedence over places specified using environment variables, which
7901 in turn take precedence over those specified by the configuration of GCC.
7908 @c @itemx LC_COLLATE
7910 @c @itemx LC_MONETARY
7911 @c @itemx LC_NUMERIC
7916 @c @findex LC_COLLATE
7918 @c @findex LC_MONETARY
7919 @c @findex LC_NUMERIC
7923 These environment variables control the way that GCC uses
7924 localization information that allow GCC to work with different
7925 national conventions. GCC inspects the locale categories
7926 @code{LC_CTYPE} and @code{LC_MESSAGES} if it has been configured to do
7927 so. These locale categories can be set to any value supported by your
7928 installation. A typical value is @samp{en_UK} for English in the United
7931 The @code{LC_CTYPE} environment variable specifies character
7932 classification. GCC uses it to determine the character boundaries in
7933 a string; this is needed for some multibyte encodings that contain quote
7934 and escape characters that would otherwise be interpreted as a string
7937 The @code{LC_MESSAGES} environment variable specifies the language to
7938 use in diagnostic messages.
7940 If the @code{LC_ALL} environment variable is set, it overrides the value
7941 of @code{LC_CTYPE} and @code{LC_MESSAGES}; otherwise, @code{LC_CTYPE}
7942 and @code{LC_MESSAGES} default to the value of the @code{LANG}
7943 environment variable. If none of these variables are set, GCC
7944 defaults to traditional C English behavior.
7948 If @code{TMPDIR} is set, it specifies the directory to use for temporary
7949 files. GCC uses temporary files to hold the output of one stage of
7950 compilation which is to be used as input to the next stage: for example,
7951 the output of the preprocessor, which is the input to the compiler
7954 @item GCC_EXEC_PREFIX
7955 @findex GCC_EXEC_PREFIX
7956 If @code{GCC_EXEC_PREFIX} is set, it specifies a prefix to use in the
7957 names of the subprograms executed by the compiler. No slash is added
7958 when this prefix is combined with the name of a subprogram, but you can
7959 specify a prefix that ends with a slash if you wish.
7961 If @code{GCC_EXEC_PREFIX} is not set, GNU CC will attempt to figure out
7962 an appropriate prefix to use based on the pathname it was invoked with.
7964 If GCC cannot find the subprogram using the specified prefix, it
7965 tries looking in the usual places for the subprogram.
7967 The default value of @code{GCC_EXEC_PREFIX} is
7968 @file{@var{prefix}/lib/gcc-lib/} where @var{prefix} is the value
7969 of @code{prefix} when you ran the @file{configure} script.
7971 Other prefixes specified with @samp{-B} take precedence over this prefix.
7973 This prefix is also used for finding files such as @file{crt0.o} that are
7976 In addition, the prefix is used in an unusual way in finding the
7977 directories to search for header files. For each of the standard
7978 directories whose name normally begins with @samp{/usr/local/lib/gcc-lib}
7979 (more precisely, with the value of @code{GCC_INCLUDE_DIR}), GCC tries
7980 replacing that beginning with the specified prefix to produce an
7981 alternate directory name. Thus, with @samp{-Bfoo/}, GCC will search
7982 @file{foo/bar} where it would normally search @file{/usr/local/lib/bar}.
7983 These alternate directories are searched first; the standard directories
7987 @findex COMPILER_PATH
7988 The value of @code{COMPILER_PATH} is a colon-separated list of
7989 directories, much like @code{PATH}. GCC tries the directories thus
7990 specified when searching for subprograms, if it can't find the
7991 subprograms using @code{GCC_EXEC_PREFIX}.
7994 @findex LIBRARY_PATH
7995 The value of @code{LIBRARY_PATH} is a colon-separated list of
7996 directories, much like @code{PATH}. When configured as a native compiler,
7997 GCC tries the directories thus specified when searching for special
7998 linker files, if it can't find them using @code{GCC_EXEC_PREFIX}. Linking
7999 using GCC also uses these directories when searching for ordinary
8000 libraries for the @samp{-l} option (but directories specified with
8001 @samp{-L} come first).
8003 @item C_INCLUDE_PATH
8004 @itemx CPLUS_INCLUDE_PATH
8005 @itemx OBJC_INCLUDE_PATH
8006 @findex C_INCLUDE_PATH
8007 @findex CPLUS_INCLUDE_PATH
8008 @findex OBJC_INCLUDE_PATH
8009 @c @itemx OBJCPLUS_INCLUDE_PATH
8010 These environment variables pertain to particular languages. Each
8011 variable's value is a colon-separated list of directories, much like
8012 @code{PATH}. When GCC searches for header files, it tries the
8013 directories listed in the variable for the language you are using, after
8014 the directories specified with @samp{-I} but before the standard header
8017 @item DEPENDENCIES_OUTPUT
8018 @findex DEPENDENCIES_OUTPUT
8019 @cindex dependencies for make as output
8020 If this variable is set, its value specifies how to output dependencies
8021 for Make based on the header files processed by the compiler. This
8022 output looks much like the output from the @samp{-M} option
8023 (@pxref{Preprocessor Options}), but it goes to a separate file, and is
8024 in addition to the usual results of compilation.
8026 The value of @code{DEPENDENCIES_OUTPUT} can be just a file name, in
8027 which case the Make rules are written to that file, guessing the target
8028 name from the source file name. Or the value can have the form
8029 @samp{@var{file} @var{target}}, in which case the rules are written to
8030 file @var{file} using @var{target} as the target name.
8034 @cindex locale definition
8035 This variable is used to pass locale information to the compiler. One way in
8036 which this information is used is to determine the character set to be used
8037 when character literals, string literals and comments are parsed in C and C++.
8038 When the compiler is configured to allow multibyte characters,
8039 the following values for @code{LANG} are recognized:
8043 Recognize JIS characters.
8045 Recognize SJIS characters.
8047 Recognize EUCJP characters.
8050 If @code{LANG} is not defined, or if it has some other value, then the
8051 compiler will use mblen and mbtowc as defined by the default locale to
8052 recognize and translate multibyte characters.
8057 @node Running Protoize
8058 @section Running Protoize
8060 The program @code{protoize} is an optional part of GNU C. You can use
8061 it to add prototypes to a program, thus converting the program to ISO
8062 C in one respect. The companion program @code{unprotoize} does the
8063 reverse: it removes argument types from any prototypes that are found.
8065 When you run these programs, you must specify a set of source files as
8066 command line arguments. The conversion programs start out by compiling
8067 these files to see what functions they define. The information gathered
8068 about a file @var{foo} is saved in a file named @file{@var{foo}.X}.
8070 After scanning comes actual conversion. The specified files are all
8071 eligible to be converted; any files they include (whether sources or
8072 just headers) are eligible as well.
8074 But not all the eligible files are converted. By default,
8075 @code{protoize} and @code{unprotoize} convert only source and header
8076 files in the current directory. You can specify additional directories
8077 whose files should be converted with the @samp{-d @var{directory}}
8078 option. You can also specify particular files to exclude with the
8079 @samp{-x @var{file}} option. A file is converted if it is eligible, its
8080 directory name matches one of the specified directory names, and its
8081 name within the directory has not been excluded.
8083 Basic conversion with @code{protoize} consists of rewriting most
8084 function definitions and function declarations to specify the types of
8085 the arguments. The only ones not rewritten are those for varargs
8088 @code{protoize} optionally inserts prototype declarations at the
8089 beginning of the source file, to make them available for any calls that
8090 precede the function's definition. Or it can insert prototype
8091 declarations with block scope in the blocks where undeclared functions
8094 Basic conversion with @code{unprotoize} consists of rewriting most
8095 function declarations to remove any argument types, and rewriting
8096 function definitions to the old-style pre-ISO form.
8098 Both conversion programs print a warning for any function declaration or
8099 definition that they can't convert. You can suppress these warnings
8102 The output from @code{protoize} or @code{unprotoize} replaces the
8103 original source file. The original file is renamed to a name ending
8104 with @samp{.save} (for DOS, the saved filename ends in @samp{.sav}
8105 without the original @samp{.c} suffix). If the @samp{.save} (@samp{.sav}
8106 for DOS) file already exists, then the source file is simply discarded.
8108 @code{protoize} and @code{unprotoize} both depend on GCC itself to
8109 scan the program and collect information about the functions it uses.
8110 So neither of these programs will work until GCC is installed.
8112 Here is a table of the options you can use with @code{protoize} and
8113 @code{unprotoize}. Each option works with both programs unless
8117 @item -B @var{directory}
8118 Look for the file @file{SYSCALLS.c.X} in @var{directory}, instead of the
8119 usual directory (normally @file{/usr/local/lib}). This file contains
8120 prototype information about standard system functions. This option
8121 applies only to @code{protoize}.
8123 @item -c @var{compilation-options}
8124 Use @var{compilation-options} as the options when running @code{gcc} to
8125 produce the @samp{.X} files. The special option @samp{-aux-info} is
8126 always passed in addition, to tell @code{gcc} to write a @samp{.X} file.
8128 Note that the compilation options must be given as a single argument to
8129 @code{protoize} or @code{unprotoize}. If you want to specify several
8130 @code{gcc} options, you must quote the entire set of compilation options
8131 to make them a single word in the shell.
8133 There are certain @code{gcc} arguments that you cannot use, because they
8134 would produce the wrong kind of output. These include @samp{-g},
8135 @samp{-O}, @samp{-c}, @samp{-S}, and @samp{-o} If you include these in
8136 the @var{compilation-options}, they are ignored.
8139 Rename files to end in @samp{.C} (@samp{.cc} for DOS-based file
8140 systems) instead of @samp{.c}. This is convenient if you are converting
8141 a C program to C++. This option applies only to @code{protoize}.
8144 Add explicit global declarations. This means inserting explicit
8145 declarations at the beginning of each source file for each function
8146 that is called in the file and was not declared. These declarations
8147 precede the first function definition that contains a call to an
8148 undeclared function. This option applies only to @code{protoize}.
8150 @item -i @var{string}
8151 Indent old-style parameter declarations with the string @var{string}.
8152 This option applies only to @code{protoize}.
8154 @code{unprotoize} converts prototyped function definitions to old-style
8155 function definitions, where the arguments are declared between the
8156 argument list and the initial @samp{@{}. By default, @code{unprotoize}
8157 uses five spaces as the indentation. If you want to indent with just
8158 one space instead, use @samp{-i " "}.
8161 Keep the @samp{.X} files. Normally, they are deleted after conversion
8165 Add explicit local declarations. @code{protoize} with @samp{-l} inserts
8166 a prototype declaration for each function in each block which calls the
8167 function without any declaration. This option applies only to
8171 Make no real changes. This mode just prints information about the conversions
8172 that would have been done without @samp{-n}.
8175 Make no @samp{.save} files. The original files are simply deleted.
8176 Use this option with caution.
8178 @item -p @var{program}
8179 Use the program @var{program} as the compiler. Normally, the name
8183 Work quietly. Most warnings are suppressed.
8186 Print the version number, just like @samp{-v} for @code{gcc}.
8189 If you need special compiler options to compile one of your program's
8190 source files, then you should generate that file's @samp{.X} file
8191 specially, by running @code{gcc} on that source file with the
8192 appropriate options and the option @samp{-aux-info}. Then run
8193 @code{protoize} on the entire set of files. @code{protoize} will use
8194 the existing @samp{.X} file because it is newer than the source file.
8198 gcc -Dfoo=bar file1.c -aux-info
8203 You need to include the special files along with the rest in the
8204 @code{protoize} command, even though their @samp{.X} files already
8205 exist, because otherwise they won't get converted.
8207 @xref{Protoize Caveats}, for more information on how to use
8208 @code{protoize} successfully.