*nix Documentation Project
·  Home
 +   man pages
·  Linux HOWTOs
·  FreeBSD Tips
·  *niX Forums

  man pages->OpenBSD man pages -> gcc (1)              



NAME    [Toc]    [Back]

       gcc, g++ - GNU project C and C++ Compiler (gcc-2.95)

SYNOPSIS    [Toc]    [Back]

       gcc [ option | filename ]...
       g++ [ option | filename ]...

WARNING    [Toc]    [Back]

       The  compiler  bundled  with OpenBSD differs significantly
       from the actual  2.95.3  release  of  the  FSF.  See  gcclocal(1) for details.

WARNING    [Toc]    [Back]

       The  information  in  this man page is an extract from the
       full documentation of the GNU C compiler, and  is  limited
       to the meaning of the options.

       This  man  page  is not kept up to date except when volunteers
 want to maintain it.   If  you  find  a  discrepancy
       between  the  man  page and the software, please check the
       Info file, which is the authoritative documentation.

       If we find that the things in this man page that  are  out
       of date cause significant confusion or complaints, we will
       stop distributing the man page.  The alternative, updating
       the  man  page when we update the Info file, is impossible
       because the rest of the work of maintaining GNU CC  leaves
       us no time for that.  The GNU project regards man pages as
       obsolete and should not let them take time away from other

       For  complete and current documentation, refer to the Info
       file `gcc' or the manual Using and  Porting  GNU  CC  (for
       version  2.0).  Both are made from the Texinfo source file

DESCRIPTION    [Toc]    [Back]

       The C and C++  compilers  are  integrated.   Both  process
       input  files  through  one or more of four stages: preprocessing,
 compilation, assembly, and linking.  Source filename
 suffixes identify the source language, but which name
       you use for the compiler governs default assumptions:

       gcc    assumes preprocessed (.i) files are C and assumes C
              style linking.

       g++    assumes preprocessed (.i) files are C++ and assumes
              C++ style linking.

       Suffixes of source file names indicate  the  language  and
       kind of processing to be done:

       .c    C source; preprocess, compile, assemble
       .C    C++ source; preprocess, compile, assemble
       .cc   C++ source; preprocess, compile, assemble
       .cxx  C++ source; preprocess, compile, assemble
       .m    Objective-C source; preprocess, compile, assemble
       .i    preprocessed C; compile, assemble
       .ii   preprocessed C++; compile, assemble
       .s    Assembler source; assemble
       .S    Assembler source; preprocess, assemble
       .h    Preprocessor file; not usually named on command line

       Files  with other suffixes are passed to the linker.  Common
 cases include:

       .o    Object file
       .a    Archive file

       Linking is always the last stage unless you use one of the
       -c,  -S,  or -E options to avoid it (or unless compilation
       errors stop the whole process).  For the link  stage,  all
       .o  files  corresponding  to  source  files, -l libraries,
       unrecognized filenames (including named  .o  object  files
       and  .a archives) are passed to the linker in command-line

OPTIONS    [Toc]    [Back]

       Options must be separate: `-dr' is  quite  different  from
       `-d -r '.

       Most `-f' and `-W' options have two contrary forms: -fname
       and -fno-name (or -Wname and -Wno-name).   Only  the  nondefault
 forms are shown here.

       Here  is  a  summary  of all the options, grouped by type.
       Explanations are in the following sections.

       Overall Options    [Toc]    [Back]
              -c -S -E -o file -pipe -v -x language

       Language Options    [Toc]    [Back]
              -ansi -fall-virtual -fcond-mismatch
              -fdollars-in-identifiers -fenum-int-equiv
              -fexternal-templates -fno-asm -fno-builtin
              -fno-builtin-<function> -fhosted -fno-hosted
              -ffreestanding -fno-freestanding
              -fno-strict-prototype -fsigned-bitfields
              -fsigned-char -fthis-is-variable
              -funsigned-bitfields -funsigned-char
              -fwritable-strings -traditional -traditional-cpp

       Warning Options    [Toc]    [Back]
              -fsyntax-only -pedantic -pedantic-errors -w -W
              -Wall -Waggregate-return -Wcast-align -Wcast-qual
              -Wchar-subscript -Wcomment -Wconversion
              -Wenum-clash -Werror -Wformat -Wid-clash-len
              -Wimplicit -Wimplicit-int
              -Wimplicit-function-declaration -Winline
              -Wlong-long -Wmain -Wmissing-prototypes
              -Wmissing-declarations -Wnested-externs -Wno-import
              -Wparentheses -Wpointer-arith -Wredundant-decls
              -Wreturn-type -Wshadow -Wstack-protector
              -Wstrict-prototypes -Wswitch -Wtemplate-debugging
              -Wtraditional -Wtrigraphs -Wuninitialized -Wunused

       Debugging Options    [Toc]    [Back]
              -a -dletters -fpretend-float -g -glevel -gcoff
              -gxcoff -gxcoff+ -gdwarf -gdwarf+ -gstabs -gstabs+
              -ggdb -p -pg -save-temps -print-file-name=library
              -print-libgcc-file-name -print-prog-name=program

       Optimization Options    [Toc]    [Back]
              -fcaller-saves -fcse-follow-jumps -fcse-skip-blocks
              -fdelayed-branch -felide-constructors
              -fexpensive-optimizations -ffast-math -ffloat-store
              -fforce-addr -fforce-mem -finline-functions
              -fkeep-inline-functions -fmemoize-lookups
              -fno-default-inline -fno-defer-pop
              -fno-function-cse -fno-inline -fno-peephole
              -fomit-frame-pointer -frerun-cse-after-loop
              -fschedule-insns -fschedule-insns2
              -fstrength-reduce -fthread-jumps -funroll-all-loops
              -funroll-loops -O -O2 -O3

       Preprocessor Options    [Toc]    [Back]
              -Aassertion -C -dD -dM -dN -Dmacro[=defn] -E -H
              -idirafter dir -include file -imacros file -iprefix
              file -iwithprefix dir -M -MD -MM -MMD -nostdinc -P
              -Umacro -undef

       Assembler Option    [Toc]    [Back]

       Linker Options    [Toc]    [Back]
              -llibrary -nostartfiles -nostdlib -static -shared
              -symbolic -Xlinker option -Wl,option -u symbol

       Directory Options    [Toc]    [Back]
              -Bprefix -Idir -I- -Ldir

       Target Options    [Toc]    [Back]
              -b  machine -V version

       Configuration Dependent Options    [Toc]    [Back]
              M680x0 Options
              -m68000 -m68020 -m68020-40 -m68030 -m68040 -m68881
              -mbitfield -mc68000 -mc68020 -mfpa -mnobitfield
              -mrtd -mshort -msoft-float
              VAX Options
              -mg -mgnu -munix

              SPARC Options
              -mepilogue -mfpu -mhard-float -mno-fpu
              -mno-epilogue -msoft-float -msparclite -mv8
              -msupersparc -mcypress

              Convex Options
              -margcount -mc1 -mc2 -mnoargcount

              AMD29K Options
              -m29000 -m29050 -mbw -mdw -mkernel-registers
              -mlarge -mnbw -mnodw -msmall -mstack-check

              M88K Options
              -m88000 -m88100 -m88110 -mbig-pic
              -mcheck-zero-division -mhandle-large-shift
              -midentify-revision -mno-check-zero-division
              -mno-ocs-debug-info -mno-ocs-frame-position
              -mno-optimize-arg-area -mno-serialize-volatile
              -mno-underscores -mocs-debug-info
              -mocs-frame-position -moptimize-arg-area
              -mserialize-volatile -mshort-data-num -msvr3 -msvr4
              -mtrap-large-shift -muse-div-instruction
              -mversion-03.00 -mwarn-passed-structs

              RS6000 Options
              -mfp-in-toc -mno-fop-in-toc

              RT Options
              -mcall-lib-mul -mfp-arg-in-fpregs -mfp-arg-in-gregs
              -mfull-fp-blocks -mhc-struct-return -min-line-mul
              -mminimum-fp-blocks -mnohc-struct-return

              MIPS Options
              -mcpu=cpu type -mips2 -mips3 -mint64 -mlong64
              -mlonglong128 -mmips-as -mgas -mrnames -mno-rnames
              -mgpopt -mno-gpopt -mstats -mno-stats -mmemcpy
              -mno-memcpy -mno-mips-tfile -mmips-tfile
              -msoft-float -mhard-float -mabicalls -mno-abicalls
              -mhalf-pic -mno-half-pic -G num -nocpp

              i386 Options
              -m486 -mno-486 -msoft-float -mno-fp-ret-in-387

              HPPA Options
              -mpa-risc-1-0 -mpa-risc-1-1 -mkernel -mshared-libs
              -mno-shared-libs -mlong-calls -mdisable-fpregs
              -mdisable-indexing -mtrailing-colon

              i960 Options
              -mcpu-type -mnumerics -msoft-float
              -mleaf-procedures -mno-leaf-procedures -mtail-call
              -mno-tail-call -mcomplex-addr -mno-complex-addr
              -mcode-align -mno-code-align -mic-compat
              -mic2.0-compat -mic3.0-compat -masm-compat
              -mintel-asm -mstrict-align -mno-strict-align
              -mold-align -mno-old-align

              DEC Alpha Options
              -mfp-regs -mno-fp-regs -mno-soft-float -msoft-float

              System V Options
              -G -Qy -Qn -YP,paths -Ym,dir

       Code Generation Options    [Toc]    [Back]
              -fcall-saved-reg -fcall-used-reg -ffixed-reg
              -finhibit-size-directive -fnonnull-objects
              -fno-common -fno-ident -fno-gnu-linker
              -fno-stack-protector -fpcc-struct-return -fpic
              -fPIC -freg-struct-return -fshared-data
              -fshort-enums -fshort-double -fvolatile
              -fvolatile-global -fverbose-asm

