Chip 2001 May/W2KPRK.iso/apps/posix/source/MAN/CC.PRT

Text File | 1999-11-17 | 35KB | 727 lines

cc - GNU project C Compiler [ options ] files is a version of the
GNU  C compiler.  It accepts a dialect of ANSI C with extensions;
this dialect is different from the dialect used in  4.3  BSD  and
earlier  distributions.  The flag causes the compiler to accept a
dialect of extended Classic C, much like the C of  these  earlier
distributions.   If  you are not already familiar with ANSI C and
its new features, you will want to build your software with  Most
older  C  compiler flags are supported by Three that are not are:
to generate symbol tables for the unsupported debugger; for  sin-
gle precision floating point in expressions, which is now the de-
fault;  and  for  alternate  compiler  passes.   The  differences
between  ANSI  C  and  Classic  C  dialects  are  too numerous to
describe here in detail.  The following quick summary is meant to
make  users  aware  of  potential subtle problems when converting
Classic C code to ANSI C.  The most obvious change  is  the  per-
vasive  use  of  Under the ANSI C dialect, the number and type of
arguments to C library functions are checked by the compiler when
standard header files are included; calls that fail to match will
yield errors.  A subtle consequence of adding prototype  declara-
tions  is that user code that inadvertently redefines a C library
function may break; for example it is no longer possible to write
an  function  that  takes  different parameters or returns a dif-
ferent value from the standard  when  including  standard  header
files.  Another issue with prototypes is that functions that take
different parameter types no longer have the same type;  function
pointers  now  differ by parameter types as well as return types.
Variable argument lists are handled differently; the old  package
is  obsolete,  replaced  by which unfortunately is not completely
compatible.  A subtle change in type promotion can be  confusing:
small  unsigned  types  are  now widened into signed types rather
than unsigned types.  A similar problem can occur with the opera-
tor, which now yields an unsigned type rather than a signed type.
One common problem is due to a change in  scoping:  external  de-
clarations  are  now  scoped to the block they occur in, so a de-
claration for (say) inside one block will no longer declare it in
all  subsequent  blocks.  The syntax for braces in structure ini-
tializations is now a bit stricter, and it is sometimes necessary
to  add braces to please the compiler.  Two very subtle and some-
times very annoying features apply to constant strings and to the
function.   Constant  strings  in the ANSI dialect are read-only;
attempts to alter them cause protection  violations.   This  ANSI
feature permits the compiler to coalesce identical strings in the
same source file, and saves  space  when  multiple  copies  of  a
binary  are running at the same time, since the read-only part of
a binary is sharable.  The most common difficulty with  read-only
strings  lies  with  the  use  of the function, which in the past
often altered a constant string argument.  It is now necessary to
copy  a  constant  string (for example, with before it may be al-
tered.  The function may now destroy any register stack  variable
in the function that made the corresponding call to the function;
to protect a local variable, the new ANSI modifier must be  used.
This  often  leads to confusing situations upon `return' from The
compiler has extended warning flags for  dealing  with  read-only
strings  and  but these are not very effective.  If your code has
problems with any of these ANSI features, you will probably  want
to  use Even with there are some differences between this dialect
of Classic C and the dialect supported  on  older  distributions.
There  are at least two differences that are a consequence of the
fact that uses an ANSI C style grammar for both  traditional  and
ANSI  modes.   The old C dialect permitted a typedef to replace a
simple type in the idiom ``unsigned this  treats  such  forms  as
syntax  errors.   The old C dialect also permitted formal parame-
ters to have the same names as typedef types; the current dialect
does  not.  Some questionable or illegal practices that were sup-
ported in the old C dialect are not supported by non-comment text
at  the end of a ``#include'' preprocessor control line is an er-
ror, not ignored; compound assignment operators must not  contain
white  space,  ``* ='' is not the same as ``*=''; the last member
declaration in a structure or union must be terminated by a semi-
colon;  it  is  not  possible to ``switch'' on function pointers;
more than one occurrence of ``#else'' at  the  same  level  in  a
preprocessor ``#if'' clause is an error, not ignored.  Some truly
ancient C practices are no longer supported.  The  idiom  of  de-
claring  an  anonymous structure and using its members to extract
fields from other structures or even non-structures  is  illegal.
Integers  are  not  automatically converted to pointers when they
are dereferenced.  The dialect  does  not  retain  the  so-called
``old-fashioned''  assignment operators (with the ``='' preceding
rather than following the operator) or initializations  (with  no
``=''  between  initializer  and  initializee).  This rest of man
page is an extract of the documentation of the and is limited  to
the meaning of the options.  If you want to be certain of the in-
formation below, check it in the manual "Using and Porting  GCC".
Refer  to  the  Info file or the DVI file which are made from the
Texinfo source file The uses a command syntax much like the  Unix
C  compiler.   The  program  accepts  options  and  file names as
operands.  Multiple single-letter options may be grouped: is very
different  from  When you invoke GNU CC, it normally does prepro-
cessing, compilation, assembly and linking.  File names which end
in  are  taken  as C source to be preprocessed and compiled; file
names ending in are taken as preprocessor output to be  compiled;
compiler  output  files plus any input files with names ending in
are assembled; then the resulting object files,  plus  any  other
input  files, are linked together to produce an executable.  Com-
mand options allow you to stop this process  at  an  intermediate
stage.  For example, the option says not to run the linker.  Then
the output consists of object  files  output  by  the  assembler.
Other  command  options are passed on to one stage of processing.
Some options control the preprocessor and others the compiler it-
self.   Yet other options control the assembler and linker; these
are not documented here, but you rarely need to use any of  them.
Here  are the options to control the overall compilation process,
including those that say whether to link,  whether  to  assemble,
and so on.  Place output in file This applies regardless to what-
ever sort of output is being produced, whether it be  an  execut-
able  file,  an  object file, an assembler file or preprocessed C
code.

If is not specified, the default is to put an executable file  in
the  object  file  in  an assembler file in and preprocessed C on
standard output.  Compile or assemble the source  files,  but  do
not  link.   Produce object files with names made by replacing or
with at the end of the input file names.  Do nothing at  all  for
object files specified as input.  Compile into assembler code but
do not assemble.  The assembler output file name is made  by  re-
placing  with  at  the end of the input file name.  Do nothing at
all for assembler source files or object files specified  as  in-
put.   Run  only the C preprocessor.  Preprocess all the C source
files specified and output the results to standard output.   Com-
piler  driver  program prints the commands it executes as it runs
the preprocessor, compiler proper, assembler and linker.  Some of
these are directed to print their own version numbers.  Use pipes
rather than temporary files for communication between the various
stages  of compilation.  This fails to work on some systems where
the assembler is unable to read from a pipe; but the  GNU  assem-
bler  has  no trouble.  Compiler driver program tries as a prefix
for each program it tries to run.  These programs are and

For each subprogram to be run, the compiler  driver  first  tries
the  prefix,  if  any.   If that name is not found, or if was not
specified, the driver tries a standard prefix, which currently is
If this does not result in a file name that is found, the unmodi-
fied program name is searched for using the directories specified
in your environment variable.

You can get a similar result from the environment variable if  it
is  defined,  its  value is used as a prefix in the same way.  If
both the option and the variable are present, the option is  used
first and the environment variable value second.  The argument is
used as a second prefix for  the  compiler  executables  and  li-
braries.   This  prefix is optional: the compiler tries each file
first with it, then without it.  This prefix follows  the  prefix
specified with or the default prefixes.

Thus, in the presence of  environment  variable  with  definition
causes  GNU CC to try the following file names for the preproces-
sor executable:

        cc/vax-cpp
        cc/cpp
        /u/foo/vax-cpp
        /u/foo/cpp
        /usr/libexec/vax-cpp
        /usr/libexec/cpp These options control the details  of  C
compilation itself.  Support all ANSI standard C programs.

This turns off certain features of GNU C  that  are  incompatible
with ANSI C, such as the and keywords, and predefined macros such
as and that identify the type of system you are using.   It  also
enables the undesirable and rarely used ANSI trigraph feature.

The alternate keywords and continue to work despite You would not
want  to  use them in an ANSI C program, of course, but it useful
to put them in header files that might be  included  in  compila-
tions  done with Alternate predefined macros such as and are also
available, with or without

The option does not cause non-ANSI programs to be  rejected  gra-
tuitously.  For that, is required in addition to

The macro is predefined when the option  is  used.   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.  Attempt to  support
some aspects of traditional C compilers.  Specifically:

* All declarations take effect globally even if they are  written
inside of a function definition.  This includes implicit declara-
tions of functions.

* The keywords and are not recognized.

* Comparisons between pointers and integers are always allowed.

* Integer types and promote to

* Out-of-range floating point literals are not an error.

* All automatic variables not declared are preserved by Ordinari-
ly, GNU C follows ANSI C: automatic variables not declared may be
clobbered.

* In the preprocessor, comments convert to nothing at all, rather
than to a space.  This allows traditional token concatenation.

* In the preprocessor,  macro  arguments  are  recognized  within
string  constants  in  a  macro  definition (and their values are
stringified, though without additional quote marks, when they ap-
pear  in  such  a  context).  The preprocessor always considers a
string constant to end at a newline.

* The predefined macro is not defined when you use but is  (since
the  GNU  extensions  which  indicates are not affected by If you
need to write header files that  work  differently  depending  on
whether is in use, by testing both of these predefined macros you
can distinguish four situations: GNU C, traditional GNU C,  other
ANSI C compilers, and other old C compilers.  Optimize.  Optimiz-
ing compilation takes somewhat more time, and a lot  more  memory
for a large function.

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

Without only variables declared are allocated in registers.   The
resulting  compiled  code  is a little worse than produced by PCC
without

With the compiler tries to reduce code size and execution time.

Some of the options described below turn specific kinds of optim-
ization  on or off.  Produce debugging information in the operat-
ing system's native format (for DBX or SDB).  GDB also  can  work
with this debugging information.

Unlike most other C compilers, GNU CC allows you to use with  The
shortcuts  taken  by  optimized  code  may  occasionally  produce
surprising results: some variables you declared may not exist  at
all;  flow  of  control may briefly move where you did not expect
it; some statements may not be executed because they compute con-
stant  results  or their values were already at hand; some state-
ments may execute in different places because they were moved out
of  loops.   Nevertheless  it  proves possible to debug optimized
output.  This makes it reasonable to use the optimizer  for  pro-
grams that might have bugs.  Inhibit all warning messages.  Print
extra warning messages for these events:

* An automatic variable is used without first being initialized.

These warnings are possible only in optimizing  compilation,  be-
cause  they  require  data flow information that is computed only
when optimizing.  If you don't specify 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 or whose address is taken, or whose size is oth-
er  than  1, 2, 4 or 8 bytes.  Also, they do not occur for struc-
tures, unions or arrays, even when they are in registers.

Note that there may be no warning about a variable that  is  used
only  to  compute a value that itself is never used, because such
computations may be deleted by  data  flow  analysis  before  the
warnings are 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 is always 1, 2 or 3, then 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 is used only if it is set.

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

* A nonvolatile automatic variable might be changed by a call  to
These  warnings  as well are possible only in optimizing compila-
tion.

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

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

        foo (a)
        {
          if (a > 0)
            return a;
        }

Spurious warnings can occur because GNU CC does not realize  that
certain functions (including and will never return.

* An expression-statement contains no side effects.

In the future, other useful warnings may also be enabled by  this
option.   Warn  whenever a function is implicitly declared.  Warn
whenever a function is defined with a return-type  that  defaults
to  Also warn about any statement with no return-value in a func-
tion whose return-type is not Warn whenever a local  variable  is
unused aside from its declaration, and whenever a function is de-
clared static but never defined.  Warn whenever a  statement  has
an  index  of  enumeral  type  and lacks a for one or more of the
named codes of  that  enumeration.   (The  presence  of  a  label
prevents this warning.) labels outside the enumeration range also
provoke warnings when this  option  is  used.   Warn  whenever  a
comment-start  sequence  appears  in a comment.  Warn if any tri-
graphs are encountered (assuming they are enabled).  All  of  the
above  options combined.  These are all the options which pertain
to usage that we do not recommend and that we believe  is  always
easy to avoid, even in conjunction with macros.

The other options below are not implied by because certain  kinds
of  useful  macros are almost impossible to write without causing
those warnings.  Warn whenever a local variable  shadows  another
local  variable.  Warn whenever two distinct identifiers match in
the first characters.  This may help you prepare a  program  that
will  compile  with  certain  obsolete,  brain-damaged compilers.
Warn about anything that depends on the size of a  function  type
or  of  GNU C assigns these types a size of 1, for convenience in
calculations with pointers and pointers to functions.  Warn when-
ever  a pointer is cast so as to remove a type qualifier from the
target type.  For example, warn if a is cast to an ordinary  Give
string constants the type so that copying the address of one into
a pointer will get a warning.  These warnings will help you  find
at  compile  time  code  that can try to write into a string con-
stant, but only if you have been very careful about using in  de-
clarations  and  prototypes.   Otherwise,  it will just be a nui-
sance; this is why we did not make request these warnings.   Gen-
erate  extra  code  to write profile information suitable for the
analysis program Generate extra code to write profile information
suitable  for  the  analysis program Generate extra code to write
profile information for basic blocks, suitable for  the  analysis
program  Eventually  GNU should be extended to process this data.
Search a standard list of directories for a library  named  which
is  actually  a file named The linker uses this file as if it had
been specified precisely by name.

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

Normally the files found  this  way  are  library  files--archive
files  whose members are object files.  The linker handles an ar-
chive file by scanning through it for members which  define  sym-
bols  that  have  so far been referenced but not defined.  But if
the file that is found is an ordinary object file, it  is  linked
in  the  usual fashion.  The only difference between using an op-
tion and specifying a file name is that searches  several  direc-
tories.   Add directory to the list of directories to be searched
for Don't use the standard system  libraries  and  startup  files
when linking.  Only the files you specify (plus will be passed to
the linker.  Machine-dependent option specifying something  about
the  type  of  target  machine.  These options are defined by the
macro in the machine description.  The default for the options is
also  defined  by that macro, which enables you to change the de-
faults.

These are the options defined in the 68000 machine description:

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

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

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

     Generate output containing Sun FPA instructions for floating
     point.

     Generate output containing library calls for floating point.

     Consider type to be 16 bits wide, like

     Do not use the bit-field instructions.  implies

     Do use the bit-field instructions.  implies This is the  de-
     fault if you use the unmodified sources.

     Use a different function-calling convention, in which  func-
     tions  that take a fixed number of arguments return with the
     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 normal-
     ly  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 otherwise
     incorrect code will be generated for calls  to  those  func-
     tions.

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

     The instruction is supported by the 68010 and 68020  proces-
     sors, but not by the 68000.

These options are defined in the Vax machine description:

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

     Do output those jump instructions, on  the  assumption  that
     you will assemble with the GNU assembler.

     Output code for g-format floating point numbers  instead  of
     d-format.

These switches are supported on the Sparc:

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

     Generate output containing library calls for floating point.

     Generate separate return instructions for statements.   This
     has  both  advantages and disadvantages; I don't recall what
     they are.

These options are defined in the Convex machine description:

     Generate output for a C1.  This is the default when the com-
     piler is configured for a C1.

     Generate output for a C2.  This is the default when the com-
     piler is configured for a C2.

     Generate code which puts  an  argument  count  in  the  word
     preceding  each  argument list.  Some nonportable Convex and
     Vax programs need this word.  (Debuggers don't; this info is
     in the symbol table.)

     Omit the argument count word.  This is the  default  if  you
     use the unmodified sources.
Specify machine-independent flags.  Most flags have both positive
and  negative  forms;  the negative form of would be 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 or
adding it.  Use the same convention for returning and 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 allowing
intercallability between GCC-compiled code and PCC-compiled code.
Do   not  store  floating-point  variables  in  registers.   This
prevents undesirable excess precision on  machines  such  as  the
68000  where the floating registers (of the 68881) keep more pre-
cision than a is supposed to have.

For most programs, the excess precision does only good, but a few
programs  rely  on the precise definition of IEEE floating point.
Use for such programs.  Do not recognize or as a keyword.   These
words  may then be used as identifiers.  You can use and instead.
Always pop the arguments to each function call as  soon  as  that
function  returns.   Normally the compiler (when optimizing) lets
arguments accumulate on the stack for several function calls  and
pops  them  all  at  once.   Perform  the  optimizations  of loop
strength reduction and elimination of iteration variables.  Allow
the combine pass to combine an instruction that copies one regis-
ter into another.  This might or might not  produce  better  code
when  used  in  addition  to I am interested in hearing about the
difference this makes.  Force memory operands to be  copied  into
registers  before  doing  arithmetic  on  them.  This may produce
better code by making all memory references potential common  su-
bexpressions.   When they are not common subexpressions, instruc-
tion combination should eliminate the separate register-load.   I
am  interested in hearing about the difference this makes.  Force
memory address constants to be copied into registers before doing
arithmetic on them.  This may produce better code just as may.  I
am interested in hearing about the difference this makes.   Don't
keep  the  frame  pointer  in a register for functions that don't
need one.  This avoids the instructions to save, set up  and  re-
store  frame  pointers; it also makes an extra register available
in many functions.

On some machines, such as the Vax, this flag has no  effect,  be-
cause  the  standard  calling  sequence automatically handles the
frame pointer and nothing is saved by pretending it  doesn't  ex-
ist.   The  machine-description  macro  controls whether a target
machine supports this flag.  Integrate all simple functions  into
their  callers.   The  compiler heuristically decides which func-
tions are simple enough to be worth integrating in this way.

If all calls to a given function are integrated, and the function
is declared then the function is normally not output as assembler
code in its own right.  Enable values to be allocated  in  regis-
ters  that will be clobbered by function calls, by emitting extra
instructions to save and restore the registers 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  machines,  usually
those  which  have  no  call-preserved  registers to use instead.
Even if all calls to a given function  are  integrated,  and  the
function  is  declared  nevertheless  output  a separate run-time
callable version of the function.  Store string constants in  the
writable  data segment and don't uniquize them.  This is for com-
patibility with old programs which assume  they  can  write  into
string  constants.   Writing  into string constants is a very bad
idea; constants should be constant.   Allow  conditional  expres-
sions  with  mismatched  types in the second and third arguments.
The value of such an expression is void.  Do not put function ad-
dresses 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 op-
timizations performed when this option is not used.  Consider all
memory references through pointers to be volatile.  Requests that
the data and 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 between  processes
running  the  same program, while private data exists in one copy
per process.  Let the type be the unsigned, like

Each kind of machine has a default for what should be.  It is ei-
ther  like by default or like by default.  (Actually, at present,
the default is always signed.)

The type is always a distinct type from either or even though its
behavior is always just like one of those two.

Note that this is equivalent to which is the negative form of Let
the type be signed, like

Note that this is equivalent to which is the negative form of  If
supported for the target machine, attempt to reorder instructions
to exploit instruction slots available after delayed  branch  in-
structions.   Treat  the register named as a fixed register; gen-
erated code should never refer to it (except perhaps as  a  stack
pointer, frame pointer or in some other fixed role).

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

This flag does not have a negative form, because it  specifies  a
three-way choice.  Treat the register named as an allocatable re-
gister 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  regis-
ter REG.

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.  Treat the register named as an allocatable re-
gister saved by functions.  It may be  allocated  even  for  tem-
poraries  or  variables  that live across a call.  Functions com-
piled this way will save and restore the register 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.   Says to make debugging dumps at times speci-
fied by Here are the possible letters:

     Dump after RTL generation.
     Dump after first jump optimization.
     Dump after last jump optimization.
     Dump after CSE (including the jump optimization  that  some-
     times follows CSE).
     Dump after loop optimization.
     Dump after flow analysis.
     Dump after instruction combination.
     Dump after local register allocation.
     Dump after global register allocation.
     Dump after delayed branch scheduling.
     Print statistics on memory usage, at the end of the run.
Issue all the warnings demanded by strict ANSI standard C; reject
all programs that use forbidden extensions.

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

does not cause warning messages for use of the alternate keywords
whose  names  begin  and end with On Suns running version 4, this
prevents linking with the shared libraries.   has  the  same  ef-
fect.)  These options control the C preprocessor, which is run on
each C source file before actual compilation.  If you use the  `-
E' option, nothing is done except C preprocessing.  Some of these
options make sense only together with `-E' because  they  request
preprocessor  output that is not suitable for actual compilation.
Tell the preprocessor not to discard comments.  Used with the op-
tion.   Search  directory  for  include  files.   Any directories
specified with options before the option are  searched  only  for
the case of "file"; they are not searched for

If additional directories are specified with  options  after  the
these  directories  are searched for all directives.  (Ordinarily
directories are used this way.)

In addition, the option inhibits the use of the current directory
as the first search directory for "file".  Therefore, the current
directory is searched only if it  is  requested  explicitly  with
Specifying  both and allows you to control precisely which direc-
tories are searched before the current one and which are searched
after.   Do not search the standard system directories for header
files.  Only the directories you have specified with options (and
the current directory, if appropriate) are searched.

Between and you can eliminate all  directories  from  the  search
path except those you specify.  Tell the preprocessor to output a
rule suitable for describing  the  dependencies  of  each  source
file.   For  each source file, the preprocessor outputs one whose
target is the object file name for that  source  file  and  whose
dependencies  are all the files in it.  This rule may be a single
line or may be continued with if it is long.

implies Like but the output mentions only the  user-header  files
included  with "file".  System header files included with are om-
itted.

implies Define macro with the empty  string  as  its  definition.
Define  macro  as  Undefine  macro Support ANSI C trigraphs.  You
don't want to know about this brain-damage.  The option also  has
this effect.  file.c               C source file
file.s               assembly language file
file.o               object file
a.out                link edited output
/tmp/cc*             temporary files
/usr/libexec/cpp     preprocessor
/usr/libexec/cc1     compiler
/usr/lib/libgnulib.a library needed by GCC on some machines
/usr/lib/crt0.o      start-up routine
/usr/lib/libc.a      standard C library, see
/usr/include         standard directory for files  as(1),  ld(1),
adb(1), dbx(1), gdb(1).  Bugs should be reported to Bugs tend ac-
tually to be fixed if they can be isolated, so it is in your  in-
terest  to  report  them  in  such  a way that they can be easily
reproduced.  Copyright (c) 1988 Free  Software  Foundation,  Inc.
Permission  is  granted to make and distribute verbatim copies of
this manual provided the copyright notice and this permission no-
tice  are preserved on all copies.  Permission is granted to copy
and distribute modified versions of this manual under the  condi-
tions  for  verbatim  copying, provided that the entire resulting
derived work is distributed under the terms of a  permission  no-
tice  identical  to  this one.  Permission is granted to copy and
distribute translations of this  manual  into  another  language,
under  the  above  conditions  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.  See the GNU CC Manual for the contributors to GNU CC.