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