![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to gcc.info-4 CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / GNUtools / cc|
Return to gcc.info-4 CVS log | Up to [Apple XNU] / GNUtools / cc |
1.1 root 1: This is Info file gcc.info, produced by Makeinfo-1.54 from the input
2: file gcc.texi.
3:
4: This file documents the use and the internals of the GNU compiler.
5:
6: Published by the Free Software Foundation 675 Massachusetts Avenue
7: Cambridge, MA 02139 USA
8:
9: Copyright (C) 1988, 1989, 1992, 1993 Free Software Foundation, Inc.
10:
11: Permission is granted to make and distribute verbatim copies of this
12: manual provided the copyright notice and this permission notice are
13: preserved on all copies.
14:
15: Permission is granted to copy and distribute modified versions of
16: this manual under the conditions for verbatim copying, provided also
17: that the sections entitled "GNU General Public License" and "Protect
18: Your Freedom--Fight `Look And Feel'" are included exactly as in the
19: original, and provided that the entire resulting derived work is
20: distributed under the terms of a permission notice identical to this
21: one.
22:
23: Permission is granted to copy and distribute translations of this
24: manual into another language, under the above conditions for modified
25: versions, except that the sections entitled "GNU General Public
26: License" and "Protect Your Freedom--Fight `Look And Feel'", and this
27: permission notice, may be included in translations approved by the Free
28: Software Foundation instead of in the original English.
29:
30:
31: File: gcc.info, Node: RS/6000 and PowerPC Options, Next: RT Options, Prev: M88K Options, Up: Submodel Options
32:
33: IBM RS/6000 and PowerPC Options
34: -------------------------------
35:
36: These `-m' options are defined for the IBM RS/6000 and PowerPC:
37: `-mpower'
38: `-mno-power'
39: `-mpower2'
40: `-mno-power2'
41: `-mpowerpc'
42: `-mno-powerpc'
43: `-mpowerpcsqr'
44: `-mno-powerpcsqr'
45: `-mpowerpc64'
46: `-mno-powerpc64'
47: GNU CC supports two related instruction set architectures for the
48: RS/6000 and PowerPC. The "POWER" instruction set are those
49: instructions supported by the `rios' chip set used in the original
50: RS/6000 systems and the "PowerPC" instruction set is the
51: architecture of the Motorola MPC6xx microprocessors. The PowerPC
52: architecture defines 64-bit instructions, but they are not
53: supported by any current processors.
54:
55: Neither architecture is a subset of the other. However there is a
56: large common subset of instructions supported by both. An MQ
57: register is included in processors supporting the POWER
58: architecture.
59:
60: You use these options to specify which instructions are available
61: on the processor you are using. The default value of these
62: options is determined when configuring GNU CC. Specifying the
63: `-mcpu=CPU_TYPE' overrides the specification of these options. We
64: recommend you use that option rather than these.
65:
66: The `-mpower' option allows GNU CC to generate instructions that
67: are found only in the POWER architecture and to use the MQ
68: register. Specifying `-mpower2' implies `-power' and also allows
69: GNU CC to generate instructions that are present in the POWER2
70: architecture but not the original POWER architecture.
71:
72: The `-mpowerpc' option allows GNU CC to generate instructions that
73: are found only in the 32-bit subset of the PowerPC architecture.
74: Specifying `-mpowerpcsqr' implies `-mpowerpc' and also allows GNU
75: CC to use the floating point square root instructions in the
76: PowerPC architecture but not in its first implementation.
77: Likewise, specifying `-mpowerpc64' implies `-mpowerpc' and also
78: allows GNU CC to use the 64-bit instructions in the PowerPC
79: architecture.
80:
81: If you specify both `-mno-power' and `-mno-powerpc', GNU CC will
82: use only the instructions in the common subset of both
83: architectures and will not use the MQ register. Specifying both
84: `-mpower' and `-mpowerpc' permits GNU CC to use any instruction
85: from either architecture and to allow use of the MQ register;
86: specify this for the Motorola MPC601.
87:
88: `-mnew-mnemonics'
89: `-mold-mnemonics'
90: Select the mnemonics for GNU CC to use in the generated assembler
91: code. `-mnew-mnemonics' requests GNU CC to produce output that
92: uses the assembler mnemonics defined for the PowerPC architecture
93: and the `-mold-mnemonics' requests GNU CC to use the assembler
94: mnemonics defined for the POWER architecture. Instructions
95: defined in only one architecture have only one mnemonic; GNU CC
96: uses that mnemonic irrespective of which of thse options is
97: specified.
98:
99: PowerPC assemblers support both the old and new mnemonics, as will
100: later POWER assemblers. Current POWER assemblers only support the
101: old mnemonics. Specify `-mnew-mnemonics' if you have an assembler
102: that sypports them, otherwise specify `-mold-mnemonics'.
103:
104: The default value of these options depends on how GNU CC was
105: configured. Specifing `-mcpu=CPU_TYPE' sometimes overrides the
106: value of these option. Unless you are building a cross-compiled,
107: you should normally not specify either `-mnew-mnemonics' or
108: `-mold-mnemonics', but should instead accept the default.
109:
110: `-mcpu=CPU_TYPE'
111: Set architecture type, register usage, choice of mnemonics, and
112: instruction scheduling parameters for machine type CPU_TYPE. By
113: default, CPU_TYPE is the target system defined when GNU CC was
114: configured. Supported values for CPU_TYPE are `rios1', `rios2',
115: `601', `603', `604', `620' and `all'.
116:
117: Specifying `-mcpu=rios1' or `-mcpu=rios2' enables the `-mpower'
118: option and disables the `-mpowerpc' option, `-mcpu=601' enables
119: both the `-mpower' and `-mpowerpc' options, `-mcpu=603' and
120: `-mcpu=604' enable the `-mpowerpc' option and disables the
121: `-mpower' option, and `-mcpu=620' enables both the `-mpowerpc' and
122: `-mpowerpc64' options and also disables the `-mpower' option.
123:
124: To generate code that will operate on all members of the RS/6000
125: and PowerPC family, specify `-mcpu=all'. In that case, GNU CC will
126: only use instructions in the common subset and will not use the MQ
127: register. The instruction scheduling parameters and choice of
128: mnemonics are not affected.
129:
130: Specifying `-mcpu=601', `-mcpu=603', `-mcpu=604', or `-mcpu=620'
131: also enables the `new-mnemonics' option.
132:
133: `-mnormal-toc'
134: `-mno-fp-in-toc'
135: `-mminimal-toc'
136: Modify generation of the TOC (Table Of Contents), which is created
137: for every executable file. The `-mnormal-toc' option is selected
138: by default. In that case, GNU CC will allocate at least one TOC
139: entry for each unique non-automatic variable reference in your
140: program. GNU CC will also place floating-point constants in the
141: TOC. However, only 16K entries are available in the TOC.
142:
143: If you receive a linker error message that says you have
144: overflowed the available TOC space, recompile your files with
145: either the `-mno-fp-in-toc' or `-mminimal-toc' options.
146: `-mno-fp-in-toc' prevents GNU CC from putting floating-point
147: constants in the TOC. `-mminimal-toc' causes GNU CC to make only
148: one TOC entry for every file. Using the `-minimal-toc' option
149: produces slightly slower and larger code than the `-mnormal-toc' or
150: `-mno-fp-in-toc' options. If you use floating-point, try the
151: `-mno-fp-in-toc' option before you specify `-mminimal-toc'.
152:
153:
154: File: gcc.info, Node: RT Options, Next: MIPS Options, Prev: RS/6000 and PowerPC Options, Up: Submodel Options
155:
156: IBM RT Options
157: --------------
158:
159: These `-m' options are defined for the IBM RT PC:
160:
161: `-min-line-mul'
162: Use an in-line code sequence for integer multiplies. This is the
163: default.
164:
165: `-mcall-lib-mul'
166: Call `lmul$$' for integer multiples.
167:
168: `-mfull-fp-blocks'
169: Generate full-size floating point data blocks, including the
170: minimum amount of scratch space recommended by IBM. This is the
171: default.
172:
173: `-mminimum-fp-blocks'
174: Do not include extra scratch space in floating point data blocks.
175: This results in smaller code, but slower execution, since scratch
176: space must be allocated dynamically.
177:
178: `-mfp-arg-in-fpregs'
179: Use a calling sequence incompatible with the IBM calling
180: convention in which floating point arguments are passed in
181: floating point registers. Note that `varargs.h' and `stdargs.h'
182: will not work with floating point operands if this option is
183: specified.
184:
185: `-mfp-arg-in-gregs'
186: Use the normal calling convention for floating point arguments.
187: This is the default.
188:
189: `-mhc-struct-return'
190: Return structures of more than one word in memory, rather than in a
191: register. This provides compatibility with the MetaWare HighC (hc)
192: compiler. Use the option `-fpcc-struct-return' for compatibility
193: with the Portable C Compiler (pcc).
194:
195: `-mnohc-struct-return'
196: Return some structures of more than one word in registers, when
197: convenient. This is the default. For compatibility with the
198: IBM-supplied compilers, use the option `-fpcc-struct-return' or the
199: option `-mhc-struct-return'.
200:
201:
202: File: gcc.info, Node: MIPS Options, Next: i386 Options, Prev: RT Options, Up: Submodel Options
203:
204: MIPS Options
205: ------------
206:
207: These `-m' options are defined for the MIPS family of computers:
208:
209: `-mcpu=CPU TYPE'
210: Assume the defaults for the machine type CPU TYPE when scheduling
211: instructions. The default CPU TYPE is `default', which picks the
212: longest cycles times for any of the machines, in order that the
213: code run at reasonable rates on all MIPS cpu's. Other choices for
214: CPU TYPE are `r2000', `r3000', `r4000', and `r6000'. While
215: picking a specific CPU TYPE will schedule things appropriately for
216: that particular chip, the compiler will not generate any code that
217: does not meet level 1 of the MIPS ISA (instruction set
218: architecture) without the `-mips2' or `-mips3' switches being used.
219:
220: `-mips2'
221: Issue instructions from level 2 of the MIPS ISA (branch likely,
222: square root instructions). The `-mcpu=r4000' or `-mcpu=r6000'
223: switch must be used in conjunction with `-mips2'.
224:
225: `-mips3'
226: Issue instructions from level 3 of the MIPS ISA (64 bit
227: instructions). You must use the `-mcpu=r4000' switch along with
228: `-mips3'.
229:
230: `-mint64'
231: `-mlong64'
232: `-mlonglong128'
233: These options don't work at present.
234:
235: `-mmips-as'
236: Generate code for the MIPS assembler, and invoke `mips-tfile' to
237: add normal debug information. This is the default for all
238: platforms except for the OSF/1 reference platform, using the
239: OSF/rose object format. If the either of the `-gstabs' or
240: `-gstabs+' switches are used, the `mips-tfile' program will
241: encapsulate the stabs within MIPS ECOFF.
242:
243: `-mgas'
244: Generate code for the GNU assembler. This is the default on the
245: OSF/1 reference platform, using the OSF/rose object format.
246:
247: `-mrnames'
248: `-mno-rnames'
249: The `-mrnames' switch says to output code using the MIPS software
250: names for the registers, instead of the hardware names (ie, A0
251: instead of $4). The GNU assembler does not support the `-mrnames'
252: switch, and the MIPS assembler will be instructed to run the MIPS
253: C preprocessor over the source file. The `-mno-rnames' switch is
254: default.
255:
256: `-mgpopt'
257: `-mno-gpopt'
258: The `-mgpopt' switch says to write all of the data declarations
259: before the instructions in the text section, this allows the MIPS
260: assembler to generate one word memory references instead of using
261: two words for short global or static data items. This is on by
262: default if optimization is selected.
263:
264: `-mstats'
265: `-mno-stats'
266: For each non-inline function processed, the `-mstats' switch
267: causes the compiler to emit one line to the standard error file to
268: print statistics about the program (number of registers saved,
269: stack size, etc.).
270:
271: `-mmemcpy'
272: `-mno-memcpy'
273: The `-mmemcpy' switch makes all block moves call the appropriate
274: string function (`memcpy' or `bcopy') instead of possibly
275: generating inline code.
276:
277: `-mmips-tfile'
278: `-mno-mips-tfile'
279: The `-mno-mips-tfile' switch causes the compiler not postprocess
280: the object file with the `mips-tfile' program, after the MIPS
281: assembler has generated it to add debug support. If `mips-tfile'
282: is not run, then no local variables will be available to the
283: debugger. In addition, `stage2' and `stage3' objects will have
284: the temporary file names passed to the assembler embedded in the
285: object file, which means the objects will not compare the same.
286: The `-mno-mips-tfile' switch should only be used when there are
287: bugs in the `mips-tfile' program that prevents compilation.
288:
289: `-msoft-float'
290: Generate output containing library calls for floating point.
291: *Warning:* the requisite libraries are not part of GNU CC.
292: Normally the facilities of the machine's usual C compiler are
293: used, but this can't be done directly in cross-compilation. You
294: must make your own arrangements to provide suitable library
295: functions for cross-compilation.
296:
297: `-mhard-float'
298: Generate output containing floating point instructions. This is
299: the default if you use the unmodified sources.
300:
301: `-mfp64'
302: Assume that the FR bit in the status word is on, and that there
303: are 32 64-bit floating point registers, instead of 32 32-bit
304: floating point registers. You must also specify the `-mcpu=r4000'
305: and `-mips3' switches.
306:
307: `-mfp32'
308: Assume that there are 32 32-bit floating point registers. This is
309: the default.
310:
311: `-mabicalls'
312: `-mno-abicalls'
313: Emit (or do not emit) the pseudo operations `.abicalls',
314: `.cpload', and `.cprestore' that some System V.4 ports use for
315: position independent code.
316:
317: `-mlong-calls'
318: `-mlong-calls'
319: Do all calls with the `JALR' instruction, which requires loading
320: up a function's address into a register before the call. You need
321: to use this switch, if you call outside of the current 512
322: megabyte segment to functions that are not through pointers.
323:
324: `-mhalf-pic'
325: `-mno-half-pic'
326: Put pointers to extern references into the data section and load
327: them up, rather than put the references in the text section.
328:
329: `-G NUM'
330: Put global and static items less than or equal to NUM bytes into
331: the small data or bss sections instead of the normal data or bss
332: section. This allows the assembler to emit one word memory
333: reference instructions based on the global pointer (GP or $28),
334: instead of the normal two words used. By default, NUM is 8 when
335: the MIPS assembler is used, and 0 when the GNU assembler is used.
336: The `-G NUM' switch is also passed to the assembler and linker.
337: All modules should be compiled with the same `-G NUM' value.
338:
339: `-nocpp'
340: Tell the MIPS assembler to not run it's preprocessor over user
341: assembler files (with a `.s' suffix) when assembling them.
342:
343: These options are defined by the macro `TARGET_SWITCHES' in the
344: machine description. The default for the options is also defined by
345: that macro, which enables you to change the defaults.
346:
347:
348: File: gcc.info, Node: i386 Options, Next: HPPA Options, Prev: MIPS Options, Up: Submodel Options
349:
350: Intel 386 Options
351: -----------------
352:
353: These `-m' options are defined for the i386 family of computers:
354:
355: `-m486'
356: `-mno-486'
357: Control whether or not code is optimized for a 486 instead of an
358: 386. Code generated for an 486 will run on a 386 and vice versa.
359:
360: `-msoft-float'
361: Generate output containing library calls for floating point.
362: *Warning:* the requisite libraries are not part of GNU CC.
363: Normally the facilities of the machine's usual C compiler are
364: used, but this can't be done directly in cross-compilation. You
365: must make your own arrangements to provide suitable library
366: functions for cross-compilation.
367:
368: On machines where a function returns floating point results in the
369: 80387 register stack, some floating point opcodes may be emitted
370: even if `-msoft-float' is used.
371:
372: `-mno-fp-ret-in-387'
373: Do not use the FPU registers for return values of functions.
374:
375: The usual calling convention has functions return values of types
376: `float' and `double' in an FPU register, even if there is no FPU.
377: The idea is that the operating system should emulate an FPU.
378:
379: The option `-mno-fp-ret-in-387' causes such values to be returned
380: in ordinary CPU registers instead.
381:
382:
383: File: gcc.info, Node: HPPA Options, Next: Intel 960 Options, Prev: i386 Options, Up: Submodel Options
384:
385: HPPA Options
386: ------------
387:
388: These `-m' options are defined for the HPPA family of computers:
389:
390: `-mpa-risc-1-0'
391: Generate code for a PA 1.0 processor.
392:
393: `-mpa-risc-1-1'
394: Generate code for a PA 1.1 processor.
395:
396: `-mlong-calls'
397: Generate code which allows calls to functions greater than 256k
398: away from the caller when the caller and callee are in the same
399: source file. Do not turn this option on unless code refuses to
400: link with "branch out of range errors" from the linker.
401:
402: `-mdisable-fpregs'
403: Prevent floating point registers from being used in any manner.
404: This is necessary for compiling kernels which perform lazy context
405: switching of floating point registers. If you use this option and
406: attempt to perform floating point operations, the compiler will
407: abort.
408:
409: `-mdisable-indexing'
410: Prevent the compiler from using indexing address modes. This
411: avoids some rather obscure problems when compiling MIG generated
412: code under MACH.
413:
414: `-mtrailing-colon'
415: Add a colon to the end of label definitions (for ELF assemblers).
416:
417:
418: File: gcc.info, Node: Intel 960 Options, Next: DEC Alpha Options, Prev: HPPA Options, Up: Submodel Options
419:
420: Intel 960 Options
421: -----------------
422:
423: These `-m' options are defined for the Intel 960 implementations:
424:
425: `-mCPU TYPE'
426: Assume the defaults for the machine type CPU TYPE for some of the
427: other options, including instruction scheduling, floating point
428: support, and addressing modes. The choices for CPU TYPE are `ka',
429: `kb', `mc', `ca', `cf', `sa', and `sb'. The default is `kb'.
430:
431: `-mnumerics'
432: `-msoft-float'
433: The `-mnumerics' option indicates that the processor does support
434: floating-point instructions. The `-msoft-float' option indicates
435: that floating-point support should not be assumed.
436:
437: `-mleaf-procedures'
438: `-mno-leaf-procedures'
439: Do (or do not) attempt to alter leaf procedures to be callable
440: with the `bal' instruction as well as `call'. This will result in
441: more efficient code for explicit calls when the `bal' instruction
442: can be substituted by the assembler or linker, but less efficient
443: code in other cases, such as calls via function pointers, or using
444: a linker that doesn't support this optimization.
445:
446: `-mtail-call'
447: `-mno-tail-call'
448: Do (or do not) make additional attempts (beyond those of the
449: machine-independent portions of the compiler) to optimize
450: tail-recursive calls into branches. You may not want to do this
451: because the detection of cases where this is not valid is not
452: totally complete. The default is `-mno-tail-call'.
453:
454: `-mcomplex-addr'
455: `-mno-complex-addr'
456: Assume (or do not assume) that the use of a complex addressing
457: mode is a win on this implementation of the i960. Complex
458: addressing modes may not be worthwhile on the K-series, but they
459: definitely are on the C-series. The default is currently
460: `-mcomplex-addr' for all processors except the CB and CC.
461:
462: `-mcode-align'
463: `-mno-code-align'
464: Align code to 8-byte boundaries for faster fetching (or don't
465: bother). Currently turned on by default for C-series
466: implementations only.
467:
468: `-mic-compat'
469: `-mic2.0-compat'
470: `-mic3.0-compat'
471: Enable compatibility with iC960 v2.0 or v3.0.
472:
473: `-masm-compat'
474: `-mintel-asm'
475: Enable compatibility with the iC960 assembler.
476:
477: `-mstrict-align'
478: `-mno-strict-align'
479: Do not permit (do permit) unaligned accesses.
480:
481: `-mold-align'
482: Enable structure-alignment compatibility with Intel's gcc release
483: version 1.3 (based on gcc 1.37). Currently this is buggy in that
484: `#pragma align 1' is always assumed as well, and cannot be turned
485: off.
486:
487:
488: File: gcc.info, Node: DEC Alpha Options, Next: Clipper Options, Prev: Intel 960 Options, Up: Submodel Options
489:
490: DEC Alpha Options
491: -----------------
492:
493: These `-m' options are defined for the DEC Alpha implementations:
494:
495: `-mno-soft-float'
496: `-msoft-float'
497: Use (do not use) the hardware floating-point instructions for
498: floating-point operations. When `-msoft-float' is specified,
499: functions in `libgcc1.c' will be used to perform floating-point
500: operations. Unless they are replaced by routines that emulate the
501: floating-point operations, or compiled in such a way as to call
502: such emulations routines, these routines will issue floating-point
503: operations. If you are compiling for an Alpha without
504: floating-point operations, you must ensure that the library is
505: built so as not to call them.
506:
507: Note that Alpha implementations without floating-point operations
508: are required to have floating-point registers.
509:
510: `-mfp-reg'
511: `-mno-fp-regs'
512: Generate code that uses (does not use) the floating-point register
513: set. `-mno-fp-regs' implies `-msoft-float'. If the floating-point
514: register set is not used, floating point operands are passed in
515: integer registers as if they were integers and floating-point
516: results are passed in $0 instead of $f0. This is a non-standard
517: calling sequence, so any function with a floating-point argument
518: or return value called by code compiled with `-mno-fp-regs' must
519: also be compiled with that option.
520:
521: A typical use of this option is building a kernel that does not
522: use, and hence need not save and restore, any floating-point
523: registers.
524:
525:
526: File: gcc.info, Node: Clipper Options, Next: System V Options, Prev: DEC Alpha Options, Up: Submodel Options
527:
528: Clipper Options
529: ---------------
530:
531: These `-m' options are defined for the Clipper implementations:
532:
533: `-mc300'
534: Produce code for a C300 Clipper processor. This is the default.
535:
536: `-mc400'
537: Produce code for a C400 Clipper processor i.e. use floting point
538: registers f8..f15.
539:
540:
541: File: gcc.info, Node: System V Options, Prev: Clipper Options, Up: Submodel Options
542:
543: Options for System V
544: --------------------
545:
546: These additional options are available on System V Release 4 for
547: compatibility with other compilers on those systems:
548:
549: `-Qy'
550: Identify the versions of each tool used by the compiler, in a
551: `.ident' assembler directive in the output.
552:
553: `-Qn'
554: Refrain from adding `.ident' directives to the output file (this is
555: the default).
556:
557: `-YP,DIRS'
558: Search the directories DIRS, and no others, for libraries
559: specified with `-l'.
560:
561: `-Ym,DIR'
562: Look in the directory DIR to find the M4 preprocessor. The
563: assembler uses this option.
564:
565:
566: File: gcc.info, Node: Code Gen Options, Next: Environment Variables, Prev: Submodel Options, Up: Invoking GCC
567:
568: Options for Code Generation Conventions
569: =======================================
570:
571: These machine-independent options control the interface conventions
572: used in code generation.
573:
574: Most of them have both positive and negative forms; the negative form
575: of `-ffoo' would be `-fno-foo'. In the table below, only one of the
576: forms is listed--the one which is not the default. You can figure out
577: the other form by either removing `no-' or adding it.
578:
579: `-fpcc-struct-return'
580: Return "short" `struct' and `union' values in memory like longer
581: ones, rather than in registers. This convention is less
582: efficient, but it has the advantage of allowing intercallability
583: between GNU CC-compiled files and files compiled with other
584: compilers.
585:
586: The precise convention for returning structures in memory depends
587: on the target configuration macros.
588:
589: Short structures and unions are those whose size and alignment
590: match that of some integer type.
591:
592: `-freg-struct-return'
593: Use the convention that `struct' and `union' values are returned
594: in registers when possible. This is more efficient for small
595: structures than `-fpcc-struct-return'.
596:
597: If you specify neither `-fpcc-struct-return' nor its contrary
598: `-freg-struct-return', GNU CC defaults to whichever convention is
599: standard for the target. If there is no standard convention, GNU
600: CC defaults to `-fpcc-struct-return', except on targets where GNU
601: CC is the principal compiler. In those cases, we can choose the
602: standard, and we chose the more efficient register return
603: alternative.
604:
605: `-fshort-enums'
606: Allocate to an `enum' type only as many bytes as it needs for the
607: declared range of possible values. Specifically, the `enum' type
608: will be equivalent to the smallest integer type which has enough
609: room.
610:
611: `-fshort-double'
612: Use the same size for `double' as for `float'.
613:
614: `-fshared-data'
615: Requests that the data and non-`const' variables of this
616: compilation be shared data rather than private data. The
617: distinction makes sense only on certain operating systems, where
618: shared data is shared between processes running the same program,
619: while private data exists in one copy per process.
620:
621: `-fno-common'
622: Allocate even uninitialized global variables in the bss section of
623: the object file, rather than generating them as common blocks.
624: This has the effect that if the same variable is declared (without
625: `extern') in two different compilations, you will get an error
626: when you link them. The only reason this might be useful is if
627: you wish to verify that the program will work on other systems
628: which always work this way.
629:
630: `-fno-ident'
631: Ignore the `#ident' directive.
632:
633: `-fno-gnu-linker'
634: Do not output global initializations (such as C++ constructors and
635: destructors) in the form used by the GNU linker (on systems where
636: the GNU linker is the standard method of handling them). Use this
637: option when you want to use a non-GNU linker, which also requires
638: using the `collect2' program to make sure the system linker
639: includes constructors and destructors. (`collect2' is included in
640: the GNU CC distribution.) For systems which *must* use
641: `collect2', the compiler driver `gcc' is configured to do this
642: automatically.
643:
644: `-finhibit-size-directive'
645: Don't output a `.size' assembler directive, or anything else that
646: would cause trouble if the function is split in the middle, and the
647: two halves are placed at locations far apart in memory. This
648: option is used when compiling `crtstuff.c'; you should not need to
649: use it for anything else.
650:
651: `-fverbose-asm'
652: Put extra commentary information in the generated assembly code to
653: make it more readable. This option is generally only of use to
654: those who actually need to read the generated assembly code
655: (perhaps while debugging the compiler itself).
656:
657: `-fvolatile'
658: Consider all memory references through pointers to be volatile.
659:
660: `-fvolatile-global'
661: Consider all memory references to extern and global data items to
662: be volatile.
663:
664: `-fpic'
665: Generate position-independent code (PIC) suitable for use in a
666: shared library, if supported for the target machine. Such code
667: accesses all constant addresses through a global offset table
668: (GOT). If the GOT size for the linked executable exceeds a
669: machine-specific maximum size, you get an error message from the
670: linker indicating that `-fpic' does not work; in that case,
671: recompile with `-fPIC' instead. (These maximums are 16k on the
672: m88k, 8k on the Sparc, and 32k on the m68k and RS/6000. The 386
673: has no such limit.)
674:
675: Position-independent code requires special support, and therefore
676: works only on certain machines. For the 386, GNU CC supports PIC
677: for System V but not for the Sun 386i. Code generated for the IBM
678: RS/6000 is always position-independent.
679:
680: The GNU assembler does not fully support PIC. Currently, you must
681: use some other assembler in order for PIC to work. We would
682: welcome volunteers to upgrade GAS to handle this; the first part
683: of the job is to figure out what the assembler must do differently.
684:
685: `-fPIC'
686: If supported for the target machine, emit position-independent
687: code, suitable for dynamic linking and avoiding any limit on the
688: size of the global offset table. This option makes a difference
689: on the m68k, m88k and the Sparc.
690:
691: Position-independent code requires special support, and therefore
692: works only on certain machines.
693:
694: `-ffixed-REG'
695: Treat the register named REG as a fixed register; generated code
696: should never refer to it (except perhaps as a stack pointer, frame
697: pointer or in some other fixed role).
698:
699: REG must be the name of a register. The register names accepted
700: are machine-specific and are defined in the `REGISTER_NAMES' macro
701: in the machine description macro file.
702:
703: This flag does not have a negative form, because it specifies a
704: three-way choice.
705:
706: `-fcall-used-REG'
707: Treat the register named REG as an allocatable register that is
708: clobbered by function calls. It may be allocated for temporaries
709: or variables that do not live across a call. Functions compiled
710: this way will not save and restore the register REG.
711:
712: Use of this flag for a register that has a fixed pervasive role in
713: the machine's execution model, such as the stack pointer or frame
714: pointer, will produce disastrous results.
715:
716: This flag does not have a negative form, because it specifies a
717: three-way choice.
718:
719: `-fcall-saved-REG'
720: Treat the register named REG as an allocatable register saved by
721: functions. It may be allocated even for temporaries or variables
722: that live across a call. Functions compiled this way will save
723: and restore the register REG if they use it.
724:
725: Use of this flag for a register that has a fixed pervasive role in
726: the machine's execution model, such as the stack pointer or frame
727: pointer, will produce disastrous results.
728:
729: A different sort of disaster will result from the use of this flag
730: for a register in which function values may be returned.
731:
732: This flag does not have a negative form, because it specifies a
733: three-way choice.
734:
735: `+e0'
736: `+e1'
737: Control whether virtual function definitions in classes are used to
738: generate code, or only to define interfaces for their callers.
739: (C++ only).
740:
741: These options are provided for compatibility with `cfront' 1.x
742: usage; the recommended alternative GNU C++ usage is in flux.
743: *Note Declarations and Definitions in One Header: C++ Interface.
744:
745: With `+e0', virtual function definitions in classes are declared
746: `extern'; the declaration is used only as an interface
747: specification, not to generate code for the virtual functions (in
748: this compilation).
749:
750: With `+e1', G++ actually generates the code implementing virtual
751: functions defined in the code, and makes them publicly visible.
752:
753:
754: File: gcc.info, Node: Environment Variables, Next: Running Protoize, Prev: Code Gen Options, Up: Invoking GCC
755:
756: Environment Variables Affecting GNU CC
757: ======================================
758:
759: This section describes several environment variables that affect how
760: GNU CC operates. They work by specifying directories or prefixes to use
761: when searching for various kinds of files.
762:
763: Note that you can also specify places to search using options such as
764: `-B', `-I' and `-L' (*note Directory Options::.). These take
765: precedence over places specified using environment variables, which in
766: turn take precedence over those specified by the configuration of GNU
767: CC. *Note Driver::.
768:
769: `TMPDIR'
770: If `TMPDIR' is set, it specifies the directory to use for temporary
771: files. GNU CC uses temporary files to hold the output of one
772: stage of compilation which is to be used as input to the next
773: stage: for example, the output of the preprocessor, which is the
774: input to the compiler proper.
775:
776: `GCC_EXEC_PREFIX'
777: If `GCC_EXEC_PREFIX' is set, it specifies a prefix to use in the
778: names of the subprograms executed by the compiler. No slash is
779: added when this prefix is combined with the name of a subprogram,
780: but you can specify a prefix that ends with a slash if you wish.
781:
782: If GNU CC cannot find the subprogram using the specified prefix, it
783: tries looking in the usual places for the subprogram.
784:
785: Other prefixes specified with `-B' take precedence over this
786: prefix.
787:
788: This prefix is also used for finding files such as `crt0.o' that
789: are used for linking.
790:
791: In addition, the prefix is used in an unusual way in finding the
792: directories to search for header files. For each of the standard
793: directories whose name normally begins with
794: `/usr/local/lib/gcc-lib' (more precisely, with the value of
795: `GCC_INCLUDE_DIR'), GNU CC tries replacing that beginning with the
796: specified prefix to produce an alternate directory name. Thus,
797: with `-Bfoo/', GNU CC will search `foo/bar' where it would
798: normally search `/usr/local/lib/bar'. These alternate directories
799: are searched first; the standard directories come next.
800:
801: `COMPILER_PATH'
802: The value of `COMPILER_PATH' is a colon-separated list of
803: directories, much like `PATH'. GNU CC tries the directories thus
804: specified when searching for subprograms, if it can't find the
805: subprograms using `GCC_EXEC_PREFIX'.
806:
807: `LIBRARY_PATH'
808: The value of `LIBRARY_PATH' is a colon-separated list of
809: directories, much like `PATH'. GNU CC tries the directories thus
810: specified when searching for special linker files, if it can't
811: find them using `GCC_EXEC_PREFIX'. Linking using GNU CC also uses
812: these directories when searching for ordinary libraries for the
813: `-l' option (but directories specified with `-L' come first).
814:
815: `C_INCLUDE_PATH'
816: `CPLUS_INCLUDE_PATH'
817: `OBJC_INCLUDE_PATH'
818: These environment variables pertain to particular languages. Each
819: variable's value is a colon-separated list of directories, much
820: like `PATH'. When GNU CC searches for header files, it tries the
821: directories listed in the variable for the language you are using,
822: after the directories specified with `-I' but before the standard
823: header file directories.
824:
825: `DEPENDENCIES_OUTPUT'
826: If this variable is set, its value specifies how to output
827: dependencies for Make based on the header files processed by the
828: compiler. This output looks much like the output from the `-M'
829: option (*note Preprocessor Options::.), but it goes to a separate
830: file, and is in addition to the usual results of compilation.
831:
832: The value of `DEPENDENCIES_OUTPUT' can be just a file name, in
833: which case the Make rules are written to that file, guessing the
834: target name from the source file name. Or the value can have the
835: form `FILE TARGET', in which case the rules are written to file
836: FILE using TARGET as the target name.
837:
838:
839: File: gcc.info, Node: Running Protoize, Prev: Environment Variables, Up: Invoking GCC
840:
841: Running Protoize
842: ================
843:
844: The program `protoize' is an optional part of GNU C. You can use it
845: to add prototypes to a program, thus converting the program to ANSI C
846: in one respect. The companion program `unprotoize' does the reverse:
847: it removes argument types from any prototypes that are found.
848:
849: When you run these programs, you must specify a set of source files
850: as command line arguments. The conversion programs start out by
851: compiling these files to see what functions they define. The
852: information gathered about a file FOO is saved in a file named `FOO.X'.
853:
854: After scanning comes actual conversion. The specified files are all
855: eligible to be converted; any files they include (whether sources or
856: just headers) are eligible as well.
857:
858: But not all the eligible files are converted. By default,
859: `protoize' and `unprotoize' convert only source and header files in the
860: current directory. You can specify additional directories whose files
861: should be converted with the `-d DIRECTORY' option. You can also
862: specify particular files to exclude with the `-x FILE' option. A file
863: is converted if it is eligible, its directory name matches one of the
864: specified directory names, and its name within the directory has not
865: been excluded.
866:
867: Basic conversion with `protoize' consists of rewriting most function
868: definitions and function declarations to specify the types of the
869: arguments. The only ones not rewritten are those for varargs functions.
870:
871: `protoize' optionally inserts prototype declarations at the
872: beginning of the source file, to make them available for any calls that
873: precede the function's definition. Or it can insert prototype
874: declarations with block scope in the blocks where undeclared functions
875: are called.
876:
877: Basic conversion with `unprotoize' consists of rewriting most
878: function declarations to remove any argument types, and rewriting
879: function definitions to the old-style pre-ANSI form.
880:
881: Both conversion programs print a warning for any function
882: declaration or definition that they can't convert. You can suppress
883: these warnings with `-q'.
884:
885: The output from `protoize' or `unprotoize' replaces the original
886: source file. The original file is renamed to a name ending with
887: `.save'. If the `.save' file already exists, then the source file is
888: simply discarded.
889:
890: `protoize' and `unprotoize' both depend on GNU CC itself to scan the
891: program and collect information about the functions it uses. So
892: neither of these programs will work until GNU CC is installed.
893:
894: Here is a table of the options you can use with `protoize' and
895: `unprotoize'. Each option works with both programs unless otherwise
896: stated.
897:
898: `-B DIRECTORY'
899: Look for the file `SYSCALLS.c.X' in DIRECTORY, instead of the
900: usual directory (normally `/usr/local/lib'). This file contains
901: prototype information about standard system functions. This option
902: applies only to `protoize'.
903:
904: `-c COMPILATION-OPTIONS'
905: Use COMPILATION-OPTIONS as the options when running `gcc' to
906: produce the `.X' files. The special option `-aux-info' is always
907: passed in addition, to tell `gcc' to write a `.X' file.
908:
909: Note that the compilation options must be given as a single
910: argument to `protoize' or `unprotoize'. If you want to specify
911: several `gcc' options, you must quote the entire set of
912: compilation options to make them a single word in the shell.
913:
914: There are certain `gcc' arguments that you cannot use, because they
915: would produce the wrong kind of output. These include `-g', `-O',
916: `-c', `-S', and `-o' If you include these in the
917: COMPILATION-OPTIONS, they are ignored.
918:
919: `-C'
920: Rename files to end in `.C' instead of `.c'. This is convenient
921: if you are converting a C program to C++. This option applies
922: only to `protoize'.
923:
924: `-g'
925: Add explicit global declarations. This means inserting explicit
926: declarations at the beginning of each source file for each function
927: that is called in the file and was not declared. These
928: declarations precede the first function definition that contains a
929: call to an undeclared function. This option applies only to
930: `protoize'.
931:
932: `-i STRING'
933: Indent old-style parameter declarations with the string STRING.
934: This option applies only to `protoize'.
935:
936: `unprotoize' converts prototyped function definitions to old-style
937: function definitions, where the arguments are declared between the
938: argument list and the initial `{'. By default, `unprotoize' uses
939: five spaces as the indentation. If you want to indent with just
940: one space instead, use `-i " "'.
941:
942: `-k'
943: Keep the `.X' files. Normally, they are deleted after conversion
944: is finished.
945:
946: `-l'
947: Add explicit local declarations. `protoize' with `-l' inserts a
948: prototype declaration for each function in each block which calls
949: the function without any declaration. This option applies only to
950: `protoize'.
951:
952: `-n'
953: Make no real changes. This mode just prints information about the
954: conversions that would have been done without `-n'.
955:
956: `-N'
957: Make no `.save' files. The original files are simply deleted.
958: Use this option with caution.
959:
960: `-p PROGRAM'
961: Use the program PROGRAM as the compiler. Normally, the name `gcc'
962: is used.
963:
964: `-q'
965: Work quietly. Most warnings are suppressed.
966:
967: `-v'
968: Print the version number, just like `-v' for `gcc'.
969:
970: If you need special compiler options to compile one of your program's
971: source files, then you should generate that file's `.X' file specially,
972: by running `gcc' on that source file with the appropriate options and
973: the option `-aux-info'. Then run `protoize' on the entire set of
974: files. `protoize' will use the existing `.X' file because it is newer
975: than the source file. For example:
976:
977: gcc -Dfoo=bar file1.c -aux-info
978: protoize *.c
979:
980: You need to include the special files along with the rest in the
981: `protoize' command, even though their `.X' files already exist, because
982: otherwise they won't get converted.
983:
984: *Note Protoize Caveats::, for more information on how to use
985: `protoize' successfully.
986:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.