OVERALL OPTIONS    [Toc]    [Back]

       -x language
              Specify  explicitly  the language for the following
              input files (rather than choosing a  default  based
              on  the file name suffix) .  This option applies to
              all following input files until the next  `-x'  option.
    Possible   values  of  language  are  `c',
              `objective-c',  `c-header',  `c++',   `cpp-output',
              `assembler', and `assembler-with-cpp'.

       -x none
              Turn  off  any specification of a language, so that
              subsequent files are  handled  according  to  their
              file  name  suffixes  (as  they are if `-x' has not
              been used at all).

       If you want only some of the four stages (preprocess, compile,
  assemble, link), you can use `-x' (or filename suffixes)
 to tell gcc where to start, and one of the  options
       `-c',  `-S',  or  `-E'  to say where gcc is to stop.  Note
       that some combinations (for example, `-x  cpp-output  -E')
       instruct gcc to do nothing at all.

       -c     Compile  or  assemble  the source files, but do not
              link.  The compiler output is an object file corresponding
 to each source file.

              By  default,  GCC  makes the object file name for a
              source file by replacing  the  suffix  `.c',  `.i',
              `.s',  etc.,  with  `.o'.  Use -o to select another
              GCC ignores any  unrecognized  input  files  (those
              that  do  not require compilation or assembly) with
              the -c option.

       -S     Stop after the stage of compilation proper; do  not
              assemble.  The output is an assembler code file for
              each non-assembler input file specified.

              By default, GCC makes the assembler file name for a
              source  file  by  replacing  the suffix `.c', `.i',
              etc., with `.s'.  Use -o to select another name.

              GCC ignores any input files that don't require compilation.

       -E     Stop  after the preprocessing stage; do not run the
              compiler proper.  The output is preprocessed source
              code, which is sent to the standard output.

              GCC ignores input files which don't require preprocessing.

       -o file
              Place output in file file.  This applies regardless
              to  whatever  sort  of  output  GCC  is  producing,
              whether it be an executable file, an  object  file,
              an assembler file or preprocessed C code.

              Since  only  one  output  file can be specified, it
              does not make sense to use `-o' when compiling more
              than  one  input  file, unless you are producing an
              executable file as output.

              If you do not specify `-o', the default is  to  put
              an  executable file in `a.out', the object file for
              `source.suffix' in `source.o', its  assembler  file
              in  `source.s',  and  all  preprocessed C source on
              standard output.

       -v     Print (on standard error output) the commands  executed
 to run the stages of compilation.  Also print
              the version number of the compiler  driver  program
              and of the preprocessor and the compiler proper.

       -pipe  Use  pipes rather than temporary files for communication
 between the various stages  of  compilation.
              This fails to work on some systems where the assembler
 cannot read from a pipe; but the GNU assembler
              has no trouble.

LANGUAGE OPTIONS    [Toc]    [Back]

       The  following  options  control the dialect of C that the
       compiler accepts:
       -ansi  Support all ANSI standard C programs.

              This turns off certain features of GNU C  that  are
              incompatible  with  ANSI C, such as the asm, inline
              and typeof keywords, and predefined macros such  as
              unix  and  vax that identify the type of system you
              are using.  It also  enables  the  undesirable  and
              rarely  used  ANSI  trigraph feature, and disallows
              `$' as part of identifiers.

              The  alternate  keywords  __asm__,   __extension__,
              __inline__  and __typeof__ continue to work despite
              `-ansi'.  You would not want to use them in an ANSI
              C  program, of course, but it is useful to put them
              in header files that might be included in  compilations
  done  with  `-ansi'.   Alternate  predefined
              macros such as __unix__ and __vax__ are also available,
 with or without `-ansi'.

              The `-ansi' option does not cause non-ANSI programs
              to be rejected gratuitously.  For that, `-pedantic'
              is required in addition to `-ansi'.

              The preprocessor predefines a macro __STRICT_ANSI__
              when you use the `-ansi' option.  Some header files
              may  notice  this  macro and refrain from declaring
              certain functions or defining certain  macros  that
              the  ANSI  standard  doesn't  call  for; this is to
              avoid interfering with any programs that might  use
              these names for other things.

              Do  not  recognize  asm, inline or typeof as a keyword.
  These words may then be used as identifiers.
              You  can use __asm__, __inline__ and __typeof__ instead.
  `-ansi' implies `-fno-asm'.

              Don't recognize built-in functions that do not  begin
  with  two leading underscores.  Currently, the
              functions affected include _exit, abort, abs, allo-
              ca,  cos,  exit,  fabs,  labs, memcmp, memcpy, sin,
              sqrt, strcmp, strcpy, and strlen.

              The `-ansi' option prevents alloca and  _exit  from
              being builtin functions.

              Prevent  calls to function from being replaced with
              an inline version during optimization.

              Compile for a hosted environment; this implies  the
              `-fbuiltin'  option,  and  implies  that suspicious
              declarations of main should be warned about.

              Compile for a freestanding  environment;  this  implies
  the  `-fno-builtin' option, and implies that
              main has no special requirements.

              Treat a function  declaration  with  no  arguments,
              such as `int foo ();', as C would treat it--as saying
 nothing about the number of arguments or  their
              types  (C++ only).  Normally, such a declaration in
              C++ means that the function foo takes no arguments.

              Support  ANSI  C trigraphs.  The `-ansi' option implies

              Attempt to support some aspects  of  traditional  C
              compilers.   For details, see the GNU C Manual; the
              duplicate list here has been  deleted  so  that  we
              won't get complaints when it is out of date.

              But  one  note  about  C++  programs  only (not C).
              `-traditional' has one additional effect  for  C++:
              assignment  to this is permitted.  This is the same
              as the effect of `-fthis-is-variable'.

              Attempt to support some aspects  of  traditional  C
              preprocessors.    This   includes  the  items  that
              specifically mention the  preprocessor  above,  but
              none of the other effects of `-traditional'.

              Permit  the  use  of `$' in identifiers (C++ only).
              You can also use  `-fno-dollars-in-identifiers'  to
              explicitly  prohibit  use  of `$'.  (GNU C++ allows
              `$' by default on some target systems but not  others.)

              Permit  implicit  conversion  of int to enumeration
              types (C++ only).  Normally GNU C++ allows  conversion
  of enum to int, but not the other way around.

              Produce smaller code for template declarations,  by
              generating  only  a  single  copy  of each template
              function where it is defined (C++  only).   To  use
              this  option  successfully,  you must also mark all
              files  that  use  templates  with  either  `#pragma
              implementation'   (the   definition)   or  `#pragma
              interface' (declarations).

              When     your     code     is     compiled     with
              `-fexternal-templates', all template instantiations
              are external.  You must arrange for  all  necessary
              instantiations  to  appear  in  the  implementation
              file; you can do this with a  typedef  that  references
  each instantiation needed.  Conversely, when
              you    compile    using    the    default    option
              `-fno-external-templates',  all template instantiations
 are explicitly internal.

              Treat all possible member functions as virtual, implicitly.
   All  member  functions (except for constructor
 functions and new or delete member  operators)
 are treated as virtual functions of the class
              where they appear.

              This does not mean that all calls to  these  member
              functions  will  be made through the internal table
              of virtual functions.   Under  some  circumstances,
              the  compiler  can determine that a call to a given
              virtual function can be  made  directly;  in  these
              cases the calls are direct in any case.

              Allow conditional expressions with mismatched types
              in the second and third arguments.   The  value  of
              such an expression is void.

              Permit assignment to this (C++ only).  The incorporation
 of user-defined free store  management  into
              C++  has  made assignment to `this' an anachronism.
              Therefore, by default it is invalid  to  assign  to
              this  within a class member function.  However, for
              backwards compatibility, you can make it valid with

              Let  the type char be unsigned, like unsigned char.

              Each kind of machine has a default  for  what  char
              should  be.  It is either like unsigned char by default
 or like signed char by default.

              Ideally,  a  portable  program  should  always  use
              signed char or unsigned char when it depends on the
              signedness of an object.  But  many  programs  have
              been  written to use plain char and expect it to be
              signed, or expect it to be unsigned,  depending  on
              the  machines  they were written for.  This option,
              and its inverse, let you make such a  program  work
              with the opposite default.

              The  type  char is always a distinct type from each
              of signed char and unsigned char, even  though  its
              behavior is always just like one of those two.

              Let the type char be signed, like signed char.

              Note     that     this     is     equivalent     to
              `-fno-unsigned-char', which is the negative form of
              `-funsigned-char'.  Likewise, `-fno-signed-char' is
              equivalent to `-funsigned-char'.




              These options control whether a bitfield is  signed
              or   unsigned,   when  declared  with  no  explicit
              `signed' or `unsigned' qualifier.  By default, such
              a  bitfield  is signed, because this is consistent:
              the basic integer types  such  as  int  are  signed

              However, when you specify `-traditional', bitfields
              are all unsigned no matter what.

              Store string constants in the writable data segment
              and don't uniquize them.  This is for compatibility
              with old programs which assume they can write  into
              string constants.  `-traditional' also has this effect.

              Writing into string constants is a very  bad  idea;
              "constants" should be constant.


       These  options control the C preprocessor, which is run on
       each C source file before actual compilation.

       If you use the `-E' option, GCC does nothing  except  preprocessing.
  Some of these options make sense only together
 with `-E' because they cause the preprocessor output to
       be unsuitable for actual compilation.

       -include file
              Process file as input before processing the regular
              input file.  In effect, the contents  of  file  are
              compiled  first.   Any `-D' and `-U' options on the
              command line are always processed before  `-include
              file',  regardless  of  the order in which they are
              written.  All the `-include' and `-imacros' options
              are  processed in the order in which they are written.

       -imacros file
              Process file as  input,  discarding  the  resulting
              output,  before  processing the regular input file.
              Because the output generated from file is  discarded,
  the  only effect of `-imacros file' is to make
              the macros defined in file available for use in the
              main  input.   The  preprocessor evaluates any `-D'
              and `-U' options on the command  line  before  processing
  `-imacrosfile', regardless of the order in
              which they are written.   All  the  `-include'  and
              `-imacros'  options  are  processed in the order in
              which they are written.

       -idirafter dir
              Add the directory dir to the second  include  path.
              The  directories  on  the  second  include path are
              searched when a header file is not found in any  of
              the  directories  in the main include path (the one
              that `-I' adds to).

       -iprefix prefix
              Specify  prefix  as  the  prefix   for   subsequent
              `-iwithprefix' options.

       -iwithprefix dir
              Add  a  directory  to the second include path.  The
              directory's name is made  by  concatenating  prefix
              and dir, where prefix was specified previously with

              Do not search the standard system  directories  for
              header files.  Only the directories you have specified
 with `-I' options (and the current  directory,
              if appropriate) are searched.

              By  using both `-nostdinc' and `-I-', you can limit
              the include-file search file to only those directories
 you specify explicitly.

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

       -undef Do not predefine any nonstandard macros.   (Including
 architecture flags).
       -E     Run  only the C preprocessor.  Preprocess all the C
              source files specified and output  the  results  to
              standard output or to the specified output file.

       -C     Tell  the  preprocessor  not  to  discard comments.
              Used with the `-E' option.

       -P     Tell the preprocessor not to generate `#line'  commands.
  Used with the `-E' option.

       -M  [ -MG ]
              Tell the preprocessor to output a rule suitable for
              make describing the  dependencies  of  each  object
              file.   For each source file, the preprocessor outputs
 one make-rule whose target is the object  file
              name  for  that  source file and whose dependencies
              are all the files `#include'd in it.  This rule may
              be  a single line or may be continued with '-newline
 if it is long.  The list of rules  is  printed
              on  standard  output  instead of the preprocessed C

              `-M' implies `-E'.

              `-MG' says to treat missing header files as  generated
  files and assume they live in the same directory
 as the source file.  It must be  specified  in
              addition to `-M'.

       -MM  [ -MG ]
              Like  `-M'  but  the  output mentions only the user
              header files included with `#include file"'.   System
  header  files  included with `#include <file>'
              are omitted.

       -MD    Like `-M' but the dependency information is written
              to  files  with  names  made by replacing `.o' with
              `.d' at the end of the output file names.  This  is
              in    addition    to    compiling   the   file   as
              specified--`-MD' does not inhibit ordinary compilation
 the way `-M' does.

              The Mach utility `md' can be used to merge the `.d'
              files into a single dependency  file  suitable  for
              using with the `make' command.

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

       -H     Print the name of each header file used,  in  addition
 to other normal activities.

              Assert  the  answer answer for question, in case it
              is tested with a preprocessor conditional  such  as
              `#if  #question(answer)'.  `-A-' disables the standard
 assertions that normally describe  the  target

              (answer)  Assert the answer answer for question, in
              case it is tested with a  preprocessor  conditional
              such  as  `#if  #question(answer)'.  `-A-' disables
              the standard assertions that normally describe  the
              target machine.

              Define macro macro with the string `1' as its definition.

              Define macro macro as  defn.     All  instances  of
              `-D'  on  the command line are processed before any
              `-U' options.

              Undefine macro macro.  `-U' options  are  evaluated
              after  all  `-D' options, but before any `-include'
              and `-imacros' options.

       -dM    Tell the preprocessor to output only a list of  the
              macro  definitions that are in effect at the end of
              preprocessing.  Used with the `-E' option.

       -dD    Tell the preprocessor to pass all macro definitions
              into  the  output,  in their proper sequence in the
              rest of the output.

       -dN    Like `-dD' except that the macro arguments and contents
 are omitted.  Only `#define name' is included
              in the output.

ASSEMBLER OPTION    [Toc]    [Back]

              Pass option as an option to the assembler.  If  op-
              tion contains commas, it is split into multiple options
 at the commas.

LINKER OPTIONS    [Toc]    [Back]

       These options come into play when the compiler  links  object
 files into an executable output file.  They are meaningless
 if the compiler is not doing a link step.

              A file name that does not end in a  special  recognized
  suffix  is considered to name an object file
              or library.  (Object files are  distinguished  from
              libraries  by the linker according to the file contents.)
  If GCC does  a  link  step,  these  object
              files are used as input to the linker.

              Use the library named library when linking.

              The  linker searches a standard list of directories
              for the library, which is  actually  a  file  named
              `liblibrary.a'.   The linker then uses this file as
              if it had been specified precisely by name.

              The directories searched include  several  standard
              system  directories  plus any that you specify with

              Normally the  files  found  this  way  are  library
              files--archive   files  whose  members  are  object
              files.  The linker handles an archive file by scanning
  through  it  for members which define symbols
              that have so far been referenced but  not  defined.
              However,  if  the  linker  finds an ordinary object
              file rather than a  library,  the  object  file  is
              linked  in  the usual fashion.  The only difference
              between using an `-l' option and specifying a  file
              name  is that `-l' surrounds library with `lib' and
              `.a' and searches several directories.

       -lobjc You need this special case of the -l option in  order
 to link an Objective C program.

              Do  not  use the standard system startup files when
              linking.  The standard libraries are used normally.

              Don't use the standard system libraries and startup
              files when linking.  Only  the  files  you  specify
              will be passed to the linker.

              On  systems that support dynamic linking, this prevents
 linking with the shared libraries.  On  other
              systems, this option has no effect.

              Produce  a  shared  object which can then be linked
              with other objects to form an executable.   Only  a
              few systems support this option.

              Bind  references  to global symbols when building a
              shared object.  Warn about  any  unresolved  references
  (unless overridden by the link editor option
              `-Xlinker -z -Xlinker defs').  Only a  few  systems
              support this option.

       -Xlinker option
              Pass  option  as  an option to the linker.  You can
              use this to supply system-specific  linker  options
              which GNU CC does not know how to recognize.

              If  you  want to pass an option that takes an argument,
 you must use `-Xlinker' twice, once  for  the
              option  and once for the argument.  For example, to
              pass `-assert definitions', you must write `-Xlink-
              er -assert -Xlinker definitions'.  It does not work
              to write `-Xlinker "-assert definitions"',  because
              this passes the entire string as a single argument,
              which is not what the linker expects.

              Pass option as an option to the linker.  If  option
              contains  commas, it is split into multiple options
              at the commas.

       -u symbol
              Pretend the symbol symbol is  undefined,  to  force
              linking  of  library modules to define it.  You can
              use `-u' multiple times with different  symbols  to
              force loading of additional library modules.

DIRECTORY OPTIONS    [Toc]    [Back]

       These  options  specify  directories  to search for header
       files, for libraries and for parts of the compiler:

       -Idir  Append directory dir to  the  list  of  directories
              searched for include files.

       -I-    Any  directories  you specify with `-I' options before
 the `-I-' option are  searched  only  for  the
              case  of  `#include  "file"'; they are not searched
              for `#include <file>'.

              If additional directories are specified  with  `-I'
              options  after  the  `-I-',  these  directories are
              searched for all `#include' directives.  (Ordinarily
 all `-I' directories are used this way.)

              In  addition,  the `-I-' option inhibits the use of
              the current directory (where the current input file
              came  from) as the first search directory for `#in-
              clude "file"'.  There is no way  to  override  this
              effect  of  `-I-'.   With  `-I.'  you  can  specify
              searching the directory which was current when  the
              compiler was invoked.  That is not exactly the same
              as what the preprocessor does by default, but it is
              often satisfactory.
              `-I-' does not inhibit the use of the standard system
 directories for header files.  Thus, `-I-'  and
              `-nostdinc' are independent.

       -Ldir  Add  directory dir to the list of directories to be
              searched for `-l'.

              This option specifies where to  find  the  executables,
  libraries and data files of the compiler itself.

              The compiler driver program runs one or more of the
              subprograms  `cpp', `cc1' (or, for C++, `cc1plus'),
              `as' and `ld'.  It tries prefix  as  a  prefix  for
              each program it tries to run, both with and without

              For each subprogram to be run, the compiler  driver
              first  tries the `-B' prefix, if any.  If that name
              is not found, or if `-B'  was  not  specified,  the
              driver  tries  two  standard  prefixes,  which  are
              `/usr/lib/gcc/' and `/usr/local/lib/gcc-lib/'.   If
              neither  of  those  results  in a file name that is
              found, the compiler driver searches for the unmodified
  program name, using the directories specified
              in your `PATH' environment variable.

              The  run-time  support  file  `libgcc.a'  is   also
              searched  for using the `-B' prefix, if needed.  If
              it is not found there, the  two  standard  prefixes
              above are tried, and that is all.  The file is left
              out of the link if it is not found by those  means.
              Most  of  the time, on most machines, `libgcc.a' is
              not actually necessary.

              You can get a similar result from  the  environment
              variable  GCC_EXEC_PREFIX;  if  it  is defined, its
              value is used as a prefix in the same way.  If both
              the  `-B'  option  and the GCC_EXEC_PREFIX variable
              are present, the `-B' option is used first and  the
              environment variable value second.

WARNING OPTIONS    [Toc]    [Back]

       Warnings are diagnostic messages that report constructions
       which are not inherently erroneous but which are risky  or
       suggest there may have been an error.

       These  options  control  the  amount and kinds of warnings
       produced by GNU CC:

              Check the code for syntax errors,  but  don't  emit
              any output.
       -w     Inhibit all warning messages.

              Inhibit  warning messages about the use of #import.

              Issue all the  warnings  demanded  by  strict  ANSI
              standard  C; reject all programs that use forbidden

              Valid ANSI standard C programs should compile properly
 with or without this option (though a rare few
              will require `-ansi').  However, without  this  option,
 certain GNU extensions and traditional C features
 are supported as  well.   With  this  option,
              they  are rejected.  There is no reason to use this
              option; it exists only to satisfy pedants.

              `-pedantic' does not cause warning messages for use
              of the alternate keywords whose names begin and end
              with `__'.  Pedantic warnings are also disabled  in
              the  expression that follows __extension__.  However,
 only system header files should use  these  escape
  routes;  application  programs  should  avoid

              Like `-pedantic', except that errors  are  produced
              rather than warnings.

       -W     Print extra warning messages for these events:

          o   A  nonvolatile  automatic variable might be changed
              by a call to longjmp.  These warnings are  possible
              only in optimizing compilation.

              The  compiler  sees  only  the calls to setjmp.  It
              cannot know where longjmp will be called; in  fact,
              a  signal handler could call it at any point in the
              code.  As a result, you may get a warning even when
              there  is in fact no problem because longjmp cannot
              in fact be called at the place which would cause  a

          o   A function can return either with or without a value.
  (Falling off the end of the function  body  is
              considered  returning  without a value.)  For example,
 this function would evoke such a warning:

              foo (a)
                if (a > 0)
                  return a;
              Spurious warnings can occur because GNU CC does not
              realize that certain functions (including abort and
              longjmp) will never return.

          o   An expression-statement or the left-hand side of  a
              comma expression contains no side effects.  To suppress
 the warning, cast the  unused  expression  to
              void.   For example, an expression such as `x[i,j]'
              will cause a warning, but `x[(void)i,j]' will  not.

          o   An unsigned value is compared against zero with `>'
              or `<='.

              Warn whenever a  declaration  does  not  specify  a

              Warn  whenever  a function is used before being declared.

              Same as -Wimplicit-int and -Wimplicit-function-declaration.

       -Wmain Warn  if  the  main function is declared or defined
              with a suspicious type.  Typically, it is  a  function
 with external linkage, returning int, and taking
 zero or two arguments.

              Warn whenever a function is defined with a  returntype
 that defaults to int.  Also warn about any re-
              turn statement with no return-value in  a  function
              whose return-type is not void.

              Warn whenever a local variable is unused aside from
              its declaration, whenever a  function  is  declared
              static  but never defined, and whenever a statement
              computes a result that is explicitly not used.

              Warn whenever a switch statement has  an  index  of
              enumeral  type  and lacks a case for one or more of
              the named codes of that enumeration.  (The presence
              of  a  default  label prevents this warning.)  case
              labels outside the enumeration range  also  provoke
              warnings when this option is used.

              Warn whenever a comment-start sequence `/*' appears
              in a comment.

              Warn if any  trigraphs  are  encountered  (assuming
              they are enabled).

              Check calls to printf and scanf, etc., to make sure
              that the arguments supplied have types  appropriate
              to the format string specified.

              Warn  if an array subscript has type char.  This is
              a common cause of error, as programmers often  forget
 that this type is signed on some machines.

              An  automatic  variable is used without first being

              These warnings are possible only in optimizing compilation,
  because  they require data flow information
 that is computed only when optimizing.  If you
              don't  specify  `-O',  you  simply  won't get these

              These warnings occur only for  variables  that  are
              candidates  for  register  allocation.   Therefore,
              they do not occur for a variable that  is  declared
              volatile,  or whose address is taken, or whose size
              is other than 1, 2, 4 or 8 bytes.   Also,  they  do
              not  occur  for  structures, unions or arrays, even
              when they are in registers.

              Note that there may be no warning about a  variable
              that is used only to compute a value that itself is
              never used, because such computations may be deleted
  by  data  flow analysis before the warnings are

              These warnings are made optional because GNU CC  is
              not  smart  enough  to  see all the reasons why the
              code might be correct despite appearing to have  an
              error.  Here is one example of how this can happen:

                int x;
                switch (y)
                  case 1: x = 1;
                  case 2: x = 4;
                  case 3: x = 5;
                foo (x);

              If the value of y is always 1, 2 or 3,  then  x  is
              always  initialized,  but GNU CC doesn't know this.
              Here is another common case:

                int save_y;
                if (change_y) save_y = y, y = new_y;
                if (change_y) y = save_y;

              This has no bug because save_y is used only  if  it
              is set.

              Some  spurious  warnings  can be avoided if you declare
 as volatile all the functions  you  use  that
              never return.

              Warn  if  parentheses  are  omitted in certain contexts.

              When using templates in a C++ program, warn if  debugging
 is not yet fully available (C++ only).

       -Wall  All  of the above `-W' options combined.  These are
              all the options which pertain to usage that we recommend
  avoiding  and  that  we  believe is easy to
              avoid, even in conjunction with macros.

       The remaining `-W...' options are not implied  by  `-Wall'
       because  they  warn  about  constructions that we consider
       reasonable to use, on occasion, in clean programs.

              Warn about certain constructs that  behave  differently
 in traditional and ANSI C.

          o   Macro  arguments  occurring within string constants
              in the macro body.  These would substitute the  argument
  in  traditional C, but are part of the constant
 in ANSI C.

          o   A function declared external in one block and  then
              used after the end of the block.

          o   A switch statement has an operand of type long.
              Warn  whenever a local variable shadows another local

              Warn whenever two distinct identifiers match in the
              first  len characters.  This may help you prepare a
              program that will compile  with  certain  obsolete,
              brain-damaged compilers.

              Warn about anything that depends on the "size of" a
              function type or of  void.   GNU  C  assigns  these
              types  a size of 1, for convenience in calculations
              with void * pointers and pointers to functions.

              Warn whenever a pointer is cast so as to  remove  a
              type  qualifier from the target type.  For example,
              warn if a const char * is cast to an ordinary  char

              Warn  whenever  a pointer is cast such that the required
 alignment of the target is  increased.   For
              example,  warn  if  a char * is cast to an int * on
              machines where integers can  only  be  accessed  at
              two- or four-byte boundaries.

              Give  string  constants the type const char[length]
              so that copying the address of one into a non-const
              char  * pointer will get a warning.  These warnings
              will help you find at compile time  code  that  can
              try  to  write  into a string constant, but only if
              you have been very careful  about  using  const  in
              declarations  and  prototypes.   Otherwise, it will
              just be a nuisance; this is why  we  did  not  make
              `-Wall' request these warnings.

              Warn  if  a prototype causes a type conversion that
              is different from what would happen to the same argument
  in  the  absence  of a prototype.  This includes
 conversions of fixed point to  floating  and
              vice  versa,  and conversions changing the width or
              signedness of a fixed point  argument  except  when
              the same as the default promotion.

              Warn  if  any  functions  that return structures or
              unions are defined or called.  (In languages  where
              you  can return an array, this also elicits a warning.)

              Warn if stack protection is enabled and a  function
              can not be protected.

              Warn  if  a function is declared or defined without
              specifying the argument types.  (An old-style function
  definition  is permitted without a warning if
              preceded by a declaration which specifies the argument

              Warn if a global function is defined without a previous
 prototype declaration.  This warning  is  issued
  even if the definition itself provides a prototype.
  The aim is to detect global functions that
              fail to be declared in header files.

              Warn if a global function is defined without a previous
 declaration.  Do so even  if  the  definition
              itself  provides  a  prototype.  Use this option to
              detect global functions that are  not  declared  in
              header files.

              Warn  if anything is declared more than once in the
              same scope, even in cases where  multiple  declaration
 is valid and changes nothing.

              Warn if an extern declaration is encountered within
              an function.

              Warn about conversion between different enumeration
              types (C++ only).

              Warn  if  long long type is used.  This is default.
              To  inhibit  the   warning   messages,   use   flag
              `-Wno-long-long'.     Flags    `-W-long-long'   and
              `-Wno-long-long' are taken into account  only  when
              flag `-pedantic' is used.

              (C++ only.)  In a derived class, the definitions of
              virtual functions must match the type signature  of
              a virtual function declared in the base class.  Use
              this option to  request  warnings  when  a  derived
              class  declares a function that may be an erroneous
              attempt to define a virtual function: that is, warn
              when  a  function  with  the same name as a virtual
              function in the base class, but with a type  signature
  that doesn't match any virtual functions from
              the base class.

              Warn if a function can not be inlined,  and  either
              it  was  declared  as  inline,  or  else  the -fin-
              line-functions option was given.

              Treat warnings as errors; abort  compilation  after
              any warning.

DEBUGGING OPTIONS    [Toc]    [Back]

       GNU  CC  has various special options that are used for debugging
 either your program or GCC:

       -g     Produce debugging information in the operating system's
 native format (stabs, COFF, XCOFF, or DWARF).
              GDB can work with this debugging information.

              On most systems that use stabs format, `-g' enables
              use  of  extra  debugging information that only GDB
              can use; this  extra  information  makes  debugging
              work better in GDB but will probably make other debuggers
 crash or refuse to read  the  program.   If
              you want to control for certain whether to generate
              the extra information, use  `-gstabs+',  `-gstabs',
              `-gxcoff+',  `-gxcoff',  `-gdwarf+',  or  `-gdwarf'
              (see below).

              Unlike most other C compilers, GNU CC allows you to
              use  `-g'  with `-O'.  The shortcuts taken by optimized
 code may occasionally produce surprising  results:
 some variables you declared may not exist at
              all; flow of control may briefly move where you did
              not  expect it; some statements may not be executed
              because they compute constant results or their values
  were already at hand; some statements may execute
 in different places because  they  were  moved
              out of loops.

              Nevertheless  it proves possible to debug optimized
              output.  This makes it reasonable to use the  optimizer
 for programs that might have bugs.

       The  following options are useful when GNU CC is generated
       with the capability for more than one debugging format.

       -ggdb  Produce debugging information in the native  format
              (if that is supported), including GDB extensions if
              at all possible.

              Produce debugging information in stabs  format  (if
              that  is  supported), without GDB extensions.  This
              is the format used by DBX on most BSD systems.

              Produce debugging information in stabs  format  (if
              that is supported), using GNU extensions understood
              only by the GNU debugger (GDB).  The use  of  these
              extensions  is likely to make other debuggers crash
              or refuse to read the program.

       -gcoff Produce debugging information in  COFF  format  (if
              that is supported).  This is the format used by SDB
              on most System V systems prior to System V  Release

              Produce  debugging  information in XCOFF format (if
              that is supported).  This is the format used by the
              DBX debugger on IBM RS/6000 systems.

              Produce  debugging  information in XCOFF format (if
              that is supported), using GNU extensions understood
              only  by  the GNU debugger (GDB).  The use of these
              extensions is likely to make other debuggers  crash
              or refuse to read the program.

              Produce  debugging  information in DWARF format (if
              that is supported).  This is the format used by SDB
              on most System V Release 4 systems.

              Produce  debugging  information in DWARF format (if
              that is supported), using GNU extensions understood
              only  by  the GNU debugger (GDB).  The use of these
              extensions is likely to make other debuggers  crash
              or refuse to read the program.


 Similar pages
Name OS Title
g++ NetBSD GNU project C++ Compiler
c++ FreeBSD GNU project C and C++ Compiler (gcc-3.2.1)
g++ FreeBSD GNU project C and C++ Compiler (gcc-3.2.1)
CC FreeBSD GNU project C and C++ Compiler (gcc-3.2.1)
g++ OpenBSD GNU project C++ Compiler
c++ OpenBSD GNU project C++ Compiler
c++ NetBSD GNU project C++ Compiler
cc FreeBSD GNU project C and C++ Compiler (gcc-3.2.1)
gcc FreeBSD GNU project C and C++ Compiler (gcc-3.2.1)
gcc-2.96 Linux GNU project C and C++ Compiler (gcc-2.96)
Copyright © 2004-2005 DeniX Solutions SRL
newsletter delivery service