![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to internals-1 CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10dc / cmd / gcc|
Return to internals-1 CVS log | Up to [Research Unix] / researchv10dc / cmd / gcc |
1.1 ! root 1: ! 2: ! 3: File: internals, Node: Top, Next: Copying, Up: (DIR) ! 4: ! 5: Introduction ! 6: ************ ! 7: ! 8: This manual documents how to run, install and port the GNU C compiler, as ! 9: well as its new features and incompatibilities, and how to report bugs. ! 10: ! 11: * Menu: ! 12: ! 13: * Copying:: GNU CC General Public License says ! 14: how you can copy and share GNU CC. ! 15: * Contributors:: People who have contributed to GNU CC. ! 16: * Options:: Command options supported by `gcc'. ! 17: * Installation:: How to configure, compile and install GNU CC. ! 18: * Trouble:: If you have trouble installing GNU CC. ! 19: * Incompatibilities:: Incompatibilities of GNU CC. ! 20: * Extensions:: GNU extensions to the C language. ! 21: * Bugs:: How to report bugs (if you want to get them fixed). ! 22: * Portability:: Goals of GNU CC's portability features. ! 23: * Interface:: Function-call interface of GNU CC output. ! 24: * Passes:: Order of passes, what they do, and what each file is for. ! 25: * RTL:: The intermediate representation that most passes work on. ! 26: * Machine Desc:: How to write machine description instruction patterns. ! 27: * Machine Macros:: How to write the machine description C macros. ! 28: ! 29: ! 30: ! 31: File: internals, Node: Copying, Next: Contributors, Prev: Top, Up: Top ! 32: ! 33: GNU CC GENERAL PUBLIC LICENSE ! 34: ***************************** ! 35: ! 36: (Clarified 11 Feb 1988) ! 37: ! 38: The license agreements of most software companies keep you at the mercy ! 39: of those companies. By contrast, our general public license is intended to ! 40: give everyone the right to share GNU CC. To make sure that you get the ! 41: rights we want you to have, we need to make restrictions that forbid anyone ! 42: to deny you these rights or to ask you to surrender the rights. Hence this ! 43: license agreement. ! 44: ! 45: Specifically, we want to make sure that you have the right to give away ! 46: copies of GNU CC, that you receive source code or else can get it if you ! 47: want it, that you can change GNU CC or use pieces of it in new free ! 48: programs, and that you know you can do these things. ! 49: ! 50: To make sure that everyone has such rights, we have to forbid you to ! 51: deprive anyone else of these rights. For example, if you distribute copies ! 52: of GNU CC, you must give the recipients all the rights that you have. You ! 53: must make sure that they, too, receive or can get the source code. And you ! 54: must tell them their rights. ! 55: ! 56: Also, for our own protection, we must make certain that everyone finds ! 57: out that there is no warranty for GNU CC. If GNU CC is modified by someone ! 58: else and passed on, we want its recipients to know that what they have is ! 59: not what we distributed, so that any problems introduced by others will not ! 60: reflect on our reputation. ! 61: ! 62: Therefore we (Richard Stallman and the Free Software Foundation, Inc.) ! 63: make the following terms which say what you must do to be allowed to ! 64: distribute or change GNU CC. ! 65: ! 66: COPYING POLICIES ! 67: ================ ! 68: ! 69: 1. You may copy and distribute verbatim copies of GNU CC source code as you ! 70: receive it, in any medium, provided that you conspicuously and ! 71: appropriately publish on each copy a valid copyright notice ! 72: ``Copyright (C) 1988 Free Software Foundation, Inc.'' (or with ! 73: whatever year is appropriate); keep intact the notices on all files ! 74: that refer to this License Agreement and to the absence of any ! 75: warranty; and give any other recipients of the GNU CC program a copy ! 76: of this License Agreement along with the program. You may charge a ! 77: distribution fee for the physical act of transferring a copy. ! 78: ! 79: 2. You may modify your copy or copies of GNU CC or any portion of it, and ! 80: copy and distribute such modifications under the terms of Paragraph 1 ! 81: above, provided that you also do the following: ! 82: ! 83: * cause the modified files to carry prominent notices stating that ! 84: you changed the files and the date of any change; and ! 85: ! 86: * cause the whole of any work that you distribute or publish, that ! 87: in whole or in part contains or is a derivative of GNU CC or any ! 88: part thereof, to be licensed at no charge to all third parties on ! 89: terms identical to those contained in this License Agreement ! 90: (except that you may choose to grant more extensive warranty ! 91: protection to some or all third parties, at your option). ! 92: ! 93: * You may charge a distribution fee for the physical act of ! 94: transferring a copy, and you may at your option offer warranty ! 95: protection in exchange for a fee. ! 96: ! 97: Mere aggregation of another unrelated program with this program (or ! 98: its derivative) on a volume of a storage or distribution medium does ! 99: not bring the other program under the scope of these terms. ! 100: ! 101: 3. You may copy and distribute GNU CC (or a portion or derivative of it, ! 102: under Paragraph 2) in object code or executable form under the terms ! 103: of Paragraphs 1 and 2 above provided that you also do one of the ! 104: following: ! 105: ! 106: * accompany it with the complete corresponding machine-readable ! 107: source code, which must be distributed under the terms of ! 108: Paragraphs 1 and 2 above; or, ! 109: ! 110: * accompany it with a written offer, valid for at least three ! 111: years, to give any third party free (except for a nominal ! 112: shipping charge) a complete machine-readable copy of the ! 113: corresponding source code, to be distributed under the terms of ! 114: Paragraphs 1 and 2 above; or, ! 115: ! 116: * accompany it with the information you received as to where the ! 117: corresponding source code may be obtained. (This alternative is ! 118: allowed only for noncommercial distribution and only if you ! 119: received the program in object code or executable form alone.) ! 120: ! 121: For an executable file, complete source code means all the source code ! 122: for all modules it contains; but, as a special exception, it need not ! 123: include source code for modules which are standard libraries that ! 124: accompany the operating system on which the executable file runs. ! 125: ! 126: 4. You may not copy, sublicense, distribute or transfer GNU CC except as ! 127: expressly provided under this License Agreement. Any attempt ! 128: otherwise to copy, sublicense, distribute or transfer GNU CC is void ! 129: and your rights to use the program under this License agreement shall ! 130: be automatically terminated. However, parties who have received ! 131: computer software programs from you with this License Agreement will ! 132: not have their licenses terminated so long as such parties remain in ! 133: full compliance. ! 134: ! 135: 5. If you wish to incorporate parts of GNU CC into other free programs ! 136: whose distribution conditions are different, write to the Free ! 137: Software Foundation at 675 Mass Ave, Cambridge, MA 02139. We have not ! 138: yet worked out a simple rule that can be stated here, but we will ! 139: often permit this. We will be guided by the two goals of preserving ! 140: the free status of all derivatives of our free software and of ! 141: promoting the sharing and reuse of software. ! 142: ! 143: Your comments and suggestions about our licensing policies and our software ! 144: are welcome! Please contact the Free Software Foundation, Inc., 675 Mass ! 145: Ave, Cambridge, MA 02139, or call (617) 876-3296. ! 146: ! 147: NO WARRANTY ! 148: =========== ! 149: ! 150: BECAUSE GNU CC IS LICENSED FREE OF CHARGE, WE PROVIDE ABSOLUTELY NO ! 151: WARRANTY, TO THE EXTENT PERMITTED BY APPLICABLE STATE LAW. EXCEPT WHEN ! 152: OTHERWISE STATED IN WRITING, FREE SOFTWARE FOUNDATION, INC, RICHARD M. ! 153: STALLMAN AND/OR OTHER PARTIES PROVIDE GNU CC "AS IS" WITHOUT WARRANTY OF ! 154: ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE ! 155: IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. ! 156: THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF GNU CC IS WITH YOU. ! 157: SHOULD GNU CC PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY ! 158: SERVICING, REPAIR OR CORRECTION. ! 159: ! 160: IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW WILL RICHARD M. STALLMAN, ! 161: THE FREE SOFTWARE FOUNDATION, INC., AND/OR ANY OTHER PARTY WHO MAY MODIFY ! 162: AND REDISTRIBUTE GNU CC AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, ! 163: INCLUDING ANY LOST PROFITS, LOST MONIES, OR OTHER SPECIAL, INCIDENTAL OR ! 164: CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE (INCLUDING ! 165: BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES ! 166: SUSTAINED BY THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY ! 167: OTHER PROGRAMS) GNU CC, EVEN IF YOU HAVE BEEN ADVISED OF THE POSSIBILITY OF ! 168: SUCH DAMAGES, OR FOR ANY CLAIM BY ANY OTHER PARTY. ! 169: ! 170: ! 171: File: internals, Node: Contributors, Next: Options, Prev: Copying, Up: Top ! 172: ! 173: Contributors to GNU CC ! 174: ********************** ! 175: ! 176: In addition to Richard Stallman, several people have written parts of GNU CC. ! 177: ! 178: * The idea of using RTL and some of the optimization ideas came from the ! 179: U. of Arizona Portable Optimizer, written by Jack Davidson and ! 180: Christopher Fraser. See ``Register Allocation and Exhaustive Peephole ! 181: Optimization'', Software Practice and Experience 14 (9), Sept. 1984, ! 182: 857-866. ! 183: ! 184: * Paul Rubin wrote most of the preprocessor. ! 185: ! 186: * Leonard Tower wrote parts of the parser, RTL generator, RTL ! 187: definitions, and of the Vax machine description. ! 188: ! 189: * Ted Lemon wrote parts of the RTL reader and printer. ! 190: ! 191: * Nobuyuki Hikichi of Software Research Associates, Tokyo, contributed ! 192: the support for the SONY NEWS machine. ! 193: ! 194: * Charles LaBrec contributed the support for the Integrated Solutions ! 195: 68020 system. ! 196: ! 197: * Michael Tiemann of MCC wrote the description of the National ! 198: Semiconductor 32000 series cpu, with some contributions from Jan Stein ! 199: of the Chalmers Computer Club. Tiemann also wrote the code for inline ! 200: function integration. ! 201: ! 202: * Robert Brown implemented the support for Encore 32000 systems. ! 203: ! 204: * Michael Kashtan of SRI adapted GNU CC to the Vomit-Making System. ! 205: ! 206: * Alex Crain provided changes for the 3b1. ! 207: ! 208: * Chris Hanson and another person who should remind me of his name ! 209: assisted in making GNU CC work on HP-UX for the 9000 series 300. ! 210: ! 211: ! 212: File: internals, Node: Options, Next: Installation, Prev: Contributors, Up: Top ! 213: ! 214: GNU CC Command Options ! 215: ********************** ! 216: ! 217: The GNU C compiler uses a command syntax much like the Unix C compiler. ! 218: The `gcc' program accepts options and file names as operands. Multiple ! 219: single-letter options may *not* be grouped: `-dr' is very different from ! 220: `-d -r'. ! 221: ! 222: When you invoke GNU CC, it normally does preprocessing, compilation, ! 223: assembly and linking. File names which end in `.c' are taken as C source ! 224: to be preprocessed and compiled; compiler output files plus any input files ! 225: with names ending in `.s' are assembled; then the resulting object files, ! 226: plus any other input files, are linked together to produce an executable. ! 227: ! 228: Command options allow you to stop this process at an intermediate stage. ! 229: For example, the `-c' option says not to run the linker. Then the output ! 230: consists of object files output by the assembler. ! 231: ! 232: Other command options are passed on to one stage. Some options control the ! 233: preprocessor and others the compiler itself. Yet other options control the ! 234: assembler and linker; these are not documented here because the GNU ! 235: assembler and linker are not yet released. ! 236: ! 237: Here are the options to control the overall compilation process, including ! 238: those that say whether to link, whether to assemble, and so on. ! 239: ! 240: `-o FILE' ! 241: Place output in file FILE. This applies regardless to whatever sort ! 242: of output is being produced, whether it be an executable file, an ! 243: object file, an assembler file or preprocessed C code. ! 244: ! 245: If `-o' is not specified, the default is to put an executable file in ! 246: `a.out', the object file `SOURCE.c' in `SOURCE.o', an assembler file ! 247: in `SOURCE.s', and preprocessed C on standard output. ! 248: ! 249: `-c' ! 250: Compile or assemble the source files, but do not link. Produce object ! 251: files with names made by replacing `.c' or `.s' with `.o' at the end ! 252: of the input file names. Do nothing at all for object files specified ! 253: as input. ! 254: ! 255: `-S' ! 256: Compile into assembler code but do not assemble. The assembler output ! 257: file name is made by replacing `.c' with `.s' at the end of the input ! 258: file name. Do nothing at all for assembler source files or object ! 259: files specified as input. ! 260: ! 261: `-E' ! 262: Run only the C preprocessor. Preprocess all the C source files ! 263: specified and output the results to standard output. ! 264: ! 265: `-v' ! 266: Compiler driver program prints the commands it executes as it runs the ! 267: preprocessor, compiler proper, assembler and linker. Some of these ! 268: are directed to print their own version numbers. ! 269: ! 270: `-BPREFIX' ! 271: Compiler driver program tries PREFIX as a prefix for each program it ! 272: tries to run. These programs are `cpp', `cc1', `as' and `ld'. ! 273: ! 274: For each subprogram to be run, the compiler driver first tries the ! 275: `-B' prefix, if any. If that name is not found, or if `-B' was not ! 276: specified, the driver tries two standard prefixes, which are ! 277: `/usr/lib/gcc-' and `/usr/local/lib/gcc-'. If neither of those ! 278: results in a file name that is found, the unmodified program name is ! 279: searched for using the directories specified in your `PATH' ! 280: environment variable. ! 281: ! 282: The run-time support file `gnulib' is also searched for using the `-B' ! 283: prefix, if needed. If it is not found there, the two standard ! 284: prefixes above are tried, and that is all. The file is left out of ! 285: the link if it is not found by those means. Most of the time, on most ! 286: machines, you can do without it. ! 287: ! 288: These options control the details of C compilation itself. ! 289: ! 290: `-ansi' ! 291: Support all ANSI standard C programs. ! 292: ! 293: This turns off certain features of GNU C that are incompatible with ! 294: ANSI C, such as the `asm', `inline' and `typeof' keywords, and ! 295: predefined macros such as `unix' and `vax' that identify the type of ! 296: system you are using. It also enables the undesirable and rarely used ! 297: ANSI trigraph feature. ! 298: ! 299: The `-ansi' option does not cause non-ANSI programs to be rejected ! 300: gratuitously. For that, `-pedantic' is required in addition to `-ansi'. ! 301: ! 302: The macro `__STRICT_ANSI__' is predefined when the `-ansi' option is ! 303: used. Some header files may notice this macro and refrain from ! 304: declaring certain functions or defining certain macros that the ANSI ! 305: standard doesn't call for; this is to avoid interfering with any ! 306: programs that might use these names for other things. ! 307: ! 308: `-traditional' ! 309: Attempt to support some aspects of traditional C compilers. ! 310: Specifically: ! 311: ! 312: * All `extern' declarations take effect globally even if they are ! 313: written inside of a function definition. This includes implicit ! 314: declarations of functions. ! 315: ! 316: * The keywords `typeof', `inline', `signed', `const' and `volatile' ! 317: are not recognized. ! 318: ! 319: * Comparisons between pointers and integers are always allowed. ! 320: ! 321: * Integer types `unsigned short' and `unsigned char' promote to ! 322: `unsigned int'. ! 323: ! 324: * In the preprocessor, comments convert to nothing at all, rather ! 325: than to a space. This allows traditional token concatenation. ! 326: ! 327: * In the preprocessor, single and double quote characters are ! 328: ignored when scanning macro definitions, so that macro arguments ! 329: can be replaced even within a string or character constant. ! 330: Quote characters are also ignored when skipping text inside a ! 331: failing conditional directive. ! 332: ! 333: `-O' ! 334: Optimize. Optimizing compilation takes somewhat more time, and a lot ! 335: more memory for a large function. ! 336: ! 337: Without `-O', the compiler's goal is to reduce the cost of compilation ! 338: and to make debugging produce the expected results. Statements are ! 339: independent: if you stop the program with a breakpoint between ! 340: statements, you can then assign a new value to any variable or change ! 341: the program counter to any other statement in the function and get ! 342: exactly the results you would expect from the source code. ! 343: ! 344: Without `-O', only variables declared `register' are allocated in ! 345: registers. The resulting compiled code is a little worse than ! 346: produced by PCC without `-O'. ! 347: ! 348: With `-O', the compiler tries to reduce code size and execution time. ! 349: ! 350: Some of the `-f' options described below turn specific kinds of ! 351: optimization on or off. ! 352: ! 353: `-g' ! 354: Produce debugging information in DBX format. ! 355: ! 356: Unlike most other C compilers, GNU CC allows you to use `-g' with ! 357: `-O'. The shortcuts taken by optimized code may occasionally produce ! 358: surprising results: some variables you declared may not exist at all; ! 359: flow of control may briefly move where you did not expect it; some ! 360: statements may not be executed because they compute constant results ! 361: or their values were already at hand; some statements may execute in ! 362: different places because they were moved out of loops. Nevertheless ! 363: it proves possible to debug optimized output. This makes it ! 364: reasonable to use the optimizer for programs that might have bugs. ! 365: ! 366: `-gg' ! 367: Produce debugging information in GDB's own format. This requires the ! 368: GNU assembler and linker in order to work. ! 369: ! 370: `-w' ! 371: Inhibit all warning messages. ! 372: ! 373: `-W' ! 374: Print extra warning messages for these events: ! 375: ! 376: * An automatic variable is used without first being initialized. ! 377: ! 378: These warnings are possible only in optimizing compilation, ! 379: because they require data flow information that is computed only ! 380: when optimizing. They occur only for variables that are ! 381: candidates for register allocation. Therefore, they do not occur ! 382: for a variable that is declared `volatile', or whose address is ! 383: taken, or whose size is other than 1, 2, 4 or 8 bytes. Also, ! 384: they do not occur for structures, unions or arrays, even when ! 385: they are in registers. ! 386: ! 387: Note that there may be no warning about a variable that is used ! 388: only to compute a value that itself is never used, because such ! 389: computations may be deleted by the flow analysis pass before the ! 390: warnings are printed. ! 391: ! 392: These warnings are made optional because GNU CC is not smart ! 393: enough to see all the reasons why the code might be correct ! 394: despite appearing to have an error. Here is one example of how ! 395: this can happen: ! 396: ! 397: { ! 398: int x; ! 399: switch (y) ! 400: { ! 401: case 1: x = 1; ! 402: break; ! 403: case 2: x = 4; ! 404: break; ! 405: case 3: x = 5; ! 406: } ! 407: foo (x); ! 408: } ! 409: ! 410: If the value of `y' is always 1, 2 or 3, then `x' is always ! 411: initialized, but GNU CC doesn't know this. Here is another ! 412: common case: ! 413: ! 414: { ! 415: int save_y; ! 416: if (change_y) save_y = y, y = new_y; ! 417: ... ! 418: if (change_y) y = save_y; ! 419: } ! 420: ! 421: This has no bug because `x' is used only if it is set. ! 422: ! 423: * A nonvolatile automatic variable might be changed by a call to ! 424: `longjmp'. These warnings as well are possible only in ! 425: optimizing compilation. ! 426: ! 427: The compiler sees only the calls to `setjmp'. It cannot know ! 428: where `longjmp' will be called; in fact, a signal handler could ! 429: call it at any point in the code. As a result, you may get a ! 430: warning even when there is in fact no problem because `longjmp' ! 431: cannot in fact be called at the place which would cause a problem. ! 432: ! 433: * A function can return either with or without a value. (Falling ! 434: off the end of the function body is considered returning without ! 435: a value.) For example, this function would inspire such a warning: ! 436: ! 437: foo (a) ! 438: { ! 439: if (a > 0) ! 440: return a; ! 441: } ! 442: ! 443: Spurious warnings can occur because GNU CC does not realize that ! 444: certain functions (including `abort' and `longjmp') will never ! 445: return. ! 446: ! 447: In the future, other useful warnings may also be enabled by this option. ! 448: ! 449: `-Wimplicit' ! 450: Warn whenever a function is implicitly declared. ! 451: ! 452: `-Wreturn-type' ! 453: Warn whenever a function is defined with a return-type that defaults ! 454: to `int'. Also warn about any `return' statement with no return-value ! 455: in a function whose return-type is not `void'. ! 456: ! 457: `-Wcomment' ! 458: Warn whenever a comment-start sequence `/*' appears in a comment. ! 459: ! 460: `-Wall' ! 461: All of the above `-W' options combined. ! 462: ! 463: `-p' ! 464: Generate extra code to write profile information suitable for the ! 465: analysis program `prof'. ! 466: ! 467: `-pg' ! 468: Generate extra code to write profile information suitable for the ! 469: analysis program `gprof'. ! 470: ! 471: `-lLIBRARY' ! 472: Search a standard list of directories for a library named LIBRARY, ! 473: which is actually a file named `libLIBRARY.a'. The linker uses this ! 474: file as if it had been specified precisely by name. ! 475: ! 476: The directories searched include several standard system directories ! 477: plus any that you specify with `-L'. ! 478: ! 479: Normally the files found this way are library files---archive files ! 480: whose members are object files. The linker handles an archive file by ! 481: through it for members which define symbols that have so far been ! 482: referenced but not defined. But if the file that is found is an ! 483: ordinary object file, it is linked in the usual fashion. The only ! 484: difference between an `-l' option and the full file name of the file ! 485: that is found is syntactic and the fact that several directories are ! 486: searched. ! 487: ! 488: `-LDIR' ! 489: Add directory DIR to the list of directories to be searched for `-l'. ! 490: ! 491: `-nostdlib' ! 492: Don't use the standard system libraries and startup files when ! 493: linking. Only the files you specify (plus `gnulib') will be passed to ! 494: the linker. ! 495: ! 496: `-mMACHINESPEC' ! 497: Machine-dependent option specifying something about the type of target ! 498: machine. These options are defined by the macro `TARGET_SWITCHES' in ! 499: the machine description. The default for the options is also defined ! 500: by that macro, which enables you to change the defaults. ! 501: ! 502: These are the `-m' options defined in the 68000 machine description: ! 503: ! 504: `-m68020' ! 505: Generate output for a 68020 (rather than a 68000). This is the ! 506: default if you use the unmodified sources. ! 507: ! 508: `-m68000' ! 509: Generate output for a 68000 (rather than a 68020). ! 510: ! 511: `-m68881' ! 512: Generate output containing 68881 instructions for floating point. ! 513: This is the default if you use the unmodified sources. ! 514: ! 515: `-msoft-float' ! 516: Generate output containing library calls for floating point. ! 517: ! 518: `-mshort' ! 519: Consider type `int' to be 16 bits wide, like `short int'. ! 520: ! 521: `-mnobitfield' ! 522: Do not use the bit-field instructions. `-m68000' implies ! 523: `-mnobitfield'. ! 524: ! 525: `-mbitfield' ! 526: Do use the bit-field instructions. `-m68020' implies ! 527: `-mbitfield'. This is the default if you use the unmodified ! 528: sources. ! 529: ! 530: `-mrtd' ! 531: Use a different function-calling convention, in which functions ! 532: that take a fixed number of arguments return with the `rtd' ! 533: instruction, which pops their arguments while returning. This ! 534: saves one instruction in the caller since there is no need to pop ! 535: the arguments there. ! 536: ! 537: This calling convention is incompatible with the one normally ! 538: used on Unix, so you cannot use it if you need to call libraries ! 539: compiled with the Unix compiler. ! 540: ! 541: Also, you must provide function prototypes for all functions that ! 542: take variable numbers of arguments (including `printf'); ! 543: otherwise incorrect code will be generated for calls to those ! 544: functions. ! 545: ! 546: In addition, seriously incorrect code will result if you call a ! 547: function with too many arguments. (Normally, extra arguments are ! 548: harmlessly ignored.) ! 549: ! 550: The `rtd' instruction is supported by the 68010 and 68020 ! 551: processors, but not by the 68000. ! 552: ! 553: These `-m' options are defined in the Vax machine description: ! 554: ! 555: `-munix' ! 556: Do not output certain jump instructions (`aobleq' and so on) that ! 557: the Unix assembler for the Vax cannot handle across long ranges. ! 558: ! 559: `-mgnu' ! 560: Do output those jump instructions, on the assumption that you ! 561: will assemble with the GNU assembler. ! 562: ! 563: `-mg' ! 564: Output code for g-format floating point numbers instead of ! 565: d-format. ! 566: ! 567: `-fFLAG' ! 568: Specify machine-independent flags. These are the flags: ! 569: ! 570: `-ffloat-store' ! 571: Do not store floating-point variables in registers. This ! 572: prevents undesirable excess precision on machines such as the ! 573: 68000 where the floating registers (of the 68881) keep more ! 574: precision than a `double' is supposed to have. ! 575: ! 576: For most programs, the excess precision does only good, but a few ! 577: programs rely on the precise definition of IEEE floating point. ! 578: Use `-ffloat-store' for such programs. ! 579: ! 580: `-fno-asm' ! 581: Do not recognize `asm', `inline' or `typeof' as a keyword. These ! 582: words may then be used as identifiers. ! 583: ! 584: `-fno-defer-pop' ! 585: Always pop the arguments to each function call as soon as that ! 586: function returns. Normally the compiler (when optimizing) lets ! 587: arguments accumulate on the stack for several function calls and ! 588: pops them all at once. ! 589: ! 590: `-fcombine-regs' ! 591: Allow the combine pass to combine an instruction that copies one ! 592: register into another. This might or might not produce better ! 593: code when used in addition to `-O'. I am interested in hearing ! 594: about the difference this makes. ! 595: ! 596: `-fforce-mem' ! 597: Force memory operands to be copied into registers before doing ! 598: arithmetic on them. This may produce better code by making all ! 599: memory references potential common subexpressions. When they are ! 600: not common subexpressions, instruction combination should ! 601: eliminate the separate register-load. I am interested in hearing ! 602: about the difference this makes. ! 603: ! 604: `-fforce-addr' ! 605: Force memory address constants to be copied into registers before ! 606: doing arithmetic on them. This may produce better code just as ! 607: `-fforce-mem' may. I am interested in hearing about the ! 608: difference this makes. ! 609: ! 610: `-fomit-frame-pointer' ! 611: Don't keep the frame pointer in a register for functions that ! 612: don't need one. This avoids the instructions to save, set up and ! 613: restore frame pointers; it also makes an extra register available ! 614: in many functions. *It also makes debugging impossible.* ! 615: ! 616: On some machines, such as the Vax, this flag has no effect, ! 617: because the standard calling sequence automatically handles the ! 618: frame pointer and nothing is saved by pretending it doesn't ! 619: exist. The machine-description macro `FRAME_POINTER_REQUIRED' ! 620: controls whether a target machine supports this flag. *note ! 621: Registers::. ! 622: ! 623: `-finline-functions' ! 624: Integrate all simple functions into their callers. The compiler ! 625: heuristically decides which functions are simple enough to be ! 626: worth integrating in this way. ! 627: ! 628: If all calls to a given function are integrated, and the function ! 629: is declared `static', then the function is normally not output as ! 630: assembler code in its own right. ! 631: ! 632: `-fkeep-inline-functions' ! 633: Even if all calls to a given function are integrated, and the ! 634: function is declared `static', nevertheless output a separate ! 635: run-time callable version of the function. ! 636: ! 637: `-fwritable-strings' ! 638: Store string constants in the writable data segment and don't ! 639: uniquize them. This is for compatibility with old programs which ! 640: assume they can write into string constants. Writing into string ! 641: constants is a very bad idea; ``constants'' should be constant. ! 642: ! 643: `-fno-function-cse' ! 644: Do not put function addresses in registers; make each instruction ! 645: that calls a constant function contain the function's address ! 646: explicitly. ! 647: ! 648: This option results in less efficient code, but some strange ! 649: hacks that alter the assembler output may be confused by the ! 650: optimizations performed when this option is not used. ! 651: ! 652: `-fvolatile' ! 653: Consider all memory references through pointers to be volatile. ! 654: ! 655: `-funsigned-char' ! 656: Let the type `char' be the unsigned, like `unsigned char'. ! 657: ! 658: Each kind of machine has a default for what `char' should be. It ! 659: is either like `unsigned char' by default or like `signed char' ! 660: by default. (Actually, at present, the default is always signed.) ! 661: ! 662: The type `char' is always a distinct type from either `signed ! 663: char' or `unsigned char', even though its behavior is always just ! 664: like one of those two. ! 665: ! 666: `-fsigned-char' ! 667: Let the type `char' be signed, like `signed char'. ! 668: ! 669: `-ffixed-REG' ! 670: Treat the register named REG as a fixed register; generated code ! 671: should never refer to it (except perhaps as a stack pointer, ! 672: frame pointer or in some other fixed role). ! 673: ! 674: REG must be the name of a register. The register names accepted ! 675: are machine-specific and are defined in the `REGISTER_NAMES' ! 676: macro in the machine description macro file. ! 677: ! 678: `-fcall-used-REG' ! 679: Treat the register named REG as an allocatable register that is ! 680: clobbered by function calls. It may be allocated for temporaries ! 681: or variables that do not live across a call. Functions compiled ! 682: this way will not save and restore the register REG. ! 683: ! 684: Use of this flag for a register that has a fixed pervasive role ! 685: in the machine's execution model, such as the stack pointer or ! 686: frame pointer, will produce disastrous results. ! 687: ! 688: `-fcall-saved-REG' ! 689: Treat the register named REG as an allocatable register saved by ! 690: functions. It may be allocated even for temporaries or variables ! 691: that live across a call. Functions compiled this way will save ! 692: and restore the register REG if they use it. ! 693: ! 694: Use of this flag for a register that has a fixed pervasive role ! 695: in the machine's execution model, such as the stack pointer or ! 696: frame pointer, will produce disastrous results. ! 697: ! 698: A different sort of disaster will result from the use of this ! 699: flag for a register in which function values are may be returned. ! 700: ! 701: `-dLETTERS' ! 702: Says to make debugging dumps at times specified by LETTERS. Here are ! 703: the possible letters: ! 704: ! 705: `r' ! 706: Dump after RTL generation. ! 707: `j' ! 708: Dump after first jump optimization. ! 709: `J' ! 710: Dump after last jump optimization. ! 711: `s' ! 712: Dump after CSE (including the jump optimization that sometimes ! 713: follows CSE). ! 714: `L' ! 715: Dump after loop optimization. ! 716: `f' ! 717: Dump after flow analysis. ! 718: `c' ! 719: Dump after instruction combination. ! 720: `l' ! 721: Dump after local register allocation. ! 722: `g' ! 723: Dump after global register allocation. ! 724: `m' ! 725: Print statistics on memory usage, at the end of the run. ! 726: ! 727: `-pedantic' ! 728: Issue all the warnings demanded by strict ANSI standard C; reject all ! 729: programs that use forbidden extensions. ! 730: ! 731: Valid ANSI standard C programs should compile properly with or without ! 732: this option (though a rare few will require `-ansi'). However, ! 733: without this option, certain GNU extensions and traditional C features ! 734: are supported as well. With this option, they are rejected. There is ! 735: no reason to use this option; it exists only to satisfy pedants. ! 736: ! 737: These options control the C preprocessor, which is run on each C source ! 738: file before actual compilation. If you use the `-E' option, nothing is ! 739: done except C preprocessing. Some of these options make sense only ! 740: together with `-E' because they request preprocessor output that is not ! 741: suitable for actual compilation. ! 742: ! 743: `-C' ! 744: Tell the preprocessor not to discard comments. Used with the `-E' ! 745: option. ! 746: ! 747: `-IDIR' ! 748: Search directory DIR for include files. ! 749: ! 750: `-I-' ! 751: Any directories specified with `-I' options before the `-I-' option ! 752: are searched only for the case of `#include "FILE"'; they are not ! 753: searched for `#include <FILE>'. ! 754: ! 755: If additional directories are specified with `-I' options after the ! 756: `-I-', these directories are searched for all `#include' directives. ! 757: (Ordinarily *all* `-I' directories are used this way.) ! 758: ! 759: In addition, the `-I-' option inhibits the use of the current ! 760: directory as the first search directory for `#include "FILE"'. ! 761: Therefore, the current directory is searched only if it is requested ! 762: explicitly with `-I.'. Specifying both `-I-' and `-I.' allows you to ! 763: control precisely which directories are searched before the current ! 764: one and which are searched after. ! 765: ! 766: `-nostdinc' ! 767: Do not search the standard system directories for header files. Only ! 768: the directories you have specified with `-I' options (and the current ! 769: directory, if appropriate) are searched. ! 770: ! 771: Between `-nostdinc' and `-I-', you can eliminate all directories from ! 772: the search path except those you specify. ! 773: ! 774: `-M' ! 775: Tell the preprocessor to output a rule suitable for `make' describing ! 776: the dependencies of each source file. For each source file, the ! 777: preprocessor outputs one `make'-rule whose target is the object file ! 778: name for that source file and whose dependencies are all the files ! 779: `#include'd in it. This rule may be a single line or may be continued ! 780: with `\'-newline if it is long. ! 781: ! 782: `-M' implies `-E'. ! 783: ! 784: `-MM' ! 785: Like `-M' but the output mentions only the user-header files included ! 786: with `#include "FILE"'. System header files included with `#include ! 787: <FILE>' are omitted. ! 788: ! 789: `-MM' implies `-E'. ! 790: ! 791: `-DMACRO' ! 792: Define macro MACRO with the empty string as its definition. ! 793: ! 794: `-DMACRO=DEFN' ! 795: Define macro MACRO as DEFN. ! 796: ! 797: `-UMACRO' ! 798: Undefine macro MACRO. ! 799: ! 800: `-T' ! 801: Support ANSI C trigraphs. You don't want to know about this ! 802: brain-damage. The `-ansi' option also has this effect. ! 803: ! 804: ! 805: File: internals, Node: Installation, Next: Trouble, Prev: Options, Up: Top ! 806: ! 807: Installing GNU CC ! 808: ***************** ! 809: ! 810: Here is the procedure for installing GNU CC on a Unix system. ! 811: ! 812: * Menu: ! 813: ! 814: * VMS Install:: See below for installation on VMS. ! 815: ! 816: ! 817: 1. Edit `Makefile'. If you are using HPUX, you must make a few changes ! 818: described in comments at the beginning of the file. ! 819: ! 820: 2. Choose configuration files. ! 821: ! 822: * Make a symbolic link named `config.h' to the top-level config ! 823: file for the machine you are using (*Note Config::.). This file ! 824: is responsible for defining information about the host machine. ! 825: It includes `tm.h'. ! 826: ! 827: The file's name should be `config-MACHINE.h'. On VMS, use ! 828: `config-vms.h' rather than `config-vax.h'. On the HP 9000 series ! 829: 300, use `config-hp9k3.h' rather than `config-m68k.h'. ! 830: ! 831: If your system does not support symbolic links, you might want to ! 832: set up `config.h' to contain a `#include' command which refers to ! 833: the appropriate file. ! 834: ! 835: * Make a symbolic link named `tm.h' to the machine-description ! 836: macro file for your machine (its name should be `tm-MACHINE.h'). ! 837: ! 838: For the 68000/68020, do not use `tm-m68k.h' directly; instead use ! 839: one of the files `tm-sun3.h', `tm-sun2.h', `tm-isi68.h', ! 840: `tm-news800.h' or `tm-3b1.h'. Each of those files includes ! 841: `tm-m68k.h' but sets up a few things differently as appropriate ! 842: to the specific model of machine. ! 843: ! 844: There are two files you can use for a 680x0 running HPUX: ! 845: `tm-hp9k320.h' and `tm-hp9k320g.h'. Use the former if you are ! 846: installing GNU CC alone. The latter is for another option where ! 847: GNU CC together with the GNU assembler, linker, debugger and ! 848: other utilities are used to replace all of HPUX that deals with ! 849: compilation. Not all of the pieces of GNU software needed for ! 850: this mode of operation are as yet in distribution; full ! 851: instructions will appear here in the future. ! 852: ! 853: For the 32000, use `tm-sequent.h' if you are using a Sequent ! 854: machine, or `tm-encore.h' for an Encore machine; otherwise, ! 855: perhaps `tm-ns32k.h' will work for you. ! 856: ! 857: For the vax, use `tm-vax.h' on Unix, or `tm-vms.h' on VMS. ! 858: ! 859: * Make a symbolic link named `md' to the machine description ! 860: pattern file (its name should be `MACHINE.md'). ! 861: ! 862: * Make a symbolic link named `aux-output.c' to the output ! 863: subroutine file for your machine (its name should be ! 864: `OUTPUT-MACHINE.c'). ! 865: ! 866: 3. Make sure the Bison parser generator is installed. (This is unnecessary ! 867: if the Bison output file `parse.tab.c' is more recent than `parse.y' ! 868: and you do not plan to change `parse.y'.) ! 869: ! 870: Note that if you have an old version of Bison you may get an error ! 871: from the line with the `%expect' directive. If so, simply remove that ! 872: line from `parse.y' and proceed. ! 873: ! 874: 4. If you are using a Sun, make sure the environment variable ! 875: `FLOAT_OPTION' is not set. If this option were set to `f68881' when ! 876: `gnulib' is compiled, the resulting code would demand to be linked ! 877: with a special startup file and will not link properly without special ! 878: pains. ! 879: ! 880: 5. Build the compiler. Just type `make' in the compiler directory. ! 881: ! 882: 6. Move the first-stage object files and executables into a subdirectory ! 883: with this command: ! 884: ! 885: make stage1 ! 886: ! 887: The files are moved into a subdirectory named `stage1'. Once ! 888: installation is complete, you may wish to delete these files with `rm ! 889: -r stage1'. ! 890: ! 891: 7. Recompile the compiler with itself, with this command: ! 892: ! 893: make CC=stage1/gcc CFLAGS="-g -O -Bstage1/" ! 894: ! 895: On a 68000 or 68020 system lacking floating point hardware, unless you ! 896: have selected a `tm.h' file that expects by default that there is no ! 897: such hardware, do this instead: ! 898: ! 899: make CC=stage1/gcc CFLAGS="-g -O -Bstage1/ -msoft-float" ! 900: ! 901: 8. If you wish to test the compiler by compiling it with itself one more ! 902: time, do this: ! 903: ! 904: make stage2 ! 905: make CC=stage2/gcc CFLAGS="-g -O -Bstage2/" ! 906: foreach file (*.o) ! 907: cmp $file stage2/$file ! 908: end ! 909: ! 910: This will notify you if any of these stage 3 object files differs from ! 911: those of stage 2. Any difference, no matter how innocuous, indicates ! 912: that the stage 2 compiler has compiled GNU CC incorrectly, and is ! 913: therefore a potentially serious bug which you should investigate and ! 914: report (*Note Bugs::.). ! 915: ! 916: 9. Install the compiler driver, the compiler's passes and run-time support. ! 917: You can use the following command: ! 918: ! 919: make install ! 920: ! 921: This copies the files `cc1', `cpp' and `gnulib' to files `gcc-cc1', ! 922: `gcc-cpp' and `gcc-gnulib' in directory `/usr/local/lib', which is ! 923: where the compiler driver program looks for them. It also copies the ! 924: driver program `gcc' into the directory `/usr/local', so that it ! 925: appears in typical execution search paths. ! 926: ! 927: *Warning: the GNU CPP may not work for `ioctl.h', `ttychars.h' and ! 928: other system header files unless the `-traditional' option is used.* ! 929: The bug is in the header files: at least on some machines, they rely ! 930: on behavior that is incompatible with ANSI C. This behavior consists ! 931: of substituting for macro argument names when they appear inside of ! 932: character constants. The `-traditional' option tells GNU CC to behave ! 933: the way these headers expect. ! 934: ! 935: Because of this problem, you might prefer to configure GNU CC to use ! 936: the system's own C preprocessor. To do so, make the file ! 937: `/usr/local/lib/gcc-cpp' a link to `/lib/cpp'. ! 938: ! 939: Alternatively, on Sun systems and 4.3BSD at least, you can correct the ! 940: include files by running the shell script `fixincludes'. This ! 941: installs modified, corrected copies of the files `ioctl.h' and ! 942: `ttychars.h' in a special directory where only GNU CC will normally ! 943: look for them. ! 944: ! 945: The file `/usr/include/vaxuba/qvioctl.h' used in the X window system ! 946: needs a similar correction. ! 947: ! 948: If you cannot install the compiler's passes and run-time support in ! 949: `/usr/local/lib', you can alternatively use the `-B' option to specify a ! 950: prefix by which they may be found. The compiler concatenates the prefix ! 951: with the names `cpp', `cc1' and `gnulib'. Thus, you can put the files in ! 952: a directory `/usr/foo/gcc' and specify `-B/usr/foo/gcc/' when you run GNU CC. ! 953: ! 954: ! 955: File: internals, Node: VMS Install, Prev: Installation, Up: Installation ! 956: ! 957: Installing GNU CC on VMS ! 958: ======================== ! 959: ! 960: The VMS version of GNU CC is distributed in an unusual tape format which ! 961: consists of several tape files. The first is a command file; the second is ! 962: an executable program which reads Unix tar format; the third is another ! 963: command file which uses this program to read the remainder of the tape. ! 964: ! 965: To load the tape, it suffices to mount it `/foreign' and then do `@mta0:' ! 966: to execute the command file at the beginning of the tape. ! 967: ! 968: The tape contains executables and object files as well as sources, so no ! 969: compilation is necessary unless you change the sources. (This is a good ! 970: thing, since you probably don't have any other C compiler.) If you must ! 971: recompile, here is how: ! 972: ! 973: 1. Copy the file `tm-vms.h' to `tm.h', `config-vms.h' to `config.h', ! 974: `vax.md' to `md.' and `output-vax.c' to `aux-output.c'. ! 975: ! 976: 2. Type `@make' to do recompile everything. ! 977: ! 978: To install the `GCC' command so you can use the compiler easily, in the ! 979: same manner as you use the VMS C compiler, you must install the VMS CLD ! 980: file for GNU CC as follows: ! 981: ! 982: 1. Define the VMS logical names `GNU_CC' and `GNU_CC_INCLUDE' to point to ! 983: the directories where the GNU CC executables (`gcc-cpp', `gcc-cc1', ! 984: etc.) and the C include files are kept. This should be done with the ! 985: commands: ! 986: ! 987: $ assign /super /system disk:[gcc] gnu_cc ! 988: $ assign /super /system disk:[gcc.include] gnu_cc_include ! 989: ! 990: with the appropriate disk and directory names. These commands can be ! 991: placed in your system startup file so they will be executed whenever ! 992: the machine is rebooted. ! 993: ! 994: 2. Install the `GCC' command with the command line: ! 995: ! 996: $ set command /table=sys$library:dcltables gnu_cc:gcc ! 997: ! 998: Now you can invoke the compiler with a command like `gcc /verbose ! 999: file.c', which is equivalent to the command `gcc -v -c file.c' in Unix. ! 1000: ! 1001: ! 1002: File: internals, Node: Trouble, Next: Incompatibilities, Prev: Installation, Up: Top ! 1003: ! 1004: Trouble in Installation ! 1005: *********************** ! 1006: ! 1007: Here are some of the things that have caused trouble for people installing ! 1008: GNU CC. ! 1009: ! 1010: ! 1011: ! 1012: On certain systems, defining certain environment variables such as ! 1013: `CC' can interfere with the functioning of `make'. ! 1014: ! 1015: ! 1016: File: internals, Node: Incompatibilities, Next: Extensions, Prev: Trouble, Up: Top ! 1017: ! 1018: Incompatibilities of GNU CC ! 1019: *************************** ! 1020: ! 1021: There are several noteworthy incompatibilities between GNU C and most ! 1022: existing (non-ANSI) versions of C. ! 1023: ! 1024: Ultimately our intention is that the `-traditional' option will eliminate ! 1025: most of these incompatibilities by telling GNU C to behave like the other C ! 1026: compilers. ! 1027: ! 1028: * GNU CC normally makes string constants read-only. If several ! 1029: identical-looking string constants are used, GNU CC stores only one ! 1030: copy of the string. ! 1031: ! 1032: One consequence is that you cannot call `mktemp' with a string ! 1033: constant argument. The function `mktemp' always alters the string its ! 1034: argument points to. ! 1035: ! 1036: Another consequence is that `sscanf' does not work on some systems ! 1037: when passed a string constant as its format control string. This is ! 1038: because `sscanf' incorrectly tries to write into the string constant. ! 1039: ! 1040: The best solution to these problems is to change the program to use ! 1041: `char'-array variables with initialization strings for these purposes ! 1042: instead of string constants. But if this is not possible, you can use ! 1043: the `-fwritable-strings' flag, which directs GNU CC to handle string ! 1044: constants the same way most C compilers do. ! 1045: ! 1046: * GNU CC does not substitute macro arguments when they appear inside of ! 1047: string constants. For example, the following macro in GNU CC ! 1048: ! 1049: #define foo(a) "a" ! 1050: ! 1051: will produce output `"a"' regardless of what the argument A is. ! 1052: ! 1053: The `-traditional' option directs GNU CC to handle such cases (among ! 1054: others) in the old-fashioned (non-ANSI) fashion. ! 1055: ! 1056: * When you use `setjmp' and `longjmp', the only automatic variables ! 1057: guaranteed to remain valid are those declared `volatile'. This is a ! 1058: consequence of automatic register allocation. Consider this function: ! 1059: ! 1060: jmp_buf j; ! 1061: ! 1062: foo () ! 1063: { ! 1064: int a, b; ! 1065: ! 1066: a = fun1 (); ! 1067: if (setjmp (j)) ! 1068: return a; ! 1069: ! 1070: a = fun2 (); ! 1071: /* `longjmp (j)' may be occur in `fun3'. */ ! 1072: return a + fun3 (); ! 1073: } ! 1074: ! 1075: Here `a' may or may not be restored to its first value when the ! 1076: `longjmp' occurs. If `a' is allocated in a register, then its first ! 1077: value is restored; otherwise, it keeps the last value stored in it. ! 1078: ! 1079: If you use the `-W' option with the `-O' option, you will get a ! 1080: warning when GNU CC thinks such a problem might be possible. ! 1081: ! 1082: * Declarations of external variables and functions within a block apply ! 1083: only to the block containing the declaration. In other words, they ! 1084: have the same scope as any other declaration in the same place. ! 1085: ! 1086: In some other C compilers, a `extern' declaration affects all the rest ! 1087: of the file even if it happens within a block. ! 1088: ! 1089: The `-traditional' option directs GNU C to treat all `extern' ! 1090: declarations as global, like traditional compilers. ! 1091: ! 1092: * In traditional C, you can combine `long', etc., with a typedef name, ! 1093: as shown here: ! 1094: ! 1095: typedef int foo; ! 1096: typedef long foo bar; ! 1097: ! 1098: In ANSI C, this is not allowed: `long' and other type modifiers ! 1099: require an explicit `int'. Because this criterion is expressed by ! 1100: Bison grammar rules rather than C code, the `-traditional' flag cannot ! 1101: alter it. ! 1102: ! 1103: * When compiling functions that return structures or unions, GNU CC ! 1104: output code uses a method different from that used on most versions of ! 1105: Unix. As a result, code compiled with GNU CC cannot call a ! 1106: structure-returning function compiled with PCC, and vice versa. ! 1107: ! 1108: The method used by GCC is as follows: a structure or union which is 1, ! 1109: 2, 4 or 8 bytes long is returned like a scalar. A structure or union ! 1110: with any other size is stored into an address supplied by the caller ! 1111: in a special, fixed register. ! 1112: ! 1113: PCC usually handles all sizes of structures and unions by returning ! 1114: the address of a block of static storage containing the value. This ! 1115: method is not used in GCC because it is slower and nonreentrant. ! 1116: ! 1117: On systems where PCC works this way, you may be able to make ! 1118: GCC-compiled code call such functions that were compiled with PCC by ! 1119: declaring them to return a pointer to the structure or union instead ! 1120: of the structure or union itself. For example, instead of this: ! 1121: ! 1122: struct foo nextfoo (); ! 1123: ! 1124: write this: ! 1125: ! 1126: struct foo *nextfoo (); ! 1127: #define nextfoo *nextfoo ! 1128: ! 1129: (Note that this assumes you are using the GNU preprocessor, so that ! 1130: the ANSI antirecursion rules for macro expansions are effective.) ! 1131: ! 1132:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.