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

  man pages->Linux man pages -> gcc-2.96 (1)              



NAME    [Toc]    [Back]

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

SYNOPSIS    [Toc]    [Back]

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

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

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

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

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

       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

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

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 non-default 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 -fcond-mismatch -fdollars-in-identifiers
	      -fexternal-templates -fno-asm -fno-builtin -fhosted -fno-hosted
	      -ffreestanding -fno-freestanding -fno-strict-prototype
	      -fsigned-bitfields -fsigned-char -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 -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 -Wstrict-prototypes -Wswitch -Wtraditional -Wtrigraphs
	      -Wuninitialized -Wunused -Wunused-function -Wunused-label
	      -Wunused-parameter -Wunused-variable -Wunused-value

       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

       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 -muser-registers

	      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 -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 -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', `objec-
	      tive-c', `c-header', `c++', `cpp-output', `assembler', and  `as-

       -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

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

	      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

       -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

	      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, alloca, cos, exit, fabs, labs, memcmp, mem-
	      cpy, sin, sqrt, strcmp, strcpy, and strlen.

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

	      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	`-tri-

	      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.

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

	      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  implementa-
	      tion' (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.

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

	      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

	      Ideally, a portable program should always use signed char or un-
	      signed 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 types.

	      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.  `-tradition-
	      al' 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

       -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 `-iprefix'.

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

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

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

	      (answer) Assert the answer answer for question, in  case	it  is
	      tested  with  a  preprocessor  conditional  such	as `#if #ques-
	      tion(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 option 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

	      The  directories searched include several standard system directories
 plus any that you specify with `-L'.

	      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

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

	      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 `-Xlinker -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

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

       -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 `#include "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

	      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 `machine/version/'.

	      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_PRE-
	      FIX  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

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

	      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 __ex-
	      tension__.  However, only system header files should  use  these
	      escape routes; application programs should avoid them.

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

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

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

	      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 return-type that defaults
 to int.  Also warn about any return statement with no return-value
 in a function whose return-type is not void.

	      Warn whenever a static function is declared but not defined or a
	      non-inline static function is unused.

	      Warn whenever a label is declared but not used.

	      To suppress this warning use the unused attribute.

	      Warn whenever a function parameter is unused aside from its declaration.

	      To suppress this warning use the unused attribute.

	      Warn  whenever  a local variable or non-constant static variable
	      is unused aside from its declaration

	      To suppress this warning use the unused attribute.

	      Warn whenever a statement computes a result that	is  explicitly
	      not used.

	      To suppress this warning cast the expression to void.

	      All all the above `-Wunused' options combined.

	      In  order  to  get a warning about an unused function parameter,
	      you must either  specify	`-W  -Wunused'	or  separatly  specify

	      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

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

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

	      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

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

	      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

		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.

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

	      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

	      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

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

	      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

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

	      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.

       -gcofflevel -gxcofflevel

	      Request  debugging information and also use level to specify how
	      much information.  The default level is 2.

	      Level 1 produces minimal information, enough  for  making  backtraces
  in  parts  of  the program that you don't plan to debug.
	      This includes descriptions of functions and external  variables,
	      but no information about local variables and no line numbers.

	      Level  3 includes extra information, such as all the macro definitions
 present in the program.  Some  debuggers	support  macro
	      expansion when you use `-g3'.

       -p     Generate	extra  code  to write profile information suitable for
	      the analysis program prof.

       -pg    Generate extra code to write profile  information  suitable  for
	      the analysis program gprof.

       -a     Generate	extra  code  to  write	profile  information for basic
	      blocks, which will record the number of times each  basic  block
	      is  executed.   This  data  could  be analyzed by a program like
	      tcov.  Note, however, that the format of the data  is  not  what
	      tcov  expects.   Eventually  GNU	gprof  should  be  extended to
	      process this data.

       -ax    Generate extra code to read  basic  block  profiling  parameters
	      from  file `bb.in' and write profiling results to file `bb.out'.
	      `bb.in' contains a list of functions. Whenever a function on the
	      list  is entered, profiling is turned on. When the outmost function
 is left, profiling is turned off. If  a  function  name  is
	      prefixed	with `-' the function is excluded from profiling. If a
	      function name is not unique it can be disambiguated  by  writing
	      `/path/filename.d:functionname'.	`bb.out' will list some available
 filenames.  Four function names  have  a  special  meaning:
	      `__bb_jumps__'  will  cause  jump  frequencies  to be written to
	      `bb.out'.  `__bb_trace__'  will  cause  the  sequence  of  basic
	      blocks to be piped into `gzip' and written to file `bbtrace.gz'.
	      `__bb_hidecall__' will cause call instructions  to  be  excluded
	      from the trace.  `__bb_showret__' will cause return instructions
	      to be included in the trace.

	      Says to make debugging dumps during compilation at times	specified
  by letters.  This is used for debugging the compiler.  The
	      file names for most of the dumps are made by appending a word to
	      the source file name (e.g.  `foo.c.rtl' or `foo.c.jump').

       -dM    Dump  all  macro	definitions,  at the end of preprocessing, and
	      write no output.

       -dN    Dump all macro names, at the end of preprocessing.

       -dD    Dump all macro definitions, at the end of preprocessing, in  addition
 to normal output.

       -dy    Dump debugging information during parsing, to standard error.

       -dr    Dump after RTL generation, to `file.rtl'.

       -dx    Just  generate RTL for a function instead of compiling it.  Usually
 used with `r'.

       -dj    Dump after first jump optimization, to `file.jump'.

       -ds    Dump after CSE (including the jump optimization  that  sometimes
	      follows CSE), to `file.cse'.

       -dL    Dump after loop optimization, to `file.loop'.

       -dt    Dump  after the second CSE pass (including the jump optimization
	      that sometimes follows CSE), to `file.cse2'.

       -df    Dump after flow analysis, to `file.flow'.

       -dc    Dump after instruction combination, to `file.combine'.

       -dS    Dump  after  the	 first	 instruction   scheduling   pass,   to

       -dl    Dump after local register allocation, to `file.lreg'.

       -dg    Dump after global register allocation, to `file.greg'.

       -dR    Dump   after   the   second   instruction  scheduling  pass,  to

       -dJ    Dump after last jump optimization, to `file.jump2'.

       -dd    Dump after delayed branch scheduling, to `file.dbr'.

       -dk    Dump after conversion from registers to stack, to  `file.stack'.

       -da    Produce all the dumps listed above.

       -dm    Print  statistics  on  memory  usage,  at the end of the run, to
	      standard error.

       -dp    Annotate the assembler output with a  comment  indicating  which
	      pattern and alternative was used.

	      When  running  a cross-compiler, pretend that the target machine
	      uses the same floating point format as the host  machine.   This
	      causes  incorrect  output  of the actual floating constants, but
	      the actual instruction sequence will probably be the same as GNU
	      CC would make when running on the target machine.

	      Store  the  usual  "temporary"  intermediate  files permanently;
	      place them in the current directory and name them based  on  the
	      source  file.   Thus,  compiling	`foo.c'  with `-c -save-temps'
	      would produce files `foo.cpp' and `foo.s', as well as `foo.o'.

	      Print the full absolute name of the library file library	  that
	      would  be  used when linking--and do not do anything else.  With
	      this option, GNU CC does not compile or link anything;  it  just
	      prints the file name.

	      Same as `-print-file-name=libgcc.a'.

	      Like  `-print-file-name',  but  searches	for  a program such as


       These options control various sorts of optimizations:


       -O1    Optimize.  Optimizing compilation takes somewhat more time,  and
	      a lot more memory for a large function.

	      Without  `-O', the compiler's goal is to reduce the cost of compilation
 and to make debugging  produce  the  expected  results.
	      Statements  are  independent:  if  you  stop  the program with a
	      breakpoint between statements, you can then assign a  new  value
	      to  any  variable  or  change  the  program counter to any other
	      statement in the function and get exactly the results you  would
	      expect from the source code.

	      Without  `-O', only variables declared register are allocated in
	      registers.  The resulting compiled code is a little  worse  than
	      produced by PCC without `-O'.

	      With  `-O', the compiler tries to reduce code size and execution

	      When you specify `-O',  the  two	options  `-fthread-jumps'  and
	      `-fdefer-pop' are turned on.  On machines that have delay slots,
	      the `-fdelayed-branch' option is turned on.  For those  machines
	      that  can  support  debugging  even without a frame pointer, the
	      `-fomit-frame-pointer' option is turned on.   On	some  machines
	      other flags may also be turned on.

       -O2    Optimize	even more.  Nearly all supported optimizations that do
	      not involve a space-speed  tradeoff  are	performed.   Loop  unrolling
  and  function  inlining	are not done, for example.  As
	      compared to -O, this option increases both compilation time  and
	      the performance of the generated code.

       -O3    Optimize yet more. This turns on everything -O2 does, along with

 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)
gcc NetBSD GNU project C and C++ Compiler (gcc-2.95)
g++ OpenBSD GNU project C++ Compiler
cc OpenBSD GNU project C and C++ Compiler (gcc-2.95)
c++ OpenBSD GNU project C++ Compiler
gcc OpenBSD GNU project C and C++ Compiler (gcc-2.95)
cc NetBSD GNU project C and C++ Compiler (gcc-2.95)
Copyright © 2004-2005 DeniX Solutions SRL
newsletter delivery service