![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to gcc.info-3 CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / GNUtools / cc|
Return to gcc.info-3 CVS log | Up to [Apple XNU] / GNUtools / cc |
1.1 root 1: This is Info file gcc.info, produced by Makeinfo-1.54 from the input
2: file gcc.texi.
3:
4: This file documents the use and the internals of the GNU compiler.
5:
6: Published by the Free Software Foundation 675 Massachusetts Avenue
7: Cambridge, MA 02139 USA
8:
9: Copyright (C) 1988, 1989, 1992, 1993 Free Software Foundation, Inc.
10:
11: Permission is granted to make and distribute verbatim copies of this
12: manual provided the copyright notice and this permission notice are
13: preserved on all copies.
14:
15: Permission is granted to copy and distribute modified versions of
16: this manual under the conditions for verbatim copying, provided also
17: that the sections entitled "GNU General Public License" and "Protect
18: Your Freedom--Fight `Look And Feel'" are included exactly as in the
19: original, and provided that the entire resulting derived work is
20: distributed under the terms of a permission notice identical to this
21: one.
22:
23: Permission is granted to copy and distribute translations of this
24: manual into another language, under the above conditions for modified
25: versions, except that the sections entitled "GNU General Public
26: License" and "Protect Your Freedom--Fight `Look And Feel'", and this
27: permission notice, may be included in translations approved by the Free
28: Software Foundation instead of in the original English.
29:
30:
31: File: gcc.info, Node: Optimize Options, Next: Preprocessor Options, Prev: Debugging Options, Up: Invoking GCC
32:
33: Options That Control Optimization
34: =================================
35:
36: These options control various sorts of optimizations:
37:
38: `-O'
39: `-O1'
40: Optimize. Optimizing compilation takes somewhat more time, and a
41: lot more memory for a large function.
42:
43: Without `-O', the compiler's goal is to reduce the cost of
44: compilation and to make debugging produce the expected results.
45: Statements are independent: if you stop the program with a
46: breakpoint between statements, you can then assign a new value to
47: any variable or change the program counter to any other statement
48: in the function and get exactly the results you would expect from
49: the source code.
50:
51: Without `-O', only variables declared `register' are allocated in
52: registers. The resulting compiled code is a little worse than
53: produced by PCC without `-O'.
54:
55: With `-O', the compiler tries to reduce code size and execution
56: time.
57:
58: When `-O' is specified, the two options `-fthread-jumps' and
59: `-fdelayed-branch' are turned on. On some machines other flags may
60: also be turned on.
61:
62: `-O2'
63: Optimize even more. Nearly all supported optimizations that do not
64: involve a space-speed tradeoff are performed. As compared to `-O',
65: this option increases both compilation time and the performance of
66: the generated code.
67:
68: `-O2' turns on all optional optimizations except for loop unrolling
69: and frame pointer elimination.
70:
71: `-O0'
72: Do not optimize.
73:
74: If you use multiple `-O' options, with or without level numbers,
75: the last such option is the one that is effective.
76:
77: Options of the form `-fFLAG' specify machine-independent flags.
78: Most flags have both positive and negative forms; the negative form of
79: `-ffoo' would be `-fno-foo'. In the table below, only one of the forms
80: is listed--the one which is not the default. You can figure out the
81: other form by either removing `no-' or adding it.
82:
83: `-ffloat-store'
84: Do not store floating point variables in registers, and inhibit
85: other options that might change whether a floating point value is
86: taken from a register or memory.
87:
88: This option prevents undesirable excess precision on machines such
89: as the 68000 where the floating registers (of the 68881) keep more
90: precision than a `double' is supposed to have. For most programs,
91: the excess precision does only good, but a few programs rely on the
92: precise definition of IEEE floating point. Use `-ffloat-store' for
93: such programs.
94:
95: `-fno-default-inline'
96: Do not make member functions inline by default merely because they
97: are defined inside the class scope (C++ only). Otherwise, when
98: you specify `-O', member functions defined inside class scope are
99: compiled inline by default; i.e., you don't need to add `inline'
100: in front of the member function name.
101:
102: `-fno-defer-pop'
103: Always pop the arguments to each function call as soon as that
104: function returns. For machines which must pop arguments after a
105: function call, the compiler normally lets arguments accumulate on
106: the stack for several function calls and pops them all at once.
107:
108: `-fforce-mem'
109: Force memory operands to be copied into registers before doing
110: arithmetic on them. This may produce better code by making all
111: memory references potential common subexpressions. When they are
112: not common subexpressions, instruction combination should
113: eliminate the separate register-load. I am interested in hearing
114: about the difference this makes.
115:
116: `-fforce-addr'
117: Force memory address constants to be copied into registers before
118: doing arithmetic on them. This may produce better code just as
119: `-fforce-mem' may. I am interested in hearing about the
120: difference this makes.
121:
122: `-fomit-frame-pointer'
123: Don't keep the frame pointer in a register for functions that
124: don't need one. This avoids the instructions to save, set up and
125: restore frame pointers; it also makes an extra register available
126: in many functions. *It also makes debugging impossible on some
127: machines.*
128:
129: On some machines, such as the Vax, this flag has no effect, because
130: the standard calling sequence automatically handles the frame
131: pointer and nothing is saved by pretending it doesn't exist. The
132: machine-description macro `FRAME_POINTER_REQUIRED' controls
133: whether a target machine supports this flag. *Note Registers::.
134:
135: `-fno-inline'
136: Don't pay attention to the `inline' keyword. Normally this option
137: is used to keep the compiler from expanding any functions inline.
138: Note that if you are not optimizing, no functions can be expanded
139: inline.
140:
141: `-finline-functions'
142: Integrate all simple functions into their callers. The compiler
143: heuristically decides which functions are simple enough to be worth
144: integrating in this way.
145:
146: If all calls to a given function are integrated, and the function
147: is declared `static', then the function is normally not output as
148: assembler code in its own right.
149:
150: `-fkeep-inline-functions'
151: Even if all calls to a given function are integrated, and the
152: function is declared `static', nevertheless output a separate
153: run-time callable version of the function.
154:
155: `-fno-function-cse'
156: Do not put function addresses in registers; make each instruction
157: that calls a constant function contain the function's address
158: explicitly.
159:
160: This option results in less efficient code, but some strange hacks
161: that alter the assembler output may be confused by the
162: optimizations performed when this option is not used.
163:
164: `-ffast-math'
165: This option allows GCC to violate some ANSI or IEEE rules and/or
166: specifications in the interest of optimizing code for speed. For
167: example, it allows the compiler to assume arguments to the `sqrt'
168: function are non-negative numbers.
169:
170: This option should never be turned on by any `-O' option since it
171: can result in incorrect output for programs which depend on an
172: exact implementation of IEEE or ANSI rules/specifications for math
173: functions.
174:
175: The following options control specific optimizations. The `-O2'
176: option turns on all of these optimizations except `-funroll-loops' and
177: `-funroll-all-loops'. On most machines, the `-O' option turns on the
178: `-fthread-jumps' and `-fdelayed-branch' options, but specific machines
179: may handle it differently.
180:
181: You can use the following flags in the rare cases when "fine-tuning"
182: of optimizations to be performed is desired.
183:
184: `-fstrength-reduce'
185: Perform the optimizations of loop strength reduction and
186: elimination of iteration variables.
187:
188: `-fthread-jumps'
189: Perform optimizations where we check to see if a jump branches to a
190: location where another comparison subsumed by the first is found.
191: If so, the first branch is redirected to either the destination of
192: the second branch or a point immediately following it, depending
193: on whether the condition is known to be true or false.
194:
195: `-fcse-follow-jumps'
196: In common subexpression elimination, scan through jump instructions
197: when the target of the jump is not reached by any other path. For
198: example, when CSE encounters an `if' statement with an `else'
199: clause, CSE will follow the jump when the condition tested is
200: false.
201:
202: `-fcse-skip-blocks'
203: This is similar to `-fcse-follow-jumps', but causes CSE to follow
204: jumps which conditionally skip over blocks. When CSE encounters a
205: simple `if' statement with no else clause, `-fcse-skip-blocks'
206: causes CSE to follow the jump around the body of the `if'.
207:
208: `-frerun-cse-after-loop'
209: Re-run common subexpression elimination after loop optimizations
210: has been performed.
211:
212: `-fexpensive-optimizations'
213: Perform a number of minor optimizations that are relatively
214: expensive.
215:
216: `-fdelayed-branch'
217: If supported for the target machine, attempt to reorder
218: instructions to exploit instruction slots available after delayed
219: branch instructions.
220:
221: `-fschedule-insns'
222: If supported for the target machine, attempt to reorder
223: instructions to eliminate execution stalls due to required data
224: being unavailable. This helps machines that have slow floating
225: point or memory load instructions by allowing other instructions
226: to be issued until the result of the load or floating point
227: instruction is required.
228:
229: `-fschedule-insns2'
230: Similar to `-fschedule-insns', but requests an additional pass of
231: instruction scheduling after register allocation has been done.
232: This is especially useful on machines with a relatively small
233: number of registers and where memory load instructions take more
234: than one cycle.
235:
236: `-fcaller-saves'
237: Enable values to be allocated in registers that will be clobbered
238: by function calls, by emitting extra instructions to save and
239: restore the registers around such calls. Such allocation is done
240: only when it seems to result in better code than would otherwise
241: be produced.
242:
243: This option is enabled by default on certain machines, usually
244: those which have no call-preserved registers to use instead.
245:
246: `-funroll-loops'
247: Perform the optimization of loop unrolling. This is only done for
248: loops whose number of iterations can be determined at compile time
249: or run time. `-funroll-loop' implies both `-fstrength-reduce' and
250: `-frerun-cse-after-loop'.
251:
252: `-funroll-all-loops'
253: Perform the optimization of loop unrolling. This is done for all
254: loops and usually makes programs run more slowly.
255: `-funroll-all-loops' implies `-fstrength-reduce' as well as
256: `-frerun-cse-after-loop'.
257:
258: `-fno-peephole'
259: Disable any machine-specific peephole optimizations.
260:
261:
262: File: gcc.info, Node: Preprocessor Options, Next: Assembler Options, Prev: Optimize Options, Up: Invoking GCC
263:
264: Options Controlling the Preprocessor
265: ====================================
266:
267: These options control the C preprocessor, which is run on each C
268: source file before actual compilation.
269:
270: If you use the `-E' option, nothing is done except preprocessing.
271: Some of these options make sense only together with `-E' because they
272: cause the preprocessor output to be unsuitable for actual compilation.
273:
274: `-include FILE'
275: Process FILE as input before processing the regular input file.
276: In effect, the contents of FILE are compiled first. Any `-D' and
277: `-U' options on the command line are always processed before
278: `-include FILE', regardless of the order in which they are
279: written. All the `-include' and `-imacros' options are processed
280: in the order in which they are written.
281:
282: `-imacros FILE'
283: Process FILE as input, discarding the resulting output, before
284: processing the regular input file. Because the output generated
285: from FILE is discarded, the only effect of `-imacros FILE' is to
286: make the macros defined in FILE available for use in the main
287: input.
288:
289: Any `-D' and `-U' options on the command line are always processed
290: before `-imacros FILE', regardless of the order in which they are
291: written. All the `-include' and `-imacros' options are processed
292: in the order in which they are written.
293:
294: `-idirafter DIR'
295: Add the directory DIR to the second include path. The directories
296: on the second include path are searched when a header file is not
297: found in any of the directories in the main include path (the one
298: that `-I' adds to).
299:
300: `-iprefix PREFIX'
301: Specify PREFIX as the prefix for subsequent `-iwithprefix' options.
302:
303: `-iwithprefix DIR'
304: Add a directory to the second include path. The directory's name
305: is made by concatenating PREFIX and DIR, where PREFIX was
306: specified previously with `-iprefix'. If you have not specified a
307: prefix yet, the directory containing the installed passes of the
308: compiler is used as the default.
309:
310: `-iwithprefixbefore DIR'
311: Add a directory to the main include path. The directory's name is
312: made by concatenating PREFIX and DIR, as in the case of
313: `-iwithprefix'.
314:
315: `-nostdinc'
316: Do not search the standard system directories for header files.
317: Only the directories you have specified with `-I' options (and the
318: current directory, if appropriate) are searched. *Note Directory
319: Options::, for information on `-I'.
320:
321: By using both `-nostdinc' and `-I-', you can limit the include-file
322: search path to only those directories you specify explicitly.
323:
324: `-undef'
325: Do not predefine any nonstandard macros. (Including architecture
326: flags).
327:
328: `-E'
329: Run only the C preprocessor. Preprocess all the C source files
330: specified and output the results to standard output or to the
331: specified output file.
332:
333: `-C'
334: Tell the preprocessor not to discard comments. Used with the `-E'
335: option.
336:
337: `-P'
338: Tell the preprocessor not to generate `#line' commands. Used with
339: the `-E' option.
340:
341: `-M'
342: Tell the preprocessor to output a rule suitable for `make'
343: describing the dependencies of each object file. For each source
344: file, the preprocessor outputs one `make'-rule whose target is the
345: object file name for that source file and whose dependencies are
346: all the `#include' header files it uses. This rule may be a
347: single line or may be continued with `\'-newline if it is long.
348: The list of rules is printed on standard output instead of the
349: preprocessed C program.
350:
351: `-M' implies `-E'.
352:
353: Another way to specify output of a `make' rule is by setting the
354: environment variable `DEPENDENCIES_OUTPUT' (*note Environment
355: Variables::.).
356:
357: `-MM'
358: Like `-M' but the output mentions only the user header files
359: included with `#include "FILE"'. System header files included
360: with `#include <FILE>' are omitted.
361:
362: `-MD'
363: Like `-M' but the dependency information is written to files with
364: names made by replacing `.o' with `.d' at the end of the output
365: file names. This is in addition to compiling the input files as
366: specified--`-MD' does not inhibit ordinary compilation the way
367: `-M' does.
368:
369: The Mach utility `md' can be used to merge the `.d' files into a
370: single dependency file suitable for using with the `make' command.
371:
372: `-MMD'
373: Like `-MD' except mention only user header files, not system
374: header files.
375:
376: `-H'
377: Print the name of each header file used, in addition to other
378: normal activities.
379:
380: `-AQUESTION(ANSWER)'
381: Assert the answer ANSWER for QUESTION, in case it is tested with a
382: preprocessor conditional such as `#if #QUESTION(ANSWER)'. `-A-'
383: disables the standard assertions that normally describe the target
384: machine.
385:
386: `-DMACRO'
387: Define macro MACRO with the string `1' as its definition.
388:
389: `-DMACRO=DEFN'
390: Define macro MACRO as DEFN. All instances of `-D' on the command
391: line are processed before any `-U' options.
392:
393: `-UMACRO'
394: Undefine macro MACRO. `-U' options are evaluated after all `-D'
395: options, but before any `-include' and `-imacros' options.
396:
397: `-dM'
398: Tell the preprocessor to output only a list of the macro
399: definitions that are in effect at the end of preprocessing. Used
400: with the `-E' option.
401:
402: `-dD'
403: Tell the preprocessing to pass all macro definitions into the
404: output, in their proper sequence in the rest of the output.
405:
406: `-dN'
407: Like `-dD' except that the macro arguments and contents are
408: omitted. Only `#define NAME' is included in the output.
409:
410: `-trigraphs'
411: Support ANSI C trigraphs. You don't want to know about this
412: brain-damage. The `-ansi' option also has this effect.
413:
414:
415: File: gcc.info, Node: Assembler Options, Next: Link Options, Prev: Preprocessor Options, Up: Invoking GCC
416:
417: Passing Options to the Assembler
418: ================================
419:
420: `-Wa,OPTION'
421: Pass OPTION as an option to the assembler. If OPTION contains
422: commas, it is split into multiple options at the commas.
423:
424:
425: File: gcc.info, Node: Link Options, Next: Directory Options, Prev: Assembler Options, Up: Invoking GCC
426:
427: Options for Linking
428: ===================
429:
430: These options come into play when the compiler links object files
431: into an executable output file. They are meaningless if the compiler is
432: not doing a link step.
433:
434: `OBJECT-FILE-NAME'
435: A file name that does not end in a special recognized suffix is
436: considered to name an object file or library. (Object files are
437: distinguished from libraries by the linker according to the file
438: contents.) If linking is done, these object files are used as
439: input to the linker.
440:
441: `-c'
442: `-S'
443: `-E'
444: If any of these options is used, then the linker is not run, and
445: object file names should not be used as arguments. *Note Overall
446: Options::.
447:
448: `-lLIBRARY'
449: Search the library named LIBRARY when linking.
450:
451: It makes a difference where in the command you write this option;
452: the linker searches processes libraries and object files in the
453: order they are specified. Thus, `foo.o -lz bar.o' searches
454: library `z' after file `foo.o' but before `bar.o'. If `bar.o'
455: refers to functions in `z', those functions may not be loaded.
456:
457: The linker searches a standard list of directories for the library,
458: which is actually a file named `libLIBRARY.a'. The linker then
459: uses this file as if it had been specified precisely by name.
460:
461: The directories searched include several standard system
462: directories plus any that you specify with `-L'.
463:
464: Normally the files found this way are library files--archive files
465: whose members are object files. The linker handles an archive
466: file by scanning through it for members which define symbols that
467: have so far been referenced but not defined. But if the file that
468: is found is an ordinary object file, it is linked in the usual
469: fashion. The only difference between using an `-l' option and
470: specifying a file name is that `-l' surrounds LIBRARY with `lib'
471: and `.a' and searches several directories.
472:
473: `-lobjc'
474: You need this special case of the `-l' option in order to link an
475: Objective C program.
476:
477: `-nostartfiles'
478: Do not use the standard system startup files when linking. The
479: standard libraries are used normally.
480:
481: `-nostdlib'
482: Don't use the standard system libraries and startup files when
483: linking. Only the files you specify will be passed to the linker.
484:
485: `-static'
486: On systems that support dynamic linking, this prevents linking
487: with the shared libraries. On other systems, this option has no
488: effect.
489:
490: `-shared'
491: Produce a shared object which can then be linked with other
492: objects to form an executable. Only a few systems support this
493: option.
494:
495: `-symbolic'
496: Bind references to global symbols when building a shared object.
497: Warn about any unresolved references (unless overridden by the
498: link editor option `-Xlinker -z -Xlinker defs'). Only a few
499: systems support this option.
500:
501: `-Xlinker OPTION'
502: Pass OPTION as an option to the linker. You can use this to
503: supply system-specific linker options which GNU CC does not know
504: how to recognize.
505:
506: If you want to pass an option that takes an argument, you must use
507: `-Xlinker' twice, once for the option and once for the argument.
508: For example, to pass `-assert definitions', you must write
509: `-Xlinker -assert -Xlinker definitions'. It does not work to write
510: `-Xlinker "-assert definitions"', because this passes the entire
511: string as a single argument, which is not what the linker expects.
512:
513: `-Wl,OPTION'
514: Pass OPTION as an option to the linker. If OPTION contains
515: commas, it is split into multiple options at the commas.
516:
517: `-u SYMBOL'
518: Pretend the symbol SYMBOL is undefined, to force linking of
519: library modules to define it. You can use `-u' multiple times with
520: different symbols to force loading of additional library modules.
521:
522:
523: File: gcc.info, Node: Directory Options, Next: Target Options, Prev: Link Options, Up: Invoking GCC
524:
525: Options for Directory Search
526: ============================
527:
528: These options specify directories to search for header files, for
529: libraries and for parts of the compiler:
530:
531: `-IDIR'
532: Append directory DIR to the list of directories searched for
533: include files.
534:
535: `-I-'
536: Any directories you specify with `-I' options before the `-I-'
537: option are searched only for the case of `#include "FILE"'; they
538: are not searched for `#include <FILE>'.
539:
540: If additional directories are specified with `-I' options after
541: the `-I-', these directories are searched for all `#include'
542: directives. (Ordinarily *all* `-I' directories are used this way.)
543:
544: In addition, the `-I-' option inhibits the use of the current
545: directory (where the current input file came from) as the first
546: search directory for `#include "FILE"'. There is no way to
547: override this effect of `-I-'. With `-I.' you can specify
548: searching the directory which was current when the compiler was
549: invoked. That is not exactly the same as what the preprocessor
550: does by default, but it is often satisfactory.
551:
552: `-I-' does not inhibit the use of the standard system directories
553: for header files. Thus, `-I-' and `-nostdinc' are independent.
554:
555: `-LDIR'
556: Add directory DIR to the list of directories to be searched for
557: `-l'.
558:
559: `-BPREFIX'
560: This option specifies where to find the executables, libraries and
561: data files of the compiler itself.
562:
563: The compiler driver program runs one or more of the subprograms
564: `cpp', `cc1', `as' and `ld'. It tries PREFIX as a prefix for each
565: program it tries to run, both with and without `MACHINE/VERSION/'
566: (*note Target Options::.).
567:
568: For each subprogram to be run, the compiler driver first tries the
569: `-B' prefix, if any. If that name is not found, or if `-B' was
570: not specified, the driver tries two standard prefixes, which are
571: `/usr/lib/gcc/' and `/usr/local/lib/gcc-lib/'. If neither of
572: those results in a file name that is found, the unmodified program
573: name is searched for using the directories specified in your
574: `PATH' environment variable.
575:
576: `-B' prefixes that effectively specify directory names also apply
577: to libraries in the linker, because the compiler translates these
578: options into `-L' options for the linker.
579:
580: The run-time support file `libgcc.a' can also be searched for using
581: the `-B' prefix, if needed. If it is not found there, the two
582: standard prefixes above are tried, and that is all. The file is
583: left out of the link if it is not found by those means.
584:
585: Another way to specify a prefix much like the `-B' prefix is to use
586: the environment variable `GCC_EXEC_PREFIX'. *Note Environment
587: Variables::.
588:
589:
590: File: gcc.info, Node: Target Options, Next: Submodel Options, Prev: Directory Options, Up: Invoking GCC
591:
592: Specifying Target Machine and Compiler Version
593: ==============================================
594:
595: By default, GNU CC compiles code for the same type of machine that
596: you are using. However, it can also be installed as a cross-compiler,
597: to compile for some other type of machine. In fact, several different
598: configurations of GNU CC, for different target machines, can be
599: installed side by side. Then you specify which one to use with the
600: `-b' option.
601:
602: In addition, older and newer versions of GNU CC can be installed side
603: by side. One of them (probably the newest) will be the default, but
604: you may sometimes wish to use another.
605:
606: `-b MACHINE'
607: The argument MACHINE specifies the target machine for compilation.
608: This is useful when you have installed GNU CC as a cross-compiler.
609:
610: The value to use for MACHINE is the same as was specified as the
611: machine type when configuring GNU CC as a cross-compiler. For
612: example, if a cross-compiler was configured with `configure
613: i386v', meaning to compile for an 80386 running System V, then you
614: would specify `-b i386v' to run that cross compiler.
615:
616: When you do not specify `-b', it normally means to compile for the
617: same type of machine that you are using.
618:
619: `-V VERSION'
620: The argument VERSION specifies which version of GNU CC to run.
621: This is useful when multiple versions are installed. For example,
622: VERSION might be `2.0', meaning to run GNU CC version 2.0.
623:
624: The default version, when you do not specify `-V', is controlled
625: by the way GNU CC is installed. Normally, it will be a version
626: that is recommended for general use.
627:
628: The `-b' and `-V' options actually work by controlling part of the
629: file name used for the executable files and libraries used for
630: compilation. A given version of GNU CC, for a given target machine, is
631: normally kept in the directory `/usr/local/lib/gcc-lib/MACHINE/VERSION'.
632:
633: Thus, sites can customize the effect of `-b' or `-V' either by
634: changing the names of these directories or adding alternate names (or
635: symbolic links). If in directory `/usr/local/lib/gcc-lib/' the file
636: `80386' is a link to the file `i386v', then `-b 80386' becomes an alias
637: for `-b i386v'.
638:
639: In one respect, the `-b' or `-V' do not completely change to a
640: different compiler: the top-level driver program `gcc' that you
641: originally invoked continues to run and invoke the other executables
642: (preprocessor, compiler per se, assembler and linker) that do the real
643: work. However, since no real work is done in the driver program, it
644: usually does not matter that the driver program in use is not the one
645: for the specified target and version.
646:
647: The only way that the driver program depends on the target machine is
648: in the parsing and handling of special machine-specific options.
649: However, this is controlled by a file which is found, along with the
650: other executables, in the directory for the specified version and
651: target machine. As a result, a single installed driver program adapts
652: to any specified target machine and compiler version.
653:
654: The driver program executable does control one significant thing,
655: however: the default version and target machine. Therefore, you can
656: install different instances of the driver program, compiled for
657: different targets or versions, under different names.
658:
659: For example, if the driver for version 2.0 is installed as `ogcc'
660: and that for version 2.1 is installed as `gcc', then the command `gcc'
661: will use version 2.1 by default, while `ogcc' will use 2.0 by default.
662: However, you can choose either version with either command with the
663: `-V' option.
664:
665:
666: File: gcc.info, Node: Submodel Options, Next: Code Gen Options, Prev: Target Options, Up: Invoking GCC
667:
668: Hardware Models and Configurations
669: ==================================
670:
671: Earlier we discussed the standard option `-b' which chooses among
672: different installed compilers for completely different target machines,
673: such as Vax vs. 68000 vs. 80386.
674:
675: In addition, each of these target machine types can have its own
676: special options, starting with `-m', to choose among various hardware
677: models or configurations--for example, 68010 vs 68020, floating
678: coprocessor or none. A single installed version of the compiler can
679: compile for any model or configuration, according to the options
680: specified.
681:
682: Some configurations of the compiler also support additional special
683: options, usually for compatibility with other compilers on the same
684: platform.
685:
686: These options are defined by the macro `TARGET_SWITCHES' in the
687: machine description. The default for the options is also defined by
688: that macro, which enables you to change the defaults.
689:
690: * Menu:
691:
692: * M680x0 Options::
693: * VAX Options::
694: * SPARC Options::
695: * Convex Options::
696: * AMD29K Options::
697: * M88K Options::
698: * RS/6000 and PowerPC Options::
699: * RT Options::
700: * MIPS Options::
701: * i386 Options::
702: * HPPA Options::
703: * Intel 960 Options::
704: * DEC Alpha Options::
705: * Clipper Options::
706: * System V Options::
707:
708:
709: File: gcc.info, Node: M680x0 Options, Next: VAX Options, Up: Submodel Options
710:
711: M680x0 Options
712: --------------
713:
714: These are the `-m' options defined for the 68000 series. The default
715: values for these options depends on which style of 68000 was selected
716: when the compiler was configured; the defaults for the most common
717: choices are given below.
718:
719: `-m68000'
720: `-mc68000'
721: Generate output for a 68000. This is the default when the
722: compiler is configured for 68000-based systems.
723:
724: `-m68020'
725: `-mc68020'
726: Generate output for a 68020. This is the default when the
727: compiler is configured for 68020-based systems.
728:
729: `-m68881'
730: Generate output containing 68881 instructions for floating point.
731: This is the default for most 68020 systems unless `-nfp' was
732: specified when the compiler was configured.
733:
734: `-m68030'
735: Generate output for a 68030. This is the default when the
736: compiler is configured for 68030-based systems.
737:
738: `-m68040'
739: Generate output for a 68040. This is the default when the
740: compiler is configured for 68040-based systems.
741:
742: This option inhibits the use of 68881/68882 instructions that have
743: to be emulated by software on the 68040. If your 68040 does not
744: have code to emulate those instructions, use `-m68040'.
745:
746: `-m68020-40'
747: Generate output for a 68040, without using any of the new
748: instructions. This results in code which can run relatively
749: efficiently on either a 68020/68881 or a 68030 or a 68040. The
750: generated code does use the 68881 instructions that are emulated
751: on the 68040.
752:
753: `-mfpa'
754: Generate output containing Sun FPA instructions for floating point.
755:
756: `-msoft-float'
757: Generate output containing library calls for floating point.
758: *Warning:* the requisite libraries are not part of GNU CC.
759: Normally the facilities of the machine's usual C compiler are
760: used, but this can't be done directly in cross-compilation. You
761: must make your own arrangements to provide suitable library
762: functions for cross-compilation.
763:
764: `-mshort'
765: Consider type `int' to be 16 bits wide, like `short int'.
766:
767: `-mnobitfield'
768: Do not use the bit-field instructions. The `-m68000' option
769: implies `-mnobitfield'.
770:
771: `-mbitfield'
772: Do use the bit-field instructions. The `-m68020' option implies
773: `-mbitfield'. This is the default if you use a configuration
774: designed for a 68020.
775:
776: `-mrtd'
777: Use a different function-calling convention, in which functions
778: that take a fixed number of arguments return with the `rtd'
779: instruction, which pops their arguments while returning. This
780: saves one instruction in the caller since there is no need to pop
781: the arguments there.
782:
783: This calling convention is incompatible with the one normally used
784: on Unix, so you cannot use it if you need to call libraries
785: compiled with the Unix compiler.
786:
787: Also, you must provide function prototypes for all functions that
788: take variable numbers of arguments (including `printf'); otherwise
789: incorrect code will be generated for calls to those functions.
790:
791: In addition, seriously incorrect code will result if you call a
792: function with too many arguments. (Normally, extra arguments are
793: harmlessly ignored.)
794:
795: The `rtd' instruction is supported by the 68010 and 68020
796: processors, but not by the 68000.
797:
798:
799: File: gcc.info, Node: VAX Options, Next: SPARC Options, Prev: M680x0 Options, Up: Submodel Options
800:
801: VAX Options
802: -----------
803:
804: These `-m' options are defined for the Vax:
805:
806: `-munix'
807: Do not output certain jump instructions (`aobleq' and so on) that
808: the Unix assembler for the Vax cannot handle across long ranges.
809:
810: `-mgnu'
811: Do output those jump instructions, on the assumption that you will
812: assemble with the GNU assembler.
813:
814: `-mg'
815: Output code for g-format floating point numbers instead of
816: d-format.
817:
818:
819: File: gcc.info, Node: SPARC Options, Next: Convex Options, Prev: VAX Options, Up: Submodel Options
820:
821: SPARC Options
822: -------------
823:
824: These `-m' switches are supported on the SPARC:
825:
826: `-mfpu'
827: `-mhard-float'
828: Generate output containing floating point instructions. This is
829: the default.
830:
831: `-mno-fpu'
832: `-msoft-float'
833: Generate output containing library calls for floating point.
834: *Warning:* there is no GNU floating-point library for SPARC.
835: Normally the facilities of the machine's usual C compiler are
836: used, but this cannot be done directly in cross-compilation. You
837: must make your own arrangements to provide suitable library
838: functions for cross-compilation.
839:
840: `-msoft-float' changes the calling convention in the output file;
841: therefore, it is only useful if you compile *all* of a program with
842: this option. In particular, you need to compile `libgcc.a', the
843: library that comes with GNU CC, with `-msoft-float' in order for
844: this to work.
845:
846: `-mno-epilogue'
847: `-mepilogue'
848: With `-mepilogue' (the default), the compiler always emits code for
849: function exit at the end of each function. Any function exit in
850: the middle of the function (such as a return statement in C) will
851: generate a jump to the exit code at the end of the function.
852:
853: With `-mno-epilogue', the compiler tries to emit exit code inline
854: at every function exit.
855:
856: `-mv8'
857: `-msparclite'
858: These two options select variations on the SPARC architecture.
859:
860: By default (unless specifically configured for the Fujitsu
861: SPARClite), GCC generates code for the v7 variant of the SPARC
862: architecture.
863:
864: `-mv8' will give you SPARC v8 code. The only difference from v7
865: code is that the compiler emits the integer multiply and integer
866: divide instructions which exist in SPARC v8 but not in SPARC v7.
867:
868: `-msparclite' will give you SPARClite code. This adds the integer
869: multiply, integer divide step and scan (`ffs') instructions which
870: exist in SPARClite but not in SPARC v7.
871:
872:
873: File: gcc.info, Node: Convex Options, Next: AMD29K Options, Prev: SPARC Options, Up: Submodel Options
874:
875: Convex Options
876: --------------
877:
878: These `-m' options are defined for Convex:
879:
880: `-mc1'
881: Generate output for C1. The code will run on any Convex machine.
882: The preprocessor symbol `__convex__c1__' is defined.
883:
884: `-mc2'
885: Generate output for C2. Uses instructions not available on C1.
886: Scheduling and other optimizations are chosen for max performance
887: on C2. The preprocessor symbol `__convex_c2__' is defined.
888:
889: `-mc32'
890: Generate output for C32xx. Uses instructions not available on C1.
891: Scheduling and other optimizations are chosen for max performance
892: on C32. The preprocessor symbol `__convex_c32__' is defined.
893:
894: `-mc34'
895: Generate output for C34xx. Uses instructions not available on C1.
896: Scheduling and other optimizations are chosen for max performance
897: on C34. The preprocessor symbol `__convex_c34__' is defined.
898:
899: `-mc38'
900: Generate output for C38xx. Uses instructions not available on C1.
901: Scheduling and other optimizations are chosen for max performance
902: on C38. The preprocessor symbol `__convex_c38__' is defined.
903:
904: `-margcount'
905: Generate code which puts an argument count in the word preceding
906: each argument list. This is compatible with regular CC, and a few
907: programs may need the argument count word. GDB and other
908: source-level debuggers do not need it; this info is in the symbol
909: table.
910:
911: `-mnoargcount'
912: Omit the argument count word. This is the default.
913:
914: `-mvolatile-cache'
915: Allow volatile references to be cached. This is the default.
916:
917: `-mvolatile-nocache'
918: Volatile references bypass the data cache, going all the way to
919: memory. This is only needed for multi-processor code that does
920: not use standard synchronization instructions. Making
921: non-volatile references to volatile locations will not necessarily
922: work.
923:
924: `-mlong32'
925: Type long is 32 bits, the same as type int. This is the default.
926:
927: `-mlong64'
928: Type long is 64 bits, the same as type long long. This option is
929: useless, because no library support exists for it.
930:
931:
932: File: gcc.info, Node: AMD29K Options, Next: M88K Options, Prev: Convex Options, Up: Submodel Options
933:
934: AMD29K Options
935: --------------
936:
937: These `-m' options are defined for the AMD Am29000:
938:
939: `-mdw'
940: Generate code that assumes the `DW' bit is set, i.e., that byte and
941: halfword operations are directly supported by the hardware. This
942: is the default.
943:
944: `-mnodw'
945: Generate code that assumes the `DW' bit is not set.
946:
947: `-mbw'
948: Generate code that assumes the system supports byte and halfword
949: write operations. This is the default.
950:
951: `-mnbw'
952: Generate code that assumes the systems does not support byte and
953: halfword write operations. `-mnbw' implies `-mnodw'.
954:
955: `-msmall'
956: Use a small memory model that assumes that all function addresses
957: are either within a single 256 KB segment or at an absolute
958: address of less than 256k. This allows the `call' instruction to
959: be used instead of a `const', `consth', `calli' sequence.
960:
961: `-mnormal'
962: Use the normal memory model: Generate `call' instructions only when
963: calling functions in the same file and `calli' instructions
964: otherwise. This works if each file occupies less than 256 KB but
965: allows the entire executable to be larger than 256 KB. This is
966: the default.
967:
968: `-mlarge'
969: Always use `calli' instructions. Specify this option if you expect
970: a single file to compile into more than 256 KB of code.
971:
972: `-m29050'
973: Generate code for the Am29050.
974:
975: `-m29000'
976: Generate code for the Am29000. This is the default.
977:
978: `-mkernel-registers'
979: Generate references to registers `gr64-gr95' instead of to
980: registers `gr96-gr127'. This option can be used when compiling
981: kernel code that wants a set of global registers disjoint from
982: that used by user-mode code.
983:
984: Note that when this option is used, register names in `-f' flags
985: must use the normal, user-mode, names.
986:
987: `-muser-registers'
988: Use the normal set of global registers, `gr96-gr127'. This is the
989: default.
990:
991: `-mstack-check'
992: Insert a call to `__msp_check' after each stack adjustment. This
993: is often used for kernel code.
994:
995:
996: File: gcc.info, Node: M88K Options, Next: RS/6000 and PowerPC Options, Prev: AMD29K Options, Up: Submodel Options
997:
998: M88K Options
999: ------------
1000:
1001: These `-m' options are defined for Motorola 88k architectures:
1002:
1003: `-m88000'
1004: Generate code that works well on both the m88100 and the m88110.
1005:
1006: `-m88100'
1007: Generate code that works best for the m88100, but that also runs
1008: on the m88110.
1009:
1010: `-m88110'
1011: Generate code that works best for the m88110, and may not run on
1012: the m88100.
1013:
1014: `-mbig-pic'
1015: Obsolete option to be removed from the next revision. Use `-fPIC'.
1016:
1017: `-midentify-revision'
1018: Include an `ident' directive in the assembler output recording the
1019: source file name, compiler name and version, timestamp, and
1020: compilation flags used.
1021:
1022: `-mno-underscores'
1023: In assembler output, emit symbol names without adding an underscore
1024: character at the beginning of each name. The default is to use an
1025: underscore as prefix on each name.
1026:
1027: `-mocs-debug-info'
1028: `-mno-ocs-debug-info'
1029: Include (or omit) additional debugging information (about
1030: registers used in each stack frame) as specified in the 88open
1031: Object Compatibility Standard, "OCS". This extra information
1032: allows debugging of code that has had the frame pointer
1033: eliminated. The default for DG/UX, SVr4, and Delta 88 SVr3.2 is
1034: to include this information; other 88k configurations omit this
1035: information by default.
1036:
1037: `-mocs-frame-position'
1038: When emitting COFF debugging information for automatic variables
1039: and parameters stored on the stack, use the offset from the
1040: canonical frame address, which is the stack pointer (register 31)
1041: on entry to the function. The DG/UX, SVr4, Delta88 SVr3.2, and
1042: BCS configurations use `-mocs-frame-position'; other 88k
1043: configurations have the default `-mno-ocs-frame-position'.
1044:
1045: `-mno-ocs-frame-position'
1046: When emitting COFF debugging information for automatic variables
1047: and parameters stored on the stack, use the offset from the frame
1048: pointer register (register 30). When this option is in effect,
1049: the frame pointer is not eliminated when debugging information is
1050: selected by the -g switch.
1051:
1052: `-moptimize-arg-area'
1053: `-mno-optimize-arg-area'
1054: Control how function arguments are stored in stack frames.
1055: `-moptimize-arg-area' saves space by optimizing them, but this
1056: conflicts with the 88open specifications. The opposite
1057: alternative, `-mno-optimize-arg-area', agrees with 88open
1058: standards. By default GNU CC does not optimize the argument area.
1059:
1060: `-mshort-data-NUM'
1061: Generate smaller data references by making them relative to `r0',
1062: which allows loading a value using a single instruction (rather
1063: than the usual two). You control which data references are
1064: affected by specifying NUM with this option. For example, if you
1065: specify `-mshort-data-512', then the data references affected are
1066: those involving displacements of less than 512 bytes.
1067: `-mshort-data-NUM' is not effective for NUM greater than 64k.
1068:
1069: `-mserialize-volatile'
1070: `-mno-serialize-volatile'
1071: Do, or do not, generate code to guarantee sequential consistency of
1072: volatile memory references.
1073:
1074: GNU CC always guarantees consistency by default.
1075:
1076: The order of memory references made by the m88110 processor does
1077: not always match the order of the instructions requesting those
1078: references. In particular, a load instruction may execute before
1079: a preceding store instruction. Such reordering violates
1080: sequential consistency of volatile memory references, when there
1081: are multiple processors.
1082:
1083: The extra code generated to guarantee consistency may affect the
1084: performance of your application. If you know that you can safely
1085: forgo this guarantee, you may use the option
1086: `-mno-serialize-volatile'.
1087:
1088: `-msvr4'
1089: `-msvr3'
1090: Turn on (`-msvr4') or off (`-msvr3') compiler extensions related
1091: to System V release 4 (SVr4). This controls the following:
1092:
1093: 1. Which variant of the assembler syntax to emit (which you can
1094: select independently using `-mversion-03.00').
1095:
1096: 2. `-msvr4' makes the C preprocessor recognize `#pragma weak'
1097: that is used on System V release 4.
1098:
1099: 3. `-msvr4' makes GNU CC issue additional declaration directives
1100: used in SVr4.
1101:
1102: `-msvr3' is the default for all m88k configurations except the
1103: SVr4 configuration.
1104:
1105: `-mversion-03.00'
1106: In the DG/UX configuration, there are two flavors of SVr4. This
1107: option modifies `-msvr4' to select whether the hybrid-COFF or
1108: real-ELF flavor is used. All other configurations ignore this
1109: option.
1110:
1111: `-mno-check-zero-division'
1112: `-mcheck-zero-division'
1113: Early models of the 88k architecture had problems with division by
1114: zero; in particular, many of them didn't trap. Use these options
1115: to avoid including (or to include explicitly) additional code to
1116: detect division by zero and signal an exception. All GNU CC
1117: configurations for the 88k use `-mcheck-zero-division' by default.
1118:
1119: `-muse-div-instruction'
1120: Do not emit code to check both the divisor and dividend when doing
1121: signed integer division to see if either is negative, and adjust
1122: the signs so the divide is done using non-negative numbers.
1123: Instead, rely on the operating system to calculate the correct
1124: value when the `div' instruction traps. This results in different
1125: behavior when the most negative number is divided by -1, but is
1126: useful when most or all signed integer divisions are done with
1127: positive numbers.
1128:
1129: `-mtrap-large-shift'
1130: `-mhandle-large-shift'
1131: Include code to detect bit-shifts of more than 31 bits;
1132: respectively, trap such shifts or emit code to handle them
1133: properly. By default GNU CC makes no special provision for large
1134: bit shifts.
1135:
1136: `-mwarn-passed-structs'
1137: Warn when a function passes a struct as an argument or result.
1138: Structure-passing conventions have changed during the evolution of
1139: the C language, and are often the source of portability problems.
1140: By default, GNU CC issues no such warning.
1141:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.