![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to gcc.info-3 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-3 CVS log | Up to [GCC 2.x] / gcc |
1.1.1.4 ! root 1: This is Info file gcc.info, produced by Makeinfo-1.49 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: 6: Copyright (C) 1988, 1989, 1992 Free Software Foundation, Inc. 7: 1.1.1.3 root 8: Permission is granted to make and distribute verbatim copies of this 9: manual provided the copyright notice and this permission notice are 10: preserved on all copies. 1.1 root 11: 12: Permission is granted to copy and distribute modified versions of 13: this manual under the conditions for verbatim copying, provided also 1.1.1.4 ! root 14: that the sections entitled "GNU General Public License" and "Protect ! 15: Your Freedom--Fight `Look And Feel'" are included exactly as in the ! 16: original, and provided that the entire resulting derived work is ! 17: distributed under the terms of a permission notice identical to this ! 18: one. 1.1 root 19: 20: Permission is granted to copy and distribute translations of this 21: manual into another language, under the above conditions for modified 1.1.1.3 root 22: versions, except that the sections entitled "GNU General Public 1.1.1.4 ! root 23: License" and "Protect Your Freedom--Fight `Look And Feel'", and this ! 24: permission notice, may be included in translations approved by the Free ! 25: Software Foundation instead of in the original English. ! 26: ! 27: ! 28: File: gcc.info, Node: Link Options, Next: Directory Options, Prev: Assembler Options, Up: Invoking GCC ! 29: ! 30: Options for Linking ! 31: =================== ! 32: ! 33: These options come into play when the compiler links object files ! 34: into an executable output file. They are meaningless if the compiler is ! 35: not doing a link step. ! 36: ! 37: `OBJECT-FILE-NAME' ! 38: A file name that does not end in a special recognized suffix is ! 39: considered to name an object file or library. (Object files are ! 40: distinguished from libraries by the linker according to the file ! 41: contents.) If linking is done, these object files are used as ! 42: input to the linker. ! 43: ! 44: `-c' ! 45: `-S' ! 46: `-E' ! 47: If any of these options is used, then the linker is not run, and ! 48: object file names should not be used as arguments. *Note Overall ! 49: Options::. ! 50: ! 51: `-lLIBRARY' ! 52: Search the library named LIBRARY when linking. ! 53: ! 54: It makes a difference where in the command you write this option; ! 55: the linker searches processes libraries and object files in the ! 56: order they are specified. Thus, `foo.o -lz bar.o' searches ! 57: library `z' after file `foo.o' but before `bar.o'. If `bar.o' ! 58: refers to functions in `z', those functions may not be loaded. ! 59: ! 60: The linker searches a standard list of directories for the library, ! 61: which is actually a file named `libLIBRARY.a'. The linker then ! 62: uses this file as if it had been specified precisely by name. ! 63: ! 64: The directories searched include several standard system ! 65: directories plus any that you specify with `-L'. ! 66: ! 67: Normally the files found this way are library files--archive files ! 68: whose members are object files. The linker handles an archive ! 69: file by scanning through it for members which define symbols that ! 70: have so far been referenced but not defined. But if the file that ! 71: is found is an ordinary object file, it is linked in the usual ! 72: fashion. The only difference between using an `-l' option and ! 73: specifying a file name is that `-l' surrounds LIBRARY with `lib' ! 74: and `.a' and searches several directories. ! 75: ! 76: `-lobjc' ! 77: This special case of the `-l' option is what you need to do when ! 78: you link an Objective C program. ! 79: ! 80: `-nostdlib' ! 81: Don't use the standard system libraries and startup files when ! 82: linking. Only the files you specify will be passed to the linker. ! 83: ! 84: `-static' ! 85: On systems that support dynamic linking, this prevents linking ! 86: with the shared libraries. On other systems, this option has no ! 87: effect. ! 88: ! 89: `-shared' ! 90: Produce a shared object which can then be linked with other ! 91: objects to form an executable. Only a few systems support this ! 92: option. ! 93: ! 94: `-symbolic' ! 95: Bind references to global symbols when building a shared object. ! 96: Warn about any unresolved references (unless overridden by the ! 97: link editor option `-Xlinker -z -Xlinker defs'). Only a few ! 98: systems support this option. ! 99: ! 100: `-Xlinker OPTION' ! 101: Pass OPTION as an option to the linker. You can use this to ! 102: supply system-specific linker options which GNU CC does not know ! 103: how to recognize. ! 104: ! 105: If you want to pass an option that takes an argument, you must use ! 106: `-Xlinker' twice, once for the option and once for the argument. ! 107: For example, to pass `-assert definitions', you must write ! 108: `-Xlinker -assert -Xlinker definitions'. It does not work to write ! 109: `-Xlinker "-assert definitions"', because this passes the entire ! 110: string as a single argument, which is not what the linker expects. ! 111: ! 112: `-Wl,OPTION' ! 113: Pass OPTION as an option to the linker. If OPTION contains ! 114: commas, it is split into multiple options at the commas. ! 115: ! 116: `-u SYMBOL' ! 117: Pretend the symbol SYMBOL is undefined, to force linking of ! 118: library modules to define it. You can use `-u' multiple times with ! 119: different symbols to force loading of additional library modules. ! 120: ! 121: ! 122: File: gcc.info, Node: Directory Options, Next: Target Options, Prev: Link Options, Up: Invoking GCC ! 123: ! 124: Options for Directory Search ! 125: ============================ ! 126: ! 127: These options specify directories to search for header files, for ! 128: libraries and for parts of the compiler: ! 129: ! 130: `-IDIR' ! 131: Append directory DIR to the list of directories searched for ! 132: include files. ! 133: ! 134: `-I-' ! 135: Any directories you specify with `-I' options before the `-I-' ! 136: option are searched only for the case of `#include "FILE"'; they ! 137: are not searched for `#include <FILE>'. ! 138: ! 139: If additional directories are specified with `-I' options after ! 140: the `-I-', these directories are searched for all `#include' ! 141: directives. (Ordinarily *all* `-I' directories are used this way.) ! 142: ! 143: In addition, the `-I-' option inhibits the use of the current ! 144: directory (where the current input file came from) as the first ! 145: search directory for `#include "FILE"'. There is no way to ! 146: override this effect of `-I-'. With `-I.' you can specify ! 147: searching the directory which was current when the compiler was ! 148: invoked. That is not exactly the same as what the preprocessor ! 149: does by default, but it is often satisfactory. ! 150: ! 151: `-I-' does not inhibit the use of the standard system directories ! 152: for header files. Thus, `-I-' and `-nostdinc' are independent. ! 153: ! 154: `-LDIR' ! 155: Add directory DIR to the list of directories to be searched for ! 156: `-l'. ! 157: ! 158: `-BPREFIX' ! 159: This option specifies where to find the executables, libraries and ! 160: data files of the compiler itself. ! 161: ! 162: The compiler driver program runs one or more of the subprograms ! 163: `cpp', `cc1', `as' and `ld'. It tries PREFIX as a prefix for each ! 164: program it tries to run, both with and without `MACHINE/VERSION/' ! 165: (*note Target Options::.). ! 166: ! 167: For each subprogram to be run, the compiler driver first tries the ! 168: `-B' prefix, if any. If that name is not found, or if `-B' was ! 169: not specified, the driver tries two standard prefixes, which are ! 170: `/usr/lib/gcc/' and `/usr/local/lib/gcc-lib/'. If neither of ! 171: those results in a file name that is found, the unmodified program ! 172: name is searched for using the directories specified in your ! 173: `PATH' environment variable. ! 174: ! 175: `-B' prefixes that effectively specify directory names also apply ! 176: to libraries in the linker, because the compiler translates these ! 177: options into `-L' options for the linker. ! 178: ! 179: The run-time support file `libgcc.a' can also be searched for using ! 180: the `-B' prefix, if needed. If it is not found there, the two ! 181: standard prefixes above are tried, and that is all. The file is ! 182: left out of the link if it is not found by those means. ! 183: ! 184: Another way to specify a prefix much like the `-B' prefix is to use ! 185: the environment variable `GCC_EXEC_PREFIX'. *Note Environment ! 186: Variables::. ! 187: ! 188: ! 189: File: gcc.info, Node: Target Options, Next: Submodel Options, Prev: Directory Options, Up: Invoking GCC ! 190: ! 191: Specifying Target Machine and Compiler Version ! 192: ============================================== ! 193: ! 194: By default, GNU CC compiles code for the same type of machine that ! 195: you are using. However, it can also be installed as a cross-compiler, ! 196: to compile for some other type of machine. In fact, several different ! 197: configurations of GNU CC, for different target machines, can be ! 198: installed side by side. Then you specify which one to use with the ! 199: `-b' option. ! 200: ! 201: In addition, older and newer versions of GNU CC can be installed side ! 202: by side. One of them (probably the newest) will be the default, but ! 203: you may sometimes wish to use another. ! 204: ! 205: `-b MACHINE' ! 206: The argument MACHINE specifies the target machine for compilation. ! 207: This is useful when you have installed GNU CC as a cross-compiler. ! 208: ! 209: The value to use for MACHINE is the same as was specified as the ! 210: machine type when configuring GNU CC as a cross-compiler. For ! 211: example, if a cross-compiler was configured with `configure ! 212: i386v', meaning to compile for an 80386 running System V, then you ! 213: would specify `-b i386v' to run that cross compiler. ! 214: ! 215: When you do not specify `-b', it normally means to compile for the ! 216: same type of machine that you are using. ! 217: ! 218: `-V VERSION' ! 219: The argument VERSION specifies which version of GNU CC to run. ! 220: This is useful when multiple versions are installed. For example, ! 221: VERSION might be `2.0', meaning to run GNU CC version 2.0. ! 222: ! 223: The default version, when you do not specify `-V', is controlled ! 224: by the way GNU CC is installed. Normally, it will be a version ! 225: that is recommended for general use. ! 226: ! 227: The `-b' and `-V' options actually work by controlling part of the ! 228: file name used for the executable files and libraries used for ! 229: compilation. A given version of GNU CC, for a given target machine, is ! 230: normally kept in the directory `/usr/local/lib/gcc-lib/MACHINE/VERSION'. ! 231: ! 232: It follows that sites can customize the effect of `-b' or `-V' ! 233: either by changing the names of these directories or adding alternate ! 234: names (or symbolic links). Thus, if `/usr/local/lib/gcc-lib/80386' is ! 235: a link to `/usr/local/lib/gcc-lib/i386v', then `-b 80386' becomes an ! 236: alias for `-b i386v'. ! 237: ! 238: In one respect, the `-b' or `-V' do not completely change to a ! 239: different compiler: the top-level driver program `gcc' that you ! 240: originally invoked continues to run and invoke the other executables ! 241: (preprocessor, compiler per se, assembler and linker) that do the real ! 242: work. However, since no real work is done in the driver program, it ! 243: usually does not matter that the driver program in use is not the one ! 244: for the specified target and version. ! 245: ! 246: The only way that the driver program depends on the target machine is ! 247: in the parsing and handling of special machine-specific options. ! 248: However, this is controlled by a file which is found, along with the ! 249: other executables, in the directory for the specified version and ! 250: target machine. As a result, a single installed driver program adapts ! 251: to any specified target machine and compiler version. ! 252: ! 253: The driver program executable does control one significant thing, ! 254: however: the default version and target machine. Therefore, you can ! 255: install different instances of the driver program, compiled for ! 256: different targets or versions, under different names. ! 257: ! 258: For example, if the driver for version 2.0 is installed as `ogcc' ! 259: and that for version 2.1 is installed as `gcc', then the command `gcc' ! 260: will use version 2.1 by default, while `ogcc' will use 2.0 by default. ! 261: However, you can choose either version with either command with the ! 262: `-V' option. ! 263: ! 264: ! 265: File: gcc.info, Node: Submodel Options, Next: Code Gen Options, Prev: Target Options, Up: Invoking GCC ! 266: ! 267: Specifying Hardware Models and Configurations ! 268: ============================================= ! 269: ! 270: Earlier we discussed the standard option `-b' which chooses among ! 271: different installed compilers for completely different target machines, ! 272: such as Vax vs. 68000 vs. 80386. ! 273: ! 274: In addition, each of these target machine types can have its own ! 275: special options, starting with `-m', to choose among various hardware ! 276: models or configurations--for example, 68010 vs 68020, floating ! 277: coprocessor or none. A single installed version of the compiler can ! 278: compile for any model or configuration, according to the options ! 279: specified. ! 280: ! 281: Some configurations of the compiler also support additional special ! 282: options, usually for compatibility with other compilers on the same ! 283: platform. ! 284: ! 285: These options are defined by the macro `TARGET_SWITCHES' in the ! 286: machine description. The default for the options is also defined by ! 287: that macro, which enables you to change the defaults. ! 288: ! 289: * Menu: ! 290: ! 291: * M680x0 Options:: ! 292: * VAX Options:: ! 293: * SPARC Options:: ! 294: * Convex Options:: ! 295: * AMD29K Options:: ! 296: * M88K Options:: ! 297: * RS/6000 Options:: ! 298: * RT Options:: ! 299: * MIPS Options:: ! 300: * i386 Options:: ! 301: * HPPA Options:: ! 302: * Intel 960 Options:: ! 303: * DEC Alpha Options:: ! 304: * System V Options:: ! 305: ! 306: ! 307: File: gcc.info, Node: M680x0 Options, Next: VAX Options, Up: Submodel Options ! 308: ! 309: M680x0 Options ! 310: -------------- ! 311: ! 312: These are the `-m' options defined for the 68000 series. The default ! 313: values for these options depends on which style of 68000 was selected ! 314: when the compiler was configured; the defaults for the most common ! 315: choices are given below. ! 316: ! 317: `-m68000' ! 318: `-mc68000' ! 319: Generate output for a 68000. This is the default when the ! 320: compiler is configured for 68000-based systems. ! 321: ! 322: `-m68020' ! 323: `-mc68020' ! 324: Generate output for a 68020. This is the default when the ! 325: compiler is configured for 68020-based systems. ! 326: ! 327: `-m68881' ! 328: Generate output containing 68881 instructions for floating point. ! 329: This is the default for most 68020 systems unless `-nfp' was ! 330: specified when the compiler was configured. ! 331: ! 332: `-m68030' ! 333: Generate output for a 68030. This is the default when the ! 334: compiler is configured for 68030-based systems. ! 335: ! 336: `-m68040' ! 337: Generate output for a 68040. This is the default when the ! 338: compiler is configured for 68040-based systems. ! 339: ! 340: `-m68020-40' ! 341: Generate output for a 68040, without using any of the new ! 342: instructions. This results in code which can run relatively ! 343: efficiently on either a 68020/68881 or a 68030 or a 68040. ! 344: ! 345: `-mfpa' ! 346: Generate output containing Sun FPA instructions for floating point. ! 347: ! 348: `-msoft-float' ! 349: Generate output containing library calls for floating point. ! 350: *Warning:* the requisite libraries are not part of GNU CC. ! 351: Normally the facilities of the machine's usual C compiler are ! 352: used, but this can't be done directly in cross-compilation. You ! 353: must make your own arrangements to provide suitable library ! 354: functions for cross-compilation. ! 355: ! 356: `-mshort' ! 357: Consider type `int' to be 16 bits wide, like `short int'. ! 358: ! 359: `-mnobitfield' ! 360: Do not use the bit-field instructions. `-m68000' implies ! 361: `-mnobitfield'. ! 362: ! 363: `-mbitfield' ! 364: Do use the bit-field instructions. `-m68020' implies ! 365: `-mbitfield'. This is the default if you use the unmodified ! 366: sources configured for a 68020. ! 367: ! 368: `-mrtd' ! 369: Use a different function-calling convention, in which functions ! 370: that take a fixed number of arguments return with the `rtd' ! 371: instruction, which pops their arguments while returning. This ! 372: saves one instruction in the caller since there is no need to pop ! 373: the arguments there. ! 374: ! 375: This calling convention is incompatible with the one normally used ! 376: on Unix, so you cannot use it if you need to call libraries ! 377: compiled with the Unix compiler. ! 378: ! 379: Also, you must provide function prototypes for all functions that ! 380: take variable numbers of arguments (including `printf'); otherwise ! 381: incorrect code will be generated for calls to those functions. ! 382: ! 383: In addition, seriously incorrect code will result if you call a ! 384: function with too many arguments. (Normally, extra arguments are ! 385: harmlessly ignored.) ! 386: ! 387: The `rtd' instruction is supported by the 68010 and 68020 ! 388: processors, but not by the 68000. ! 389: ! 390: ! 391: File: gcc.info, Node: VAX Options, Next: SPARC Options, Prev: M680x0 Options, Up: Submodel Options ! 392: ! 393: VAX Options ! 394: ----------- ! 395: ! 396: These `-m' options are defined for the Vax: ! 397: ! 398: `-munix' ! 399: Do not output certain jump instructions (`aobleq' and so on) that ! 400: the Unix assembler for the Vax cannot handle across long ranges. ! 401: ! 402: `-mgnu' ! 403: Do output those jump instructions, on the assumption that you will ! 404: assemble with the GNU assembler. ! 405: ! 406: `-mg' ! 407: Output code for g-format floating point numbers instead of ! 408: d-format. ! 409: ! 410: ! 411: File: gcc.info, Node: Sparc Options, Next: Convex Options, Prev: VAX Options, Up: Submodel Options ! 412: ! 413: SPARC Options ! 414: ------------- ! 415: ! 416: These `-m' switches are supported on the Sparc: ! 417: ! 418: `-mforce-align' ! 419: Make sure all objects of type `double' are 8-byte aligned in memory ! 420: and use double-word instructions to reference them. ! 421: ! 422: `-mno-epilogue' ! 423: Generate separate return instructions for `return' statements. ! 424: This has both advantages and disadvantages; I don't recall what ! 425: they are. ! 426: ! 427: ! 428: File: gcc.info, Node: Convex Options, Next: AMD29K Options, Prev: SPARC Options, Up: Submodel Options ! 429: ! 430: Convex Options ! 431: -------------- ! 432: ! 433: These `-m' options are defined for the Convex: ! 434: ! 435: `-mc1' ! 436: Generate output for a C1. This is the default when the compiler is ! 437: configured for a C1. ! 438: ! 439: `-mc2' ! 440: Generate output for a C2. This is the default when the compiler is ! 441: configured for a C2. ! 442: ! 443: `-margcount' ! 444: Generate code which puts an argument count in the word preceding ! 445: each argument list. Some nonportable Convex and Vax programs need ! 446: this word. (Debuggers don't, except for functions with ! 447: variable-length argument lists; this info is in the symbol table.) ! 448: ! 449: `-mnoargcount' ! 450: Omit the argument count word. This is the default if you use the ! 451: unmodified sources. ! 452: ! 453: ! 454: File: gcc.info, Node: AMD29K Options, Next: M88K Options, Prev: Convex Options, Up: Submodel Options ! 455: ! 456: AMD29K Options ! 457: -------------- ! 458: ! 459: These `-m' options are defined for the AMD Am29000: ! 460: ! 461: `-mdw' ! 462: Generate code that assumes the `DW' bit is set, i.e., that byte and ! 463: halfword operations are directly supported by the hardware. This ! 464: is the default. ! 465: ! 466: `-mnodw' ! 467: Generate code that assumes the `DW' bit is not set. ! 468: ! 469: `-mbw' ! 470: Generate code that assumes the system supports byte and halfword ! 471: write operations. This is the default. ! 472: ! 473: `-mnbw' ! 474: Generate code that assumes the systems does not support byte and ! 475: halfword write operations. `-mnbw' implies `-mnodw'. ! 476: ! 477: `-msmall' ! 478: Use a small memory model that assumes that all function addresses ! 479: are either within a single 256 KB segment or at an absolute ! 480: address of less than 256K. This allows the `call' instruction to ! 481: be used instead of a `const', `consth', `calli' sequence. ! 482: ! 483: `-mlarge' ! 484: Do not assume that the `call' instruction can be used; this is the ! 485: default. ! 486: ! 487: `-m29050' ! 488: Generate code for the Am29050. ! 489: ! 490: `-m29000' ! 491: Generate code for the Am29000. This is the default. ! 492: ! 493: `-mkernel-registers' ! 494: Generate references to registers `gr64-gr95' instead of ! 495: `gr96-gr127'. This option can be used when compiling kernel code ! 496: that wants a set of global registers disjoint from that used by ! 497: user-mode code. ! 498: ! 499: Note that when this option is used, register names in `-f' flags ! 500: must use the normal, user-mode, names. ! 501: ! 502: `-muser-registers' ! 503: Use the normal set of global registers, `gr96-gr127'. This is the ! 504: default. ! 505: ! 506: `-mstack-check' ! 507: Insert a call to `__msp_check' after each stack adjustment. This ! 508: is often used for kernel code. 1.1 root 509: 510: 511: File: gcc.info, Node: M88K Options, Next: RS/6000 Options, Prev: AMD29K Options, Up: Submodel Options 512: 513: M88K Options 514: ------------ 515: 516: These `-m' options are defined for Motorola 88K architectures: 517: 518: `-m88000' 519: Generate code that works well on both the m88100 and the m88110. 520: 521: `-m88100' 1.1.1.4 ! root 522: Generate code that works best for the m88100, but that also runs ! 523: on the m88110. 1.1 root 524: 525: `-m88110' 526: Generate code that works best for the m88110, and may not run on 527: the m88100. 528: 529: `-midentify-revision' 530: Include an `ident' directive in the assembler output recording the 531: source file name, compiler name and version, timestamp, and 532: compilation flags used. 533: 534: `-mno-underscores' 1.1.1.3 root 535: In assembler output, emit symbol names without adding an underscore 536: character at the beginning of each name. The default is to use an 537: underscore as prefix on each name. 1.1 root 538: 539: `-mocs-debug-info' 540: `-mno-ocs-debug-info' 541: Include (or omit) additional debugging information (about 542: registers used in each stack frame) as specified in the 88open 543: Object Compatibility Standard, "OCS". This extra information 544: allows debugging of code that has had the frame pointer 545: eliminated. The default for DG/UX, SVr4, and Delta 88 SVr3.2 is 546: to include this information; other 88k configurations omit this 547: information by default. 548: 549: `-mocs-frame-position' 550: When emitting COFF debugging information for automatic variables 551: and parameters stored on the stack, use the offset from the 552: canonical frame address, which is the stack pointer (register 31) 553: on entry to the function. The DG/UX, SVr4, Delta88 SVr3.2, and 554: BCS configurations use `-mocs-frame-position'; other 88k 555: configurations have the default `-mno-ocs-frame-position'. 556: 557: `-mno-ocs-frame-position' 558: When emitting COFF debugging information for automatic variables 559: and parameters stored on the stack, use the offset from the frame 560: pointer register (register 30). When this option is in effect, 561: the frame pointer is not eliminated when debugging information is 562: selected by the -g switch. 563: 564: `-moptimize-arg-area' 565: `-mno-optimize-arg-area' 1.1.1.3 root 566: Control how to store function arguments in stack frames. 1.1.1.4 ! root 567: `-moptimize-arg-area' saves space, but conflicts with the 88open ! 568: specifications. `-mno-optimize-arg-area' conforms to the 88open ! 569: standards. By default GNU CC does not optimize the argument area. 1.1 root 570: 571: `-mshort-data-NUM' 572: Generate smaller data references by making them relative to `r0', 573: which allows loading a value using a single instruction (rather 574: than the usual two). You control which data references are 575: affected by specifying NUM with this option. For example, if you 576: specify `-mshort-data-512', then the data references affected are 1.1.1.3 root 577: those involving displacements of less than 512 bytes. 1.1 root 578: `-mshort-data-NUM' is not effective for NUM greater than 64K. 579: 1.1.1.4 ! root 580: `-mserialize-volatile' ! 581: `-mno-serialize-volatile' ! 582: Do, or don't, generate code to guarantee sequential consistency of ! 583: volatile memory references. ! 584: ! 585: GNU CC always guarantees consistency by default, for the preferred ! 586: processor submodel. How this is done depends on the submodel. ! 587: ! 588: The m88100 processor does not reorder memory references and so ! 589: always provides sequential consistency. If you use `-m88100', GNU ! 590: CC does not generate any special instructions for sequential ! 591: consistency. ! 592: ! 593: The order of memory references made by the m88110 processor does ! 594: not always match the order of the instructions requesting those ! 595: references. In particular, a load instruction may execute before a ! 596: preceding store instruction. Such reordering violates sequential ! 597: consistency of volatile memory references, when there are multiple ! 598: processors. When you use `-m88000' or `-m88110', GNU CC generates ! 599: special instructions when appropriate, to force execution in the ! 600: proper order. ! 601: ! 602: The extra code generated to guarantee consistency may affect the ! 603: performance of your application. If you know that you can safely ! 604: forgo this guarantee, you may use `-mno-serialize-volatile'. ! 605: ! 606: If you use `-m88100' but require sequential consistency when ! 607: running on the m88110 processor, you should use ! 608: `-mserialize-volatile'. ! 609: 1.1 root 610: `-msvr4' 611: `-msvr3' 612: Turn on (`-msvr4') or off (`-msvr3') compiler extensions related 613: to System V release 4 (SVr4). This controls the following: 614: 615: 1. Which variant of the assembler syntax to emit (which you can 616: select independently using `-mversion-03.00'). 617: 618: 2. `-msvr4' makes the C preprocessor recognize `#pragma weak' 619: that is used on System V release 4. 620: 1.1.1.3 root 621: 3. `-msvr4' makes GNU CC issue additional declaration directives 622: used in SVr4. 1.1 root 623: 624: `-msvr3' is the default for all m88K configurations except the 625: SVr4 configuration. 626: 627: `-mversion-03.00' 628: In the DG/UX configuration, there are two flavors of SVr4. This 629: option modifies `-msvr4' to select whether the hybrid-COFF or 630: real-ELF flavor is used. All other configurations ignore this 631: option. 632: 633: `-mno-check-zero-division' 634: `-mcheck-zero-division' 1.1.1.3 root 635: Early models of the 88K architecture had problems with division by 636: zero; in particular, many of them didn't trap. Use these options 637: to avoid including (or to include explicitly) additional code to 638: detect division by zero and signal an exception. All GNU CC 639: configurations for the 88K use `-mcheck-zero-division' by default. 1.1 root 640: 641: `-muse-div-instruction' 642: Do not emit code to check both the divisor and dividend when doing 643: signed integer division to see if either is negative, and adjust 644: the signs so the divide is done using non-negative numbers. 645: Instead, rely on the operating system to calculate the correct 1.1.1.3 root 646: value when the `div' instruction traps. This results in different 647: behavior when the most negative number is divided by -1, but is 648: useful when most or all signed integer divisions are done with 649: positive numbers. 1.1 root 650: 651: `-mtrap-large-shift' 652: `-mhandle-large-shift' 653: Include code to detect bit-shifts of more than 31 bits; 654: respectively, trap such shifts or emit code to handle them 655: properly. By default GNU CC makes no special provision for large 656: bit shifts. 657: 658: `-mwarn-passed-structs' 1.1.1.3 root 659: Warn when a function passes a struct as an argument or result. 660: Structure-passing conventions have changed during the evolution of 661: the C language, and are often the source of portability problems. 662: By default, GNU CC issues no such warning. 1.1 root 663: 664: 665: File: gcc.info, Node: RS/6000 Options, Next: RT Options, Prev: M88K Options, Up: Submodel Options 666: 667: IBM RS/6000 Options 668: ------------------- 669: 670: Only one pair of `-m' options is defined for the IBM RS/6000: 671: 672: `-mfp-in-toc' 673: `-mno-fp-in-toc' 674: Control whether or not floating-point constants go in the Table of 675: Contents (TOC), a table of all global variable and function 1.1.1.3 root 676: addresses. By default GNU CC puts floating-point constants there; 677: if the TOC overflows, `-mno-fp-in-toc' will reduce the size of the 678: TOC, which may avoid the overflow. 1.1 root 679: 680: 681: File: gcc.info, Node: RT Options, Next: MIPS Options, Prev: RS/6000 Options, Up: Submodel Options 682: 683: IBM RT Options 684: -------------- 685: 686: These `-m' options are defined for the IBM RT PC: 687: 688: `-min-line-mul' 689: Use an in-line code sequence for integer multiplies. This is the 690: default. 691: 692: `-mcall-lib-mul' 693: Call `lmul$$' for integer multiples. 694: 695: `-mfull-fp-blocks' 696: Generate full-size floating point data blocks, including the 697: minimum amount of scratch space recommended by IBM. This is the 698: default. 699: 700: `-mminimum-fp-blocks' 1.1.1.3 root 701: Do not include extra scratch space in floating point data blocks. 702: This results in smaller code, but slower execution, since scratch 703: space must be allocated dynamically. 1.1 root 704: 705: `-mfp-arg-in-fpregs' 706: Use a calling sequence incompatible with the IBM calling 707: convention in which floating point arguments are passed in 1.1.1.3 root 708: floating point registers. Note that `varargs.h' and `stdargs.h' 1.1 root 709: will not work with floating point operands if this option is 710: specified. 711: 712: `-mfp-arg-in-gregs' 713: Use the normal calling convention for floating point arguments. 714: This is the default. 715: 716: `-mhc-struct-return' 1.1.1.3 root 717: Return structures of more than one word in memory, rather than in a 718: register. This provides compatibility with the MetaWare HighC (hc) 719: compiler. Use `-fpcc-struct-return' for compatibility with the 720: Portable C Compiler (pcc). 1.1 root 721: 722: `-mnohc-struct-return' 723: Return some structures of more than one word in registers, when 724: convenient. This is the default. For compatibility with the 725: IBM-supplied compilers, use either `-fpcc-struct-return' or 726: `-mhc-struct-return'. 727: 728: 1.1.1.2 root 729: File: gcc.info, Node: MIPS Options, Next: i386 Options, Prev: RT Options, Up: Submodel Options 1.1 root 730: 731: MIPS Options 732: ------------ 733: 734: These `-m' options are defined for the MIPS family of computers: 735: 736: `-mcpu=CPU TYPE' 737: Assume the defaults for the machine type CPU TYPE when scheduling 1.1.1.2 root 738: instructions. The default CPU TYPE is `default', which picks the 1.1 root 739: longest cycles times for any of the machines, in order that the 1.1.1.3 root 740: code run at reasonable rates on all MIPS cpu's. Other choices for 741: CPU TYPE are `r2000', `r3000', `r4000', and `r6000'. While 742: picking a specific CPU TYPE will schedule things appropriately for 743: that particular chip, the compiler will not generate any code that 744: does not meet level 1 of the MIPS ISA (instruction set 745: architecture) without the `-mips2' or `-mips3' switches being used. 1.1 root 746: 747: `-mips2' 748: Issue instructions from level 2 of the MIPS ISA (branch likely, 749: square root instructions). The `-mcpu=r4000' or `-mcpu=r6000' 1.1.1.3 root 750: switch must be used in conjunction with `-mips2'. 1.1 root 751: 752: `-mips3' 753: Issue instructions from level 3 of the MIPS ISA (64 bit 1.1.1.3 root 754: instructions). You must use the `-mcpu=r4000' switch along with 1.1 root 755: `-mips3'. 756: 757: `-mint64' 758: `-mlong64' 759: `-mlonglong128' 760: These options don't work at present. 761: 762: `-mmips-as' 763: Generate code for the MIPS assembler, and invoke `mips-tfile' to 764: add normal debug information. This is the default for all 765: platforms except for the OSF/1 reference platform, using the 766: OSF/rose object format. If the either of the `-gstabs' or 767: `-gstabs+' switches are used, the `mips-tfile' program will 768: encapsulate the stabs within MIPS ECOFF. 769: 770: `-mgas' 771: Generate code for the GNU assembler. This is the default on the 772: OSF/1 reference platform, using the OSF/rose object format. 773: 774: `-mrnames' 775: `-mno-rnames' 776: The `-mrnames' switch says to output code using the MIPS software 777: names for the registers, instead of the hardware names (ie, A0 1.1.1.3 root 778: instead of $4). The GNU assembler does not support the `-mrnames' 779: switch, and the MIPS assembler will be instructed to run the MIPS 780: C preprocessor over the source file. The `-mno-rnames' switch is 781: default. 1.1 root 782: 783: `-mgpopt' 784: `-mno-gpopt' 785: The `-mgpopt' switch says to write all of the data declarations 1.1.1.2 root 786: before the instructions in the text section, this allows the MIPS 1.1 root 787: assembler to generate one word memory references instead of using 788: two words for short global or static data items. This is on by 789: default if optimization is selected. 790: 791: `-mstats' 792: `-mno-stats' 793: For each non-inline function processed, the `-mstats' switch 794: causes the compiler to emit one line to the standard error file to 795: print statistics about the program (number of registers saved, 796: stack size, etc.). 797: 798: `-mmemcpy' 799: `-mno-memcpy' 800: The `-mmemcpy' switch makes all block moves call the appropriate 801: string function (`memcpy' or `bcopy') instead of possibly 802: generating inline code. 803: 804: `-mmips-tfile' 805: `-mno-mips-tfile' 806: The `-mno-mips-tfile' switch causes the compiler not postprocess 807: the object file with the `mips-tfile' program, after the MIPS 808: assembler has generated it to add debug support. If `mips-tfile' 809: is not run, then no local variables will be available to the 810: debugger. In addition, `stage2' and `stage3' objects will have 811: the temporary file names passed to the assembler embedded in the 1.1.1.2 root 812: object file, which means the objects will not compare the same. 813: The `-mno-mips-tfile' switch should only be used when there are 814: bugs in the `mips-tfile' program that prevents compilation. 1.1 root 815: 816: `-msoft-float' 1.1.1.3 root 817: Generate output containing library calls for floating point. 818: *Warning:* the requisite libraries are not part of GNU CC. 1.1 root 819: Normally the facilities of the machine's usual C compiler are 820: used, but this can't be done directly in cross-compilation. You 821: must make your own arrangements to provide suitable library 822: functions for cross-compilation. 823: 824: `-mhard-float' 825: Generate output containing floating point instructions. This is 826: the default if you use the unmodified sources. 827: 828: `-mfp64' 829: Assume that the FR bit in the status word is on, and that there 830: are 32 64-bit floating point registers, instead of 32 32-bit 1.1.1.3 root 831: floating point registers. You must also specify the `-mcpu=r4000' 832: and `-mips3' switches. 1.1 root 833: 834: `-mfp32' 1.1.1.3 root 835: Assume that there are 32 32-bit floating point registers. This is 836: the default. 1.1 root 837: 838: `-mabicalls' 839: `-mno-abicalls' 840: Emit the `.abicalls', `.cpload', and `.cprestore' pseudo 1.1.1.3 root 841: operations that some System V.4 ports use for position independent 842: code. 1.1 root 843: 844: `-mhalf-pic' 845: `-mno-half-pic' 846: Put pointers to extern references into the data section and load 847: them up, rather than put the references in the text section. 848: These options do not work at present. 849: 850: `-G NUM' 851: Put global and static items less than or equal to NUM bytes into 852: the small data or bss sections instead of the normal data or bss 853: section. This allows the assembler to emit one word memory 854: reference instructions based on the global pointer (GP or $28), 855: instead of the normal two words used. By default, NUM is 8 when 1.1.1.3 root 856: the MIPS assembler is used, and 0 when the GNU assembler is used. 857: The `-G NUM' switch is also passed to the assembler and linker. 1.1 root 858: All modules should be compiled with the same `-G NUM' value. 859: 1.1.1.2 root 860: `-nocpp' 861: Tell the MIPS assembler to not run it's preprocessor over user 862: assembler files (with a `.s' suffix) when assembling them. 863: 1.1 root 864: These options are defined by the macro `TARGET_SWITCHES' in the 865: machine description. The default for the options is also defined by 866: that macro, which enables you to change the defaults. 867: 868: 1.1.1.4 ! root 869: File: gcc.info, Node: i386 Options, Next: HPPA Options, Prev: MIPS Options, Up: Submodel Options 1.1.1.2 root 870: 871: Intel 386 Options 872: ----------------- 873: 874: These `-m' options are defined for the i386 family of computers: 875: 876: `-m486' 1.1.1.4 ! root 877: `-mno-486' 1.1.1.2 root 878: Control whether or not code is optimized for a 486 instead of an 879: 386. Code generated for an 486 will run on a 386 and vice versa. 880: 881: `-msoft-float' 1.1.1.3 root 882: Generate output containing library calls for floating point. 883: *Warning:* the requisite libraries are not part of GNU CC. 1.1.1.2 root 884: Normally the facilities of the machine's usual C compiler are 885: used, but this can't be done directly in cross-compilation. You 886: must make your own arrangements to provide suitable library 887: functions for cross-compilation. 888: 1.1.1.4 ! root 889: On machines where a function returns floating point results in the 1.1.1.3 root 890: 80387 register stack, some floating point opcodes may be emitted 891: even if `-msoft-float' is used. 1.1.1.2 root 892: 1.1.1.4 ! root 893: `-mno-fp-ret-in-387' ! 894: Don't use the FPU registers for return values of functions. ! 895: ! 896: The usual calling convention has functions return values of types ! 897: `float' and `double' in an FPU register, even if there is no FPU. ! 898: The idea is that the operating system should emulate an FPU. ! 899: ! 900: The option `-mno-fp-ret-in-387' causes such values to be returned ! 901: in ordinary CPU registers instead. ! 902: ! 903: ! 904: File: gcc.info, Node: HPPA Options, Next: Intel 960 Options, Prev: i386 Options, Up: Submodel Options ! 905: ! 906: HPPA Options ! 907: ------------ ! 908: ! 909: This `-m' option is defined for the HPPA family of computers: ! 910: ! 911: `-mno-bss' ! 912: Disable the use of the BSS section. This may be necessary with ! 913: older versions of pa-gas. It is highly recommended that you pick ! 914: up a new version of pa-gas from `jaguar.cs.utah.edu'. ! 915: ! 916: `-mpa-risc-1-0' ! 917: Generate code for a PA 1.0 processor. ! 918: ! 919: `-mpa-risc-1-1' ! 920: Generate code for a PA 1.1 processor. ! 921: ! 922: `-mkernel' ! 923: Generate code which is suitable for use in kernels. Specifically, ! 924: avoid `add' instructions in which one of the arguments is the DP ! 925: register; generate `addil' instructions instead. This avoids a ! 926: rather serious bug in the HP-UX linker. ! 927: ! 928: `-mshared-libs' ! 929: Generate code that can be linked against HP-UX shared libraries. ! 930: This option is not fully function yet, and is not on by default ! 931: for any PA target. ! 932: ! 933: `-mno-shared-libs' ! 934: Don't generate code that will be linked against shared libraries. ! 935: This is the default for all PA targets. ! 936: ! 937: `-mlong-calls' ! 938: Generate code which allows calls to functions greater than 256K ! 939: away from the caller when the caller and callee are in the same ! 940: source file. Do not turn this option on unless code refuses to ! 941: link with "branch out of range errors" from the linker. ! 942: ! 943: ! 944: File: gcc.info, Node: Intel 960 Options, Next: DEC Alpha Options, Prev: HPPA Options, Up: Submodel Options ! 945: ! 946: Intel 960 Options ! 947: ----------------- ! 948: ! 949: These `-m' options are defined for the Intel 960 implementations: ! 950: ! 951: `-mCPU TYPE' ! 952: Assume the defaults for the machine type CPU TYPE for some of the ! 953: other options, including instruction scheduling, floating point ! 954: support, and addressing modes. The choices for CPU TYPE are `ka', ! 955: `kb', `mc', `ca', `cf', `sa', and `sb'. The default is `kb'. ! 956: ! 957: `-mnumerics' ! 958: `-msoft-float' ! 959: The `-mnumerics' option indicates that the processor does support ! 960: floating-point instructions. The `-msoft-float' option indicates ! 961: that floating-point support should not be assumed. ! 962: ! 963: `-mleaf-procedures' ! 964: `-mno-leaf-procedures' ! 965: Do (or do not) attempt to alter leaf procedures to be callable ! 966: with the `bal' instruction as well as `call'. This will result in ! 967: more efficient code for explicit calls when the `bal' instruction ! 968: can be substituted by the assembler or linker, but less efficient ! 969: code in other cases, such as calls via function pointers, or using ! 970: a linker that doesn't support this optimization. ! 971: ! 972: `-mtail-call' ! 973: `-mno-tail-call' ! 974: Do (or do not) make additional attempts (beyond those of the ! 975: machine-independent portions of the compiler) to optimize ! 976: tail-recursive calls into branches. You may not want to do this ! 977: because the detection of cases where this is not valid is not ! 978: totally complete. The default is `-mno-tail-call'. ! 979: ! 980: `-mcomplex-addr' ! 981: `-mno-complex-addr' ! 982: Assume (or do not assume) that the use of a complex addressing ! 983: mode is a win on this implementation of the i960. Complex ! 984: addressing modes may not be worthwhile on the K-series, but they ! 985: definitely are on the C-series. The default is currently ! 986: `-mcomplex-addr' for all processors except the CB and CC. ! 987: ! 988: `-mcode-align' ! 989: `-mno-code-align' ! 990: Align code to 8-byte boundaries for faster fetching (or don't ! 991: bother). Currently turned on by default for C-series ! 992: implementations only. ! 993: ! 994: `-mic-compat' ! 995: `-mic2.0-compat' ! 996: `-mic3.0-compat' ! 997: Enable compatibility with iC960 v2.0 or v3.0. ! 998: ! 999: `-masm-compat' ! 1000: `-mintel-asm' ! 1001: Enable compatibility with the iC960 assembler. ! 1002: ! 1003: `-mstrict-align' ! 1004: `-mno-strict-align' ! 1005: Do not permit (do permit) unaligned accesses. ! 1006: ! 1007: `-mold-align' ! 1008: Enable structure-alignment compatibility with Intel's gcc release ! 1009: version 1.3 (based on gcc 1.37). Currently this is buggy in that ! 1010: `#pragma align 1' is always assumed as well, and cannot be turned ! 1011: off. ! 1012: ! 1013: ! 1014: File: gcc.info, Node: DEC Alpha Options, Next: System V Options, Prev: Intel 960 Options, Up: Submodel Options ! 1015: ! 1016: DEC Alpha Options ! 1017: ----------------- ! 1018: ! 1019: These `-m' options are defined for the DEC Alpha implementations: ! 1020: ! 1021: `-mno-soft-float' ! 1022: `-msoft-float' ! 1023: Use (do not use) the hardware floating-point instructions for ! 1024: floating-point operations. When `-msoft-float' is specified, ! 1025: functions in `libgcc1.c' will be used to perform floating-point ! 1026: operations. Unless they are replaced by routines that emulate the ! 1027: floating-point operations, or compiled in such a way as to call ! 1028: such emulations routines, these routines will issue floating-point ! 1029: operations. If you are compiling for an Alpha without ! 1030: floating-point operations, you must ensure that the library is ! 1031: built so as not to call them. ! 1032: ! 1033: Note that Alpha implementations without floating-point operations ! 1034: are required to have floating-point registers. ! 1035: ! 1036: `-mfp-reg' ! 1037: `-mno-fp-regs' ! 1038: Generate code that uses (does not use) the floating-point register ! 1039: set. `-mno-fp-regs' implies `-msoft-float'. If the floating-point ! 1040: register set is not used, floating point operands are passed in ! 1041: integer registers as if they were integers and floating-point ! 1042: results are passed in $0 instead of $f0. This is a non-standard ! 1043: calling sequence, so any function with a floating-point argument ! 1044: or return value called by code compiled with `-mno-fp-regs' must ! 1045: also be compiled with that option. ! 1046: ! 1047: A typical use of this option is building a kernel that does not ! 1048: use, and hence need not save and restore, any floating-point ! 1049: registers. ! 1050: ! 1051: ! 1052: File: gcc.info, Node: System V Options, Prev: DEC Alpha Options, Up: Submodel Options ! 1053: ! 1054: Options for System V ! 1055: -------------------- ! 1056: ! 1057: These additional options are available on System V Release 4 for ! 1058: compatibility with other compilers on those systems: ! 1059: ! 1060: `-Qy' ! 1061: Identify the versions of each tool used by the compiler, in a ! 1062: `.ident' assembler directive in the output. ! 1063: ! 1064: `-Qn' ! 1065: Refrain from adding `.ident' directives to the output file (this is ! 1066: the default). ! 1067: ! 1068: `-YP,DIRS' ! 1069: Search the directories DIRS, and no others, for libraries ! 1070: specified with `-l'. ! 1071: ! 1072: `-Ym,DIR' ! 1073: Look in the directory DIR to find the M4 preprocessor. The ! 1074: assembler uses this option. ! 1075: 1.1.1.2 root 1076: 1.1 root 1077: File: gcc.info, Node: Code Gen Options, Next: Environment Variables, Prev: Submodel Options, Up: Invoking GCC 1078: 1079: Options for Code Generation Conventions 1080: ======================================= 1081: 1082: These machine-independent options control the interface conventions 1083: used in code generation. 1084: 1.1.1.3 root 1085: Most of them have both positive and negative forms; the negative form 1086: of `-ffoo' would be `-fno-foo'. In the table below, only one of the 1087: forms is listed--the one which is not the default. You can figure out 1088: the other form by either removing `no-' or adding it. 1.1 root 1089: 1090: `-fpcc-struct-return' 1091: Use the same convention for returning `struct' and `union' values 1092: that is used by the usual C compiler on your system. This 1093: convention is less efficient for small structures, and on many 1094: machines it fails to be reentrant; but it has the advantage of 1095: allowing intercallability between GNU CC-compiled code and 1096: PCC-compiled code. 1097: 1098: `-fshort-enums' 1099: Allocate to an `enum' type only as many bytes as it needs for the 1100: declared range of possible values. Specifically, the `enum' type 1101: will be equivalent to the smallest integer type which has enough 1102: room. 1103: 1104: `-fshort-double' 1105: Use the same size for `double' as for `float'. 1106: 1107: `-fshared-data' 1108: Requests that the data and non-`const' variables of this 1109: compilation be shared data rather than private data. The 1110: distinction makes sense only on certain operating systems, where 1111: shared data is shared between processes running the same program, 1112: while private data exists in one copy per process. 1113: 1114: `-fno-common' 1.1.1.3 root 1115: Allocate even uninitialized global variables in the bss section of 1116: the object file, rather than generating them as common blocks. 1117: This has the effect that if the same variable is declared (without 1118: `extern') in two different compilations, you will get an error 1119: when you link them. The only reason this might be useful is if you 1120: wish to verify that the program will work on other systems which 1121: always work this way. 1.1 root 1122: 1123: `-fno-ident' 1124: Ignore the `#ident' directive. 1125: 1126: `-fno-gnu-linker' 1127: Don't output global initializations such as C++ constructors and 1128: destructors in the form used by the GNU linker (on systems where 1.1.1.3 root 1129: the GNU linker is the standard method of handling them). Use this 1130: option when you want to use a "collect" program and a non-GNU 1131: linker. 1.1 root 1132: 1133: `-finhibit-size-directive' 1134: Don't output a `.size' assembler directive, or anything else that 1.1.1.3 root 1135: would cause trouble if the function is split in the middle, and the 1136: two halves are placed at locations far apart in memory. This 1137: option is used when compiling `crtstuff.c'; you should not need to 1138: use it for anything else. 1139: 1.1.1.4 ! root 1140: `-fnonnull-objects' ! 1141: Assume that objects reached through references are not null (C++ ! 1142: only). ! 1143: ! 1144: Normally, GNU C++ makes conservative assumptions about objects ! 1145: reached through references. For example, the compiler must check ! 1146: that `a' is not null in code like the following: ! 1147: ! 1148: obj &a = g (); ! 1149: a.f (2); ! 1150: ! 1151: Checking that references of this sort have non-null values requires ! 1152: extra code, however, and it is unnecessary for many programs. You ! 1153: can use `-fnonnull-objects' to omit the checks for null, if your ! 1154: program doesn't require checking. ! 1155: 1.1.1.3 root 1156: `-fverbose-asm' 1157: Put extra commentary information in the generated assembly code to 1158: make it more readable. This option is generally only of use to 1159: those who actually need to read the generated assembly code 1160: (perhaps while debugging the compiler itself). 1.1 root 1161: 1162: `-fvolatile' 1163: Consider all memory references through pointers to be volatile. 1164: 1165: `-fpic' 1.1.1.4 ! root 1166: If supported for the target machine, generate position-independent ! 1167: code (PIC) suitable for use in a shared library. All addresses ! 1168: will be accessed through a global offset table (GOT). If the GOT ! 1169: size for the linked executable exceeds a machine-specific maximum ! 1170: size, you will get an error message from the linker indicating ! 1171: that `-fpic' does not work; recompile with `-fPIC' instead. ! 1172: (These maximums are 16k on the m88k, 8k on the Sparc, and 32k on ! 1173: the m68k and RS/6000. The 386 has no such limit.) 1.1 root 1174: 1175: Position-independent code requires special support, and therefore 1.1.1.4 ! root 1176: works only on certain machines. For the 386, GNU CC supports PIC ! 1177: for System V but not for the Sun 386i. Code generated for the IBM 1.1 root 1178: RS/6000 is always position-independent. 1179: 1.1.1.3 root 1180: The GNU assembler does not fully support PIC. Currently, you must 1181: use some other assembler in order for PIC to work. We would 1.1.1.2 root 1182: welcome volunteers to upgrade GAS to handle this; the first part 1.1.1.3 root 1183: of the job is to figure out what the assembler must do differently. 1.1.1.2 root 1184: 1.1 root 1185: `-fPIC' 1186: If supported for the target machine, emit position-independent 1187: code, suitable for dynamic linking and avoiding any limit on the 1188: size of the global offset table. This option makes a difference 1189: on the m68k, m88k and the Sparc. 1190: 1191: Position-independent code requires special support, and therefore 1192: works only on certain machines. 1193: 1194: `-ffixed-REG' 1195: Treat the register named REG as a fixed register; generated code 1196: should never refer to it (except perhaps as a stack pointer, frame 1197: pointer or in some other fixed role). 1198: 1199: REG must be the name of a register. The register names accepted 1.1.1.3 root 1200: are machine-specific and are defined in the `REGISTER_NAMES' macro 1201: in the machine description macro file. 1.1 root 1202: 1203: This flag does not have a negative form, because it specifies a 1204: three-way choice. 1205: 1206: `-fcall-used-REG' 1207: Treat the register named REG as an allocatable register that is 1208: clobbered by function calls. It may be allocated for temporaries 1209: or variables that do not live across a call. Functions compiled 1210: this way will not save and restore the register REG. 1211: 1.1.1.3 root 1212: Use of this flag for a register that has a fixed pervasive role in 1213: the machine's execution model, such as the stack pointer or frame 1214: pointer, will produce disastrous results. 1.1 root 1215: 1216: This flag does not have a negative form, because it specifies a 1217: three-way choice. 1218: 1219: `-fcall-saved-REG' 1220: Treat the register named REG as an allocatable register saved by 1221: functions. It may be allocated even for temporaries or variables 1222: that live across a call. Functions compiled this way will save 1223: and restore the register REG if they use it. 1224: 1.1.1.3 root 1225: Use of this flag for a register that has a fixed pervasive role in 1226: the machine's execution model, such as the stack pointer or frame 1227: pointer, will produce disastrous results. 1.1 root 1228: 1.1.1.3 root 1229: A different sort of disaster will result from the use of this flag 1230: for a register in which function values may be returned. 1.1 root 1231: 1232: This flag does not have a negative form, because it specifies a 1233: three-way choice. 1234: 1235:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.