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