![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to gcc.1 CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GCC 2.x] / gcc|
Return to gcc.1 CVS log | Up to [GCC 2.x] / gcc |
1.1 root 1: .\" Copyright (c) 1991 Free Software Foundation -*-Text-*-
2: .\" See section COPYING for conditions for redistribution
3: .\" FIXME: no info here on predefines. Should there be? extra for C++...
4: .TH GCC 1 "27dec1991" "GNU Tools" "GNU Tools"
5: .de BP
6: .sp
7: .ti \-.2i
8: \(**
9: ..
10: .SH NAME
11: gcc, g++ \- GNU project C and C++ Compiler (v2 preliminary)
12: .SH SYNOPSIS
13: .RB gcc " [" \c
14: .IR option " | " filename " ].\|.\|.
15: .br
16: .RB g++ " [" \c
17: .IR option " | " filename " ].\|.\|.
18: .SH WARNING
19: The information in this man page is an extract from the full
20: documentation of the GNU C compiler, and is limited to the meaning of
21: the options.
22:
23: For complete, current documentation, refer to the Info file `\|\c
24: .B gcc\c
25: \&\|' or the manual
26: .I
27: Using and Porting GNU CC (for version 2.0)\c
28: \&. Both are made from the Texinfo source file
29: .BR gcc.texinfo .
30: .SH DESCRIPTION
31: The C and C++ compilers are integrated. Both process input files
32: through one or more of four stages: preprocessing, compilation,
33: assembly, and linking. Source filename suffixes identify the source
34: language, but which name you use for the compiler governs default
35: assumptions:
36: .TP
37: .B gcc
38: assumes preprocessed (\c
39: .B .i\c
40: \&) files are C and assumes C style linking.
41: .TP
42: .B g++
43: assumes preprocessed (\c
44: .B .i\c
45: \&) files are C++ and assumes C++ style linking.
46: .PP
47: Suffixes of source file names indicate the language and kind of
48: processing to be done:
49:
50: .ta \w'.cxx 'u
51: .B .c\c
52: \& C source; preprocess, compile, assemble
53: .br
54: .B .C\c
55: \& C++ source; preprocess, compile, assemble
56: .br
57: .B .cc\c
58: \& C++ source; preprocess, compile, assemble
59: .br
60: .B .cxx\c
61: \& C++ source; preprocess, compile, assemble
62: .br
63: .B .m\c
64: \& Objective-C source; preprocess, compile, assemble
65: .br
66: .B .i\c
67: \& preprocessed C or C++; compile, assemble
68: .br
69: .B .s\c
70: \& Assembler source; assemble
71: .br
72: .B .S\c
73: \& Assembler source; preprocess, assemble
74: .br
75: .B .h\c
76: \& Preprocessor file; not usually named on command line
77:
78: .I ??\c
79: \& Other (unrecognized) files passed to linker.
80: .br
81: \& Common cases:
82: .br
83: .B .o\c
84: \& Object file
85: .br
86: .B .a\c
87: \& Archive file
88:
89: Linking is always the last stage unless you use one of the
90: .BR \-c ,
91: .BR \-S ,
92: or
93: .B \-E
94: options to avoid it (or unless compilation errors stop the whole
95: process). For the link stage, all
96: .B .o
97: files corresponding to source files,
98: .B \-l
99: libraries, unrecognized filenames (including named
100: .B .o
101: object files and
102: .B .a
103: archives)
104: are passed to the linker in command-line order.
105:
106: .SH OPTIONS
107: Options must be separate: `\|\c
108: .B \-dr\c
109: \&\|' is quite different from `\|\c
110: .B \-d \-r
111: \&\|'.
112:
113: Most `\|\c
114: .B \-f\c
115: \&\|' and `\|\c
116: .B \-W\c
117: \&\|' options have two contrary forms:
118: .BI \-f name
119: and
120: .BI \-fno\- name\c
121: \& (or
122: .BI \-W name
123: and
124: .BI \-Wno\- name\c
125: \&). Only the non-default forms are shown here.
126:
127: Here is a summary of all the options, grouped by type. Explanations are
128: in the following sections.
129:
130: .hy 0
131: .na
132: .TP
133: .B Overall Options
134: .br
135: \-c
136: \-S
137: \-E
138: .RI "\-o " file
139: \-pipe
140: \-v
141: \-vpath
142: \-vspec
143: .RI "\-x " language
144:
145: .TP
146: .B Language Options
147: \-ansi
148: \-fall\-virtual
149: \-fcond\-mismatch
150: \-fdollars\-in\-identifiers
151: \-fenum\-int\-equiv
152: \-fno\-asm
153: \-fno\-builtin
154: \-fno\-strict\-prototype
155: \-fsigned\-bitfields
156: \-fsigned\-char
157: \-fthis\-is\-variable
158: \-funsigned\-bitfields
159: \-funsigned\-char
160: \-fwritable\-strings
161: \-traditional
162: \-traditional\-cpp
163: \-trigraphs
164:
165: .TP
166: .B Warning Options
167: \-fsyntax\-only
168: \-pedantic
169: \-pedantic\-errors
170: \-w
171: \-W
172: \-Wall
173: \-Waggregate\-return
174: \-Wcast\-align
175: \-Wcast\-qual
176: \-Wcomment
177: \-Wconversion
178: \-Wenum\-clash
179: \-Werror
180: \-Wformat
181: .RI \-Wid\-clash\- len
182: \-Wimplicit
183: \-Wmissing\-prototypes
184: \-Wno\-parentheses
185: \-Wpointer\-arith
186: \-Wreturn\-type
187: \-Wshadow
188: \-Wstrict\-prototypes
189: \-Wswitch
190: \-Wtraditional
191: \-Wtrigraphs
192: \-Wuninitialized
193: \-Wunused
194: \-Wwrite\-strings
195:
196: .TP
197: .B Debugging Options
198: \-a
199: .RI \-d letters
200: \-fpretend\-float
201: \-g
202: \-gdbx
203: \-gdwarf
204: \-ggdb
205: \-gsdb
206: \-p
207: \-pg
208: \-save\-temps
209:
210: .TP
211: .B Optimization Options
212: \-fcaller\-saves
213: \-fcse\-follow\-jumps
214: \-fdelayed\-branch
215: \-felide\-constructors
216: \-fexpensive\-optimizations
217: \-ffloat\-store
218: \-fforce\-addr
219: \-fforce\-mem
220: \-finline
221: \-finline\-functions
222: \-fkeep\-inline\-functions
223: \-fmemoize\-lookups
224: \-fno\-default\-inline
225: \-fno\-defer\-pop
226: \-fno\-function\-cse
227: \-fomit\-frame\-pointer
228: \-frerun\-cse\-after\-loop
229: \-fschedule\-insns
230: \-fschedule\-insns2
231: \-fstrength\-reduce
232: \-fthread\-jumps
233: \-funroll\-all\-loops
234: \-funroll\-loops
235: \-O
236: \-O2
237:
238: .TP
239: .B Preprocessor Options
240: \-C
241: \-dD
242: \-dM
243: \-dN
244: .RI \-D macro [\|= defn \|]
245: \-E
246: \-H
247: .RI "\-i " file
248: \-M
249: \-MD
250: \-MM
251: \-MMD
252: \-nostdinc
253: \-P
254: .RI \-U macro
255: \-undef
256:
257: .TP
258: .B Linker Options
259: \-dynamic
260: .RI \-l library
261: \-nostdlib
262: \-static
263:
264: .TP
265: .B Directory Options
266: .RI \-B prefix
267: .RI \-I dir
268: \-I\-
269: .RI \-L dir
270:
271: .TP
272: .B Target Options
273: .RI "\-b " machine
274: .RI "\-V " version
275:
276: .TP
277: .B Machine Dependent Options
278: .I M680x0\ Options
279: .br
280: \-m68000
281: \-m68020
282: \-m68881
283: \-mbitfield
284: \-mc68000
285: \-mc68020
286: \-mfpa
287: \-mnobitfield
288: \-mrtd
289: \-mshort
290: \-msoft\-float
291:
292: .I VAX Options
293: .br
294: \-mg
295: \-mgnu
296: \-munix
297:
298: .I SPARC Options
299: .br
300: \-mfpu
301: \-mno\-epilogue
302:
303: .I Convex Options
304: .br
305: \-margcount
306: \-mc1
307: \-mc2
308: \-mnoargcount
309:
310: .I AMD29K Options
311: .br
312: \-m29000
313: \-m29050
314: \-mbw
315: \-mdw
316: \-mkernel\-registers
317: \-mlarge
318: \-mnbw
319: \-mnodw
320: \-msmall
321: \-mstack\-check
322: \-muser\-registers
323:
324: .I M88K Options
325: .br
326: \-mbig\-pic
327: \-mcheck\-zero\-division
328: \-mhandle\-large\-shift
329: \-midentify\-revision
330: \-mno\-check\-zero\-division
331: \-mno\-ocs\-debug\-info
332: \-mno\-ocs\-frame\-position
333: \-mno\-optimize\-arg\-area
334: \-mno\-underscores
335: \-mocs\-debug\-info
336: \-mocs\-frame\-position
337: \-moptimize\-arg\-area
338: .RI \-mshort\-data\- num
339: \-msvr3
340: \-msvr4
341: \-mtrap\-large\-shift
342: \-muse\-div\-instruction
343: \-mversion\-03.00
344: \-mwarn\-passed\-structs
345:
346: .I RS6000 Options
347: .br
348: \-mfp\-in\-toc
349: \-mno\-fop\-in\-toc
350:
351: .I RT Options
352: .br
353: \-mcall\-lib\-mul
354: \-mfp\-arg\-in\-fpregs
355: \-mfp\-arg\-in\-gregs
356: \-mfull\-fp\-blocks
357: \-mhc\-struct\-return
358: \-min\-line\-mul
359: \-mminimum\-fp\-blocks
360: \-mnohc\-struct\-return
361:
362: .I MIPS Options
363: .br
364: \-mcpu=\fIcpu type\fP
365: \-mips2
366: \-mips3
367: \-mint64
368: \-mlong64
369: \-mlonglong128
370: \-mmips\-as
371: \-mgas
372: \-mrnames
373: \-mno\-rnames
374: \-mgpopt
375: \-mno\-gpopt
376: \-mstats
377: \-mno\-stats
378: \-mmemcpy
379: \-mno\-memcpy
380: \-mno\-mips\-tfile
381: \-mmips\-tfile
382: \-msoft\-float
383: \-mhard\-float
384: \-mabicalls
385: \-mno\-abicalls
386: \-mhalf\-pic
387: \-mno\-half\-pic
388: \-G \fInum\fP
389:
390: .TP
391: .B Code Generation Options
392: .RI +e N
393: .RI \-fcall\-saved\- reg
394: .RI \-fcall\-used\- reg
395: .RI \-ffixed\- reg
396: \-fno\-common
397: \-fno\-gnu\-binutils
398: \-fnonnull\-objects
399: \-fpcc\-struct\-return
400: \-fpic
401: \-fPIC
402: \-fshared\-data
403: \-fshort\-enums
404: \-fshort\-double
405: \-fvolatile
406: .ad b
407: .hy 1
408:
409: .SH OVERALL OPTIONS
410: .TP
411: .BI "\-x " "language"
412: Specify explicitly the
413: .I language\c
414: \& for the following input files (rather than choosing a default based
415: on the file name suffix) . This option applies to all following input
416: files until the next `\|\c
417: .B \-x\c
418: \&\|' option. Possible values of \c
419: .I language\c
420: \& are
421: `\|\c
422: .B c\c
423: \&\|', `\|\c
424: .B objective\-c\c
425: \&\|', `\|\c
426: .B c\-header\c
427: \&\|', `\|\c
428: .B c++\c
429: \&\|',
430: `\|\c
431: .B cpp\-output\c
432: \&\|', `\|\c
433: .B assembler\c
434: \&\|', and `\|\c
435: .B assembler\-with\-cpp\c
436: \&\|'.
437: .TP
438: .B \-x none
439: Turn off any specification of a language, so that subsequent files are
440: handled according to their file name suffixes (as they are if `\|\c
441: .B \-x\c
442: \&\|'
443: has not been used at all).
444: .PP
445:
446: If you want only some of the four stages (preprocess, compile,
447: assemble, link), you can use
448: `\|\c
449: .B \-x\c
450: \&\|' (or filename suffixes) to tell \c
451: .B gcc\c
452: \& where to start, and
453: one of the options `\|\c
454: .B \-c\c
455: \&\|', `\|\c
456: .B \-S\c
457: \&\|', or `\|\c
458: .B \-E\c
459: \&\|' to say where
460: \c
461: .B gcc\c
462: \& is to stop. Note that some combinations (for example,
463: `\|\c
464: .B \-x cpp\-output \-E\c
465: \&\|') instruct \c
466: .B gcc\c
467: \& to do nothing at all.
468: .TP
469: .B \-c
470: Compile or assemble the source files, but do not link. The compiler
471: output is an object file corresponding to each source file.
472:
473: By default, GCC makes the object file name for a source file by replacing
474: the suffix `\|\c
475: .B .c\c
476: \&\|', `\|\c
477: .B .i\c
478: \&\|', `\|\c
479: .B .s\c
480: \&\|', etc., with `\|\c
481: .B .o\c
482: \&\|'. Use
483: .B \-o\c
484: \& to select another name.
485:
486: GCC ignores any unrecognized input files (those that do not require
487: compilation or assembly) with the
488: .B \-c
489: option.
490: .TP
491: .B \-S
492: Stop after the stage of compilation proper; do not assemble. The output
493: is an assembler code file for each non-assembler input
494: file specified.
495:
496: By default, GCC makes the assembler file name for a source file by
497: replacing the suffix `\|\c
498: .B .c\c
499: \&\|', `\|\c
500: .B .i\c
501: \&\|', etc., with `\|\c
502: .B .s\c
503: \&\|'. Use
504: .B \-o\c
505: \& to select another name.
506:
507:
508: GCC ignores any input files that don't require compilation.
509: .TP
510: .B \-E
511: Stop after the preprocessing stage; do not run the compiler proper. The
512: output is preprocessed source code, which is sent to the
513: standard output.
514:
515: GCC ignores input files which don't require preprocessing.
516: .TP
517: .BI "\-o " file\c
518: \&
519: Place output in file \c
520: .I file\c
521: \&. This applies regardless to whatever
522: sort of output GCC is producing, whether it be an executable file,
523: an object file, an assembler file or preprocessed C code.
524:
525: Since only one output file can be specified, it does not make sense to
526: use `\|\c
527: .B \-o\c
528: \&\|' when compiling more than one input file, unless you are
529: producing an executable file as output.
530:
531: If you do not specify `\|\c
532: .B \-o\c
533: \&\|', the default is to put an executable file
534: in `\|\c
535: .B a.out\c
536: \&\|', the object file for `\|\c
537: .B \c
538: .I source\c
539: \&.\c
540: .I suffix\c
541: \&\c
542: \&\|' in
543: `\|\c
544: .B \c
545: .I source\c
546: \&.o\c
547: \&\|', its assembler file in `\|\c
548: .B \c
549: .I source\c
550: \&.s\c
551: \&\|', and
552: all preprocessed C source on standard output.
553: .TP
554: .B \-v
555: Print (on standard error output) the commands executed to run the stages
556: of compilation. Also print the version number of the compiler driver
557: program and of the preprocessor and the compiler proper.
558: .TP
559: .B \-vpath
560: Print (on standard error output) all attempts at finding files, tracing
561: how the `\|\c
562: .B \-B\c
563: \&\|', `\|\c
564: .B \-b\c
565: \&\|', and `\|\c
566: .B \-V\c
567: \&\|' options interact. Also,
568: print the commands executed to run the stages of compilation and version
569: numbers, like the `\|\c
570: .B \-v\c
571: \&\|' option.
572: .TP
573: .B \-vspec
574: Print (on standard error output) all spec's processed by the
575: \c
576: .B do_spec_1\c
577: \& function in `\|\c
578: .B gcc.c\c
579: \&\|'. Also, print the commands
580: executed to run the stages of compilation and version numbers, like the
581: `\|\c
582: .B \-v\c
583: \&\|' option.
584: .TP
585: .B \-pipe
586: Use pipes rather than temporary files for communication between the
587: various stages of compilation. This fails to work on some systems where
588: the assembler cannot read from a pipe; but the GNU assembler has
589: no trouble.
590: .PP
591:
592: .SH LANGUAGE OPTIONS
593: The following options control the dialect of C that the compiler
594: accepts:
595: .TP
596: .B \-ansi
597: .I
598: Support all ANSI standard C programs.
599: .I
600:
601: This turns off certain features of GNU C that are incompatible with
602: ANSI C, such as the \c
603: .B asm\c
604: \&, \c
605: .B inline\c
606: \& and \c
607: .B typeof\c
608: \&
609: keywords, and predefined macros such as \c
610: .B unix\c
611: \& and \c
612: .B vax\c
613: \&
614: that identify the type of system you are using. It also enables the
615: undesirable and rarely used ANSI trigraph feature, and makes the
616: preprocessor accept `\|\c
617: .B $\c
618: \&\|' as part of identifiers.
619:
620: The alternate keywords \c
621: .B __asm__\c
622: \&, \c
623: .B __extension__\c
624: \&,
625: \c
626: .B __inline__\c
627: \& and \c
628: .B __typeof__\c
629: \& continue to work despite
630: `\|\c
631: .B \-ansi\c
632: \&\|'. You would not want to use them in an ANSI C program, of
633: course, but it is useful to put them in header files that might be included
634: in compilations done with `\|\c
635: .B \-ansi\c
636: \&\|'. Alternate predefined macros
637: such as \c
638: .B __unix__\c
639: \& and \c
640: .B __vax__\c
641: \& are also available, with or
642: without `\|\c
643: .B \-ansi\c
644: \&\|'.
645:
646: The `\|\c
647: .B \-ansi\c
648: \&\|' option does not cause non-ANSI programs to be
649: rejected gratuitously. For that, `\|\c
650: .B \-pedantic\c
651: \&\|' is required in
652: addition to `\|\c
653: .B \-ansi\c
654: \&\|'.
655:
656: The preprocessor predefines a macro \c
657: .B __STRICT_ANSI__\c
658: \& when you use the `\|\c
659: .B \-ansi\c
660: \&\|'
661: option. Some header files may notice this macro and refrain
662: from declaring certain functions or defining certain macros that the
663: ANSI standard doesn't call for; this is to avoid interfering with any
664: programs that might use these names for other things.
665: .TP
666: .B \-fno\-asm
667: Do not recognize \c
668: .B asm\c
669: \&, \c
670: .B inline\c
671: \& or \c
672: .B typeof\c
673: \& as a
674: keyword. These words may then be used as identifiers. You can
675: use \c
676: .B __asm__\c
677: \&, \c
678: .B __inline__\c
679: \& and \c
680: .B __typeof__\c
681: \& instead.
682: `\|\c
683: .B \-ansi\c
684: \&\|' implies `\|\c
685: .B \-fno\-asm\c
686: \&\|'.
687: .TP
688: .B \-fno\-builtin
689: .I (Ignored for C++.)
690: Don't recognize non-ANSI built-in functions. `\|\c
691: .B \-ansi\c
692: \&\|' also has this
693: effect. Currently, the only function affected is
694: .B alloca\c
695: \&.
696: .TP
697: .B \-fno\-strict\-prototype
698: .I
699: (C++ only.)
700: Consider the declaration \c
701: .B int foo ();\c
702: \&. In C++, this means that the
703: function \c
704: .B foo\c
705: \& takes no arguments. In ANSI C, this is declared
706: .B int foo(void);\c
707: \&. With the flag `\|\c
708: .B \-fno\-strict\-prototype\c
709: \&\|',
710: declaring functions with no arguments is equivalent to declaring its
711: argument list to be untyped, i.e., \c
712: .B int foo ();\c
713: \& is equivalent to
714: saying \c
715: .B int foo (...);\c
716: \&.
717: .TP
718: .B \-trigraphs
719: Support ANSI C trigraphs. The `\|\c
720: .B \-ansi\c
721: \&\|' option implies `\|\c
722: .B \-trigraphs\c
723: \&\|'.
724: .TP
725: .B \-traditional
726: Attempt to support some aspects of traditional C compilers.
727:
728: Specifically, for both C and C++ programs:
729: .TP
730: \ \ \ \(bu
731: In the preprocessor, comments convert to nothing at all, rather than
732: to a space. This allows traditional token concatenation.
733: .TP
734: \ \ \ \(bu
735: In the preprocessor, macro arguments are recognized within string
736: constants in a macro definition (and their values are stringified,
737: though without additional quote marks, when they appear in such a
738: context). The preprocessor always considers a string constant to end
739: at a newline.
740: .TP
741: \ \ \ \(bu
742: The preprocessor does not predefine the macro \c
743: .B __STDC__\c
744: \& when you use
745: `\|\c
746: .B \-traditional\c
747: \&\|', but still predefines\c
748: .B __GNUC__\c
749: \& (since the GNU extensions indicated by
750: .B __GNUC__\c
751: \& are not affected by
752: `\|\c
753: .B \-traditional\c
754: \&\|'). If you need to write header files that work
755: differently depending on whether `\|\c
756: .B \-traditional\c
757: \&\|' is in use, by
758: testing both of these predefined macros you can distinguish four
759: situations: GNU C, traditional GNU C, other ANSI C compilers, and
760: other old C compilers.
761: .TP
762: \ \ \ \(bu
763: In the preprocessor, comments convert to nothing at all, rather than
764: to a space. This allows traditional token concatenation.
765: .TP
766: \ \ \ \(bu
767: In the preprocessor, macro arguments are recognized within string
768: constants in a macro definition (and their values are stringified,
769: though without additional quote marks, when they appear in such a
770: context). The preprocessor always considers a string constant to end
771: at a newline.
772: .TP
773: \ \ \ \(bu
774: The preprocessor does not predefine the macro \c
775: .B __STDC__\c
776: \& when you use
777: `\|\c
778: .B \-traditional\c
779: \&\|', but still predefines\c
780: .B __GNUC__\c
781: \& (since the GNU extensions indicated by
782: .B __GNUC__\c
783: \& are not affected by
784: `\|\c
785: .B \-traditional\c
786: \&\|'). If you need to write header files that work
787: differently depending on whether `\|\c
788: .B \-traditional\c
789: \&\|' is in use, by
790: testing both of these predefined macros you can distinguish four
791: situations: GNU C, traditional GNU C, other ANSI C compilers, and
792: other old C compilers.
793: .PP
794: .TP
795: \ \ \ \(bu
796: String ``constants'' are not necessarily constant; they are stored in
797: writable space, and identical looking constants are allocated
798: separately. (This is the same as the effect of
799: `\|\c
800: .B \-fwritable\-strings\c
801: \&\|'.)
802:
803: In addition, `\|\c
804: .B \-traditional\c
805: \&\|' has these effects for C programs (not C++):
806: .TP
807: \ \ \ \(bu
808: All \c
809: .B extern\c
810: \& declarations take effect globally even if they
811: are written inside of a function definition. This includes implicit
812: declarations of functions.
813: .TP
814: \ \ \ \(bu
815: The keywords \c
816: .B typeof\c
817: \&, \c
818: .B inline\c
819: \&, \c
820: .B signed\c
821: \&, \c
822: .B const\c
823: \&
824: and \c
825: .B volatile\c
826: \& are not recognized. (You can still use the
827: alternative keywords such as \c
828: .B __typeof__\c
829: \&, \c
830: .B __inline__\c
831: \&, and
832: so on.)
833: .TP
834: \ \ \ \(bu
835: Comparisons between pointers and integers are always allowed.
836: .TP
837: \ \ \ \(bu
838: Integer types \c
839: .B unsigned short\c
840: \& and \c
841: .B unsigned char\c
842: \& promote
843: to \c
844: .B unsigned int\c
845: \&.
846: .TP
847: \ \ \ \(bu
848: Out-of-range floating point literals are not an error.
849: .TP
850: \ \ \ \(bu
851: All automatic variables not declared \c
852: .B register\c
853: \& are preserved by
854: \c
855: .B longjmp\c
856: \&. Ordinarily, GNU C follows ANSI C: automatic variables
857: not declared \c
858: .B volatile\c
859: \& may be clobbered.
860:
861: Finally, for C++ programs only (not C), `\|\c
862: .B \-traditional\c
863: \&\|' has one additional effect: assignment to
864: .B this
865: is permitted. This is the same as the effect of `\|\c
866: .B \-fthis\-is\-variable\c
867: \&\|'.
868: .TP
869: .B \-traditional\-cpp
870: Attempt to support some aspects of traditional C preprocessors.
871: This includes the items that specifically mention the preprocessor above,
872: but none of the other effects of `\|\c
873: .B \-traditional\c
874: \&\|'.
875: .TP
876: .B \-fdollars\-in\-identifiers
877: .I
878: (C++ only.)
879: Permit the use of `\|\c
880: .B $\c
881: \&\|' in identifiers. (For GNU C, this is the default, and you can
882: forbid it with `\|\c
883: .B \-ansi\c
884: \&\|'.)
885: Traditional C allowed the character `\|\c
886: .B $\c
887: \&\|' to form part of identifiers; by default, GNU C also
888: allows this. However, ANSI C forbids `\|\c
889: .B $\c
890: \&\|' in identifiers, and GNU C++ also forbids it by default on most
891: platforms (though on some platforms it's enabled by default for GNU
892: C++ as well).
893: .TP
894: .B \-fenum\-int\-equiv
895: .I
896: (C++ only.)
897: Normally GNU C++ allows conversion of
898: .B enum
899: to
900: .B int\c
901: \&, but not the other way around. Use this option if you want GNU C++
902: to allow conversion of
903: .B int
904: to
905: .B enum
906: as well.
907: .TP
908: .B \-fall\-virtual
909: .I
910: (C++ only.)
911: When you use the `\|\c
912: .B \-fall\-virtual\c
913: \&\|', all member functions
914: (except for constructor functions and new/delete member operators)
915: declared in the same class with a ``method-call'' operator method are
916: treated as virtual functions of the given class. In effect, all
917: of these methods become ``implicitly virtual.''
918:
919: This does \c
920: .I not\c
921: \& mean that all calls to these methods will be made through the
922: internal table of virtual functions. There are some circumstances
923: under which it is obvious that a call to a given virtual function can
924: be made directly, and in these cases the calls still go direct.
925:
926: The effect of making all methods of a class with a declared
927: \&`\|\c
928: .B
929: operator->()()\c
930: \&\|' implicitly virtual using `\|\c
931: .B \-fall\-virtual\c
932: \&\|' extends
933: also to all non-constructor methods of any class derived from such a
934: class.
935: .TP
936: .B \-fcond\-mismatch
937: Allow conditional expressions with mismatched types in the second and
938: third arguments. The value of such an expression is void.
939: .TP
940: .B \-fthis\-is\-variable
941: .I
942: (C++ only.)
943: The incorporation of user-defined free store management into C++ has
944: made assignment to \c
945: .B this\c
946: \& an anachronism. Therefore, by default GNU
947: C++ treats the type of \c
948: .B this\c
949: \& in a member function of \c
950: .B class X\c
951: \&
952: to be \c
953: .B X *const\c
954: \&. In other words, it is illegal to assign to
955: \c
956: .B this\c
957: \& within a class member function. However, for backwards
958: compatibility, you can invoke the old behavior by using
959: \&`\|\c
960: .B \-fthis\-is\-variable\c
961: \&\|'.
962: .TP
963: .B \-funsigned\-char
964: Let the type \c
965: .B char\c
966: \& be unsigned, like \c
967: .B unsigned char\c
968: \&.
969:
970: Each kind of machine has a default for what \c
971: .B char\c
972: \& should
973: be. It is either like \c
974: .B unsigned char\c
975: \& by default or like
976: \c
977: .B signed char\c
978: \& by default.
979:
980: Ideally, a portable program should always use \c
981: .B signed char\c
982: \& or
983: \c
984: .B unsigned char\c
985: \& when it depends on the signedness of an object.
986: But many programs have been written to use plain \c
987: .B char\c
988: \& and
989: expect it to be signed, or expect it to be unsigned, depending on the
990: machines they were written for. This option, and its inverse, let you
991: make such a program work with the opposite default.
992:
993: The type \c
994: .B char\c
995: \& is always a distinct type from each of
996: \c
997: .B signed char\c
998: \& and \c
999: .B unsigned char\c
1000: \&, even though its behavior
1001: is always just like one of those two.
1002:
1003: .TP
1004: .B \-fsigned\-char
1005: Let the type \c
1006: .B char\c
1007: \& be signed, like \c
1008: .B signed char\c
1009: \&.
1010:
1011: Note that this is equivalent to `\|\c
1012: .B \-fno\-unsigned\-char\c
1013: \&\|', which is
1014: the negative form of `\|\c
1015: .B \-funsigned\-char\c
1016: \&\|'. Likewise,
1017: `\|\c
1018: .B \-fno\-signed\-char\c
1019: \&\|' is equivalent to `\|\c
1020: .B \-funsigned\-char\c
1021: \&\|'.
1022: .TP
1023: .B \-fsigned\-bitfields
1024: .TP
1025: .B \-funsigned\-bitfields
1026: .TP
1027: .B \-fno\-signed\-bitfields
1028: .TP
1029: .B \-fno\-unsigned\-bitfields
1030: These options control whether a bitfield is
1031: signed or unsigned, when declared with no explicit `\|\c
1032: .B signed\c
1033: \&\|' or `\|\c
1034: .B unsigned\c
1035: \&\|' qualifier. By default, such a bitfield is
1036: signed, because this is consistent: the basic integer types such as
1037: \c
1038: .B int\c
1039: \& are signed types.
1040:
1041: However, when you specify `\|\c
1042: .B \-traditional\c
1043: \&\|', bitfields are all unsigned
1044: no matter what.
1045: .TP
1046: .B \-fwritable\-strings
1047: Store string constants in the writable data segment and don't uniquize
1048: them. This is for compatibility with old programs which assume they
1049: can write into string constants. `\|\c
1050: .B \-traditional\c
1051: \&\|' also has this
1052: effect.
1053:
1054: Writing into string constants is a very bad idea; ``constants'' should
1055: be constant.
1056: .PP
1057:
1058: .SH PREPROCESSOR OPTIONS
1059: These options control the C preprocessor, which is run on each C source
1060: file before actual compilation.
1061:
1062: If you use the `\|\c
1063: .B \-E\c
1064: \&\|' option, GCC does nothing except preprocessing.
1065: Some of these options make sense only together with `\|\c
1066: .B \-E\c
1067: \&\|' because
1068: they cause the preprocessor output to be unsuitable for actual
1069: compilation.
1070: .TP
1071: .BI "\-i " file\c
1072: \&
1073: Process \c
1074: .I file\c
1075: \& as input, discarding the resulting output, before
1076: processing the regular input file. Because the output generated from
1077: \c
1078: .I file\c
1079: \& is discarded, the only effect of `\|\c
1080: .B \-i \c
1081: .I file\c
1082: \&\c
1083: \&\|' is to
1084: make the macros defined in \c
1085: .I file\c
1086: \& available for use in the main
1087: input. The preprocessor evaluates any `\|\c
1088: .B \-D\c
1089: \&\|' and `\|\c
1090: .B \-U\c
1091: \&\|' options
1092: on the command line before processing `\|\c
1093: .B \-i\c
1094: \&\|' \c
1095: .I file\c
1096: \&.
1097: .TP
1098: .B \-nostdinc
1099: Do not search the standard system directories for header files. Only
1100: the directories you have specified with `\|\c
1101: .B \-I\c
1102: \&\|' options (and the
1103: current directory, if appropriate) are searched.
1104:
1105: By using both `\|\c
1106: .B \-nostdinc\c
1107: \&\|' and `\|\c
1108: .B \-I\-\c
1109: \&\|', you can limit the include-file search file to only those
1110: directories you specify explicitly.
1111: .TP
1112: .B \-undef
1113: Do not predefine any nonstandard macros. (Including architecture flags).
1114: .TP
1115: .B \-E
1116: Run only the C preprocessor. Preprocess all the C source files
1117: specified and output the results to standard output or to the
1118: specified output file.
1119: .TP
1120: .B \-C
1121: Tell the preprocessor not to discard comments. Used with the
1122: `\|\c
1123: .B \-E\c
1124: \&\|' option.
1125: .TP
1126: .B \-P
1127: Tell the preprocessor not to generate `\|\c
1128: .B #line\c
1129: \&\|' commands.
1130: Used with the `\|\c
1131: .B \-E\c
1132: \&\|' option.
1133: .TP
1134: .B \-M
1135: Tell the preprocessor to output a rule suitable for \c
1136: .B make\c
1137: \&
1138: describing the dependencies of each object file. For each source file,
1139: the preprocessor outputs one \c
1140: .B make\c
1141: \&-rule whose target is the object
1142: file name for that source file and whose dependencies are all the files
1143: `\|\c
1144: .B #include\c
1145: \&\|'d in it. This rule may be a single line or may be
1146: continued with `\|\c
1147: .B \e\c
1148: \&\|'-newline if it is long. The list of rules is
1149: printed on standard output instead of the preprocessed C program.
1150:
1151: `\|\c
1152: .B \-M\c
1153: \&\|' implies `\|\c
1154: .B \-E\c
1155: \&\|'.
1156: .TP
1157: .B \-MM
1158: Like `\|\c
1159: .B \-M\c
1160: \&\|' but the output mentions only the user header files
1161: included with `\|\c
1162: .B #include "\c
1163: .I file\c
1164: \&"\c
1165: \&\|'. System header files
1166: included with `\|\c
1167: .B #include <\c
1168: .I file\c
1169: \&>\c
1170: \&\|' are omitted.
1171: .TP
1172: .B \-MD
1173: Like `\|\c
1174: .B \-M\c
1175: \&\|' but the dependency information is written to files with
1176: names made by replacing `\|\c
1177: .B .c\c
1178: \&\|' with `\|\c
1179: .B .d\c
1180: \&\|' at the end of the
1181: input file names. This is in addition to compiling the file as
1182: specified\(em\&`\|\c
1183: .B \-MD\c
1184: \&\|' does not inhibit ordinary compilation the way
1185: `\|\c
1186: .B \-M\c
1187: \&\|' does.
1188:
1189: The Mach utility `\|\c
1190: .B md\c
1191: \&\|' can be used to merge the `\|\c
1192: .B .d\c
1193: \&\|' files
1194: into a single dependency file suitable for using with the `\|\c
1195: .B make\c
1196: \&\|'
1197: command.
1198: .TP
1199: .B \-MMD
1200: Like `\|\c
1201: .B \-MD\c
1202: \&\|' except mention only user header files, not system
1203: header files.
1204: .TP
1205: .B \-H
1206: Print the name of each header file used, in addition to other normal
1207: activities.
1208: .TP
1209: .BI \-D macro
1210: Define macro \c
1211: .I macro\c
1212: \& with the string `\|\c
1213: .B 1\c
1214: \&\|' as its definition.
1215: .TP
1216: .BI \-D macro = defn
1217: Define macro \c
1218: .I macro\c
1219: \& as \c
1220: .I defn\c
1221: \&. All instances of `\|\c
1222: .B \-D\c
1223: \&\|' on
1224: the command line are processed before any `\|\c
1225: .B \-U\c
1226: \&\|' or `\|\c
1227: .B \-i\c
1228: \&\|' options.
1229: .TP
1230: .BI \-U macro
1231: Undefine macro \c
1232: .I macro\c
1233: \&. `\|\c
1234: .B \-U\c
1235: \&\|' options are evaluated after all `\|\c
1236: .B \-D\c
1237: \&\|' options, but before any `\|\c
1238: .B \-i\c
1239: \&\|' options.
1240: .TP
1241: .B \-dM
1242: Tell the preprocessor to output only a list of the macro definitions
1243: that are in effect at the end of preprocessing. Used with the `\|\c
1244: .B \-E\c
1245: \&\|'
1246: option.
1247: .TP
1248: .B \-dD
1249: Tell the preprocessing to pass all macro definitions into the output, in
1250: their proper sequence in the rest of the output.
1251: .TP
1252: .B \-dN
1253: Like `\|\c
1254: .B \-dD\c
1255: \&\|' except that the macro arguments and contents are omitted.
1256: Only `\|\c
1257: .B #define \c
1258: .I name\c
1259: \&\c
1260: \&\|' is included in the output.
1261: .PP
1262:
1263: .SH LINKER OPTIONS
1264: These options come into play when the compiler links object files into
1265: an executable output file. They are meaningless if the compiler is
1266: not doing a link step.
1267: .TP
1268: .I object-file-name
1269: A file name that does not end in a special recognized suffix is
1270: considered to name an object file or library. (Object files are
1271: distinguished from libraries by the linker according to the file
1272: contents.) If GCC does a link step, these object files are used as input
1273: to the linker.
1274: .TP
1275: .B \-dynamic
1276: On systems that support dynamic linking, you can use this option to
1277: request it explicitly.
1278: .TP
1279: .BI \-l library\c
1280: \&
1281: Use the library named \c
1282: .I library\c
1283: \& when linking.
1284:
1285: The linker searches a standard list of directories for the library,
1286: which is actually a file named `\|\c
1287: .B lib\c
1288: .I library\c
1289: \&.a\c
1290: \&\|'. The linker
1291: then uses this file as if it had been specified precisely by name.
1292:
1293: The directories searched include several standard system directories
1294: plus any that you specify with `\|\c
1295: .B \-L\c
1296: \&\|'.
1297:
1298: Normally the files found this way are library files\(em\&archive files
1299: whose members are object files. The linker handles an archive file by
1300: scanning through it for members which define symbols that have so far
1301: been referenced but not defined. However, if the linker finds an
1302: ordinary object file rather than a library, the object file is linked
1303: in the usual fashion. The only difference between using an `\|\c
1304: .B \-l\c
1305: \&\|' option and specifying a file
1306: name is that `\|\c
1307: .B \-l\c
1308: \&\|' surrounds
1309: .I library
1310: with `\|\c
1311: .B lib\c
1312: \&\|' and `\|\c
1313: .B .a\c
1314: \&\|' and searches several directories.
1315: .TP
1316: .B \-nostdlib
1317: Don't use the standard system libraries and startup files when linking.
1318: Only the files you specify will be passed to the linker.
1319: .TP
1320: .B \-static
1321: On systems that support dynamic linking, this prevents linking with the shared
1322: libraries. (`\|\c
1323: .B \-g\c
1324: \&\|' also has this effect.) On other systems, this option has no effect.
1325: .PP
1326:
1327: .SH DIRECTORY OPTIONS
1328: These options specify directories to search for header files, for
1329: libraries and for parts of the compiler:
1330: .TP
1331: .BI "\-I" "dir"\c
1332: \&
1333: Append directory \c
1334: .I dir\c
1335: \& to the list of directories searched for include files.
1336: .TP
1337: .B \-I\-
1338: Any directories you specify with `\|\c
1339: .B \-I\c
1340: \&\|' options before the `\|\c
1341: .B \-I\-\c
1342: \&\|'
1343: option are searched only for the case of `\|\c
1344: .B
1345: #include "\c
1346: .I file\c
1347: .B
1348: \&"\c
1349: \&\|';
1350: they are not searched for `\|\c
1351: .B #include <\c
1352: .I file\c
1353: \&>\c
1354: \&\|'.
1355:
1356: If additional directories are specified with `\|\c
1357: .B \-I\c
1358: \&\|' options after
1359: the `\|\c
1360: .B \-I\-\c
1361: \&\|', these directories are searched for all `\|\c
1362: .B #include\c
1363: \&\|'
1364: directives. (Ordinarily \c
1365: .I all\c
1366: \& `\|\c
1367: .B \-I\c
1368: \&\|' directories are used
1369: this way.)
1370:
1371: In addition, the `\|\c
1372: .B \-I\-\c
1373: \&\|' option inhibits the use of the current
1374: directory (where the current input file came from) as the first search
1375: directory for `\|\c
1376: .B
1377: #include "\c
1378: .I file\c
1379: .B
1380: \&"\c
1381: \&\|'. There is no way to
1382: override this effect of `\|\c
1383: .B \-I\-\c
1384: \&\|'. With `\|\c
1385: .B \-I.\c
1386: \&\|' you can specify
1387: searching the directory which was current when the compiler was
1388: invoked. That is not exactly the same as what the preprocessor does
1389: by default, but it is often satisfactory.
1390:
1391: `\|\c
1392: .B \-I\-\c
1393: \&\|' does not inhibit the use of the standard system directories
1394: for header files. Thus, `\|\c
1395: .B \-I\-\c
1396: \&\|' and `\|\c
1397: .B \-nostdinc\c
1398: \&\|' are
1399: independent.
1400: .TP
1401: .BI "\-L" "dir"\c
1402: \&
1403: Add directory \c
1404: .I dir\c
1405: \& to the list of directories to be searched
1406: for `\|\c
1407: .B \-l\c
1408: \&\|'.
1409: .TP
1410: .BI "\-B" "prefix"\c
1411: \&
1412: This option specifies where to find the executables, libraries and
1413: data files of the compiler itself.
1414:
1415: The compiler driver program runs one or more of the subprograms
1416: `\|\c
1417: .B cpp\c
1418: \&\|', `\|\c
1419: .B cc1\c
1420: \&\|' (or, for C++, `\|\c
1421: .B cc1plus\c
1422: \&\|'), `\|\c
1423: .B as\c
1424: \&\|' and `\|\c
1425: .B ld\c
1426: \&\|'. It tries
1427: \c
1428: .I prefix\c
1429: \& as a prefix for each program it tries to run, both with and
1430: without `\|\c
1431: .B \c
1432: .I machine\c
1433: \&/\c
1434: .I version\c
1435: \&/\c
1436: \&\|'.
1437:
1438: For each subprogram to be run, the compiler driver first tries the
1439: `\|\c
1440: .B \-B\c
1441: \&\|' prefix, if any. If that name is not found, or if `\|\c
1442: .B \-B\c
1443: \&\|'
1444: was not specified, the driver tries two standard prefixes, which are
1445: `\|\c
1446: .B /usr/lib/gcc/\c
1447: \&\|' and `\|\c
1448: .B /usr/local/lib/gcc/\c
1449: \&\|'. If neither of
1450: those results in a file name that is found, the compiler driver
1451: searches for the unmodified program
1452: name, using the directories specified in your
1453: `\|\c
1454: .B PATH\c
1455: \&\|' environment variable.
1456:
1457: The run-time support file `\|\c
1458: .B libgcc.a\c
1459: \&\|' is also searched for using the
1460: `\|\c
1461: .B \-B\c
1462: \&\|' prefix, if needed. If it is not found there, the two
1463: standard prefixes above are tried, and that is all. The file is left
1464: out of the link if it is not found by those means. Most of the time,
1465: on most machines, `\|\c
1466: .B libgcc.a\c
1467: \&\|' is not actually necessary.
1468:
1469: You can get a similar result from the environment variable
1470: \c
1471: .B GCC_EXEC_PREFIX\c
1472: \&; if it is defined, its value is used as a prefix
1473: in the same way. If both the `\|\c
1474: .B \-B\c
1475: \&\|' option and the
1476: \c
1477: .B GCC_EXEC_PREFIX\c
1478: \& variable are present, the `\|\c
1479: .B \-B\c
1480: \&\|' option is
1481: used first and the environment variable value second.
1482: .PP
1483:
1484: .SH WARNING OPTIONS
1485: Warnings are diagnostic messages that report constructions which
1486: are not inherently erroneous but which are risky or suggest there
1487: may have been an error.
1488:
1489: These options control the amount and kinds of warnings produced by GNU
1490: CC:
1491: .TP
1492: .B \-fsyntax\-only
1493: Check the code for syntax errors, but don't emit any output.
1494: .TP
1495: .B \-w
1496: Inhibit all warning messages.
1497: .TP
1498: .B \-pedantic
1499: Issue all the warnings demanded by strict ANSI standard C; reject
1500: all programs that use forbidden extensions.
1501:
1502: Valid ANSI standard C programs should compile properly with or without
1503: this option (though a rare few will require `\|\c
1504: .B \-ansi\c
1505: \&\|'). However,
1506: without this option, certain GNU extensions and traditional C features
1507: are supported as well. With this option, they are rejected. There is
1508: no reason to \c
1509: .I use\c
1510: \& this option; it exists only to satisfy pedants.
1511:
1512: `\|\c
1513: .B \-pedantic\c
1514: \&\|' does not cause warning messages for use of the
1515: alternate keywords whose names begin and end with `\|\c
1516: .B __\c
1517: \&\|'. Pedantic
1518: warnings are also disabled in the expression that follows
1519: \c
1520: .B __extension__\c
1521: \&. However, only system header files should use
1522: these escape routes; application programs should avoid them.
1523: .TP
1524: .B \-pedantic\-errors
1525: Like `\|\c
1526: .B \-pedantic\c
1527: \&\|', except that errors are produced rather than
1528: warnings.
1529: .TP
1530: .B \-Werror
1531: Treat warnings as errors; abort compilation after any warning.
1532: .TP
1533: .B \-W
1534: Print extra warning messages for these events:
1535: .TP
1536: \ \ \ \(bu
1537: A nonvolatile automatic variable might be changed by a call to
1538: \c
1539: .B longjmp\c
1540: \&. These warnings are possible only in
1541: optimizing compilation.
1542:
1543: The compiler sees only the calls to \c
1544: .B setjmp\c
1545: \&. It cannot know
1546: where \c
1547: .B longjmp\c
1548: \& will be called; in fact, a signal handler could
1549: call it at any point in the code. As a result, you may get a warning
1550: even when there is in fact no problem because \c
1551: .B longjmp\c
1552: \& cannot
1553: in fact be called at the place which would cause a problem.
1554: .TP
1555: \ \ \ \(bu
1556: A function can return either with or without a value. (Falling
1557: off the end of the function body is considered returning without
1558: a value.) For example, this function would evoke such a
1559: warning:
1560: .sp
1561: .br
1562: foo\ (a)
1563: .br
1564: {
1565: .br
1566: \ \ if\ (a\ >\ 0)
1567: .br
1568: \ \ \ \ return\ a;
1569: .br
1570: }
1571: .br
1572: .sp
1573:
1574: Spurious warnings can occur because GNU CC does not realize that
1575: certain functions (including \c
1576: .B abort\c
1577: \& and \c
1578: .B longjmp\c
1579: \&)
1580: will never return.
1581: .TP
1582: \ \ \ \(bu
1583: An expression-statement contains no side effects.
1584: .TP
1585: \ \ \ \(bu
1586: An unsigned value is compared against zero with `\|\c
1587: .B >\c
1588: \&\|' or `\|\c
1589: .B <=\c
1590: \&\|'.
1591: .PP
1592: .TP
1593: .B \-Wimplicit
1594: Warn whenever a function or parameter is implicitly declared.
1595: .TP
1596: .B \-Wreturn\-type
1597: Warn whenever a function is defined with a return-type that defaults
1598: to \c
1599: .B int\c
1600: \&. Also warn about any \c
1601: .B return\c
1602: \& statement with no
1603: return-value in a function whose return-type is not \c
1604: .B void\c
1605: \&.
1606: .TP
1607: .B \-Wunused
1608: Warn whenever a local variable is unused aside from its declaration,
1609: whenever a function is declared static but never defined, and whenever
1610: a statement computes a result that is explicitly not used.
1611: .TP
1612: .B \-Wswitch
1613: Warn whenever a \c
1614: .B switch\c
1615: \& statement has an index of enumeral type
1616: and lacks a \c
1617: .B case\c
1618: \& for one or more of the named codes of that
1619: enumeration. (The presence of a \c
1620: .B default\c
1621: \& label prevents this
1622: warning.) \c
1623: .B case\c
1624: \& labels outside the enumeration range also
1625: provoke warnings when this option is used.
1626: .TP
1627: .B \-Wcomment
1628: Warn whenever a comment-start sequence `\|\c
1629: .B /*\c
1630: \&\|' appears in a comment.
1631: .TP
1632: .B \-Wtrigraphs
1633: Warn if any trigraphs are encountered (assuming they are enabled).
1634: .TP
1635: .B \-Waggregate\-return
1636: Warn if any functions that return structures or unions are defined or
1637: called. (In languages where you can return an array, this also elicits
1638: a warning.)
1639: .TP
1640: .B \-Wformat
1641: Check calls to \c
1642: .B printf\c
1643: \& and \c
1644: .B scanf\c
1645: \&, etc., to make sure that
1646: the arguments supplied have types appropriate to the format string
1647: specified.
1648: .TP
1649: .B \-Wuninitialized
1650: An automatic variable is used without first being initialized.
1651:
1652: These warnings are possible only in optimizing compilation,
1653: because they require data flow information that is computed only
1654: when optimizing. If you don't specify `\|\c
1655: .B \-O\c
1656: \&\|', you simply won't
1657: get these warnings.
1658:
1659: These warnings occur only for variables that are candidates for
1660: register allocation. Therefore, they do not occur for a variable that
1661: is declared \c
1662: .B volatile\c
1663: \&, or whose address is taken, or whose size
1664: is other than 1, 2, 4 or 8 bytes. Also, they do not occur for
1665: structures, unions or arrays, even when they are in registers.
1666:
1667: Note that there may be no warning about a variable that is used only
1668: to compute a value that itself is never used, because such
1669: computations may be deleted by data flow analysis before the warnings
1670: are printed.
1671:
1672: These warnings are made optional because GNU CC is not smart
1673: enough to see all the reasons why the code might be correct
1674: despite appearing to have an error. Here is one example of how
1675: this can happen:
1676:
1677: .sp
1678: .br
1679: {
1680: .br
1681: \ \ int\ x;
1682: .br
1683: \ \ switch\ (y)
1684: .br
1685: \ \ \ \ {
1686: .br
1687: \ \ \ \ case\ 1:\ x\ =\ 1;
1688: .br
1689: \ \ \ \ \ \ break;
1690: .br
1691: \ \ \ \ case\ 2:\ x\ =\ 4;
1692: .br
1693: \ \ \ \ \ \ break;
1694: .br
1695: \ \ \ \ case\ 3:\ x\ =\ 5;
1696: .br
1697: \ \ \ \ }
1698: .br
1699: \ \ foo\ (x);
1700: .br
1701: }
1702: .br
1703: .sp
1704:
1705:
1706: If the value of \c
1707: .B y\c
1708: \& is always 1, 2 or 3, then \c
1709: .B x\c
1710: \& is
1711: always initialized, but GNU CC doesn't know this. Here is
1712: another common case:
1713:
1714: .sp
1715: .br
1716: {
1717: .br
1718: \ \ int\ save_y;
1719: .br
1720: \ \ if\ (change_y)\ save_y\ =\ y,\ y\ =\ new_y;
1721: .br
1722: \ \ .\|.\|.
1723: .br
1724: \ \ if\ (change_y)\ y\ =\ save_y;
1725: .br
1726: }
1727: .br
1728: .sp
1729:
1730:
1731: This has no bug because \c
1732: .B save_y\c
1733: \& is used only if it is set.
1734:
1735: Some spurious warnings can be avoided if you declare as
1736: \c
1737: .B volatile\c
1738: \& all the functions you use that never return.
1739: .TP
1740: .B \-Wstrict\-prototypes
1741: Warn if a function is declared or defined without specifying the
1742: argument types. (An old-style function definition is permitted without
1743: a warning if preceded by a declaration which specifies the argument
1744: types.)
1745: .TP
1746: .B \-Wmissing\-prototypes
1747: Warn if a global function is defined without a previous prototype
1748: declaration. This warning is issued even if the definition itself
1749: provides a prototype. The aim is to detect global functions that fail
1750: to be declared in header files.
1751: .TP
1752: .B \-Wall
1753: All of the above `\|\c
1754: .B \-W\c
1755: \&\|' options combined. These are all the
1756: options which pertain to usage that we recommend avoiding and that we
1757: believe is easy to avoid, even in conjunction with macros.
1758: .PP
1759:
1760: The remaining `\|\c
1761: .B \-W.\|.\|.\c
1762: \&\|' options are not implied by `\|\c
1763: .B \-Wall\c
1764: \&\|'
1765: because they warn about constructions that we consider reasonable to
1766: use, on occasion, in clean programs.
1767: .TP
1768: .B \-Wtraditional
1769: Warn about certain constructs that behave differently in traditional and
1770: ANSI C.
1771: .TP
1772: \ \ \ \(bu
1773: Macro arguments occurring within string constants in the macro body.
1774: These would substitute the argument in traditional C, but are part of
1775: the constant in ANSI C.
1776: .TP
1777: \ \ \ \(bu
1778: A function declared external in one block and then used after the end of
1779: the block.
1780: .TP
1781: \ \ \ \(bu
1782: A \c
1783: .B switch\c
1784: \& statement has an operand of type \c
1785: .B long\c
1786: \&.
1787: .PP
1788: .TP
1789: .B \-Wshadow
1790: Warn whenever a local variable shadows another local variable.
1791: .TP
1792: .BI "\-Wid\-clash\-" "len"\c
1793: \&
1794: Warn whenever two distinct identifiers match in the first \c
1795: .I len\c
1796: \&
1797: characters. This may help you prepare a program that will compile
1798: with certain obsolete, brain-damaged compilers.
1799: .TP
1800: .B \-Wpointer\-arith
1801: Warn about anything that depends on the ``size of'' a function type or
1802: of \c
1803: .B void\c
1804: \&. GNU C assigns these types a size of 1, for
1805: convenience in calculations with \c
1806: .B void *\c
1807: \& pointers and pointers
1808: to functions.
1809: .TP
1810: .B \-Wcast\-qual
1811: Warn whenever a pointer is cast so as to remove a type qualifier from
1812: the target type. For example, warn if a \c
1813: .B const char *\c
1814: \& is cast
1815: to an ordinary \c
1816: .B char *\c
1817: \&.
1818: .TP
1819: .B \-Wcast\-align
1820: Warn whenever a pointer is cast such that the required alignment of the
1821: target is increased. For example, warn if a \c
1822: .B char *\c
1823: \& is cast to
1824: an \c
1825: .B int *\c
1826: \& on machines where integers can only be accessed at
1827: two- or four-byte boundaries.
1828: .TP
1829: .B \-Wwrite\-strings
1830: Give string constants the type \c
1831: .B const char[\c
1832: .I length\c
1833: \&]\c
1834: \& so that
1835: copying the address of one into a non-\c
1836: .B const\c
1837: \& \c
1838: .B char *\c
1839: \&
1840: pointer will get a warning. These warnings will help you find at
1841: compile time code that can try to write into a string constant, but
1842: only if you have been very careful about using \c
1843: .B const\c
1844: \& in
1845: declarations and prototypes. Otherwise, it will just be a nuisance;
1846: this is why we did not make `\|\c
1847: .B \-Wall\c
1848: \&\|' request these warnings.
1849: .TP
1850: .B \-Wconversion
1851: Warn if a prototype causes a type conversion that is different from what
1852: would happen to the same argument in the absence of a prototype. This
1853: includes conversions of fixed point to floating and vice versa, and
1854: conversions changing the width or signedness of a fixed point argument
1855: except when the same as the default promotion.
1856: .TP
1857: .B \-Wenum\-clash
1858: .I (C++ only.)
1859: Warn when converting between different enumeration types.
1860: .TP
1861: .B \-Wno\-parentheses
1862: Disable warnings that parentheses are suggested around an expression.
1863: .TP
1864: .B \-Woverloaded\-virtual
1865: .I (C++ only.)
1866: In a derived class, the definitions of virtual functions must match
1867: the type signature of a virtual function declared in the base class.
1868: Use this option to request warnings when a derived class declares a
1869: function that may be an erroneous attempt to define a virtual
1870: function: that is, warn when a function with the same name as a
1871: virtual function in the base class, but with a type signature that
1872: doesn't match any virtual functions from the base class.
1873: .PP
1874:
1875: .SH DEBUGGING OPTIONS
1876: GNU CC has various special options that are used for debugging
1877: either your program or GCC:
1878: .TP
1879: .B \-g
1880: Produce debugging information in the operating system's native format
1881: (for DBX or SDB or DWARF). GDB also can work with this debugging
1882: information. On most systems that use DBX format, `\|\c
1883: .B \-g\c
1884: \&\|' enables use
1885: of extra debugging information that only GDB can use; if you want to
1886: control for certain whether to generate this information, use
1887: `\|\c
1888: .B \-ggdb\c
1889: \&\|' or `\|\c
1890: .B \-gdbx\c
1891: \&\|'.
1892:
1893: Unlike most other C compilers, GNU CC allows you to use `\|\c
1894: .B \-g\c
1895: \&\|' with
1896: `\|\c
1897: .B \-O\c
1898: \&\|'. The shortcuts taken by optimized code may occasionally
1899: produce surprising results: some variables you declared may not exist
1900: at all; flow of control may briefly move where you did not expect it;
1901: some statements may not be executed because they compute constant
1902: results or their values were already at hand; some statements may
1903: execute in different places because they were moved out of loops.
1904:
1905: Nevertheless it proves possible to debug optimized output. This makes
1906: it reasonable to use the optimizer for programs that might have bugs.
1907:
1908: The following options are useful when GNU CC is configured and
1909: compiled with the capability for more than one debugging format.
1910: .TP
1911: .B \-ggdb
1912: Produce debugging information in DBX format (if that is supported),
1913: including GDB extensions.
1914: .TP
1915: .B \-gdbx
1916: Produce debugging information in DBX format (if that is supported),
1917: without GDB extensions.
1918: .TP
1919: .B \-gsdb
1920: Produce debugging information in SDB format (if that is supported).
1921: .TP
1922: .B \-gdwarf
1923: Produce debugging information in DWARF format (if that is supported).
1924: .PP
1925: .BI "\-g" "level"
1926: .br
1927: .BI "\-ggdb" "level"
1928: .br
1929: .BI "\-gdbx" "level"
1930: .br
1931: .BI "\-gsdb" "level"
1932: .TP
1933: .BI "\-gdwarf" "level"
1934: Request debugging information and also use \c
1935: .I level\c
1936: \& to specify how
1937: much information. The default level is 2.
1938:
1939: Level 1 produces minimal information, enough for making backtraces in
1940: parts of the program that you don't plan to debug. This includes
1941: descriptions of functions and external variables, but no information
1942: about local variables and no line numbers.
1943: .TP
1944: .B \-p
1945: Generate extra code to write profile information suitable for the
1946: analysis program \c
1947: .B prof\c
1948: \&.
1949: .TP
1950: .B \-pg
1951: Generate extra code to write profile information suitable for the
1952: analysis program \c
1953: .B gprof\c
1954: \&.
1955: .TP
1956: .B \-a
1957: Generate extra code to write profile information for basic blocks,
1958: which will record the number of times each basic block is executed.
1959: This data could be analyzed by a program like \c
1960: .B tcov\c
1961: \&. Note,
1962: however, that the format of the data is not what \c
1963: .B tcov\c
1964: \& expects.
1965: Eventually GNU \c
1966: .B gprof\c
1967: \& should be extended to process this data.
1968: .TP
1969: .BI "\-d" "letters"\c
1970: \&
1971: Says to make debugging dumps during compilation at times specified by
1972: \c
1973: .I letters\c
1974: \&. This is used for debugging the compiler. The file names
1975: for most of the dumps are made by appending a word to the source file
1976: name (e.g. `\|\c
1977: .B foo.c.rtl\c
1978: \&\|' or `\|\c
1979: .B foo.c.jump\c
1980: \&\|').
1981: .TP
1982: .B \-dM
1983: Dump all macro definitions, at the end of preprocessing, and write no
1984: output.
1985: .TP
1986: .B \-dN
1987: Dump all macro names, at the end of preprocessing.
1988: .TP
1989: .B \-dD
1990: Dump all macro definitions, at the end of preprocessing, in addition to
1991: normal output.
1992: .TP
1993: .B \-dy
1994: Dump debugging information during parsing, to standard error.
1995: .TP
1996: .B \-dr
1997: Dump after RTL generation, to `\|\c
1998: .B \c
1999: .I file\c
2000: \&.rtl\c
2001: \&\|'.
2002: .TP
2003: .B \-dx
2004: Just generate RTL for a function instead of compiling it. Usually used
2005: with `\|\c
2006: .B r\c
2007: \&\|'.
2008: .TP
2009: .B \-dj
2010: Dump after first jump optimization, to `\|\c
2011: .B \c
2012: .I file\c
2013: \&.jump\c
2014: \&\|'.
2015: .TP
2016: .B \-ds
2017: Dump after CSE (including the jump optimization that sometimes
2018: follows CSE), to `\|\c
2019: .B \c
2020: .I file\c
2021: \&.cse\c
2022: \&\|'.
2023: .TP
2024: .B \-dL
2025: Dump after loop optimization, to `\|\c
2026: .B \c
2027: .I file\c
2028: \&.loop\c
2029: \&\|'.
2030: .TP
2031: .B \-dt
2032: Dump after the second CSE pass (including the jump optimization that
2033: sometimes follows CSE), to `\|\c
2034: .B \c
2035: .I file\c
2036: \&.cse2\c
2037: \&\|'.
2038: .TP
2039: .B \-df
2040: Dump after flow analysis, to `\|\c
2041: .B \c
2042: .I file\c
2043: \&.flow\c
2044: \&\|'.
2045: .TP
2046: .B \-dc
2047: Dump after instruction combination, to `\|\c
2048: .B \c
2049: .I file\c
2050: \&.combine\c
2051: \&\|'.
2052: .TP
2053: .B \-dS
2054: Dump after the first instruction scheduling pass, to
2055: `\|\c
2056: .B \c
2057: .I file\c
2058: \&.sched\c
2059: \&\|'.
2060: .TP
2061: .B \-dl
2062: Dump after local register allocation, to `\|\c
2063: .B \c
2064: .I file\c
2065: \&.lreg\c
2066: \&\|'.
2067: .TP
2068: .B \-dg
2069: Dump after global register allocation, to `\|\c
2070: .B \c
2071: .I file\c
2072: \&.greg\c
2073: \&\|'.
2074: .TP
2075: .B \-dR
2076: Dump after the second instruction scheduling pass, to
2077: `\|\c
2078: .B \c
2079: .I file\c
2080: \&.sched2\c
2081: \&\|'.
2082: .TP
2083: .B \-dJ
2084: Dump after last jump optimization, to `\|\c
2085: .B \c
2086: .I file\c
2087: \&.jump2\c
2088: \&\|'.
2089: .TP
2090: .B \-dd
2091: Dump after delayed branch scheduling, to `\|\c
2092: .B \c
2093: .I file\c
2094: \&.dbr\c
2095: \&\|'.
2096: .TP
2097: .B \-dk
2098: Dump after conversion from registers to stack, to `\|\c
2099: .B \c
2100: .I file\c
2101: \&.stack\c
2102: \&\|'.
2103: .TP
2104: .B \-dm
2105: Print statistics on memory usage, at the end of the run, to
2106: standard error.
2107: .TP
2108: .B \-dp
2109: Annotate the assembler output with a comment indicating which
2110: pattern and alternative was used.
2111: .TP
2112: .B \-fpretend\-float
2113: When running a cross-compiler, pretend that the target machine uses the
2114: same floating point format as the host machine. This causes incorrect
2115: output of the actual floating constants, but the actual instruction
2116: sequence will probably be the same as GNU CC would make when running on
2117: the target machine.
2118: .TP
2119: .B \-save\-temps
2120: Store the usual ``temporary'' intermediate files permanently; place them
2121: in the current directory and name them based on the source file. Thus,
2122: compiling `\|\c
2123: .B foo.c\c
2124: \&\|' with `\|\c
2125: .B \-c \-save\-temps\c
2126: \&\|' would produce files
2127: `\|\c
2128: .B foo.cpp\c
2129: \&\|' and `\|\c
2130: .B foo.s\c
2131: \&\|', as well as `\|\c
2132: .B foo.o\c
2133: \&\|'.
2134: .PP
2135:
2136: .SH OPTIMIZATION OPTIONS
2137: These options control various sorts of optimizations:
2138: .TP
2139: .B \-O
2140: Optimize. Optimizing compilation takes somewhat more time, and a lot
2141: more memory for a large function.
2142:
2143: Without `\|\c
2144: .B \-O\c
2145: \&\|', the compiler's goal is to reduce the cost of
2146: compilation and to make debugging produce the expected results.
2147: Statements are independent: if you stop the program with a breakpoint
2148: between statements, you can then assign a new value to any variable or
2149: change the program counter to any other statement in the function and
2150: get exactly the results you would expect from the source code.
2151:
2152: Without `\|\c
2153: .B \-O\c
2154: \&\|', only variables declared \c
2155: .B register\c
2156: \& are
2157: allocated in registers. The resulting compiled code is a little worse
2158: than produced by PCC without `\|\c
2159: .B \-O\c
2160: \&\|'.
2161:
2162: With `\|\c
2163: .B \-O\c
2164: \&\|', the compiler tries to reduce code size and execution
2165: time.
2166:
2167: When you specify `\|\c
2168: .B \-O\c
2169: \&\|', `\|\c
2170: .B \-fthread\-jumps\c
2171: \&\|' and
2172: `\|\c
2173: .B \-fdelayed\-branch\c
2174: \&\|' are turned on. On some machines other
2175: flags may also be turned on.
2176: .TP
2177: .B \-O2
2178: Highly optimize. As compared to `\|\c
2179: .B \-O\c
2180: \&\|', this
2181: option will increase both compilation time and the performance of the
2182: generated code.
2183:
2184: All `\|\c
2185: .B \-f\c
2186: .I flag\c
2187: \&\c
2188: \&\|' options that control optimization are turned on
2189: when you specify `\|\c
2190: .B \-O2\c
2191: \&\|', except `\|\c
2192: .B \-funroll\-loops\c
2193: \&\|'
2194: and `\|\c
2195: .B \-funroll\-all\-loops\c
2196: \&\|'.
2197: .PP
2198:
2199: Options of the form `\|\c
2200: .B \-f\c
2201: .I flag\c
2202: \&\c
2203: \&\|' specify machine-independent
2204: flags. Most flags have both positive and negative forms; the negative
2205: form of `\|\c
2206: .B \-ffoo\c
2207: \&\|' would be `\|\c
2208: .B \-fno\-foo\c
2209: \&\|'. The following list shows
2210: only one form\(em\&the one which is not the default.
2211: You can figure out the other form by either removing `\|\c
2212: .B no\-\c
2213: \&\|' or
2214: adding it.
2215: .TP
2216: .B \-ffloat\-store
2217: Do not store floating point variables in registers. This
2218: prevents undesirable excess precision on machines such as the
2219: 68000 where the floating registers (of the 68881) keep more
2220: precision than a \c
2221: .B double\c
2222: \& is supposed to have.
2223:
2224: For most programs, the excess precision does only good, but a few
2225: programs rely on the precise definition of IEEE floating point.
2226: Use `\|\c
2227: .B \-ffloat\-store\c
2228: \&\|' for such programs.
2229: .TP
2230: .B \-fmemoize\-lookups
2231: .TP
2232: .B \-fsave\-memoized
2233: .I
2234: (C++ only.)
2235: These flags are used to get the compiler to compile programs faster
2236: using heuristics. They are not on by default since they are only effective
2237: about half the time. The other half of the time programs compile more
2238: slowly (and take more memory).
2239:
2240: The first time the compiler must build a call to a member function (or
2241: reference to a data member), it must (1) determine whether the class
2242: implements member functions of that name; (2) resolve which member
2243: function to call (which involves figuring out what sorts of type
2244: conversions need to be made); and (3) check the visibility of the member
2245: function to the caller. All of this adds up to slower compilation.
2246: Normally, the second time a call is made to that member function (or
2247: reference to that data member), it must go through the same lengthy
2248: process again. This means that code like this
2249: .sp
2250: .br
2251: \ \ cout\ <<\ "This\ "\ <<\ p\ <<\ "\ has\ "\ <<\ n\ <<\ "\ legs.\en";
2252: .br
2253: .sp
2254: makes six passes through all three steps. By using a software cache,
2255: a ``hit'' significantly reduces this cost. Unfortunately, using the
2256: cache introduces another layer of mechanisms which must be implemented,
2257: and so incurs its own overhead. `\|\c
2258: .B \-fmemoize\-lookups\c
2259: \&\|' enables
2260: the software cache.
2261:
2262: Because access privileges (visibility) to members and member functions
2263: may differ from one function context to the next,
2264: .B g++
2265: may need to flush the cache. With the `\|\c
2266: .B \-fmemoize\-lookups\c
2267: \&\|' flag, the cache is flushed after every
2268: function that is compiled. The `\|\c
2269: \-fsave\-memoized\c
2270: \&\|' flag enables the same software cache, but when the compiler
2271: determines that the context of the last function compiled would yield
2272: the same access privileges of the next function to compile, it
2273: preserves the cache.
2274: This is most helpful when defining many member functions for the same
2275: class: with the exception of member functions which are friends of
2276: other classes, each member function has exactly the same access
2277: privileges as every other, and the cache need not be flushed.
2278: .TP
2279: .B \-fno\-default\-inline
2280: .I
2281: (C++ only.)
2282: If `\|\c
2283: .B \-fdefault\-inline\c
2284: \&\|' is enabled then member functions defined inside class
2285: scope are compiled inline by default; i.e., you don't need to
2286: add `\|\c
2287: .B inline\c
2288: \&\|' in front of the member function name. By popular
2289: demand, this option is now the default. To keep GNU C++ from inlining
2290: these member functions, specify `\|\c
2291: .B \-fno\-default\-inline\c
2292: \&\|'.
2293: .TP
2294: .B \-fno\-defer\-pop
2295: Always pop the arguments to each function call as soon as that
2296: function returns. For machines which must pop arguments after a
2297: function call, the compiler normally lets arguments accumulate on the
2298: stack for several function calls and pops them all at once.
2299: .TP
2300: .B \-fforce\-mem
2301: Force memory operands to be copied into registers before doing
2302: arithmetic on them. This may produce better code by making all
2303: memory references potential common subexpressions. When they are
2304: not common subexpressions, instruction combination should
2305: eliminate the separate register-load. I am interested in hearing
2306: about the difference this makes.
2307: .TP
2308: .B \-fforce\-addr
2309: Force memory address constants to be copied into registers before
2310: doing arithmetic on them. This may produce better code just as
2311: `\|\c
2312: .B \-fforce\-mem\c
2313: \&\|' may. I am interested in hearing about the
2314: difference this makes.
2315: .TP
2316: .B \-fomit\-frame\-pointer
2317: Don't keep the frame pointer in a register for functions that
2318: don't need one. This avoids the instructions to save, set up and
2319: restore frame pointers; it also makes an extra register available
2320: in many functions. \c
2321: .I It also makes debugging impossible on
2322: most machines.\c
2323: \&
2324:
2325: On some machines, such as the Vax, this flag has no effect, because
2326: the standard calling sequence automatically handles the frame pointer
2327: and nothing is saved by pretending it doesn't exist. The
2328: machine-description macro \c
2329: .B FRAME_POINTER_REQUIRED\c
2330: \& controls
2331: whether a target machine supports this flag.
2332: .TP
2333: .B \-finline
2334: Pay attention the \c
2335: .B inline\c
2336: \& keyword. Normally the negation of this
2337: option `\|\c
2338: .B \-fno\-inline\c
2339: \&\|' is used to keep the compiler from expanding
2340: any functions inline. However, the opposite effect may be desirable
2341: when compiling with `\|\c
2342: .B \-g\c
2343: \&\|', since `\|\c
2344: .B \-g\c
2345: \&\|' normally turns off all
2346: inline function expansion.
2347: .TP
2348: .B \-finline\-functions
2349: Integrate all simple functions into their callers. The compiler
2350: heuristically decides which functions are simple enough to be worth
2351: integrating in this way.
2352:
2353: If all calls to a given function are integrated, and the function is
2354: declared \c
2355: .B static\c
2356: \&, then GCC normally does not output the function as
2357: assembler code in its own right.
2358: .TP
2359: .B \-fcaller\-saves
2360: Enable values to be allocated in registers that will be clobbered by
2361: function calls, by emitting extra instructions to save and restore the
2362: registers around such calls. Such allocation is done only when it
2363: seems to result in better code than would otherwise be produced.
2364:
2365: This option is enabled by default on certain machines, usually those
2366: which have no call-preserved registers to use instead.
2367: .TP
2368: .B \-fkeep\-inline\-functions
2369: Even if all calls to a given function are integrated, and the function
2370: is declared \c
2371: .B static\c
2372: \&, nevertheless output a separate run-time
2373: callable version of the function.
2374: .TP
2375: .B \-fno\-function\-cse
2376: Do not put function addresses in registers; make each instruction that
2377: calls a constant function contain the function's address explicitly.
2378:
2379: This option results in less efficient code, but some strange hacks
2380: that alter the assembler output may be confused by the optimizations
2381: performed when this option is not used.
2382: .PP
2383:
2384: The following options control specific optimizations. The `\|\c
2385: .B \-O2\c
2386: \&\|'
2387: option turns on all of these optimizations except `\|\c
2388: .B \-funroll\-loops\c
2389: \&\|'
2390: and `\|\c
2391: .B \-funroll\-all\-loops\c
2392: \&\|'.
2393:
2394: The `\|\c
2395: .B \-O\c
2396: \&\|' option usually turns on
2397: the `\|\c
2398: .B \-fthread\-jumps\c
2399: \&\|' and `\|\c
2400: .B \-fdelayed\-branch\c
2401: \&\|' options, but
2402: specific machines may change the default optimizations.
2403:
2404: You can use the following flags in the rare cases when ``fine-tuning''
2405: of optimizations to be performed is desired.
2406: .TP
2407: .B \-fstrength\-reduce
2408: Perform the optimizations of loop strength reduction and
2409: elimination of iteration variables.
2410: .TP
2411: .B \-fthread\-jumps
2412: Perform optimizations where we check to see if a jump branches to a
2413: location where another comparison subsumed by the first is found. If
2414: so, the first branch is redirected to either the destination of the
2415: second branch or a point immediately following it, depending on whether
2416: the condition is known to be true or false.
2417: .TP
2418: .B \-funroll\-loops
2419: Perform the optimization of loop unrolling. This is only done for loops
2420: whose number of iterations can be determined at compile time or run time.
2421: .TP
2422: .B \-funroll\-all\-loops
2423: Perform the optimization of loop unrolling. This is done for all loops.
2424: This usually makes programs run more slowly.
2425: .TP
2426: .B \-fcse\-follow\-jumps
2427: In common subexpression elimination, scan through jump instructions in
2428: certain cases. This is not as powerful as completely global CSE, but
2429: not as slow either.
2430: .TP
2431: .B \-frerun\-cse\-after\-loop
2432: Re-run common subexpression elimination after loop optimizations has been
2433: performed.
2434: .TP
2435: .B \-felide\-constructors
2436: .I
2437: (C++ only.)
2438: Use this option to instruct the compiler to be smarter about when it can
2439: elide constructors. Without this flag, GNU C++ and cfront both
2440: generate effectively the same code for:
2441: .sp
2442: .br
2443: A\ foo\ ();
2444: .br
2445: A\ x\ (foo\ ());\ \ \ //\ x\ initialized\ by\ `foo\ ()',\ no\ ctor\ called
2446: .br
2447: A\ y\ =\ foo\ ();\ \ \ //\ call\ to\ `foo\ ()'\ heads\ to\ temporary,
2448: .br
2449: \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ //\ y\ is\ initialized\ from\ the\ temporary.
2450: .br
2451: .sp
2452: Note the difference! With this flag, GNU C++ initializes `\|\c
2453: .B y\c
2454: \&\|' directly
2455: from the call to
2456: .B foo ()
2457: without going through a temporary.
2458: .TP
2459: .B \-fexpensive\-optimizations
2460: Perform a number of minor optimizations that are relatively expensive.
2461: .TP
2462: .B \-fdelayed\-branch
2463: If supported for the target machine, attempt to reorder instructions
2464: to exploit instruction slots available after delayed branch
2465: instructions.
2466: .TP
2467: .B \-fschedule\-insns
2468: If supported for the target machine, attempt to reorder instructions to
2469: eliminate execution stalls due to required data being unavailable. This
2470: helps machines that have slow floating point or memory load instructions
2471: by allowing other instructions to be issued until the result of the load
2472: or floating point instruction is required.
2473: .TP
2474: .B \-fschedule\-insns2
2475: Similar to `\|\c
2476: .B \-fschedule\-insns\c
2477: \&\|', but requests an additional pass of
2478: instruction scheduling after register allocation has been done. This is
2479: especially useful on machines with a relatively small number of
2480: registers and where memory load instructions take more than one cycle.
2481: .PP
2482:
2483: .SH TARGET OPTIONS
2484: By default, GNU CC compiles code for the same type of machine that you
2485: are using. However, it can also be installed as a cross-compiler, to
2486: compile for some other type of machine. In fact, several different
2487: configurations of GNU CC, for different target machines, can be
2488: installed side by side. Then you specify which one to use with the
2489: `\|\c
2490: .B \-b\c
2491: \&\|' option.
2492:
2493: In addition, older and newer versions of GNU CC can be installed side
2494: by side. One of them (probably the newest) will be the default, but
2495: you may sometimes wish to use another.
2496: .TP
2497: .BI "\-b " "machine"\c
2498: \&
2499: The argument \c
2500: .I machine\c
2501: \& specifies the target machine for compilation.
2502: This is useful when you have installed GNU CC as a cross-compiler.
2503:
2504: The value to use for \c
2505: .I machine\c
2506: \& is the same as was specified as the
2507: machine type when configuring GNU CC as a cross-compiler. For
2508: example, if a cross-compiler was configured with `\|\c
2509: .B configure
2510: i386v\c
2511: \&\|', meaning to compile for an 80386 running System V, then you
2512: would specify `\|\c
2513: .B \-b i386v\c
2514: \&\|' to run that cross compiler.
2515:
2516: When you do not specify `\|\c
2517: .B \-b\c
2518: \&\|', it normally means to compile for
2519: the same type of machine that you are using.
2520: .TP
2521: .BI "\-V " "version"\c
2522: \&
2523: The argument \c
2524: .I version\c
2525: \& specifies which version of GNU CC to run.
2526: This is useful when multiple versions are installed. For example,
2527: \c
2528: .I version\c
2529: \& might be `\|\c
2530: .B 2.0\c
2531: \&\|', meaning to run GNU CC version 2.0.
2532:
2533: The default version, when you do not specify `\|\c
2534: .B \-V\c
2535: \&\|', is controlled
2536: by the way GNU CC is installed. Normally, it will be a version that
2537: is recommended for general use.
2538: .PP
2539:
2540: .SH MACHINE DEPENDENT OPTIONS
2541: Each of the target machine types can have its own special options,
2542: starting with `\|\c
2543: .B \-m\c
2544: \&\|', to choose among various hardware models or
2545: configurations\(em\&for example, 68010 vs 68020, floating coprocessor or
2546: none. A single installed version of the compiler can compile for any
2547: model or configuration, according to the options specified.
2548:
2549: These are the `\|\c
2550: .B \-m\c
2551: \&\|' options defined for the 68000 series:
2552: .TP
2553: .B \-m68020
2554: .TP
2555: .B \-mc68020
2556: Generate output for a 68020 (rather than a 68000). This is the
2557: default if you use the unmodified sources.
2558: .TP
2559: .B \-m68000
2560: .TP
2561: .B \-mc68000
2562: Generate output for a 68000 (rather than a 68020).
2563: .TP
2564: .B \-m68881
2565: Generate output containing 68881 instructions for floating point.
2566: This is the default if you use the unmodified sources.
2567: .TP
2568: .B \-mfpa
2569: Generate output containing Sun FPA instructions for floating point.
2570: .TP
2571: .B \-msoft\-float
2572: Generate output containing library calls for floating point.
2573: .I
2574: WARNING:
2575: the requisite libraries are not part of GNU CC. Normally the
2576: facilities of the machine's usual C compiler are used, but this can't
2577: be done directly in cross-compilation. You must make your own
2578: arrangements to provide suitable library functions for cross-compilation.
2579: .TP
2580: .B \-mshort
2581: Consider type \c
2582: .B int\c
2583: \& to be 16 bits wide, like \c
2584: .B short int\c
2585: \&.
2586: .TP
2587: .B \-mnobitfield
2588: Do not use the bit-field instructions. `\|\c
2589: .B \-m68000\c
2590: \&\|' implies
2591: `\|\c
2592: .B \-mnobitfield\c
2593: \&\|'.
2594: .TP
2595: .B \-mbitfield
2596: Do use the bit-field instructions. `\|\c
2597: .B \-m68020\c
2598: \&\|' implies
2599: `\|\c
2600: .B \-mbitfield\c
2601: \&\|'. This is the default if you use the unmodified
2602: sources.
2603: .TP
2604: .B \-mrtd
2605: Use a different function-calling convention, in which functions
2606: that take a fixed number of arguments return with the \c
2607: .B rtd\c
2608: \&
2609: instruction, which pops their arguments while returning. This
2610: saves one instruction in the caller since there is no need to pop
2611: the arguments there.
2612:
2613: This calling convention is incompatible with the one normally
2614: used on Unix, so you cannot use it if you need to call libraries
2615: compiled with the Unix compiler.
2616:
2617: Also, you must provide function prototypes for all functions that
2618: take variable numbers of arguments (including \c
2619: .B printf\c
2620: \&);
2621: otherwise incorrect code will be generated for calls to those
2622: functions.
2623:
2624: In addition, seriously incorrect code will result if you call a
2625: function with too many arguments. (Normally, extra arguments are
2626: harmlessly ignored.)
2627:
2628: The \c
2629: .B rtd\c
2630: \& instruction is supported by the 68010 and 68020
2631: processors, but not by the 68000.
2632: .PP
2633:
2634: These `\|\c
2635: .B \-m\c
2636: \&\|' options are defined for the Vax:
2637: .TP
2638: .B \-munix
2639: Do not output certain jump instructions (\c
2640: .B aobleq\c
2641: \& and so on)
2642: that the Unix assembler for the Vax cannot handle across long
2643: ranges.
2644: .TP
2645: .B \-mgnu
2646: Do output those jump instructions, on the assumption that you
2647: will assemble with the GNU assembler.
2648: .TP
2649: .B \-mg
2650: Output code for g-format floating point numbers instead of d-format.
2651: .PP
2652:
2653: These `\|\c
2654: .B \-m\c
2655: \&\|' switches are supported on the Sparc:
2656: .TP
2657: .B \-mfpu
2658: Generate output containing floating point instructions. This is the
2659: default if you use the unmodified sources.
2660: .TP
2661: .B \-mno\-epilogue
2662: Generate separate return instructions for \c
2663: .B return\c
2664: \& statements.
2665: This has both advantages and disadvantages; I don't recall what they
2666: are.
2667: .PP
2668:
2669: These `\|\c
2670: .B \-m\c
2671: \&\|' options are defined for the Convex:
2672: .TP
2673: .B \-mc1
2674: Generate output for a C1. This is the default when the compiler is
2675: configured for a C1.
2676: .TP
2677: .B \-mc2
2678: Generate output for a C2. This is the default when the compiler is
2679: configured for a C2.
2680: .TP
2681: .B \-margcount
2682: Generate code which puts an argument count in the word preceding each
2683: argument list. Some nonportable Convex and Vax programs need this word.
2684: (Debuggers don't, except for functions with variable-length argument
2685: lists; this info is in the symbol table.)
2686: .TP
2687: .B \-mnoargcount
2688: Omit the argument count word. This is the default if you use the
2689: unmodified sources.
2690: .PP
2691:
2692: These `\|\c
2693: .B \-m\c
2694: \&\|' options are defined for the AMD Am29000:
2695: .TP
2696: .B \-mdw
2697: Generate code that assumes the DW bit is set, i.e., that byte and
2698: halfword operations are directly supported by the hardware. This is the
2699: default.
2700: .TP
2701: .B \-mnodw
2702: Generate code that assumes the DW bit is not set.
2703: .TP
2704: .B \-mbw
2705: Generate code that assumes the system supports byte and halfword write
2706: operations. This is the default.
2707: .TP
2708: .B \-mnbw
2709: Generate code that assumes the systems does not support byte and
2710: halfword write operations. This implies `\|\c
2711: .B \-mnodw\c
2712: \&\|'.
2713: .TP
2714: .B \-msmall
2715: Use a small memory model that assumes that all function addresses are
2716: either within a single 256 KB segment or at an absolute address of less
2717: than 256K. This allows the \c
2718: .B call\c
2719: \& instruction to be used instead
2720: of a \c
2721: .B const\c
2722: \&, \c
2723: .B consth\c
2724: \&, \c
2725: .B calli\c
2726: \& sequence.
2727: .TP
2728: .B \-mlarge
2729: Do not assume that the \c
2730: .B call\c
2731: \& instruction can be used; this is the
2732: default.
2733: .TP
2734: .B \-m29050
2735: Generate code for the Am29050.
2736: .TP
2737: .B \-m29000
2738: Generate code for the Am29000. This is the default.
2739: .TP
2740: .B \-mkernel\-registers
2741: Generate references to registers \c
2742: .B gr64-gr95\c
2743: \& instead of
2744: \c
2745: .B gr96-gr127\c
2746: \&. This option can be used when compiling kernel code
2747: that wants a set of global registers disjoint from that used by
2748: user-mode code.
2749:
2750: Note that when this option is used, register names in `\|\c
2751: .B \-f\c
2752: \&\|' flags
2753: must use the normal, user-mode, names.
2754: .TP
2755: .B \-muser\-registers
2756: Use the normal set of global registers, \c
2757: .B gr96-gr127\c
2758: \&. This is the
2759: default.
2760: .TP
2761: .B \-mstack\-check
2762: Insert a call to \c
2763: .B __msp_check\c
2764: \& after each stack adjustment. This
2765: is often used for kernel code.
2766: .PP
2767:
2768: These `\|\c
2769: .B \-m\c
2770: \&\|' options are defined for Motorola 88K architectures:
2771: .TP
2772: .B \-mbig\-pic
2773: Emit position-independent code, suitable for dynamic linking, even if
2774: branches need large displacements. Equivalent to the general-use option `\|\c
2775: .B \-fPIC\c
2776: \&\|'.
2777: The general-use option `\|\c
2778: .B \-fpic\c
2779: \&\|',
2780: by contrast, only emits valid 88k code if all branches involve small
2781: displacements.
2782: GCC does not emit position-independent code by default.
2783: .TP
2784: .B \-midentify\-revision
2785: Include an \c
2786: .B ident\c
2787: \& directive in the assembler output recording the
2788: source file name, compiler name and version, timestamp, and compilation
2789: flags used.
2790: .TP
2791: .B \-mno\-underscores
2792: In assembler output, emit symbol names without adding an underscore
2793: character at the beginning of each name. The default is to use an
2794: underscore as prefix on each name.
2795: .TP
2796: .B \-mno\-check\-zero\-division
2797: .TP
2798: .B \-mcheck\-zero\-division
2799: Early models of the 88K architecture had problems with division by zero;
2800: in particular, many of them didn't trap. Use these options to avoid
2801: including (or to include explicitly) additional code to detect division
2802: by zero and signal an exception. All GCC configurations for the 88K use
2803: `\|\c
2804: .B \-mcheck\-zero\-division\c
2805: \&\|' by default.
2806: .TP
2807: .B \-mocs\-debug\-info
2808: .TP
2809: .B \-mno\-ocs\-debug\-info
2810: Include (or omit) additional debugging information (about
2811: registers used in each stack frame) as specified in the 88Open Object
2812: Compatibility Standard, ``OCS''. This extra information is not needed
2813: by GDB. The default for DG/UX, SVr4, and Delta 88 SVr3.2 is to
2814: include this information; other 88k configurations omit this information
2815: by default.
2816: .TP
2817: .B \-mocs\-frame\-position
2818: .TP
2819: .B \-mno\-ocs\-frame\-position
2820: Force (or do not require) register values to be stored in a particular
2821: place in stack frames, as specified in OCS. The DG/UX, Delta88 SVr3.2,
2822: and BCS configurations use `\|\c
2823: .B \-mocs\-frame\-position\c
2824: \&\|'; other 88k
2825: configurations have the default `\|\c
2826: .B \-mno\-ocs\-frame\-position\c
2827: \&\|'.
2828: .TP
2829: .B \-moptimize\-arg\-area
2830: .TP
2831: .B \-mno\-optimize\-arg\-area
2832: Control how to store function arguments in stack frames.
2833: `\|\c
2834: .B \-moptimize\-arg\-area\c
2835: \&\|' saves space, but may break some
2836: debuggers (not GDB). `\|\c
2837: .B \-mno\-optimize\-arg\-area\c
2838: \&\|' conforms better to
2839: standards. By default GCC does not optimize the argument area.
2840: .TP
2841: .BI "\-mshort\-data\-" "num"\c
2842: \&
2843: .I num\c
2844: \&
2845: Generate smaller data references by making them relative to \c
2846: .B r0\c
2847: \&,
2848: which allows loading a value using a single instruction (rather than the
2849: usual two). You control which data references are affected by
2850: specifying \c
2851: .I num\c
2852: \& with this option. For example, if you specify
2853: `\|\c
2854: .B \-mshort\-data\-512\c
2855: \&\|', then the data references affected are those
2856: involving displacements of less than 512 bytes.
2857: `\|\c
2858: .B \-mshort\-data\-\c
2859: .I num\c
2860: \&\c
2861: \&\|' is not effective for \c
2862: .I num\c
2863: \& greater
2864: than 64K.
2865: .TP
2866: .B \-msvr4
2867: .TP
2868: .B \-msvr3
2869: Turn on (`\|\c
2870: .B \-msvr4\c
2871: \&\|') or off (`\|\c
2872: .B \-msvr3\c
2873: \&\|') compiler extensions
2874: related to System V release 4 (SVr4). This controls the following:
2875: .TP
2876: \ \ \ \(bu
2877: Which variant of the assembler syntax to emit (which you can select
2878: independently using `\|\c
2879: .B \-mversion03.00\c
2880: \&\|').
2881: .TP
2882: \ \ \ \(bu
2883: `\|\c
2884: .B \-msvr4\c
2885: \&\|' makes the C preprocessor recognize `\|\c
2886: .B #pragma weak\c
2887: \&\|'
2888: .TP
2889: \ \ \ \(bu
2890: `\|\c
2891: .B \-msvr4\c
2892: \&\|' makes GCC issue additional declaration directives used in
2893: SVr4.
2894: .PP
2895: `\|\c
2896: .B \-msvr3\c
2897: \&\|' is the default for all m88K configurations except
2898: the SVr4 configuration.
2899: .TP
2900: .B \-mtrap\-large\-shift
2901: .TP
2902: .B \-mhandle\-large\-shift
2903: Include code to detect bit-shifts of more than 31 bits; respectively,
2904: trap such shifts or emit code to handle them properly. By default GCC
2905: makes no special provision for large bit shifts.
2906: .TP
2907: .B \-muse\-div\-instruction
2908: Very early models of the 88K architecture didn't have a divide
2909: instruction, so GCC avoids that instruction by default. Use this option
2910: to specify that it's safe to use the divide instruction.
2911: .TP
2912: .B \-mversion\-03.00
2913: Use alternative assembler syntax for the assembler version corresponding
2914: to SVr4, but without enabling the other features triggered by
2915: `\|\c
2916: .B \-svr4\c
2917: \&\|'. This is implied by `\|\c
2918: .B \-svr4\c
2919: \&\|', is the default for the
2920: SVr4 configuration of GCC, and is permitted by the DG/UX configuration
2921: only if `\|\c
2922: .B \-svr4\c
2923: \&\|' is also specified. The Delta 88 SVr3.2
2924: configuration ignores this option.
2925: .TP
2926: .B \-mwarn\-passed\-structs
2927: Warn when a function passes a struct as an argument or result.
2928: Structure-passing conventions have changed during the evolution of the C
2929: language, and are often the source of portability problems. By default,
2930: GCC issues no such warning.
2931: .PP
2932: These options are defined for the IBM RS6000:
2933:
2934: .PP
2935: .B \-mfp\-in\-toc
2936: .TP
2937: .B \-mno\-fp\-in\-toc
2938: Control whether or not floating-point constants go in the Table of
2939: Contents (TOC), a table of all global variable and function addresses. By
2940: default GCC puts floating-point constants there; if the TOC overflows,
2941: `\|\c
2942: .B \-mno\-fp\-in\-toc\c
2943: \&\|' will reduce the size of the TOC, which may avoid
2944: the overflow.
2945:
2946: .PP
2947: These `\|\c
2948: .B \-m\c
2949: \&\|' options are defined for the IBM RT PC:
2950: .TP
2951: .B \-min\-line\-mul
2952: Use an in-line code sequence for integer multiplies. This is the
2953: default.
2954: .TP
2955: .B \-mcall\-lib\-mul
2956: Call \c
2957: .B lmul$$\c
2958: \& for integer multiples.
2959: .TP
2960: .B \-mfull\-fp\-blocks
2961: Generate full-size floating point data blocks, including the minimum
2962: amount of scratch space recommended by IBM. This is the default.
2963: .TP
2964: .B \-mminimum\-fp\-blocks
2965: Do not include extra scratch space in floating point data blocks. This
2966: results in smaller code, but slower execution, since scratch space must
2967: be allocated dynamically.
2968: .TP
2969: .B \-mfp\-arg\-in\-fpregs
2970: Use a calling sequence incompatible with the IBM calling convention in
2971: which floating point arguments are passed in floating point registers.
2972: Note that \c
2973: .B varargs.h\c
2974: \& and \c
2975: .B stdargs.h\c
2976: \& will not work with
2977: floating point operands if this option is specified.
2978: .TP
2979: .B \-mfp\-arg\-in\-gregs
2980: Use the normal calling convention for floating point arguments. This is
2981: the default.
2982: .TP
2983: .B \-mhc\-struct\-return
2984: Return structures of more than one word in memory, rather than in a
2985: register. This provides compatibility with the MetaWare HighC (hc)
2986: compiler. Use `\|\c
2987: .B \-fpcc\-struct\-return\c
2988: \&\|' for compatibility with the
2989: Portable C Compiler (pcc).
2990: .TP
2991: .B \-mnohc\-struct\-return
2992: Return some structures of more than one word in registers, when
2993: convenient. This is the default. For compatibility with the
2994: IBM-supplied compilers, use either `\|\c
2995: .B \-fpcc\-struct\-return\c
2996: \&\|' or
2997: `\|\c
2998: .B \-mhc\-struct\-return\c
2999: \&\|'.
3000: .PP
3001: These `\|\c
3002: .B \-m\c
3003: \&\|' options are defined for the MIPS family of computers:
3004: .TP
3005: .BI "\-mcpu=" "cpu-type"
3006: Assume the defaults for the machine type
3007: .I cpu-type
3008: when
3009: scheduling insturctions. The default
3010: .I cpu-type
3011: is
3012: .BR default ,
3013: which picks the longest cycles times for any of the machines, in order
3014: that the code run at reasonable rates on all MIPS cpu's. Other
3015: choices for
3016: .I cpu-type
3017: are
3018: .BR r2000 ,
3019: .BR r3000 ,
3020: .BR r4000 ,
3021: and
3022: .BR r6000 .
3023: While picking a specific
3024: .I cpu-type
3025: will schedule things appropriately for that particular chip, the
3026: compiler will not generate any code that does not meet level 1 of the
3027: MIPS ISA (instruction set architecture) without the
3028: .B \-mips2
3029: or
3030: .B \-mips3
3031: switches being used.
3032: .TP
3033: .B \-mips2
3034: Issue instructions from level 2 of the MIPS ISA (branch likely, square
3035: root instructions). The
3036: .B \-mcpu=r4000
3037: or
3038: .B \-mcpu=r6000
3039: switch must be used in conjuction with
3040: .BR \-mips2 .
3041: .TP
3042: .B \-mips3
3043: Issue instructions from level 3 of the MIPS ISA (64 bit instructions).
3044: The
3045: .B \-mcpu=r4000
3046: switch must be used in conjuction with
3047: .BR \-mips2 .
3048: .TP
3049: .B \-mint64
3050: .TP
3051: .B \-mlong64
3052: .TP
3053: .B \-mlonglong128
3054: These options don't work at present.
3055: .TP
3056: .B \-mmips\-as
3057: Generate code for the MIPS assembler, and invoke
3058: .B mips\-tfile
3059: to add normal debug information. This is the default for all
3060: platforms except for the OSF/1 reference platform, using the OSF/rose
3061: object format. If the any of the
3062: .BR \-ggdb ,
3063: .BR \-gstabs ,
3064: or
3065: .B \-gstabs+
3066: switches are used, the
3067: .B mips\-tfile
3068: program will encapsulate the stabs within MIPS ECOFF.
3069: .TP
3070: .B \-mgas
3071: Generate code for the GNU assembler. This is the default on the OSF/1
3072: reference platform, using the OSF/rose object format.
3073: .TP
3074: .B \-mrnames
3075: .TP
3076: .B \-mno\-rnames
3077: The
3078: .B \-mrnames
3079: switch says to output code using the MIPS software names for the
3080: registers, instead of the hardware names (ie,
3081: .B a0
3082: instead of
3083: .BR $4 ).
3084: The GNU assembler does not support the
3085: .B \-mrnames
3086: switch, and the MIPS assembler will be instructed to run the MIPS C
3087: preprocessor over the source file. The
3088: .B \-mno\-rnames
3089: switch is default.
3090: .TP
3091: .B \-mgpopt
3092: .TP
3093: .B \-mno\-gpopt
3094: The
3095: .B \-mgpopt
3096: switch says to write all of the data declarations before the
3097: instructions in the text section, to all the MIPS assembler to
3098: generate one word memory references instead of using two words for
3099: short global or static data items. This is on by default if
3100: optimization is selected.
3101: .TP
3102: .B \-mstats
3103: .TP
3104: .B \-mno\-stats
3105: For each non-inline function processed, the
3106: .B \-mstats
3107: switch causes the compiler to emit one line to the standard error file
3108: to print statistics about the program (number of registers saved,
3109: stack size, etc.).
3110: .TP
3111: .B \-mmemcpy
3112: .TP
3113: .B \-mno\-memcpy
3114: The
3115: .B \-mmemcpy
3116: switch makes all block moves call the appropriate string function
3117: .RB ( memcpy
3118: or
3119: .BR bcopy )
3120: instead of possibly generating inline code.
3121: .TP
3122: .B \-mmips\-tfile
3123: .TP
3124: .B \-mno\-mips\-tfile
3125: The
3126: .B \-mno\-mips\-tfile
3127: switch causes the compiler not postprocess the object file with the
3128: .B mips\-tfile
3129: program, after the MIPS assembler has generated it to add debug
3130: support. If
3131: .B mips\-tfile
3132: is not run, then no local variables will be available to the debugger.
3133: In addition,
3134: .B stage2
3135: and
3136: .B stage3
3137: objects will have the temporary file names passed to the assembler
3138: embedded in the object file, which means the objects will not compare
3139: the same.
3140: .TP
3141: .B \-msoft\-float
3142: Generate output containing library calls for floating point.
3143: .I
3144: WARNING:
3145: the requisite libraries are not part of GNU CC. Normally the
3146: facilities of the machine's usual C compiler are used, but this can't
3147: be done directly in cross-compilation. You must make your own
3148: arrangements to provide suitable library functions for cross-compilation.
3149: .TP
3150: .B \-mhard\-float
3151: Generate output containing floating point instructions. This is the
3152: default if you use the unmodified sources.
3153: .TP
3154: .B \-mfp64
3155: Assume that the
3156: .B FR
3157: bit in the status word is on, and that there are 32 64-bit floating
3158: point registers, instead of 32 32-bit floating point registers. You
3159: must also specify the
3160: .B \-mcpu=r4000
3161: and
3162: .B \-mips3
3163: switches.
3164: .TP
3165: .B \-mfp32
3166: Assume that there are 32 32-bit floating point registers. This is the
3167: default.
3168: .TP
3169: .B \-mabicalls
3170: The
3171: .B \-mabicalls
3172: switch says to emit the
3173: .BR \&.abicalls ,
3174: .BR \&.cpload ,
3175: and
3176: .B \&.cprestore
3177: pseudo operations that some System V.4 ports use for position
3178: independent code.
3179: .TP
3180: .B \-mhalf\-pic
3181: .TP
3182: .B \-mno\-half\-pic
3183: The
3184: .B \-mhalf\-pic
3185: switch says to put pointers to extern references into the data section
3186: and load them up, rather than put the references in the text section.
3187: This option does not work at present.
3188: .B
3189: .BI \-G num
3190: Put global and static items less than or equal to
3191: .I num
3192: bytes into the small data or bss sections instead of the normal data
3193: or bss section. This allows the assembler to emit one word memory
3194: reference instructions based on the global pointer
3195: .RB ( gp
3196: or
3197: .BR $28 ),
3198: instead of the normal two words used. By default,
3199: .I num
3200: is 8 when the MIPS assembler is used, and 0 when the GNU
3201: assembler is used. The
3202: .BI \-G num
3203: switch is also passed to the assembler and linker. All modules should
3204: be compiled with the same
3205: .BI \-G num
3206: value.
3207: .PP
3208:
3209: .SH CODE GENERATION OPTIONS
3210: These machine-independent options control the interface conventions
3211: used in code generation.
3212:
3213: Most of them begin with `\|\c
3214: \-f\c
3215: \&\|'. These options have both positive and negative forms; the negative form
3216: of `\|\c
3217: .B \-ffoo\c
3218: \&\|' would be `\|\c
3219: .B \-fno\-foo\c
3220: \&\|'. In the table below, only
3221: one of the forms is listed\(em\&the one which is not the default. You
3222: can figure out the other form by either removing `\|\c
3223: .B no\-\c
3224: \&\|' or adding
3225: it.
3226: .TP
3227: .BI +e N
3228: .I (C++ only.)
3229: control whether virtual function definitions in classes
3230: are used to generate code, or only to define interfaces for their
3231: callers. These options are provided for compatibility with cfront
3232: 1.x usage; the recommended GNU C++ usage is to use
3233: .B #pragma interface
3234: and
3235: .B
3236: #pragma implementation\c
3237: \&, instead.
3238:
3239: With `\|\c
3240: .B +e0\c
3241: \&\|', virtual function definitions in classes are declared extern;
3242: the declaration is used only as an interface specification, not to
3243: generate code for the virtual functions (in this compilation).
3244:
3245: With `\|\c
3246: .B +e1\c
3247: \&\|',
3248: .B g++
3249: actually generates the code implementing virtual functions
3250: defined in the code, and makes them publicly visible.
3251: .TP
3252: .B \-fnonnull\-objects
3253: .I
3254: (C++ only.)
3255: Normally, GNU C++ makes conservative assumptions about objects reached
3256: through references. For example, the compiler must check that `\|\c
3257: .B a\c
3258: \&\|' is not null in code like the following:
3259: .br
3260: \ \ \ \ obj\ &a\ =\ g\ ();
3261: .br
3262: \ \ \ \ a.f\ (2);
3263: .br
3264: Checking that references of this sort have non-null values requires
3265: extra code, however, and it is unnecessary for many programs. You can
3266: use `\|\c
3267: .B \-fnonnull\-objects\c
3268: \&\|' to omit the checks for null, if your program doesn't require the
3269: default checking.
3270: .TP
3271: .B \-fpcc\-struct\-return
3272: Use the same convention for returning \c
3273: .B struct\c
3274: \& and \c
3275: .B union\c
3276: \&
3277: values that is used by the usual C compiler on your system. This
3278: convention is less efficient for small structures, and on many
3279: machines it fails to be reentrant; but it has the advantage of
3280: allowing intercallability between GCC-compiled code and PCC-compiled
3281: code.
3282: .TP
3283: .B \-fshort\-enums
3284: Allocate to an \c
3285: .B enum\c
3286: \& type only as many bytes as it needs for the
3287: declared range of possible values. Specifically, the \c
3288: .B enum\c
3289: \& type
3290: will be equivalent to the smallest integer type which has enough room.
3291: .TP
3292: .B \-fshort\-double
3293: Use the same size for
3294: .B double
3295: as for
3296: .B float
3297: \&.
3298: .TP
3299: .B \-fshared\-data
3300: Requests that the data and non-\c
3301: .B const\c
3302: \& variables of this
3303: compilation be shared data rather than private data. The distinction
3304: makes sense only on certain operating systems, where shared data is
3305: shared between processes running the same program, while private data
3306: exists in one copy per process.
3307: .TP
3308: .B \-fno\-common
3309: Allocate even uninitialized global variables in the bss section of the
3310: object file, rather than generating them as common blocks. This has the
3311: effect that if the same variable is declared (without \c
3312: .B extern\c
3313: \&) in
3314: two different compilations, you will get an error when you link them.
3315: The only reason this might be useful is if you wish to verify that the
3316: program will work on other systems which always work this way.
3317: .TP
3318: .B \-fvolatile
3319: Consider all memory references through pointers to be volatile.
3320: .TP
3321: .B \-fpic
3322: If supported for the target machines, generate position-independent code,
3323: suitable for use in a shared library.
3324: .TP
3325: .B \-fPIC
3326: If supported for the target machine, emit position-independent code,
3327: suitable for dynamic linking, even if branches need large displacements.
3328: .TP
3329: .BI "\-ffixed\-" "reg"\c
3330: \&
3331: Treat the register named \c
3332: .I reg\c
3333: \& as a fixed register; generated code
3334: should never refer to it (except perhaps as a stack pointer, frame
3335: pointer or in some other fixed role).
3336:
3337: \c
3338: .I reg\c
3339: \& must be the name of a register. The register names accepted
3340: are machine-specific and are defined in the \c
3341: .B REGISTER_NAMES\c
3342: \&
3343: macro in the machine description macro file.
3344:
3345: This flag does not have a negative form, because it specifies a
3346: three-way choice.
3347: .TP
3348: .BI "\-fcall\-used\-" "reg"\c
3349: \&
3350: Treat the register named \c
3351: .I reg\c
3352: \& as an allocatable register that is
3353: clobbered by function calls. It may be allocated for temporaries or
3354: variables that do not live across a call. Functions compiled this way
3355: will not save and restore the register \c
3356: .I reg\c
3357: \&.
3358:
3359: Use of this flag for a register that has a fixed pervasive role in the
3360: machine's execution model, such as the stack pointer or frame pointer,
3361: will produce disastrous results.
3362:
3363: This flag does not have a negative form, because it specifies a
3364: three-way choice.
3365: .TP
3366: .BI "\-fcall\-saved\-" "reg"\c
3367: \&
3368: Treat the register named \c
3369: .I reg\c
3370: \& as an allocatable register saved by
3371: functions. It may be allocated even for temporaries or variables that
3372: live across a call. Functions compiled this way will save and restore
3373: the register \c
3374: .I reg\c
3375: \& if they use it.
3376:
3377: Use of this flag for a register that has a fixed pervasive role in the
3378: machine's execution model, such as the stack pointer or frame pointer,
3379: will produce disastrous results.
3380:
3381: A different sort of disaster will result from the use of this flag for
3382: a register in which function values may be returned.
3383:
3384: This flag does not have a negative form, because it specifies a
3385: three-way choice.
3386: .TP
3387: .B \-fgnu\-binutils
3388: .TP
3389: .B \-fno\-gnu\-binutils
3390: .I
3391: (C++ only.)
3392: `\|\c
3393: .B \-fgnu\-binutils
3394: \&\|' (the default for most, but not all, platforms) makes GNU C++
3395: emit extra information for static initialization and finalization.
3396: This information has to be passed from the assembler to the GNU
3397: linker. Some assemblers won't pass this information; you must either
3398: use GNU
3399: .B as
3400: or specify the option `\|\c
3401: .B \-fno\-gnu\-binutils\c
3402: \&\|'.
3403:
3404: With `\|\c
3405: .B \-fno\-gnu\-binutils\c
3406: \&\|', you must use the program
3407: .B collect
3408: (part of the GCC distribution) for linking.
3409: .PP
3410:
3411: .SH PRAGMAS
3412: Two `\|\c
3413: .B #pragma\c
3414: \&\|' directives are supported for GNU C++, to permit using the same
3415: header file for two purposes: as a definition of interfaces to a given
3416: object class, and as the full definition of the contents of that object class.
3417: .TP
3418: .B #pragma interface
3419: .I (C++ only.)
3420: Use this directive in header files that define object classes, to save
3421: space in most of the object files that use those classes. Normally,
3422: local copies of certain information (backup copies of inline member
3423: functions, debugging information, and the internal tables that
3424: implement virtual functions) must be kept in each object file that
3425: includes class definitions. You can use this pragma to avoid such
3426: duplication. When a header file containing `\|\c
3427: .B #pragma interface\c
3428: \&\|' is included in a compilation, this auxiliary information
3429: will not be generated (unless the main input source file itself uses
3430: `\|\c
3431: .B #pragma implementation\c
3432: \&\|'). Instead, the object files will contain references to be
3433: resolved at link time.
3434: .tr !"
3435: .TP
3436: .B #pragma implementation
3437: .TP
3438: .BI "#pragma implementation !" objects .h!
3439: .I (C++ only.)
3440: Use this pragma in a main input file, when you want full output from
3441: included header files to be generated (and made globally visible).
3442: The included header file, in turn, should use `\|\c
3443: .B #pragma interface\c
3444: \&\|'.
3445: Backup copies of inline member functions, debugging information, and
3446: the internal tables used to implement virtual functions are all
3447: generated in implementation files.
3448:
3449: If you use `\|\c
3450: .B #pragma implementation\c
3451: \&\|' with no argument, it applies to an include file with the same
3452: basename as your source file; for example, in `\|\c
3453: .B allclass.cc\c
3454: \&\|', `\|\c
3455: .B #pragma implementation\c
3456: \&\|' by itself is equivalent to `\|\c
3457: .B
3458: #pragma implementation "allclass.h"\c
3459: \&\|'. Use the string argument if you want a single implementation
3460: file to include code from multiple header files.
3461:
3462: There is no way to split up the contents of a single header file into
3463: multiple implementation files.
3464: .SH FILES
3465: .ta \w'LIBDIR/g++\-include 'u
3466: file.c C source file
3467: .br
3468: file.h C header (preprocessor) file
3469: .br
3470: file.i preprocessed C source file
3471: .br
3472: file.C C++ source file
3473: .br
3474: file.cc C++ source file
3475: .br
3476: file.cxx C++ source file
3477: .br
3478: file.m Objective-C source file
3479: .br
3480: file.s assembly language file
3481: .br
3482: file.o object file
3483: .br
3484: a.out link edited output
3485: .br
3486: \fITMPDIR\fR/cc\(** temporary files
3487: .br
3488: \fILIBDIR\fR/cpp preprocessor
3489: .br
3490: \fILIBDIR\fR/cc1 compiler for C
3491: .br
3492: \fILIBDIR\fR/cc1plus compiler for C++
3493: .br
3494: \fILIBDIR\fR/collect linker front end needed on some machines
3495: .br
3496: \fILIBDIR\fR/libgcc.a GCC subroutine library
3497: .br
3498: /lib/crt[01n].o start-up routine
3499: .br
3500: \fILIBDIR\fR/ccrt0 additional start-up routine for C++
3501: .br
3502: /lib/libc.a standard C library, see
3503: .IR intro (3)
3504: .br
3505: /usr/include standard directory for
3506: .B #include
3507: files
3508: .br
3509: \fILIBDIR\fR/include standard gcc directory for
3510: .B #include
3511: files
3512: .br
3513: \fILIBDIR\fR/g++\-include additional g++ directory for
3514: .B #include
3515: .sp
3516: .I LIBDIR
3517: is usually
3518: .B /usr/local/lib/\c
3519: .IR machine / version .
3520: .br
3521: .I TMPDIR
3522: comes from the environment variable
3523: .B TMPDIR
3524: (default
3525: .B /usr/tmp
3526: if available, else
3527: .B /tmp\c
3528: \&).
3529: .SH "SEE ALSO"
3530: cpp(1), as(1), ld(1), gdb(1), adb(1), dbx(1), sdb(1).
3531: .br
3532: .RB "`\|" gcc "\|', `\|" cpp \|',
3533: .RB `\| as \|', `\| ld \|',
3534: and
3535: .RB `\| gdb \|'
3536: entries in
3537: .B info\c
3538: \&.
3539: .br
3540: .I
3541: Using and Porting GNU CC (for version 2.0)\c
3542: , Richard M. Stallman, November 1990;
3543: .I
3544: The C Preprocessor\c
3545: , Richard M. Stallman, July 1990;
3546: .I
3547: Using GDB: A Guide to the GNU Source-Level Debugger\c
3548: , Richard M. Stallman and Roland H. Pesch, December 1991;
3549: .I
3550: Using as: the GNU Assembler\c
3551: , Dean Elsner, Jay Fenlason & friends, March 1991;
3552: .I
3553: gld: the GNU linker\c
3554: , Steve Chamberlain and Roland Pesch, April 1991.
3555:
3556: .SH BUGS
3557: Report bugs to
3558: .BR bug\[email protected] .
3559: Bugs tend actually to be fixed if they can be isolated, so it is in your
3560: interest to report them in such a way that they can be easily reproduced.
3561: .SH COPYING
3562: Copyright (c) 1991 Free Software Foundation, Inc.
3563: .PP
3564: Permission is granted to make and distribute verbatim copies of
3565: this manual provided the copyright notice and this permission notice
3566: are preserved on all copies.
3567: .PP
3568: Permission is granted to copy and distribute modified versions of this
3569: manual under the conditions for verbatim copying, provided that the
3570: entire resulting derived work is distributed under the terms of a
3571: permission notice identical to this one.
3572: .PP
3573: Permission is granted to copy and distribute translations of this
3574: manual into another language, under the above conditions for modified
3575: versions, except that this permission notice may be included in
3576: translations approved by the Free Software Foundation instead of in
3577: the original English.
3578: .SH AUTHORS
3579: See the GNU CC Manual for the contributors to GNU CC.
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.