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

  man pages->FreeBSD man pages -> cc (1)              



NAME    [Toc]    [Back]

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

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 -fall-virtual -fcond-mismatch -fdollars-in-identifiers
	      -fenum-int-equiv -fexternal-templates -fno-asm -fno-builtin
	      -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 -trigraphs

       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 -Wstrict-prototypes -Wswitch
	      -Wtemplate-debugging -Wtraditional -Wtrigraphs -Wuninitialized
	      -Wunused -Wwrite-strings

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

       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
	      -m386 -m486 -mpentium -mpentiumpro -mno-486 -mcpu=cpu type
	      -march=cpu type -msoft-float -mrtd -mregparm -msvr3-shlib
	      -mno-ieee-fp -mno-fp-ret-in-387 -mfancy-math-387
	      -mno-wide-multiply -mdebug-addr -mno-move -mprofiler-epilogue

	      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 -fpcc-struct-return -fpic -fPIC
	      -freg-struct-return -fshared-data -fshort-enums -fshort-double
	      -fvolatile -fvolatile-global -fverbose-asm

FreeBSD SPECIFIC OPTIONS    [Toc]    [Back]

	      Link a user-threaded process against libc_r instead of libc.

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.

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

	      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

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

	      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.

	      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 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 an extern declaration is encountered within a function.

	      Warn about conversion between different enumeration  types  (C++

	      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

 Similar pages
Name OS Title
g++ NetBSD GNU project C++ Compiler
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)
c++ NetBSD GNU project C++ Compiler
gcc-2.96 Linux GNU project C and C++ Compiler (gcc-2.96)
g++-2.96 Linux GNU project C++ Compiler
Copyright © 2004-2005 DeniX Solutions SRL
newsletter delivery service