diff options
Diffstat (limited to 'gcc-1.40/gcc.info-2')
| -rw-r--r-- | gcc-1.40/gcc.info-2 | 913 |
1 files changed, 913 insertions, 0 deletions
diff --git a/gcc-1.40/gcc.info-2 b/gcc-1.40/gcc.info-2 new file mode 100644 index 0000000..6ca6971 --- /dev/null +++ b/gcc-1.40/gcc.info-2 @@ -0,0 +1,913 @@ +Info file gcc.info, produced by Makeinfo, -*- Text -*- from input +file gcc.texinfo. + + This file documents the use and the internals of the GNU compiler. + + Copyright (C) 1988, 1989, 1990 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 versions of +this manual under the conditions for verbatim copying, provided also +that the sections entitled "GNU General Public License" and "Protect +Your Freedom--Fight `Look And Feel'" are included exactly as in the +original, and 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 conditions for modified +versions, except that the sections entitled "GNU General Public +License" and "Protect Your Freedom--Fight `Look And Feel'" and this +permission notice may be included in translations approved by the +Free Software Foundation instead of in the original English. + + +File: gcc.info, Node: Options, Next: Installation, Prev: Boycott, Up: Top + +GNU CC Command Options +********************** + + The GNU C compiler uses a command syntax much like the Unix C +compiler. The `gcc' program accepts options and file names as +operands. Multiple single-letter options may *not* be grouped: `-dr' +is very different from `-d -r'. + + When you invoke GNU CC, it normally does preprocessing, +compilation, assembly and linking. File names which end in `.c' are +taken as C source to be preprocessed and compiled; file names ending +in `.i' are taken as preprocessor output to be compiled; compiler +output files plus any input files with names ending in `.s' are +assembled; then the resulting object files, plus any other input +files, are linked together to produce an executable. + + Command options allow you to stop this process at an intermediate +stage. For example, the `-c' 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 itself. +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. + +`-o FILE' + Place output in file FILE. This applies regardless to whatever + sort of output is being produced, whether it be an executable + file, an object file, an assembler file or preprocessed C code. + + If `-o' is not specified, the default is to put an executable + file in `a.out', the object file `SOURCE.c' in `SOURCE.o', an + assembler file in `SOURCE.s', and preprocessed C on standard + output. + +`-c' + Compile or assemble the source files, but do not link. Produce + object files with names made by replacing `.c' or `.s' with `.o' + at the end of the input file names. Do nothing at all for + object files specified as input. + +`-S' + Compile into assembler code but do not assemble. The assembler + output file name is made by replacing `.c' with `.s' at the end + of the input file name. Do nothing at all for assembler source + files or object files specified as input. + +`-E' + Run only the C preprocessor. Preprocess all the C source files + specified and output the results to standard output. + +`-v' + Compiler 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. + +`-pipe' + Use pipes rather than temporary files for communication between + the various stages of compilation. This fails to work on some + systems where the assembler is unable to read from a pipe; but + the GNU assembler has no trouble. + +`-BPREFIX' + Compiler driver program tries PREFIX as a prefix for each + program it tries to run. These programs are `cpp', `cc1', `as' + and `ld'. + + For each subprogram to be run, the compiler driver first tries + the `-B' prefix, if any. If that name is not found, or if `-B' + was not specified, the driver tries two standard prefixes, which + are `/usr/lib/gcc-' and `/usr/local/lib/gcc-'. If neither of + those results in a file name that is found, the unmodified + program name is searched for using the directories specified in + your `PATH' environment variable. + + The run-time support file `gnulib' is also searched for using + the `-B' prefix, if needed. If it is not found there, the two + standard prefixes above are tried, and that is all. The file is + left out of the link if it is not found by those means. Most of + the time, on most machines, you can do without it. + + You can get a similar result from the environment variable; + `GCC_EXEC_PREFIX' if it is defined, its value is used as a + prefix in the same way. If both the `-B' option and the + `GCC_EXEC_PREFIX' variable are present, the `-B' option is used + first and the environment variable value second. + +`-bPREFIX' + The argument PREFIX is used as a second prefix for the compiler + executables and libraries. This prefix is optional: the + compiler tries each file first with it, then without it. This + prefix follows the prefix specified with `-B' or the default + prefixes. + + Thus, `-bvax- -Bcc/' in the presence of environment variable + `GCC_EXEC_PREFIX' with definition `/u/foo/' causes GNU CC to try + the following file names for the preprocessor executable: + + cc/vax-cpp + cc/cpp + /u/foo/vax-cpp + /u/foo/cpp + /usr/local/lib/gcc-vax-cpp + /usr/local/lib/gcc-cpp + /usr/lib/gcc-vax-cpp + /usr/lib/gcc-cpp + + These options control the details of C compilation itself. + +`-ansi' + Support all ANSI standard C programs. + + This turns off certain features of GNU C that are incompatible + with ANSI C, such as the `asm', `inline' and `typeof' keywords, + and predefined macros such as `unix' and `vax' that identify the + type of system you are using. It also enables the undesirable + and rarely used ANSI trigraph feature. + + The alternate keywords `__asm__', `__inline__' and `__typeof__' + continue to work despite `-ansi'. 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 compilations done with + `-ansi'. Alternate predefined macros such as `__unix__' and + `__vax__' are also available, with or without `-ansi'. + + The `-ansi' option does not cause non-ANSI programs to be + rejected gratuitously. For that, `-pedantic' is required in + addition to `-ansi'. + + The macro `__STRICT_ANSI__' is predefined when the `-ansi' + 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. + +`-traditional' + Attempt to support some aspects of traditional C compilers. + Specifically: + + * All `extern' declarations take effect globally even if they + are written inside of a function definition. This includes + implicit declarations of functions. + + * The keywords `typeof', `inline', `signed', `const' and + `volatile' are not recognized. (You can still use the + alternative keywords such as `__typeof__', `__inline__', + and so on.) + + * Comparisons between pointers and integers are always allowed. + + * Integer types `unsigned short' and `unsigned char' promote + to `unsigned int'. + + * Out-of-range floating point literals are not an error. + + * String "constants" are not necessarily constant; they are + stored in writable space, and identical looking constants + are allocated separately. + + * All automatic variables not declared `register' are + preserved by `longjmp'. Ordinarily, GNU C follows ANSI C: + automatic variables not declared `volatile' 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 appear in such a context). The preprocessor + always considers a string constant to end at a newline. + + * The predefined macro `__STDC__' is not defined when you use + `-traditional', but `__GNUC__' is (since the GNU extensions + which `__GNUC__' indicates are not affected by + `-traditional'). If you need to write header files that + work differently depending on whether `-traditional' 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. + +`-O' + Optimize. Optimizing compilation takes somewhat more time, and + a lot more memory for a large function. + + Without `-O', the compiler's goal is to reduce the cost of + compilation and to make debugging produce the expected results. + Statements are independent: if you stop the program with a + breakpoint between statements, you can then assign a new value + to any variable or change the program counter to any other + statement in the function and get exactly the results you would + expect from the source code. + + Without `-O', only variables declared `register' are allocated + in registers. The resulting compiled code is a little worse + than produced by PCC without `-O'. + + With `-O', the compiler tries to reduce code size and execution + time. + + Some of the `-f' options described below turn specific kinds of + optimization on or off. + +`-g' + Produce debugging information in the operating 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 `-g' + with `-O'. The shortcuts taken by optimized code may + occasionally produce surprising results: some variables you + declared may not exist at all; flow of control may briefly move + where you did not expect it; some statements may not be executed + because they compute constant results or their values were + already at hand; some statements may execute in different places + because they were moved out of loops. Nevertheless it proves + possible to debug optimized output. This makes it reasonable to + use the optimizer for programs that might have bugs. + +`-gg' + Produce debugging information in the old GDB format. This is + obsolete. + +`-w' + Inhibit all warning messages. + +`-W' + Print extra warning messages for these events: + + * An automatic variable is used without first being + initialized. + + These warnings are possible only in optimizing compilation, + because they require data flow information that is computed + only when optimizing. If you don't specify `-O', you + simply won't get these warnings. + + These warnings occur only for variables that are candidates + for register allocation. Therefore, they do not occur for + a variable that is declared `volatile', or whose address is + taken, or whose size is other than 1, 2, 4 or 8 bytes. + Also, they do not occur for structures, unions or arrays, + even when they are in 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 `y' is always 1, 2 or 3, then `x' is always + initialized, but GNU CC doesn't know this. Here is another + common case: + + { + int save_y; + if (change_y) save_y = y, y = new_y; + ... + if (change_y) y = save_y; + } + + This has no bug because `save_y' is used only if it is set. + + Some spurious warnings can be avoided if you declare as + `volatile' all the functions you use that never return. + *Note Function Attributes::. + + * A nonvolatile automatic variable might be changed by a call + to `longjmp'. These warnings as well are possible only in + optimizing compilation. + + The compiler sees only the calls to `setjmp'. It cannot + know where `longjmp' will be called; in fact, a signal + handler could call it at any point in the code. As a + result, you may get a warning even when there is in fact no + problem because `longjmp' cannot in fact be called at the + place which would cause a problem. + + * A function can return either with or without a value. + (Falling off the end of the function body is considered + returning without a value.) For example, this function + would evoke such a warning: + + foo (a) + { + if (a > 0) + return a; + } + + Spurious warnings can occur because GNU CC does not realize + that certain functions (including `abort' and `longjmp') + will never return. + + * An expression-statement contains no side effects. + + In the future, other useful warnings may also be enabled by this + option. + +`-Wimplicit' + Warn whenever a function is implicitly declared. + +`-Wreturn-type' + Warn whenever a function is defined with a return-type that + defaults to `int'. Also warn about any `return' statement with + no return-value in a function whose return-type is not `void'. + +`-Wunused' + 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. + +`-Wswitch' + Warn whenever a `switch' statement has an index of enumeral type + and lacks a `case' for one or more of the named codes of that + enumeration. (The presence of a `default' label prevents this + warning.) `case' labels outside the enumeration range also + provoke warnings when this option is used. + +`-Wcomment' + Warn whenever a comment-start sequence `/*' appears in a comment. + +`-Wtrigraphs' + Warn if any trigraphs are encountered (assuming they are enabled). + +`-Wall' + All of the above `-W' options combined. These are all the + options which pertain to usage that we recommend avoiding and + that we believe is easy to avoid, even in conjunction with macros. + + The other `-W...' options below are not implied by `-Wall' + because certain kinds of useful macros are almost impossible to + write without causing those warnings. + +`-Wshadow' + Warn whenever a local variable shadows another local variable. + +`-Wid-clash-LEN' + Warn whenever two distinct identifiers match in the first LEN + characters. This may help you prepare a program that will + compile with certain obsolete, brain-damaged compilers. + +`-Wpointer-arith' + Warn about anything that depends on the "size of" a function + type or of `void'. GNU C assigns these types a size of 1, for + convenience in calculations with `void *' pointers and pointers + to functions. + +`-Wcast-qual' + Warn whenever a pointer is cast so as to remove a type qualifier + from the target type. For example, warn if a `const char *' is + cast to an ordinary `char *'. + +`-Wwrite-strings' + Give string constants the type `const char[LENGTH]' so that + copying the address of one into a non-`const' `char *' pointer + will get a warning. These warnings will help you find at + compile time code that can try to write into a string constant, + but only if you have been very careful about using `const' in + declarations and prototypes. Otherwise, it will just be a + nuisance; this is why we did not make `-Wall' request these + warnings. + +`-p' + Generate extra code to write profile information suitable for + the analysis program `prof'. + +`-pg' + Generate extra code to write profile information suitable for + the analysis program `gprof'. + +`-a' + Generate extra code to write profile information for basic + blocks, which will record the number of times each basic block + is executed. This data could be analyzed by a program like + `tcov'. Note, however, that the format of the data is not what + `tcov' expects. Eventually GNU `gprof' should be extended to + process this data. + +`-lLIBRARY' + Search a standard list of directories for a library named + LIBRARY, which is actually a file named `libLIBRARY.a'. The + linker 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 `-L'. + + Normally the files found this way are library files--archive + files whose members are object files. The linker handles an + archive file by scanning through it for members which define + symbols that have so far been referenced but not defined. 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 `-l' option and specifying a file name is that `-l' searches + several directories. + +`-LDIR' + Add directory DIR to the list of directories to be searched for + `-l'. + +`-nostdlib' + Don't use the standard system libraries and startup files when + linking. Only the files you specify will be passed to the linker. + +`-mMACHINESPEC' + Machine-dependent option specifying something about the type of + target machine. These options are defined by the macro + `TARGET_SWITCHES' in the machine description. The default for + the options is also defined by that macro, which enables you to + change the defaults. + + These are the `-m' options defined in the 68000 machine + description: + + `-m68020' + `-mc68020' + Generate output for a 68020 (rather than a 68000). This is + the default if you use the unmodified sources. + + `-m68000' + `-mc68000' + Generate output for a 68000 (rather than a 68020). + + `-m68881' + Generate output containing 68881 instructions for floating + point. This is the default if you use the unmodified + sources. + + `-mfpa' + Generate output containing Sun FPA instructions for + floating point. + + `-msoft-float' + Generate output containing library calls for floating point. + + `-mshort' + Consider type `int' to be 16 bits wide, like `short int'. + + `-mnobitfield' + Do not use the bit-field instructions. `-m68000' implies + `-mnobitfield'. + + `-mbitfield' + Do use the bit-field instructions. `-m68020' implies + `-mbitfield'. This is the default if you use the + unmodified sources. + + `-mrtd' + Use a different function-calling convention, in which + functions that take a fixed number of arguments return with + the `rtd' 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 `printf'); 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 `rtd' instruction is supported by the 68010 and 68020 + processors, but not by the 68000. + + These `-m' options are defined in the Vax machine description: + + `-munix' + Do not output certain jump instructions (`aobleq' and so + on) that the Unix assembler for the Vax cannot handle + across long ranges. + + `-mgnu' + Do output those jump instructions, on the assumption that + you will assemble with the GNU assembler. + + `-mg' + Output code for g-format floating point numbers instead of + d-format. + + These `-m' switches are supported on the Sparc: + + `-mfpu' + Generate output containing floating point instructions. + This is the default if you use the unmodified sources. + + `-mno-epilogue' + Generate separate return instructions for `return' + statements. This has both advantages and disadvantages; I + don't recall what they are. + + These `-m' options are defined in the Convex machine description: + + `-mc1' + Generate output for a C1. This is the default when the + compiler is configured for a C1. + + `-mc2' + Generate output for a C2. This is the default when the + compiler is configured for a C2. + + `-margcount' + 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.) + + `-mnoargcount' + Omit the argument count word. This is the default if you + use the unmodified sources. + +`-fFLAG' + Specify machine-independent flags. Most flags have both + positive and negative forms; the negative form of `-ffoo' would + be `-fno-foo'. 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 `no-' or adding it. + + `-fpcc-struct-return' + Use the same convention for returning `struct' and `union' + 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. + + `-ffloat-store' + 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 precision than a `double' 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 `-ffloat-store' for such programs. + + `-fno-asm' + Do not recognize `asm', `inline' or `typeof' as a keyword. + These words may then be used as identifiers. You can use + `__asm__', `__inline__' and `__typeof__' instead. + + `-fno-defer-pop' + 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. + + `-fstrength-reduce' + Perform the optimizations of loop strength reduction and + elimination of iteration variables. + + `-fcombine-regs' + Allow the combine pass to combine an instruction that + copies one register into another. This might or might not + produce better code when used in addition to `-O'. I am + interested in hearing about the difference this makes. + + `-fforce-mem' + 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 + subexpressions. When they are not common subexpressions, + instruction combination should eliminate the separate + register-load. I am interested in hearing about the + difference this makes. + + `-fforce-addr' + Force memory address constants to be copied into registers + before doing arithmetic on them. This may produce better + code just as `-fforce-mem' may. I am interested in hearing + about the difference this makes. + + `-fomit-frame-pointer' + 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 restore frame pointers; it also makes an extra + register available in many functions. *It also makes + debugging impossible.* + + On some machines, such as the Vax, this flag has no effect, + because the standard calling sequence automatically handles + the frame pointer and nothing is saved by pretending it + doesn't exist. The machine-description macro + `FRAME_POINTER_REQUIRED' controls whether a target machine + supports this flag. *Note Registers::. + + `-finline-functions' + 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 `static', then the function is + normally not output as assembler code in its own right. + + `-fcaller-saves' + Enable values to be allocated in registers 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. + + `-fkeep-inline-functions' + Even if all calls to a given function are integrated, and + the function is declared `static', nevertheless output a + separate run-time callable version of the function. + + `-fwritable-strings' + Store string constants in the writable data segment and + don't uniquize them. This is for compatibility with old + programs which assume they can write into string constants. + `-traditional' also has this effect. + + Writing into string constants is a very bad idea; + "constants" should be constant. + + `-fcond-mismatch' + Allow conditional expressions with mismatched types in the + second and third arguments. The value of such an + expression is void. + + `-fno-function-cse' + 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. + + `-fvolatile' + Consider all memory references through pointers to be + volatile. + + `-fshared-data' + Requests that the data and non-`const' 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. + + `-funsigned-char' + Let the type `char' be the unsigned, like `unsigned char'. + + Each kind of machine has a default for what `char' should + be. It is either like `unsigned char' by default or like + `signed char' by default. (Actually, at present, the + default is always signed.) + + The type `char' is always a distinct type from either + `signed char' or `unsigned char', even though its behavior + is always just like one of those two. + + Note that this is equivalent to `-fno-signed-char', which + is the negative form of `-fsigned-char'. + + `-fsigned-char' + Let the type `char' be signed, like `signed char'. + + Note that this is equivalent to `-fno-unsigned-char', which + is the negative form of `-funsigned-char'. + + `-fdelayed-branch' + If supported for the target machine, attempt to reorder + instructions to exploit instruction slots available after + delayed branch instructions. + + `-ffixed-REG' + Treat the register named REG 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). + + REG must be the name of a register. The register names + accepted are machine-specific and are defined in the + `REGISTER_NAMES' macro in the machine description macro file. + + This flag does not have a negative form, because it + specifies a three-way choice. + + `-fcall-used-REG' + Treat the register named REG 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 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. + + `-fcall-saved-REG' + Treat the register named REG 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 REG 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. + +`-dLETTERS' + Says to make debugging dumps at times specified by LETTERS. + Here are the possible letters: + + `r' + Dump after RTL generation. + + `j' + Dump after first jump optimization. + + `s' + Dump after CSE (including the jump optimization that + sometimes follows CSE). + + `L' + Dump after loop optimization. + + `f' + Dump after flow analysis. + + `c' + Dump after instruction combination. + + `l' + Dump after local register allocation. + + `g' + Dump after global register allocation. + + `d' + Dump after delayed branch scheduling. + + `J' + Dump after last jump optimization. + + `m' + Print statistics on memory usage, at the end of the run. + +`-pedantic' + Issue all the warnings demanded by strict ANSI standard C; + reject all programs that use forbidden extensions. + + Valid ANSI standard C programs should compile properly with or + without this option (though a rare few will require `-ansi'). + However, without this option, certain GNU extensions and + traditional C features are supported as well. With this option, + they are rejected. There is no reason to use this option; it + exists only to satisfy pedants. + + `-pedantic' does not cause warning messages for use of the + alternate keywords whose names begin and end with `__'. *Note + Alternate Keywords::. + +`-static' + On Suns running version 4, this prevents linking with the shared + libraries. (`-g' has the same effect.) + + 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. + +`-C' + Tell the preprocessor not to discard comments. Used with the + `-E' option. + +`-IDIR' + Search directory DIR for include files. + +`-I-' + Any directories specified with `-I' options before the `-I-' + option are searched only for the case of `#include "FILE"'; they + are not searched for `#include <FILE>'. + + If additional directories are specified with `-I' options after + the `-I-', these directories are searched for all `#include' + directives. (Ordinarily *all* `-I' directories are used this + way.) + + In addition, the `-I-' option inhibits the use of the current + directory (where the current input file came from) as the first + search directory for `#include "FILE"'. There is no way to + override this effect of `-I-'. With `-I.' you can specify + searching the directory which was current when the compiler was + invoked. That is not exactly the same as what the preprocessor + does by default, but it is often satisfactory. + + `-I-' does not inhibit the use of the standard system + directories for header files. Thus, `-I-' and `-nostdinc' are + independent. + +`-i FILE' + Process FILE as input, discarding the resulting output, before + processing the regular input file. Because the output generated + from FILE is discarded, the only effect of `-i FILE' is to make + the macros defined in FILE available for use in the main input. + +`-nostdinc' + Do not search the standard system directories for header files. + Only the directories you have specified with `-I' options (and + the current directory, if appropriate) are searched. + + Between `-nostdinc' and `-I-', you can eliminate all directories + from the search path except those you specify. + +`-M' + Tell the preprocessor to output a rule suitable for `make' + describing the dependencies of each object file. For each + source file, the preprocessor outputs one `make'-rule whose + target is the object file name for that source file and whose + dependencies are all the files `#include'd in it. This rule may + be a single line or may be continued with `\'-newline if it is + long. + + `-M' implies `-E'. + +`-MM' + Like `-M' but the output mentions only the user-header files + included with `#include "FILE"'. System header files included + with `#include <FILE>' are omitted. + + `-MM' implies `-E'. + +`-DMACRO' + Define macro MACRO with the string `1' as its definition. + +`-DMACRO=DEFN' + Define macro MACRO as DEFN. + +`-UMACRO' + Undefine macro MACRO. + +`-trigraphs' + Support ANSI C trigraphs. You don't want to know about this + brain-damage. The `-ansi' option also has this effect. + +
\ No newline at end of file |