


GCC(1)                      GNU Tools                      GCC(1)


NNAAMMEE
       gcc, g++ - GNU project C and C++ Compiler (v2 preliminary)

SSYYNNOOPPSSIISS
       gcc [[_o_p_t_i_o_n | _f_i_l_e_n_a_m_e ]...
       g++ [[_o_p_t_i_o_n | _f_i_l_e_n_a_m_e ]...

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

       For complete, current documentation,  refer  to  the  Info
       file  `ggcccc'  or  the  manual _U_s_i_n_g _a_n_d _P_o_r_t_i_n_g _G_N_U _C_C _(_f_o_r
       _v_e_r_s_i_o_n _2_._0_).  Both are made from the Texinfo source  file
       ggcccc..tteexxiinnffoo.

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

       ggcccc    assumes preprocessed (..ii) files are C and assumes C
              style linking.

       gg++++    assumes preprocessed (..ii) files are C++ and assumes
              C++ style linking.

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

       ..cc     C source; preprocess, compile, assemble
       ..CC     C++ source; preprocess, compile, assemble
       ..cccc     C++ source; preprocess, compile, assemble
       ..ccxxxx     C++ source; preprocess, compile, assemble
       ..mm     Objective-C source; preprocess, compile, assemble
       ..ii     preprocessed C or C++; compile, assemble
       ..ss     Assembler source; assemble
       ..SS     Assembler source; preprocess, assemble
       ..hh     Preprocessor file; not  usually  named  on  command
       line

       _?_?     Other (unrecognized) files passed to linker.
            Common cases:
       ..oo     Object file
       ..aa     Archive file

       Linking is always the last stage unless you use one of the
       --cc, --SS, or --EE options to avoid it (or  unless  compilation
       errors  stop  the whole process).  For the link stage, all
       ..oo files corresponding  to  source  files,  --ll  libraries,
       unrecognized  filenames  (including  named ..oo object files



GNU Tools                   27dec1991                           1





GCC(1)                      GNU Tools                      GCC(1)


       and ..aa archives) are passed to the linker in  command-line
       order.


OOPPTTIIOONNSS
       Options  must  be  separate: `--ddrr' is quite different from
       `--dd --rr '.

       Most `--ff' and `--WW' options have two contrary forms: --ff_n_a_m_e
       and  --ffnnoo--_n_a_m_e  (or  --WW_n_a_m_e  and --WWnnoo--_n_a_m_e). 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.


       OOvveerraallll OOppttiioonnss
              -c -S -E -o _f_i_l_e -pipe -v -vpath -vspec -x _l_a_n_g_u_a_g_e


       LLaanngguuaaggee OOppttiioonnss
              -ansi -fall-virtual -fcond-mismatch
              -fdollars-in-identifiers -fenum-int-equiv -fno-asm
              -fno-builtin -fno-strict-prototype
              -fsigned-bitfields -fsigned-char -fthis-is-variable
              -funsigned-bitfields -funsigned-char
              -fwritable-strings -traditional -traditional-cpp
              -trigraphs


       WWaarrnniinngg OOppttiioonnss
              -fsyntax-only -pedantic -pedantic-errors -w -W
              -Wall -Waggregate-return -Wcast-align -Wcast-qual
              -Wcomment -Wconversion -Wenum-clash -Werror
              -Wformat -Wid-clash-_l_e_n -Wimplicit
              -Wmissing-prototypes -Wno-parentheses
              -Wpointer-arith -Wreturn-type -Wshadow
              -Wstrict-prototypes -Wswitch -Wtraditional
              -Wtrigraphs -Wuninitialized -Wunused
              -Wwrite-strings


       DDeebbuuggggiinngg OOppttiioonnss
              -a -d_l_e_t_t_e_r_s -fpretend-float -g -gdbx -gdwarf -ggdb
              -gsdb -p -pg -save-temps


       OOppttiimmiizzaattiioonn OOppttiioonnss
              -fcaller-saves -fcse-follow-jumps -fdelayed-branch
              -felide-constructors -fexpensive-optimizations
              -ffloat-store -fforce-addr -fforce-mem -finline
              -finline-functions -fkeep-inline-functions
              -fmemoize-lookups -fno-default-inline
              -fno-defer-pop -fno-function-cse



GNU Tools                   27dec1991                           2





GCC(1)                      GNU Tools                      GCC(1)


              -fomit-frame-pointer -frerun-cse-after-loop
              -fschedule-insns -fschedule-insns2
              -fstrength-reduce -fthread-jumps -funroll-all-loops
              -funroll-loops -O -O2


       PPrreepprroocceessssoorr OOppttiioonnss
              -C -dD -dM -dN -D_m_a_c_r_o[=_d_e_f_n] -E -H -i _f_i_l_e -M -MD
              -MM -MMD -nostdinc -P -U_m_a_c_r_o -undef


       LLiinnkkeerr OOppttiioonnss
              -dynamic -l_l_i_b_r_a_r_y -nostdlib -static


       DDiirreeccttoorryy OOppttiioonnss
              -B_p_r_e_f_i_x -I_d_i_r -I- -L_d_i_r


       TTaarrggeett OOppttiioonnss
              -b  _m_a_c_h_i_n_e -V _v_e_r_s_i_o_n


       MMaacchhiinnee DDeeppeennddeenntt OOppttiioonnss
              _M_6_8_0_x_0 _O_p_t_i_o_n_s
              -m68000 -m68020 -m68881 -mbitfield -mc68000
              -mc68020 -mfpa -mnobitfield -mrtd -mshort
              -msoft-float

              _V_A_X _O_p_t_i_o_n_s
              -mg -mgnu -munix

              _S_P_A_R_C _O_p_t_i_o_n_s
              -mfpu -mno-epilogue

              _C_o_n_v_e_x _O_p_t_i_o_n_s
              -margcount -mc1 -mc2 -mnoargcount

              _A_M_D_2_9_K _O_p_t_i_o_n_s
              -m29000 -m29050 -mbw -mdw -mkernel-registers
              -mlarge -mnbw -mnodw -msmall -mstack-check
              -muser-registers

              _M_8_8_K _O_p_t_i_o_n_s
              -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-underscores -mocs-debug-info
              -mocs-frame-position -moptimize-arg-area
              -mshort-data-_n_u_m -msvr3 -msvr4 -mtrap-large-shift
              -muse-div-instruction -mversion-03.00
              -mwarn-passed-structs




GNU Tools                   27dec1991                           3





GCC(1)                      GNU Tools                      GCC(1)


              _R_S_6_0_0_0 _O_p_t_i_o_n_s
              -mfp-in-toc -mno-fop-in-toc

              _R_T _O_p_t_i_o_n_s
              -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

              _M_I_P_S _O_p_t_i_o_n_s
              -mcpu=_c_p_u _t_y_p_e -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 _n_u_m


       CCooddee GGeenneerraattiioonn OOppttiioonnss
              +e_N -fcall-saved-_r_e_g -fcall-used-_r_e_g -ffixed-_r_e_g
              -fno-common -fno-gnu-binutils -fnonnull-objects
              -fpcc-struct-return -fpic -fPIC -fshared-data
              -fshort-enums -fshort-double -fvolatile


OOVVEERRAALLLL OOPPTTIIOONNSS
       --xx _l_a_n_g_u_a_g_e
              Specify  explicitly  the _l_a_n_g_u_a_g_e 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  `--xx'  op-
              tion.    Possible   values  of  _l_a_n_g_u_a_g_e  are  `cc',
              `oobbjjeeccttiivvee--cc',  `cc--hheeaaddeerr',  `cc++++',   `ccpppp--oouuttppuutt',
              `aasssseemmbblleerr', and `aasssseemmbblleerr--wwiitthh--ccpppp'.

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


       If you want only some of the four stages (preprocess, com-
       pile,  assemble, link), you can use `--xx' (or filename suf-
       fixes) to tell ggcccc where to start, and one of the  options
       `--cc',  `--SS',  or  `--EE'  to say where ggcccc is to stop.  Note
       that some combinations (for example, `--xx  ccpppp--oouuttppuutt  --EE')
       instruct ggcccc to do nothing at all.

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

              By  default,  GCC  makes the object file name for a
              source file by replacing  the  suffix  `..cc',  `..ii',



GNU Tools                   27dec1991                           4





GCC(1)                      GNU Tools                      GCC(1)


              `..ss',  etc.,  with  `..oo'.  Use --oo to select another
              name.

              GCC ignores any  unrecognized  input  files  (those
              that  do  not require compilation or assembly) with
              the --cc option.

       --SS     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 `..cc', `..ii',
              etc., with `..ss'.  Use --oo to select another name.


              GCC ignores any input files that don't require com-
              pilation.

       --EE     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 prepro-
              cessing.

       --oo _f_i_l_e
               Place output in file _f_i_l_e.  This  applies  regard-
              less  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 `--oo' when compiling more
              than  one  input  file, unless you are producing an
              executable file as output.

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

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

       --vvppaatthh Print  (on  standard  error output) all attempts at
              finding files, tracing how the `--BB', `--bb', and `--VV'
              options interact.  Also, print the commands execut-
              ed to run the stages  of  compilation  and  version
              numbers, like the `--vv' option.




GNU Tools                   27dec1991                           5





GCC(1)                      GNU Tools                      GCC(1)


       --vvssppeecc Print  (on  standard  error output) all spec's pro-
              cessed by the ddoo__ssppeecc__11 function in `ggcccc..cc'.  Also,
              print  the  commands  executed to run the stages of
              compilation and version numbers, like the `--vv'  op-
              tion.

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



LLAANNGGUUAAGGEE OOPPTTIIOONNSS
       The  following  options  control the dialect of C that the
       compiler accepts:

       --aannssii  _S_u_p_p_o_r_t _a_l_l _A_N_S_I _s_t_a_n_d_a_r_d _C _p_r_o_g_r_a_m_s_.

              _T_h_i_s _t_u_r_n_s _o_f_f _c_e_r_t_a_i_n _f_e_a_t_u_r_e_s _o_f _G_N_U _C  _t_h_a_t  _a_r_e
              _i_n_c_o_m_p_a_t_i_b_l_e  _w_i_t_h  ANSI C, such as the aassmm, iinnlliinnee
              and ttyyppeeooff keywords, and predefined macros such  as
              uunniixx  and  vvaaxx that identify the type of system you
              are using.  It also  enables  the  undesirable  and
              rarely  used  ANSI  trigraph feature, and makes the
              preprocessor accept `$$' as part of identifiers.

              The  alternate  keywords  ____aassmm____,   ____eexxtteennssiioonn____,
              ____iinnlliinnee____  and ____ttyyppeeooff____ continue to work despite
              `--aannssii'.  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  compila-
              tions  done  with  `--aannssii'.   Alternate  predefined
              macros such as ____uunniixx____ and ____vvaaxx____ are also avail-
              able, with or without `--aannssii'.

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

              The preprocessor predefines a macro ____SSTTRRIICCTT__AANNSSII____
              when you use the `--aannssii' 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.

       --ffnnoo--aassmm
              Do  not  recognize  aassmm, iinnlliinnee or ttyyppeeooff as a key-
              word.  These words may then be used as identifiers.
              You  can use ____aassmm____, ____iinnlliinnee____ and ____ttyyppeeooff____ in-
              stead.  `--aannssii' implies `--ffnnoo--aassmm'.



GNU Tools                   27dec1991                           6





GCC(1)                      GNU Tools                      GCC(1)


       --ffnnoo--bbuuiillttiinn
              _(_I_g_n_o_r_e_d _f_o_r _C_+_+_._)  Don't recognize non-ANSI built-
              in  functions.   `--aannssii' also has this effect. Cur-
              rently, the only function affected is aallllooccaa.

       --ffnnoo--ssttrriicctt--pprroottoottyyppee
              _(_C_+_+ _o_n_l_y_._)  Consider the declaration iinntt ffoooo  (());;.
              In  C++,  this means that the function ffoooo takes no
              arguments.   In  ANSI  C,  this  is  declared   iinntt
              ffoooo((vvooiidd));;.  With the flag `--ffnnoo--ssttrriicctt--pprroottoottyyppee',
              declaring functions with no arguments is equivalent
              to declaring its argument list to be untyped, i.e.,
              iinntt ffoooo (());; is equivalent to saying iinntt ffoooo ((......));;.

       --ttrriiggrraapphhss
              Support  ANSI  C trigraphs.  The `--aannssii' option im-
              plies `--ttrriiggrraapphhss'.

       --ttrraaddiittiioonnaall
              Attempt to support some aspects  of  traditional  C
              compilers.

              Specifically, for both C and C++ programs:

          o   In the preprocessor, comments convert to nothing at
              all, rather than to a space.   This  allows  tradi-
              tional token concatenation.

          o   In the preprocessor, macro arguments are recognized
              within string constants in a macro definition  (and
              their  values are stringified, though without addi-
              tional quote marks, when they appear in such a con-
              text).   The preprocessor always considers a string
              constant to end at a newline.

          o   The  preprocessor  does  not  predefine  the  macro
              ____SSTTDDCC____  when  you  use  `--ttrraaddiittiioonnaall', but still
              predefines____GGNNUUCC____ (since the GNU extensions  indi-
              cated    by    ____GGNNUUCC____   are   not   affected   by
              `--ttrraaddiittiioonnaall').  If you need to write header files
              that   work   differently   depending   on  whether
              `--ttrraaddiittiioonnaall' is in use, by testing both of  these
              predefined  macros  you can distinguish four situa-
              tions: GNU C, traditional GNU C, other ANSI C  com-
              pilers, and other old C compilers.

          o   In the preprocessor, comments convert to nothing at
              all, rather than to a space.   This  allows  tradi-
              tional token concatenation.

          o   In the preprocessor, macro arguments are recognized
              within string constants in a macro definition  (and
              their  values are stringified, though without addi-
              tional quote marks, when they appear in such a con-



GNU Tools                   27dec1991                           7





GCC(1)                      GNU Tools                      GCC(1)


              text).   The preprocessor always considers a string
              constant to end at a newline.

          o   The  preprocessor  does  not  predefine  the  macro
              ____SSTTDDCC____  when  you  use  `--ttrraaddiittiioonnaall', but still
              predefines____GGNNUUCC____ (since the GNU extensions  indi-
              cated    by    ____GGNNUUCC____   are   not   affected   by
              `--ttrraaddiittiioonnaall').  If you need to write header files
              that   work   differently   depending   on  whether
              `--ttrraaddiittiioonnaall' is in use, by testing both of  these
              predefined  macros  you can distinguish four situa-
              tions: GNU C, traditional GNU C, other ANSI C  com-
              pilers, and other old C compilers.


          o   String  ``constants'' are not necessarily constant;
              they are stored in writable  space,  and  identical
              looking  constants are allocated separately.  (This
              is the same as the effect of `--ffwwrriittaabbllee--ssttrriinnggss'.)

              In addition, `--ttrraaddiittiioonnaall' has these effects for C
              programs (not C++):

          o   All eexxtteerrnn declarations take effect  globally  even
              if  they  are  written inside of a function defini-
              tion.  This includes implicit declarations of func-
              tions.

          o   The  keywords  ttyyppeeooff,  iinnlliinnee,  ssiiggnneedd,  ccoonnsstt and
              vvoollaattiillee are not recognized.  (You  can  still  use
              the  alternative keywords such as ____ttyyppeeooff____, ____iinn--
              lliinnee____, and so on.)

          o   Comparisons between pointers and integers  are  al-
              ways allowed.

          o   Integer types uunnssiiggnneedd sshhoorrtt and uunnssiiggnneedd cchhaarr pro-
              mote to uunnssiiggnneedd iinntt.

          o   Out-of-range floating point literals are not an er-
              ror.

          o   All  automatic  variables not declared rreeggiisstteerr are
              preserved by lloonnggjjmmpp.  Ordinarily,  GNU  C  follows
              ANSI  C:  automatic variables not declared vvoollaattiillee
              may be clobbered.

              Finally,   for   C++   programs   only   (not   C),
              `--ttrraaddiittiioonnaall'  has  one additional effect: assign-
              ment to tthhiiss is permitted.  This is the same as the
              effect of `--fftthhiiss--iiss--vvaarriiaabbllee'.

       --ttrraaddiittiioonnaall--ccpppp
              Attempt  to  support  some aspects of traditional C



GNU Tools                   27dec1991                           8





GCC(1)                      GNU Tools                      GCC(1)


              preprocessors.   This  includes  the   items   that
              specifically  mention  the  preprocessor above, but
              none of the other effects of `--ttrraaddiittiioonnaall'.

       --ffddoollllaarrss--iinn--iiddeennttiiffiieerrss
              _(_C_+_+ _o_n_l_y_._)  Permit the use of `$$' in  identifiers.
              (For GNU C, this is the default, and you can forbid
              it with `--aannssii'.)  Traditional C allowed the  char-
              acter  `$$' to form part of identifiers; by default,
              GNU C also allows this.  However,  ANSI  C  forbids
              `$$'  in identifiers, and GNU C++ also forbids it by
              default on most platforms (though on some platforms
              it's enabled by default for GNU C++ as well).

       --ffeennuumm--iinntt--eeqquuiivv
              _(_C_+_+  _o_n_l_y_._)  Normally GNU C++ allows conversion of
              eennuumm to iinntt, but not the  other  way  around.   Use
              this option if you want GNU C++ to allow conversion
              of iinntt to eennuumm as well.

       --ffaallll--vviirrttuuaall
              _(_C_+_+ _o_n_l_y_._)  When you use the `--ffaallll--vviirrttuuaall',  all
              member  functions (except for constructor functions
              and new/delete member operators)  declared  in  the
              same  class  with a ``method-call'' operator method
              are treated  as  virtual  functions  of  the  given
              class.   In  effect,  all  of  these methods become
              ``implicitly virtual.''

              This does _n_o_t mean that all calls to these  methods
              will  be made through the internal table of virtual
              functions.   There  are  some  circumstances  under
              which  it is obvious that a call to a given virtual
              function can be made directly, and in  these  cases
              the calls still go direct.

              The  effect of making all methods of a class with a
              declared `ooppeerraattoorr-->>(())(())' implicitly virtual  using
              `--ffaallll--vviirrttuuaall' extends also to all non-constructor
              methods of any class derived from such a class.

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

       --fftthhiiss--iiss--vvaarriiaabbllee
              _(_C_+_+ _o_n_l_y_._)  The incorporation of user-defined free
              store  management  into  C++ has made assignment to
              tthhiiss an anachronism.  Therefore, by default GNU C++
              treats  the  type  of  tthhiiss in a member function of
              ccllaassss XX to be XX **ccoonnsstt.  In other words, it is  il-
              legal to assign to tthhiiss within a class member func-
              tion.  However, for  backwards  compatibility,  you



GNU Tools                   27dec1991                           9





GCC(1)                      GNU Tools                      GCC(1)


              can    invoke    the    old   behavior   by   using
              `--fftthhiiss--iiss--vvaarriiaabbllee'.

       --ffuunnssiiggnneedd--cchhaarr
              Let the type cchhaarr be unsigned, like uunnssiiggnneedd  cchhaarr.

              Each  kind  of  machine has a default for what cchhaarr
              should be.  It is either like uunnssiiggnneedd cchhaarr by  de-
              fault or like ssiiggnneedd cchhaarr by default.

              Ideally,  a  portable  program  should  always  use
              ssiiggnneedd cchhaarr or uunnssiiggnneedd cchhaarr when it depends on the
              signedness  of  an  object.  But many programs have
              been written to use plain cchhaarr 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 cchhaarr is always a distinct type  from  each
              of  ssiiggnneedd  cchhaarr and uunnssiiggnneedd cchhaarr, even though its
              behavior is always just like one of those two.


       --ffssiiggnneedd--cchhaarr
              Let the type cchhaarr be signed, like ssiiggnneedd cchhaarr.

              Note     that     this     is     equivalent     to
              `--ffnnoo--uunnssiiggnneedd--cchhaarr', which is the negative form of
              `--ffuunnssiiggnneedd--cchhaarr'.  Likewise, `--ffnnoo--ssiiggnneedd--cchhaarr' is
              equivalent to `--ffuunnssiiggnneedd--cchhaarr'.

       --ffssiiggnneedd--bbiittffiieellddss

       --ffuunnssiiggnneedd--bbiittffiieellddss

       --ffnnoo--ssiiggnneedd--bbiittffiieellddss

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

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

       --ffwwrriittaabbllee--ssttrriinnggss
              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.  `--ttrraaddiittiioonnaall' also has this ef-



GNU Tools                   27dec1991                          10





GCC(1)                      GNU Tools                      GCC(1)


              fect.

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



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

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

       --ii _f_i_l_e
               Process _f_i_l_e as input,  discarding  the  resulting
              output,  before  processing the regular input file.
              Because the output generated from _f_i_l_e is  discard-
              ed,  the  only  effect  of `--ii _f_i_l_e' is to make the
              macros defined in _f_i_l_e available  for  use  in  the
              main  input.   The  preprocessor evaluates any `--DD'
              and `--UU' options on the command  line  before  pro-
              cessing `--ii' _f_i_l_e.

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

              By using both `--nnoossttddiinncc' and `--II--', you can  limit
              the include-file search file to only those directo-
              ries you specify explicitly.

       --uunnddeeff Do not predefine any nonstandard macros.   (Includ-
              ing architecture flags).

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

       --CC     Tell  the  preprocessor  not  to  discard comments.
              Used with the `--EE' option.

       --PP     Tell the preprocessor not to generate `##lliinnee'  com-
              mands.  Used with the `--EE' option.

       --MM     Tell the preprocessor to output a rule suitable for
              mmaakkee describing the  dependencies  of  each  object
              file.   For each source file, the preprocessor out-
              puts one mmaakkee-rule whose target is the object  file
              name  for  that  source file and whose dependencies



GNU Tools                   27dec1991                          11





GCC(1)                      GNU Tools                      GCC(1)


              are all the files `##iinncclluuddee'd in it.  This rule may
              be  a single line or may be continued with `\\'-new-
              line if it is long.  The list of rules  is  printed
              on  standard  output  instead of the preprocessed C
              program.

              `--MM' implies `--EE'.

       --MMMM    Like `--MM' but the output  mentions  only  the  user
              header  files included with `##iinncclluuddee _f_i_l_e"'.  Sys-
              tem header files included  with  `##iinncclluuddee  <<_f_i_l_e>'
              are omitted.

       --MMDD    Like `--MM' but the dependency information is written
              to files with names made  by  replacing  `..cc'  with
              `..dd'  at  the end of the input file names.  This is
              in   addition   to   compiling    the    file    as
              specified--`--MMDD' does not inhibit ordinary compila-
              tion the way `--MM' does.

              The Mach utility `mmdd' can be used to merge the `..dd'
              files  into  a  single dependency file suitable for
              using with the `mmaakkee' command.

       --MMMMDD   Like `--MMDD' except mention only user  header  files,
              not system header files.

       --HH     Print  the  name of each header file used, in addi-
              tion to other normal activities.

       --DD_m_a_c_r_o
              Define macro _m_a_c_r_o with the string `11' as its defi-
              nition.

       --DD_m_a_c_r_o==_d_e_f_n
              Define  macro  _m_a_c_r_o  as  _d_e_f_n.    All instances of
              `--DD' on the command line are processed  before  any
              `--UU' or `--ii' options.

       --UU_m_a_c_r_o
              Undefine  macro  _m_a_c_r_o.  `--UU' options are evaluated
              after all `--DD' options, but  before  any  `--ii'  op-
              tions.

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

       --ddDD    Tell  the  preprocessing  to pass all macro defini-
              tions into the output, in their proper sequence  in
              the rest of the output.

       --ddNN    Like `--ddDD' except that the macro arguments and con-
              tents are omitted.  Only `##ddeeffiinnee _n_a_m_e' is included



GNU Tools                   27dec1991                          12





GCC(1)                      GNU Tools                      GCC(1)


              in the output.



LLIINNKKEERR OOPPTTIIOONNSS
       These  options  come into play when the compiler links ob-
       ject files into an executable output file.  They are mean-
       ingless if the compiler is not doing a link step.

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

       --ddyynnaammiicc
              On systems that support dynamic  linking,  you  can
              use this option to request it explicitly.

       --ll_l_i_b_r_a_r_y
               Use the library named _l_i_b_r_a_r_y when linking.

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

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

              Normally the  files  found  this  way  are  library
              files--archive   files  whose  members  are  object
              files.  The linker handles an archive file by scan-
              ning  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 `--ll' option and specifying a  file
              name  is that `--ll' surrounds _l_i_b_r_a_r_y with `lliibb' and
              `..aa' and searches several directories.

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

       --ssttaattiicc
              On systems that support dynamic linking, this  pre-
              vents linking with the shared libraries.  (`--gg' al-
              so has this effect.)  On other systems, this option



GNU Tools                   27dec1991                          13





GCC(1)                      GNU Tools                      GCC(1)


              has no effect.



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

       --II_d_i_r   Append directory _d_i_r to the  list  of  directories
              searched for include files.

       --II--    Any  directories  you specify with `--II' options be-
              fore the `--II--' option are  searched  only  for  the
              case  of  `##iinncclluuddee  ""_f_i_l_e""'; they are not searched
              for `##iinncclluuddee <<_f_i_l_e>'.

              If additional directories are specified  with  `--II'
              options  after  the  `--II--',  these  directories are
              searched for all `##iinncclluuddee' directives.  (Ordinari-
              ly _a_l_l `--II' directories are used this way.)

              In  addition,  the `--II--' option inhibits the use of
              the current directory (where the current input file
              came  from) as the first search directory for `##iinn--
              cclluuddee ""_f_i_l_e""'.  There is no way  to  override  this
              effect  of  `--II--'.   With  `--II..'  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.

              `--II--' does not inhibit the use of the standard sys-
              tem directories for header files.  Thus, `--II--'  and
              `--nnoossttddiinncc' are independent.

       --LL_d_i_r   Add directory _d_i_r to the list of directories to be
              searched for `--ll'.

       --BB_p_r_e_f_i_x
               This option specifies where to find  the  executa-
              bles,  libraries and data files of the compiler it-
              self.

              The compiler driver program runs one or more of the
              subprograms  `ccpppp', `cccc11' (or, for C++, `cccc11pplluuss'),
              `aass' and `lldd'.  It tries _p_r_e_f_i_x  as  a  prefix  for
              each program it tries to run, both with and without
              `_m_a_c_h_i_n_e/_v_e_r_s_i_o_n/'.

              For each subprogram to be run, the compiler  driver
              first  tries the `--BB' prefix, if any.  If that name
              is not found, or if `--BB'  was  not  specified,  the
              driver  tries  two  standard  prefixes,  which  are
              `//uussrr//lliibb//ggcccc//' and `//uussrr//llooccaall//lliibb//ggcccc//'.  If nei-



GNU Tools                   27dec1991                          14





GCC(1)                      GNU Tools                      GCC(1)


              ther 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 `PPAATTHH' environment variable.

              The  run-time  support  file  `lliibbggcccc..aa'  is   also
              searched  for using the `--BB' 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, `lliibbggcccc..aa' is
              not actually necessary.

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



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

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

       --ffssyynnttaaxx--oonnllyy
              Check the code for syntax errors,  but  don't  emit
              any output.

       --ww     Inhibit all warning messages.

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

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

              `--ppeeddaannttiicc' 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 ____eexxtteennssiioonn____.   Howev-
              er,  only  system header files should use these es-



GNU Tools                   27dec1991                          15





GCC(1)                      GNU Tools                      GCC(1)


              cape  routes;  application  programs  should  avoid
              them.

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

       --WWeerrrroorr
              Treat warnings as errors; abort  compilation  after
              any warning.

       --WW     Print extra warning messages for these events:

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

              The  compiler  sees  only  the calls to sseettjjmmpp.  It
              cannot know where lloonnggjjmmpp 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 lloonnggjjmmpp cannot
              in fact be called at the place which would cause  a
              problem.

          o   A function can return either with or without a val-
              ue.  (Falling off the end of the function  body  is
              considered  returning  without a value.)  For exam-
              ple, 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 aabboorrtt and
              lloonnggjjmmpp) will never return.

          o   An expression-statement contains no side effects.

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


       --WWiimmpplliicciitt
              Warn whenever a function or parameter is implicitly
              declared.

       --WWrreettuurrnn--ttyyppee
              Warn whenever a function is defined with a  return-
              type that defaults to iinntt.  Also warn about any rree--



GNU Tools                   27dec1991                          16





GCC(1)                      GNU Tools                      GCC(1)


              ttuurrnn statement with no return-value in  a  function
              whose return-type is not vvooiidd.

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

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

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

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

       --WWaaggggrreeggaattee--rreettuurrnn
              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 warn-
              ing.)

       --WWffoorrmmaatt
              Check calls to pprriinnttff and ssccaannff, etc., to make sure
              that  the arguments supplied have types appropriate
              to the format string specified.

       --WWuunniinniittiiaalliizzeedd
              An automatic variable is used without  first  being
              initialized.

              These warnings are possible only in optimizing com-
              pilation, because they require data  flow  informa-
              tion that is computed only when optimizing.  If you
              don't specify `--OO',  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
              vvoollaattiillee, or whose address is taken, or whose  size
              is  other  than  1, 2, 4 or 8 bytes.  Also, they do
              not occur for structures, unions  or  arrays,  even
              when they are in registers.




GNU Tools                   27dec1991                          17





GCC(1)                      GNU Tools                      GCC(1)


              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 delet-
              ed 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;
                    break;
                  case 2: x = 4;
                    break;
                  case 3: x = 5;
                  }
                foo (x);
              }



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


              {
                int save_y;
                if (change_y) save_y = y, y = new_y;
                ...
                if (change_y) y = save_y;
              }



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

              Some spurious warnings can be avoided  if  you  de-
              clare  as  vvoollaattiillee  all the functions you use that
              never return.

       --WWssttrriicctt--pprroottoottyyppeess
              Warn if a function is declared or  defined  without
              specifying the argument types.  (An old-style func-
              tion definition is permitted without a  warning  if
              preceded by a declaration which specifies the argu-
              ment types.)



GNU Tools                   27dec1991                          18





GCC(1)                      GNU Tools                      GCC(1)


       --WWmmiissssiinngg--pprroottoottyyppeess
              Warn if a global function is defined without a pre-
              vious  prototype  declaration.  This warning is is-
              sued even if the definition itself provides a  pro-
              totype.  The aim is to detect global functions that
              fail to be declared in header files.

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


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

       --WWttrraaddiittiioonnaall
              Warn  about  certain constructs that behave differ-
              ently in traditional and ANSI C.

          o   Macro arguments occurring within  string  constants
              in  the macro body.  These would substitute the ar-
              gument in traditional C, but are part of  the  con-
              stant in ANSI C.

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

          o   A sswwiittcchh statement has an operand of type lloonngg.


       --WWsshhaaddooww
              Warn whenever a local variable shadows another  lo-
              cal variable.

       --WWiidd--ccllaasshh--_l_e_n
                Warn  whenever  two distinct identifiers match in
              the first _l_e_n characters.  This may help  you  pre-
              pare a program that will compile with certain obso-
              lete, brain-damaged compilers.

       --WWppooiinntteerr--aarriitthh
              Warn about anything that depends on the ``size of''
              a  function  type  or of vvooiidd.  GNU C assigns these
              types a size of 1, for convenience in  calculations
              with vvooiidd ** pointers and pointers to functions.

       --WWccaasstt--qquuaall
              Warn  whenever  a pointer is cast so as to remove a
              type qualifier from the target type.  For  example,
              warn  if a ccoonnsstt cchhaarr ** is cast to an ordinary cchhaarr
              **.




GNU Tools                   27dec1991                          19





GCC(1)                      GNU Tools                      GCC(1)


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

       --WWwwrriittee--ssttrriinnggss
              Give string constants the type  ccoonnsstt  cchhaarr[[_l_e_n_g_t_h]
              so that copying the address of one into a non-ccoonnsstt
              cchhaarr ** 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 ccoonnsstt in
              declarations and prototypes.   Otherwise,  it  will
              just  be  a  nuisance;  this is why we did not make
              `--WWaallll' request these warnings.

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

       --WWeennuumm--ccllaasshh
              _(_C_+_+ _o_n_l_y_._)  Warn when converting between different
              enumeration types.

       --WWnnoo--ppaarreenntthheesseess
              Disable  warnings  that  parentheses  are suggested
              around an expression.

       --WWoovveerrllooaaddeedd--vviirrttuuaall
              _(_C_+_+ _o_n_l_y_._)  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 signa-
              ture that doesn't match any virtual functions  from
              the base class.



DDEEBBUUGGGGIINNGG OOPPTTIIOONNSS
       GNU  CC  has various special options that are used for de-
       bugging either your program or GCC:

       --gg     Produce debugging information in the operating sys-



GNU Tools                   27dec1991                          20





GCC(1)                      GNU Tools                      GCC(1)


              tem's native format (for DBX or SDB or DWARF).  GDB
              also can work with this debugging information.   On
              most  systems that use DBX format, `--gg' enables use
              of extra debugging information that  only  GDB  can
              use;  if you want to control for certain whether to
              generate this information, use `--ggggddbb' or  `--ggddbbxx'.

              Unlike most other C compilers, GNU CC allows you to
              use `--gg' with `--OO'.  The shortcuts taken  by  opti-
              mized  code may occasionally produce surprising re-
              sults: 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 val-
              ues were already at hand; some statements may  exe-
              cute  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 opti-
              mizer for programs that might have bugs.

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

       --ggggddbb  Produce debugging information  in  DBX  format  (if
              that is supported), including GDB extensions.

       --ggddbbxx  Produce  debugging  information  in  DBX format (if
              that is supported), without GDB extensions.

       --ggssddbb  Produce debugging information  in  SDB  format  (if
              that is supported).

       --ggddwwaarrff
              Produce  debugging  information in DWARF format (if
              that is supported).

       --gg_l_e_v_e_l
       --ggggddbb_l_e_v_e_l
       --ggddbbxx_l_e_v_e_l
       --ggssddbb_l_e_v_e_l

       --ggddwwaarrff_l_e_v_e_l
              Request debugging information and also use _l_e_v_e_l 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 informa-
              tion about local variables and no line numbers.



GNU Tools                   27dec1991                          21





GCC(1)                      GNU Tools                      GCC(1)


       --pp     Generate extra code to  write  profile  information
              suitable for the analysis program pprrooff.

       --ppgg    Generate  extra  code  to write profile information
              suitable for the analysis program ggpprrooff.

       --aa     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 ttccoovv.  Note,
              however, that the format of the data  is  not  what
              ttccoovv  expects.   Eventually GNU ggpprrooff should be ex-
              tended to process this data.

       --dd_l_e_t_t_e_r_s
               Says to make debugging dumps during compilation at
              times  specified  by _l_e_t_t_e_r_s.  This is used for de-
              bugging the compiler.  The file names for  most  of
              the  dumps  are  made  by  appending  a word to the
              source   file   name    (e.g.     `ffoooo..cc..rrttll'    or
              `ffoooo..cc..jjuummpp').

       --ddMM    Dump  all  macro definitions, at the end of prepro-
              cessing, and write no output.

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

       --ddDD    Dump  all  macro definitions, at the end of prepro-
              cessing, in addition to normal output.

       --ddyy    Dump debugging information during parsing, to stan-
              dard error.

       --ddrr    Dump after RTL generation, to `_f_i_l_e.rtl'.

       --ddxx    Just generate RTL for a function instead of compil-
              ing it.  Usually used with `rr'.

       --ddjj    Dump after first jump optimization, to `_f_i_l_e.jump'.

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

       --ddLL    Dump after loop optimization, to `_f_i_l_e.loop'.

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

       --ddff    Dump after flow analysis, to `_f_i_l_e.flow'.

       --ddcc    Dump    after    instruction    combination,     to
              `_f_i_l_e.combine'.




GNU Tools                   27dec1991                          22





GCC(1)                      GNU Tools                      GCC(1)


       --ddSS    Dump  after  the first instruction scheduling pass,
              to `_f_i_l_e.sched'.

       --ddll    Dump   after   local   register   allocation,    to
              `_f_i_l_e.lreg'.

       --ddgg    Dump   after   global   register   allocation,   to
              `_f_i_l_e.greg'.

       --ddRR    Dump after the second instruction scheduling  pass,
              to `_f_i_l_e.sched2'.

       --ddJJ    Dump after last jump optimization, to `_f_i_l_e.jump2'.

       --dddd    Dump   after   delayed   branch   scheduling,    to
              `_f_i_l_e.dbr'.

       --ddkk    Dump  after  conversion from registers to stack, to
              `_f_i_l_e.stack'.

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

       --ddpp    Annotate  the assembler output with a comment indi-
              cating which pattern and alternative was used.

       --ffpprreetteenndd--ffllooaatt
              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 ma-
              chine.

       --ssaavvee--tteemmppss
              Store the usual  ``temporary''  intermediate  files
              permanently;  place  them  in the current directory
              and name them based on the source file.  Thus, com-
              piling  `ffoooo..cc' with `--cc --ssaavvee--tteemmppss' would produce
              files `ffoooo..ccpppp' and `ffoooo..ss', as well as `ffoooo..oo'.



OOPPTTIIMMIIZZAATTIIOONN OOPPTTIIOONNSS
       These options control various sorts of optimizations:

       --OO     Optimize.  Optimizing  compilation  takes  somewhat
              more  time, and a lot more memory for a large func-
              tion.

              Without `--OO', the compiler's goal is to reduce  the
              cost  of  compilation and to make debugging produce
              the expected results.  Statements are  independent:



GNU Tools                   27dec1991                          23





GCC(1)                      GNU Tools                      GCC(1)


              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  re-
              sults you would expect from the source code.

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

              With `--OO', the compiler tries to reduce  code  size
              and execution time.

              When   you   specify   `--OO',  `--fftthhrreeaadd--jjuummppss'  and
              `--ffddeellaayyeedd--bbrraanncchh' are turned on.  On some machines
              other flags may also be turned on.

       --OO22    Highly  optimize.  As compared to `--OO', this option
              will increase both compilation time and the perfor-
              mance of the generated code.

              All  `--ff_f_l_a_g' options that control optimization are
              turned  on   when   you   specify   `--OO22',   except
              `--ffuunnrroollll--llooooppss' and `--ffuunnrroollll--aallll--llooooppss'.


       Options  of  the form `--ff_f_l_a_g' specify machine-independent
       flags.  Most flags have both positive and negative  forms;
       the  negative  form  of  `--ffffoooo' would be `--ffnnoo--ffoooo'.  The
       following list shows only one form--the one which  is  not
       the  default.  You can figure out the other form by either
       removing `nnoo--' or adding it.

       --ffffllooaatt--ssttoorree
              Do not store floating point variables in registers.
              This  prevents  undesirable excess precision on ma-
              chines such as the 68000 where the floating  regis-
              ters (of the 68881) keep more precision than a ddoouu--
              bbllee is supposed to have.

              For most programs, the excess precision  does  only
              good,  but a few programs rely on the precise defi-
              nition of IEEE floating point.  Use `--ffffllooaatt--ssttoorree'
              for such programs.

       --ffmmeemmooiizzee--llooookkuuppss

       --ffssaavvee--mmeemmooiizzeedd
              _(_C_+_+  _o_n_l_y_._)   These flags are used to get the com-
              piler to compile programs faster using  heuristics.
              They  are not on by default since they are only ef-
              fective about half the time.  The other half of the
              time  programs  compile  more slowly (and take more



GNU Tools                   27dec1991                          24





GCC(1)                      GNU Tools                      GCC(1)


              memory).

              The first time the compiler must build a call to  a
              member function (or reference to a data member), it
              must (1) determine  whether  the  class  implements
              member  functions  of  that name; (2) resolve which
              member function to call  (which  involves  figuring
              out  what  sorts  of  type  conversions  need to be
              made); and (3) check the visibility of  the  member
              function  to  the  caller.   All of this adds up to
              slower compilation.  Normally, the  second  time  a
              call  is made to that member function (or reference
              to that data member), it must go through  the  same
              lengthy  process  again.  This means that code like
              this

                cout << "This " << p << " has " << n << " legs.\n";

              makes six passes through all three steps.  By using
              a software cache, a ``hit''  significantly  reduces
              this  cost.   Unfortunately, using the cache intro-
              duces another layer of mechanisms which must be im-
              plemented,   and   so   incurs  its  own  overhead.
              `--ffmmeemmooiizzee--llooookkuuppss' enables the software cache.

              Because access privileges (visibility)  to  members
              and  member  functions may differ from one function
              context to the next, gg++++  may  need  to  flush  the
              cache. With the `--ffmmeemmooiizzee--llooookkuuppss' flag, the cache
              is flushed after every function that  is  compiled.
              The  `-fsave-memoized'  flag enables the same soft-
              ware cache, but when the compiler  determines  that
              the  context  of  the  last function compiled would
              yield the same access privileges of the next  func-
              tion  to  compile, it preserves the cache.  This is
              most helpful when defining  many  member  functions
              for  the  same  class: with the exception of member
              functions which are friends of other classes,  each
              member  function has exactly the same access privi-
              leges as every other, and the  cache  need  not  be
              flushed.

       --ffnnoo--ddeeffaauulltt--iinnlliinnee
              _(_C_+_+  _o_n_l_y_._)  If `--ffddeeffaauulltt--iinnlliinnee' is enabled then
              member functions defined  inside  class  scope  are
              compiled inline by default; i.e., you don't need to
              add `iinnlliinnee' in front of the member function  name.
              By  popular demand, this option is now the default.
              To keep GNU C++ from inlining  these  member  func-
              tions, specify `--ffnnoo--ddeeffaauulltt--iinnlliinnee'.

       --ffnnoo--ddeeffeerr--ppoopp
              Always  pop  the arguments to each function call as
              soon as that function returns.  For machines  which



GNU Tools                   27dec1991                          25





GCC(1)                      GNU Tools                      GCC(1)


              must  pop arguments after a function call, the com-
              piler normally lets  arguments  accumulate  on  the
              stack  for several function calls and pops them all
              at once.

       --ffffoorrccee--mmeemm
              Force memory operands to be copied  into  registers
              before  doing arithmetic on them.  This may produce
              better code by making all memory references  poten-
              tial common subexpressions.  When they are not com-
              mon subexpressions, instruction combination  should
              eliminate  the separate register-load.  I am inter-
              ested in hearing about the difference this makes.

       --ffffoorrccee--aaddddrr
              Force memory address constants to  be  copied  into
              registers  before  doing  arithmetic on them.  This
              may produce better code just as `--ffffoorrccee--mmeemm'  may.
              I  am  interested  in  hearing about the difference
              this makes.

       --ffoommiitt--ffrraammee--ppooiinntteerr
              Don't keep the frame  pointer  in  a  register  for
              functions that don't need one.  This avoids the in-
              structions to save, set up and restore frame point-
              ers;  it  also makes an extra register available in
              many functions.  _I_t _a_l_s_o _m_a_k_e_s _d_e_b_u_g_g_i_n_g _i_m_p_o_s_s_i_b_l_e
              _o_n most machines.

              On some machines, such as the Vax, this flag has no
              effect, because the standard calling sequence auto-
              matically  handles the frame pointer and nothing is
              saved by pretending it doesn't exist.  The machine-
              description  macro  FFRRAAMMEE__PPOOIINNTTEERR__RREEQQUUIIRREEDD controls
              whether a target machine supports this flag.

       --ffiinnlliinnee
              Pay attention the  iinnlliinnee  keyword.   Normally  the
              negation  of  this  option `--ffnnoo--iinnlliinnee' is used to
              keep the compiler from expanding any functions  in-
              line.   However,  the opposite effect may be desir-
              able when compiling with `--gg', since `--gg'  normally
              turns off all inline function expansion.

       --ffiinnlliinnee--ffuunnccttiioonnss
              Integrate  all simple functions into their callers.
              The compiler heuristically decides which  functions
              are  simple  enough to be worth integrating in this
              way.

              If all calls to a given  function  are  integrated,
              and  the function is declared ssttaattiicc, then GCC nor-
              mally does not output  the  function  as  assembler
              code in its own right.



GNU Tools                   27dec1991                          26





GCC(1)                      GNU Tools                      GCC(1)


       --ffccaalllleerr--ssaavveess
              Enable  values  to  be  allocated in registers that
              will be clobbered by function  calls,  by  emitting
              extra  instructions  to save and restore the regis-
              ters around such calls.  Such  allocation  is  done
              only  when  it  seems to result in better code than
              would otherwise be produced.

              This option is enabled by default  on  certain  ma-
              chines,  usually those which have no call-preserved
              registers to use instead.

       --ffkkeeeepp--iinnlliinnee--ffuunnccttiioonnss
              Even if all calls to a given function are integrat-
              ed,  and the function is declared ssttaattiicc, neverthe-
              less output a separate run-time callable version of
              the function.

       --ffnnoo--ffuunnccttiioonn--ccssee
              Do  not  put  function addresses in registers; make
              each instruction that  calls  a  constant  function
              contain the function's address explicitly.

              This  option  results  in  less efficient code, but
              some strange hacks that alter the assembler  output
              may be confused by the optimizations performed when
              this option is not used.


       The following options control specific optimizations.  The
       `--OO22'  option  turns  on all of these optimizations except
       `--ffuunnrroollll--llooooppss' and `--ffuunnrroollll--aallll--llooooppss'.

       The `--OO' option usually turns on the `--fftthhrreeaadd--jjuummppss'  and
       `--ffddeellaayyeedd--bbrraanncchh'  options,  but  specific  machines  may
       change the default optimizations.

       You can use the following flags in  the  rare  cases  when
       ``fine-tuning''  of  optimizations  to be performed is de-
       sired.

       --ffssttrreennggtthh--rreedduuccee
              Perform the optimizations of loop  strength  reduc-
              tion and elimination of iteration variables.

       --fftthhrreeaadd--jjuummppss
              Perform  optimizations  where  we check to see if a
              jump branches to a location where another  compari-
              son  subsumed  by  the  first is found.  If so, the
              first branch is redirected to either  the  destina-
              tion  of  the  second branch or a point immediately
              following it, depending on whether the condition is
              known to be true or false.




GNU Tools                   27dec1991                          27





GCC(1)                      GNU Tools                      GCC(1)


       --ffuunnrroollll--llooooppss
              Perform  the  optimization of loop unrolling.  This
              is only done for loops whose number  of  iterations
              can be determined at compile time or run time.

       --ffuunnrroollll--aallll--llooooppss
              Perform  the  optimization of loop unrolling.  This
              is done for all loops.  This usually makes programs
              run more slowly.

       --ffccssee--ffoollllooww--jjuummppss
              In  common  subexpression elimination, scan through
              jump instructions in certain cases.  This is not as
              powerful  as completely global CSE, but not as slow
              either.

       --ffrreerruunn--ccssee--aafftteerr--lloooopp
              Re-run common subexpression elimination after  loop
              optimizations has been performed.

       --ffeelliiddee--ccoonnssttrruuccttoorrss
              _(_C_+_+  _o_n_l_y_._)   Use this option to instruct the com-
              piler to be smarter about when it  can  elide  con-
              structors.   Without  this flag, GNU C++ and cfront
              both generate effectively the same code for:

              A foo ();
              A x (foo ());   // x initialized by `foo ()', no ctor called
              A y = foo ();   // call to `foo ()' heads to tempo-
              rary,
                              // y is initialized from the tempo-
              rary.

              Note  the difference!  With this flag, GNU C++ ini-
              tializes `yy' directly from the call to ffoooo (()) with-
              out going through a temporary.

       --ffeexxppeennssiivvee--ooppttiimmiizzaattiioonnss
              Perform  a  number  of minor optimizations that are
              relatively expensive.

       --ffddeellaayyeedd--bbrraanncchh
              If supported for the target machine, attempt to re-
              order  instructions  to  exploit  instruction slots
              available after delayed branch instructions.

       --ffsscchheedduullee--iinnssnnss
              If supported for the target machine, attempt to re-
              order  instructions  to  eliminate execution stalls
              due to required data being unavailable.  This helps
              machines  that  have  slow floating point or memory
              load instructions by allowing other instructions to
              be  issued until the result of the load or floating
              point instruction is required.



GNU Tools                   27dec1991                          28





GCC(1)                      GNU Tools                      GCC(1)


       --ffsscchheedduullee--iinnssnnss22
              Similar to `--ffsscchheedduullee--iinnssnnss', but requests an  ad-
              ditional  pass of instruction scheduling after reg-
              ister allocation has been done.  This is especially
              useful  on  machines with a relatively small number
              of registers and  where  memory  load  instructions
              take more than one cycle.



TTAARRGGEETT OOPPTTIIOONNSS
       By  default, GNU CC compiles code for the same type of ma-
       chine that you are using.  However, it  can  also  be  in-
       stalled  as  a  cross-compiler,  to compile for some other
       type of machine.  In fact,  several  different  configura-
       tions of GNU CC, for different target machines, can be in-
       stalled side by side.  Then you specify which one  to  use
       with the `--bb' option.

       In addition, older and newer versions of GNU CC can be in-
       stalled side by side.  One of them (probably  the  newest)
       will be the default, but you may sometimes wish to use an-
       other.

       --bb _m_a_c_h_i_n_e
               The argument _m_a_c_h_i_n_e specifies the target  machine
              for  compilation.  This is useful when you have in-
              stalled GNU CC as a cross-compiler.

              The value to use for _m_a_c_h_i_n_e is  the  same  as  was
              specified  as the machine type when configuring GNU
              CC as a cross-compiler.  For example, if  a  cross-
              compiler  was  configured  with  `ccoonnffiigguurree i386v',
              meaning to compile for an 80386 running  System  V,
              then you would specify `--bb ii338866vv' to run that cross
              compiler.

              When you do not specify `--bb', it normally means  to
              compile  for  the same type of machine that you are
              using.

       --VV _v_e_r_s_i_o_n
               The argument _v_e_r_s_i_o_n specifies  which  version  of
              GNU  CC  to run.  This is useful when multiple ver-
              sions are installed.  For example, _v_e_r_s_i_o_n might be
              `22..00', meaning to run GNU CC version 2.0.

              The  default version, when you do not specify `--VV',
              is controlled by the way GNU CC is installed.  Nor-
              mally, it will be a version that is recommended for
              general use.






GNU Tools                   27dec1991                          29





GCC(1)                      GNU Tools                      GCC(1)


MMAACCHHIINNEE DDEEPPEENNDDEENNTT OOPPTTIIOONNSS
       Each of the target machine types can have its own  special
       options, starting with `--mm', to choose among various hard-
       ware  models  or  configurations--for  example,  68010  vs
       68020,  floating  coprocessor or none.  A single installed
       version of the compiler can compile for any model or  con-
       figuration, according to the options specified.

       These are the `--mm' options defined for the 68000 series:

       --mm6688002200

       --mmcc6688002200
              Generate  output for a 68020 (rather than a 68000).
              This is the  default  if  you  use  the  unmodified
              sources.

       --mm6688000000

       --mmcc6688000000
              Generate  output for a 68000 (rather than a 68020).

       --mm6688888811
              Generate output containing 68881  instructions  for
              floating point.  This is the default if you use the
              unmodified sources.

       --mmffppaa  Generate output containing Sun FPA instructions for
              floating point.

       --mmssoofftt--ffllooaatt
              Generate output containing library calls for float-
              ing point.  _W_A_R_N_I_N_G_: the  requisite  libraries  are
              not part of GNU CC.  Normally the facilities of the
              machine's usual C compiler are used, but this can't
              be  done  directly  in cross-compilation.  You must
              make your own arrangements to provide suitable  li-
              brary functions for cross-compilation.

       --mmsshhoorrtt
              Consider  type  iinntt  to be 16 bits wide, like sshhoorrtt
              iinntt.

       --mmnnoobbiittffiieelldd
              Do not use the bit-field  instructions.   `--mm6688000000'
              implies `--mmnnoobbiittffiieelldd'.

       --mmbbiittffiieelldd
              Do  use  the bit-field instructions.  `--mm6688002200' im-
              plies `--mmbbiittffiieelldd'.  This is the default if you use
              the unmodified sources.

       --mmrrttdd  Use  a  different  function-calling  convention, in
              which functions that take a fixed number  of  argu-



GNU Tools                   27dec1991                          30





GCC(1)                      GNU Tools                      GCC(1)


              ments  return  with the rrttdd instruction, which pops
              their arguments while returning.   This  saves  one
              instruction in the caller since there is no need to
              pop the arguments there.

              This calling convention is  incompatible  with  the
              one  normally used on Unix, so you cannot use it if
              you need to call libraries compiled with  the  Unix
              compiler.

              Also,  you must provide function prototypes for all
              functions that take variable numbers  of  arguments
              (including  pprriinnttff);  otherwise incorrect code will
              be generated for calls to those functions.

              In addition, seriously incorrect code  will  result
              if  you  call  a  function with too many arguments.
              (Normally, extra arguments are harmlessly ignored.)

              The  rrttdd  instruction is supported by the 68010 and
              68020 processors, but not by the 68000.


       These `--mm' options are defined for the Vax:

       --mmuunniixx Do not output certain jump instructions (aaoobblleeqq and
              so  on)  that the Unix assembler for the Vax cannot
              handle across long ranges.

       --mmggnnuu  Do output those jump instructions, on  the  assump-
              tion that you will assemble with the GNU assembler.

       --mmgg    Output code for g-format floating point numbers in-
              stead of d-format.


       These `--mm' switches are supported on the Sparc:

       --mmffppuu  Generate  output containing floating point instruc-
              tions.  This is the default if you use the  unmodi-
              fied sources.

       --mmnnoo--eeppiilloogguuee
              Generate  separate  return  instructions for rreettuurrnn
              statements.  This has both advantages and disadvan-
              tages; I don't recall what they are.


       These `--mm' options are defined for the Convex:

       --mmcc11   Generate output for a C1.  This is the default when
              the compiler is configured for a C1.

       --mmcc22   Generate output for a C2.  This is the default when



GNU Tools                   27dec1991                          31





GCC(1)                      GNU Tools                      GCC(1)


              the compiler is configured for a C2.

       --mmaarrggccoouunntt
              Generate  code  which puts an argument count in the
              word  preceding  each  argument  list.   Some  non-
              portable  Convex  and  Vax programs need this word.
              (Debuggers don't, except for functions  with  vari-
              able-length  argument  lists;  this  info is in the
              symbol table.)

       --mmnnooaarrggccoouunntt
              Omit the argument count word.  This is the  default
              if you use the unmodified sources.


       These `--mm' options are defined for the AMD Am29000:

       --mmddww   Generate code that assumes the DW bit is set, i.e.,
              that byte and halfword operations are directly sup-
              ported by the hardware.  This is the default.

       --mmnnooddww Generate code that assumes the DW bit is not set.

       --mmbbww   Generate code that assumes the system supports byte
              and halfword write operations.   This  is  the  de-
              fault.

       --mmnnbbww  Generate  code  that  assumes  the systems does not
              support byte and halfword write  operations.   This
              implies `--mmnnooddww'.

       --mmssmmaallll
              Use  a  small  memory  model  that assumes that all
              function addresses are either within a  single  256
              KB  segment  or at an absolute address of less than
              256K.  This allows the ccaallll instruction to be  used
              instead of a ccoonnsstt, ccoonnsstthh, ccaallllii sequence.

       --mmllaarrggee
              Do  not  assume  that  the  ccaallll instruction can be
              used; this is the default.

       --mm2299005500
              Generate code for the Am29050.

       --mm2299000000
              Generate code for the Am29000.   This  is  the  de-
              fault.

       --mmkkeerrnneell--rreeggiisstteerrss
              Generate  references to registers ggrr6644--ggrr9955 instead
              of ggrr9966--ggrr112277.  This option can be used  when  com-
              piling  kernel code that wants a set of global reg-
              isters disjoint from that used by user-mode code.



GNU Tools                   27dec1991                          32





GCC(1)                      GNU Tools                      GCC(1)


              Note that when this option is used, register  names
              in  `--ff'  flags  must  use  the  normal, user-mode,
              names.

       --mmuusseerr--rreeggiisstteerrss
              Use the normal set of global registers, ggrr9966--ggrr112277.
              This is the default.

       --mmssttaacckk--cchheecckk
              Insert  a  call to ____mmsspp__cchheecckk after each stack ad-
              justment.  This is often used for kernel code.


       These `--mm' options are defined for Motorola 88K  architec-
       tures:

       --mmbbiigg--ppiicc
              Emit position-independent code, suitable for dynam-
              ic linking, even if branches need  large  displace-
              ments.    Equivalent   to  the  general-use  option
              `--ffPPIICC'.  The general-use option `--ffppiicc',  by  con-
              trast,  only  emits  valid 88k code if all branches
              involve small displacements.  GCC does not emit po-
              sition-independent code by default.

       --mmiiddeennttiiffyy--rreevviissiioonn
              Include  an iiddeenntt directive in the assembler output
              recording the source file name, compiler  name  and
              version, timestamp, and compilation flags used.

       --mmnnoo--uunnddeerrssccoorreess
              In  assembler  output,  emit  symbol  names without
              adding an underscore character at the beginning  of
              each  name.  The default is to use an underscore as
              prefix on each name.

       --mmnnoo--cchheecckk--zzeerroo--ddiivviissiioonn

       --mmcchheecckk--zzeerroo--ddiivviissiioonn
              Early models of the 88K architecture  had  problems
              with  division by zero; in particular, many of them
              didn't trap.  Use these options to avoid  including
              (or  to  include explicitly) additional code to de-
              tect division by zero and signal an exception.  All
              GCC     configurations     for    the    88K    use
              `--mmcchheecckk--zzeerroo--ddiivviissiioonn' by default.

       --mmooccss--ddeebbuugg--iinnffoo

       --mmnnoo--ooccss--ddeebbuugg--iinnffoo
              Include (or omit) additional debugging  information
              (about registers used in each stack frame) as spec-
              ified in the 88Open Object Compatibility  Standard,
              ``OCS''.   This  extra information is not needed by



GNU Tools                   27dec1991                          33





GCC(1)                      GNU Tools                      GCC(1)


              GDB.  The default for DG/UX,  SVr4,  and  Delta  88
              SVr3.2  is  to  include this information; other 88k
              configurations omit this information by default.

       --mmooccss--ffrraammee--ppoossiittiioonn

       --mmnnoo--ooccss--ffrraammee--ppoossiittiioonn
              Force (or do not require)  register  values  to  be
              stored  in  a  particular place in stack frames, as
              specified in OCS.  The DG/UX, Delta88  SVr3.2,  and
              BCS configurations use `--mmooccss--ffrraammee--ppoossiittiioonn'; oth-
              er   88k   configurations    have    the    default
              `--mmnnoo--ooccss--ffrraammee--ppoossiittiioonn'.

       --mmooppttiimmiizzee--aarrgg--aarreeaa

       --mmnnoo--ooppttiimmiizzee--aarrgg--aarreeaa
              Control  how  to  store function arguments in stack
              frames.  `--mmooppttiimmiizzee--aarrgg--aarreeaa' saves space, but may
              break      some      debuggers      (not      GDB).
              `--mmnnoo--ooppttiimmiizzee--aarrgg--aarreeaa' conforms better  to  stan-
              dards.   By default GCC does not optimize the argu-
              ment area.

       --mmsshhoorrtt--ddaattaa--_n_u_m
               _n_u_m Generate smaller  data  references  by  making
              them  relative  to rr00, which allows loading a value
              using a single instruction (rather than  the  usual
              two).   You  control  which data references are af-
              fected by specifying _n_u_m with this option.  For ex-
              ample,  if you specify `--mmsshhoorrtt--ddaattaa--551122', then the
              data references affected are those  involving  dis-
              placements     of     less    than    512    bytes.
              `--mmsshhoorrtt--ddaattaa--_n_u_m' is not effective for _n_u_m greater
              than 64K.

       --mmssvvrr44

       --mmssvvrr33 Turn  on  (`--mmssvvrr44') or off (`--mmssvvrr33') compiler ex-
              tensions related to  System  V  release  4  (SVr4).
              This controls the following:

          o   Which  variant  of  the  assembler  syntax  to emit
              (which   you   can   select   independently   using
              `--mmvveerrssiioonn0033..0000').

          o   `--mmssvvrr44' makes the C preprocessor recognize `##pprraagg--
              mmaa wweeaakk'

          o   `--mmssvvrr44' makes GCC issue additional declaration di-
              rectives used in SVr4.

       `--mmssvvrr33' is the default for all m88K configurations except
       the SVr4 configuration.



GNU Tools                   27dec1991                          34





GCC(1)                      GNU Tools                      GCC(1)


       --mmttrraapp--llaarrggee--sshhiifftt

       --mmhhaannddllee--llaarrggee--sshhiifftt
              Include code to detect bit-shifts of more  than  31
              bits;  respectively,  trap such shifts or emit code
              to handle them properly.  By default GCC  makes  no
              special provision for large bit shifts.

       --mmuussee--ddiivv--iinnssttrruuccttiioonn
              Very  early  models  of the 88K architecture didn't
              have a divide instruction, so GCC avoids  that  in-
              struction  by  default.  Use this option to specify
              that it's safe to use the divide instruction.

       --mmvveerrssiioonn--0033..0000
              Use alternative assembler syntax for the  assembler
              version corresponding to SVr4, but without enabling
              the other features triggered by `--ssvvrr44'.   This  is
              implied  by  `--ssvvrr44',  is  the default for the SVr4
              configuration of GCC, and is permitted by the DG/UX
              configuration  only  if  `--ssvvrr44' is also specified.
              The Delta 88 SVr3.2 configuration ignores this  op-
              tion.

       --mmwwaarrnn--ppaasssseedd--ssttrruuccttss
              Warn when a function passes a struct as an argument
              or  result.   Structure-passing  conventions   have
              changed during the evolution of the C language, and
              are often the source of portability  problems.   By
              default, GCC issues no such warning.

       These options are defined for the IBM RS6000:


       --mmffpp--iinn--ttoocc

       --mmnnoo--ffpp--iinn--ttoocc
              Control  whether or not floating-point constants go
              in the Table of Contents  (TOC),  a  table  of  all
              global variable and function addresses.  By default
              GCC puts floating-point constants there; if the TOC
              overflows, `--mmnnoo--ffpp--iinn--ttoocc' will reduce the size of
              the TOC, which may avoid the overflow.


       These `--mm' options are defined for the IBM RT PC:

       --mmiinn--lliinnee--mmuull
              Use an in-line code  sequence  for  integer  multi-
              plies.  This is the default.

       --mmccaallll--lliibb--mmuull
              Call llmmuull$$$$ for integer multiples.




GNU Tools                   27dec1991                          35





GCC(1)                      GNU Tools                      GCC(1)


       --mmffuullll--ffpp--bblloocckkss
              Generate  full-size floating point data blocks, in-
              cluding the minimum amount of scratch space  recom-
              mended by IBM.  This is the default.

       --mmmmiinniimmuumm--ffpp--bblloocckkss
              Do  not  include  extra  scratch  space in floating
              point data blocks.  This results in  smaller  code,
              but  slower  execution, since scratch space must be
              allocated dynamically.

       --mmffpp--aarrgg--iinn--ffpprreeggss
              Use a calling sequence incompatible  with  the  IBM
              calling  convention  in  which floating point argu-
              ments are passed in floating point registers.  Note
              that  vvaarraarrggss..hh  and  ssttddaarrggss..hh  will not work with
              floating point operands if this  option  is  speci-
              fied.

       --mmffpp--aarrgg--iinn--ggrreeggss
              Use  the  normal  calling  convention  for floating
              point arguments.  This is the default.

       --mmhhcc--ssttrruucctt--rreettuurrnn
              Return structures of more than one word in  memory,
              rather  than in a register.  This provides compati-
              bility with the MetaWare HighC (hc) compiler.   Use
              `--ffppcccc--ssttrruucctt--rreettuurrnn'  for  compatibility  with the
              Portable C Compiler (pcc).

       --mmnnoohhcc--ssttrruucctt--rreettuurrnn
              Return some structures of more  than  one  word  in
              registers,  when  convenient.  This is the default.
              For compatibility with the IBM-supplied  compilers,
              use       either      `--ffppcccc--ssttrruucctt--rreettuurrnn'      or
              `--mmhhcc--ssttrruucctt--rreettuurrnn'.

       These `--mm' options are defined for the MIPS family of com-
       puters:

       --mmccppuu==_c_p_u_-_t_y_p_e
              Assume  the  defaults for the machine type _c_p_u_-_t_y_p_e
              when scheduling insturctions.  The default _c_p_u_-_t_y_p_e
              is  ddeeffaauulltt,  which  picks the longest cycles times
              for any of the machines, in order that the code run
              at  reasonable  rates  on  all  MIPS  cpu's.  Other
              choices for _c_p_u_-_t_y_p_e are rr22000000, rr33000000,  rr44000000,  and
              rr66000000.   While  picking  a  specific  _c_p_u_-_t_y_p_e will
              schedule things appropriately for  that  particular
              chip,  the compiler will not generate any code that
              does not meet level 1 of the MIPS ISA  (instruction
              set  architecture)  without  the  --mmiippss22  or --mmiippss33
              switches being used.




GNU Tools                   27dec1991                          36





GCC(1)                      GNU Tools                      GCC(1)


       --mmiippss22 Issue instructions from level 2  of  the  MIPS  ISA
              (branch  likely,  square  root  instructions).  The
              --mmccppuu==rr44000000 or --mmccppuu==rr66000000 switch must be  used  in
              conjuction with --mmiippss22.

       --mmiippss33 Issue instructions from level 3 of the MIPS ISA (64
              bit instructions).  The --mmccppuu==rr44000000 switch must  be
              used in conjuction with --mmiippss22.

       --mmiinntt6644

       --mmlloonngg6644

       --mmlloonngglloonngg112288
              These options don't work at present.

       --mmmmiippss--aass
              Generate  code  for  the MIPS assembler, and invoke
              mmiippss--ttffiillee to add normal debug  information.   This
              is  the  default  for  all platforms except for the
              OSF/1 reference platform, using the OSF/rose object
              format.   If  the  any  of  the  --ggggddbb, --ggssttaabbss, or
              --ggssttaabbss++ switches are used, the mmiippss--ttffiillee  program
              will encapsulate the stabs within MIPS ECOFF.

       --mmggaass  Generate  code  for the GNU assembler.  This is the
              default on the OSF/1 reference platform, using  the
              OSF/rose object format.

       --mmrrnnaammeess

       --mmnnoo--rrnnaammeess
              The  --mmrrnnaammeess  switch says to output code using the
              MIPS software names for the registers,  instead  of
              the hardware names (ie, aa00 instead of $$44).  The GNU
              assembler does not support the --mmrrnnaammeess switch, and
              the  MIPS  assembler  will be instructed to run the
              MIPS C preprocessor  over  the  source  file.   The
              --mmnnoo--rrnnaammeess switch is default.

       --mmggppoopptt

       --mmnnoo--ggppoopptt
              The  --mmggppoopptt  switch  says to write all of the data
              declarations before the instructions  in  the  text
              section,  to all the MIPS assembler to generate one
              word memory references instead of using  two  words
              for  short global or static data items.  This is on
              by default if optimization is selected.

       --mmssttaattss

       --mmnnoo--ssttaattss
              For each non-inline function processed, the --mmssttaattss



GNU Tools                   27dec1991                          37





GCC(1)                      GNU Tools                      GCC(1)


              switch  causes the compiler to emit one line to the
              standard error file to print statistics  about  the
              program  (number  of  registers  saved, stack size,
              etc.).

       --mmmmeemmccppyy

       --mmnnoo--mmeemmccppyy
              The --mmmmeemmccppyy switch makes all block moves call  the
              appropriate  string  function (mmeemmccppyy or bbccooppyy) in-
              stead of possibly generating inline code.

       --mmmmiippss--ttffiillee

       --mmnnoo--mmiippss--ttffiillee
              The --mmnnoo--mmiippss--ttffiillee switch causes the compiler  not
              postprocess  the  object  file  with the mmiippss--ttffiillee
              program, after the MIPS assembler has generated  it
              to  add  debug  support.  If mmiippss--ttffiillee is not run,
              then no local variables will be  available  to  the
              debugger.   In  addition, ssttaaggee22 and ssttaaggee33 objects
              will have the temporary file names  passed  to  the
              assembler  embedded in the object file, which means
              the objects will not compare the same.

       --mmssoofftt--ffllooaatt
              Generate output containing library calls for float-
              ing  point.   _W_A_R_N_I_N_G_:  the requisite libraries are
              not part of GNU CC.  Normally the facilities of the
              machine's usual C compiler are used, but this can't
              be done directly in  cross-compilation.   You  must
              make  your own arrangements to provide suitable li-
              brary functions for cross-compilation.

       --mmhhaarrdd--ffllooaatt
              Generate output containing floating point  instruc-
              tions.   This is the default if you use the unmodi-
              fied sources.

       --mmffpp6644 Assume that the FFRR bit in the status  word  is  on,
              and  that there are 32 64-bit floating point regis-
              ters, instead of 32 32-bit  floating  point  regis-
              ters.   You  must  also specify the --mmccppuu==rr44000000 and
              --mmiippss33 switches.

       --mmffpp3322 Assume that there are 32 32-bit floating point reg-
              isters.  This is the default.

       --mmaabbiiccaallllss
              The  --mmaabbiiccaallllss  switch says to emit the ..aabbiiccaallllss,
              ..ccppllooaadd, and ..ccpprreessttoorree pseudo operations that some
              System V.4 ports use for position independent code.





GNU Tools                   27dec1991                          38





GCC(1)                      GNU Tools                      GCC(1)


       --mmhhaallff--ppiicc

       --mmnnoo--hhaallff--ppiicc
              The --mmhhaallff--ppiicc switch says to put pointers  to  ex-
              tern references into the data section and load them
              up, rather than put the references in the text sec-
              tion.  This option does not work at present.  --GG_n_u_m
              Put global and static items less than or  equal  to
              _n_u_m  bytes  into the small data or bss sections in-
              stead of the normal data or bss section.  This  al-
              lows  the  assembler to emit one word memory refer-
              ence instructions based on the global  pointer  (ggpp
              or  $$2288), instead of the normal two words used.  By
              default, _n_u_m is 8 when the MIPS assembler is  used,
              and  0  when  the GNU assembler is used.  The --GG_n_u_m
              switch is also passed to the assembler and  linker.
              All  modules should be compiled with the same --GG_n_u_m
              value.



CCOODDEE GGEENNEERRAATTIIOONN OOPPTTIIOONNSS
       These machine-independent options  control  the  interface
       conventions used in code generation.

       Most  of  them  begin  with `-f'.  These options have both
       positive and negative forms; the negative form of  `--ffffoooo'
       would  be `--ffnnoo--ffoooo'.  In the table below, only one of the
       forms is listed--the one which is not  the  default.   You
       can  figure out the other form by either removing `nnoo--' or
       adding it.

       ++ee_N    _(_C_+_+ _o_n_l_y_._)  control whether virtual function defi-
              nitions  in  classes  are used to generate code, or
              only to define interfaces for their callers.  These
              options  are provided for compatibility with cfront
              1.x usage; the recommended GNU C++ usage is to  use
              ##pprraaggmmaa  iinntteerrffaaccee  and ##pprraaggmmaa iimmpplleemmeennttaattiioonn, in-
              stead.

              With `++ee00', virtual function definitions in classes
              are  declared  extern; the declaration is used only
              as an interface specification, not to generate code
              for the virtual functions (in this compilation).

              With  `++ee11', gg++++ actually generates the code imple-
              menting virtual functions defined in the code,  and
              makes them publicly visible.

       --ffnnoonnnnuullll--oobbjjeeccttss
              _(_C_+_+  _o_n_l_y_._)   Normally, GNU C++ makes conservative
              assumptions about objects  reached  through  refer-
              ences.   For  example, the compiler must check that
              `aa' is not null in code like the following:



GNU Tools                   27dec1991                          39





GCC(1)                      GNU Tools                      GCC(1)


                  obj &a = g ();
                  a.f (2);
              Checking that references of this sort have non-null
              values  requires extra code, however, and it is un-
              necessary  for  many   programs.    You   can   use
              `--ffnnoonnnnuullll--oobbjjeeccttss' to omit the checks for null, if
              your program doesn't require the default  checking.

       --ffppcccc--ssttrruucctt--rreettuurrnn
              Use  the  same  convention for returning ssttrruucctt and
              uunniioonn values that is used by the usual  C  compiler
              on  your system.  This convention is less efficient
              for small structures, and on many machines it fails
              to be reentrant; but it has the advantage of allow-
              ing intercallability between GCC-compiled code  and
              PCC-compiled code.

       --ffsshhoorrtt--eennuummss
              Allocate  to  an eennuumm type only as many bytes as it
              needs for the declared range  of  possible  values.
              Specifically,  the  eennuumm type will be equivalent to
              the smallest integer type which has enough room.

       --ffsshhoorrtt--ddoouubbllee
              Use the same size for ddoouubbllee as for ffllooaatt .

       --ffsshhaarreedd--ddaattaa
              Requests that the data and non-ccoonnsstt  variables  of
              this compilation be shared data rather than private
              data.  The distinction makes sense only on  certain
              operating  systems, where shared data is shared be-
              tween processes running  the  same  program,  while
              private data exists in one copy per process.

       --ffnnoo--ccoommmmoonn
              Allocate even uninitialized global variables in the
              bss section of the object file, rather than  gener-
              ating  them  as common blocks.  This has the effect
              that if the same variable is declared (without  eexx--
              tteerrnn)  in  two different compilations, you will get
              an error when you link them.  The only reason  this
              might  be  useful is if you wish to verify that the
              program will work on  other  systems  which  always
              work this way.

       --ffvvoollaattiillee
              Consider  all memory references through pointers to
              be volatile.

       --ffppiicc  If supported for the target machines, generate  po-
              sition-independent  code,  suitable  for  use  in a
              shared library.

       --ffPPIICC  If supported for the target machine, emit position-



GNU Tools                   27dec1991                          40





GCC(1)                      GNU Tools                      GCC(1)


              independent  code,  suitable  for  dynamic linking,
              even if branches need large displacements.

       --ffffiixxeedd--_r_e_g
               Treat the register named _r_e_g as a fixed  register;
              generated  code  should  never  refer to it (except
              perhaps as a stack pointer,  frame  pointer  or  in
              some other fixed role).

              _r_e_g  must  be the name of a register.  The register
              names accepted are machine-specific and are defined
              in the RREEGGIISSTTEERR__NNAAMMEESS macro in the machine descrip-
              tion macro file.

              This flag does not have a negative form, because it
              specifies a three-way choice.

       --ffccaallll--uusseedd--_r_e_g
                Treat  the  register  named _r_e_g as an allocatable
              register that is clobbered by function  calls.   It
              may  be allocated for temporaries or variables that
              do not live across a call.  Functions compiled this
              way will not save and restore the register _r_e_g.

              Use  of  this  flag for a register that has a fixed
              pervasive role in the  machine's  execution  model,
              such  as  the  stack pointer or frame pointer, will
              produce disastrous results.

              This flag does not have a negative form, because it
              specifies a three-way choice.

       --ffccaallll--ssaavveedd--_r_e_g
                Treat  the  register  named _r_e_g as an allocatable
              register saved by functions.  It may  be  allocated
              even  for temporaries or variables that live across
              a call.  Functions compiled this way will save  and
              restore the register _r_e_g if they use it.

              Use  of  this  flag for a register that has a fixed
              pervasive role in the  machine's  execution  model,
              such  as  the  stack pointer or frame pointer, will
              produce disastrous results.

              A different sort of disaster will result  from  the
              use  of  this flag for a register in which function
              values may be returned.

              This flag does not have a negative form, because it
              specifies a three-way choice.

       --ffggnnuu--bbiinnuuttiillss





GNU Tools                   27dec1991                          41





GCC(1)                      GNU Tools                      GCC(1)


       --ffnnoo--ggnnuu--bbiinnuuttiillss
              _(_C_+_+  _o_n_l_y_._)   `--ffggnnuu--bbiinnuuttiillss  '  (the default for
              most, but not all, platforms) makes  GNU  C++  emit
              extra information for static initialization and fi-
              nalization.  This information has to be passed from
              the  assembler  to the GNU linker.  Some assemblers
              won't pass this information; you  must  either  use
              GNU aass or specify the option `--ffnnoo--ggnnuu--bbiinnuuttiillss'.

              With  `--ffnnoo--ggnnuu--bbiinnuuttiillss', you must use the program
              ccoolllleecctt (part of the GCC distribution) for linking.



PPRRAAGGMMAASS
       Two  `##pprraaggmmaa'  directives  are  supported for GNU C++, to
       permit using the same header file for two purposes:  as  a
       definition  of  interfaces to a given object class, and as
       the full definition of the contents of that object  class.

       ##pprraaggmmaa iinntteerrffaaccee
              _(_C_+_+  _o_n_l_y_._)   Use  this  directive in header files
              that define object classes, to save space  in  most
              of  the  object files that use those classes.  Nor-
              mally, local copies of certain information  (backup
              copies of inline member functions, debugging infor-
              mation, and the internal tables that implement vir-
              tual  functions)  must  be kept in each object file
              that includes class definitions.  You can use  this
              pragma  to  avoid  such duplication.  When a header
              file containing `##pprraaggmmaa iinntteerrffaaccee' is included  in
              a  compilation, this auxiliary information will not
              be generated (unless the main input source file it-
              self  uses `##pprraaggmmaa iimmpplleemmeennttaattiioonn').  Instead, the
              object files will contain references to be resolved
              at link time.

       ##pprraaggmmaa iimmpplleemmeennttaattiioonn

       ##pprraaggmmaa iimmpplleemmeennttaattiioonn ""_o_b_j_e_c_t_s..hh""
              _(_C_+_+  _o_n_l_y_._)  Use this pragma in a main input file,
              when you want  full  output  from  included  header
              files  to be generated (and made globally visible).
              The included  header  file,  in  turn,  should  use
              `##pprraaggmmaa  iinntteerrffaaccee'.  Backup copies of inline mem-
              ber functions, debugging information, and  the  in-
              ternal  tables  used to implement virtual functions
              are all generated in implementation files.

              If you use `##pprraaggmmaa iimmpplleemmeennttaattiioonn' with  no  argu-
              ment,  it  applies to an include file with the same
              basename as  your  source  file;  for  example,  in
              `aallllccllaassss..cccc',  `##pprraaggmmaa  iimmpplleemmeennttaattiioonn' by itself
              is   equivalent    to    `##pprraaggmmaa    iimmpplleemmeennttaattiioonn



GNU Tools                   27dec1991                          42





GCC(1)                      GNU Tools                      GCC(1)


              ""aallllccllaassss..hh""'.  Use the string argument if you want
              a single implementation file to include  code  from
              multiple header files.

              There  is no way to split up the contents of a sin-
              gle header file into multiple implementation files.

FFIILLEESS
       file.c             C source file
       file.h             C header (preprocessor) file
       file.i             preprocessed C source file
       file.C             C++ source file
       file.cc            C++ source file
       file.cxx           C++ source file
       file.m             Objective-C source file
       file.s             assembly language file
       file.o             object file
       a.out              link edited output
       _T_M_P_D_I_R/cc*         temporary files
       _L_I_B_D_I_R/cpp         preprocessor
       _L_I_B_D_I_R/cc1         compiler for C
       _L_I_B_D_I_R/cc1plus     compiler for C++
       _L_I_B_D_I_R/collect     linker  front  end  needed  on some ma-
       chines
       _L_I_B_D_I_R/libgcc.a    GCC subroutine library
       /lib/crt[01n].o    start-up routine
       _L_I_B_D_I_R/ccrt0       additional start-up routine for C++
       /lib/libc.a        standard C library, see _i_n_t_r_o(3)
       /usr/include       standard directory for ##iinncclluuddee files
       _L_I_B_D_I_R/include     standard  gcc  directory  for  ##iinncclluuddee
       files
       _L_I_B_D_I_R/g++-include additional g++ directory for ##iinncclluuddee

       _L_I_B_D_I_R is usually //uussrr//llooccaall//lliibb//_m_a_c_h_i_n_e/_v_e_r_s_i_o_n.
       _T_M_P_D_I_R comes from the environment variable TTMMPPDDIIRR (default
       //uussrr//ttmmpp if available, else //ttmmpp).

SSEEEE AALLSSOO
       cpp(1), as(1), ld(1), gdb(1), adb(1), dbx(1), sdb(1).
       `ggcccc', `ccpppp', `aass',``ld'',, and `ggddbb' entries in iinnffoo.
       _U_s_i_n_g _a_n_d _P_o_r_t_i_n_g _G_N_U _C_C _(_f_o_r  _v_e_r_s_i_o_n  _2_._0_),  Richard  M.
       Stallman,  November  1990;  _T_h_e _C _P_r_e_p_r_o_c_e_s_s_o_r, Richard M.
       Stallman, July 1990; _U_s_i_n_g _G_D_B_: _A _G_u_i_d_e _t_o _t_h_e _G_N_U _S_o_u_r_c_e_-
       _L_e_v_e_l  _D_e_b_u_g_g_e_r,  Richard M. Stallman and Roland H. Pesch,
       December 1991; _U_s_i_n_g _a_s_: _t_h_e _G_N_U _A_s_s_e_m_b_l_e_r,  Dean  Elsner,
       Jay  Fenlason  & friends, March 1991; _g_l_d_: _t_h_e _G_N_U _l_i_n_k_e_r,
       Steve Chamberlain and Roland Pesch, April 1991.


BBUUGGSS
       Report bugs to bbuugg--ggcccc@@pprreepp..aaii..mmiitt..eedduu.  Bugs tend actual-
       ly  to  be fixed if they can be isolated, so it is in your
       interest to report them in such a way  that  they  can  be
       easily reproduced.



GNU Tools                   27dec1991                          43





GCC(1)                      GNU Tools                      GCC(1)


CCOOPPYYIINNGG
       Copyright (c) 1991 Free Software Foundation, Inc.

       Permission  is  granted  to  make  and distribute verbatim
       copies of this manual provided the  copyright  notice  and
       this permission notice are preserved on all copies.

       Permission is granted to copy and distribute modified ver-
       sions of this manual under  the  conditions  for  verbatim
       copying,  provided  that the entire resulting derived work
       is distributed under the  terms  of  a  permission  notice
       identical to this one.

       Permission  is granted to copy and distribute translations
       of this manual into another language, under the above con-
       ditions for modified versions, except that this permission
       notice may be included in  translations  approved  by  the
       Free  Software  Foundation  instead of in the original En-
       glish.

AAUUTTHHOORRSS
       See the GNU CC Manual for the contributors to GNU CC.



































GNU Tools                   27dec1991                          44


