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