![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to g++.1 CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GCC 2.x] / gcc / cp|
Return to g++.1 CVS log | Up to [GCC 2.x] / gcc / cp |
1.1 ! root 1: .\" Copyright (c) 1991, 1992 Free Software Foundation -*-Text-*- ! 2: .\" See section COPYING for conditions for redistribution ! 3: .\" FIXME: no info here on predefines. Should there be? extra for C++... ! 4: .TH G++ 1 "30apr1993" "GNU Tools" "GNU Tools" ! 5: .de BP ! 6: .sp ! 7: .ti \-.2i ! 8: \(** ! 9: .. ! 10: .SH NAME ! 11: g++ \- GNU project C++ Compiler (v2.4) ! 12: .SH SYNOPSIS ! 13: .RB g++ " [" \c ! 14: .IR option " | " filename " ].\|.\|. ! 15: .SH DESCRIPTION ! 16: The C and C++ compilers are integrated; ! 17: .B g++ ! 18: is a script to call ! 19: .B gcc with options to recognize C++. ! 20: .B gcc ! 21: processes input files ! 22: through one or more of four stages: preprocessing, compilation, ! 23: assembly, and linking. This man page contains full descriptions for ! 24: .I only ! 25: C++ specific aspects of the compiler, though it also contains ! 26: summaries of some general-purpose options. For a fuller explanation ! 27: of the compiler, see ! 28: .BR gcc ( 1 ). ! 29: ! 30: C++ source files use one of the suffixes `\|\c ! 31: .B .C\c ! 32: \&\|', `\|\c ! 33: .B .cc\c ! 34: \&\|', or `\|\c ! 35: .B .cxx\c ! 36: \&\|'; preprocessed C++ files use the suffix `\|\c ! 37: .B .ii\c ! 38: \&\|'. ! 39: .SH OPTIONS ! 40: There are many command-line options, including options to control ! 41: details of optimization, warnings, and code generation, which are ! 42: common to both ! 43: .B gcc ! 44: and ! 45: .B g++\c ! 46: \&. For full information on all options, see ! 47: .BR gcc ( 1 ). ! 48: ! 49: Options must be separate: `\|\c ! 50: .B \-dr\c ! 51: \&\|' is quite different from `\|\c ! 52: .B \-d \-r ! 53: \&\|'. ! 54: ! 55: Most `\|\c ! 56: .B \-f\c ! 57: \&\|' and `\|\c ! 58: .B \-W\c ! 59: \&\|' options have two contrary forms: ! 60: .BI \-f name ! 61: and ! 62: .BI \-fno\- name\c ! 63: \& (or ! 64: .BI \-W name ! 65: and ! 66: .BI \-Wno\- name\c ! 67: \&). Only the non-default forms are shown here. ! 68: ! 69: .TP ! 70: .B \-c ! 71: Compile or assemble the source files, but do not link. The compiler ! 72: output is an object file corresponding to each source file. ! 73: .TP ! 74: .BI \-D macro ! 75: Define macro \c ! 76: .I macro\c ! 77: \& with the string `\|\c ! 78: .B 1\c ! 79: \&\|' as its definition. ! 80: .TP ! 81: .BI \-D macro = defn ! 82: Define macro \c ! 83: .I macro\c ! 84: \& as \c ! 85: .I defn\c ! 86: \&. ! 87: .TP ! 88: .B \-E ! 89: Stop after the preprocessing stage; do not run the compiler proper. The ! 90: output is preprocessed source code, which is sent to the ! 91: standard output. ! 92: .TP ! 93: .B \-fall\-virtual ! 94: Treat all possible member functions as virtual, implicitly. All ! 95: member functions (except for constructor functions and ! 96: .B new ! 97: or ! 98: .B delete ! 99: member operators) are treated as virtual functions of the class where ! 100: they appear. ! 101: ! 102: This does not mean that all calls to these member functions will be ! 103: made through the internal table of virtual functions. Under some ! 104: circumstances, the compiler can determine that a call to a given ! 105: virtual function can be made directly; in these cases the calls are ! 106: direct in any case. ! 107: .TP ! 108: .B \-fdollars\-in\-identifiers ! 109: Permit the use of `\|\c ! 110: .B $\c ! 111: \&\|' in identifiers. ! 112: Traditional C allowed the character `\|\c ! 113: .B $\c ! 114: \&\|' to form part of identifiers; by default, GNU C also ! 115: allows this. However, ANSI C forbids `\|\c ! 116: .B $\c ! 117: \&\|' in identifiers, and GNU C++ also forbids it by default on most ! 118: platforms (though on some platforms it's enabled by default for GNU ! 119: C++ as well). ! 120: .TP ! 121: .B \-felide\-constructors ! 122: Use this option to instruct the compiler to be smarter about when it can ! 123: elide constructors. Without this flag, GNU C++ and cfront both ! 124: generate effectively the same code for: ! 125: .sp ! 126: .br ! 127: A\ foo\ (); ! 128: .br ! 129: A\ x\ (foo\ ());\ \ \ //\ x\ initialized\ by\ `foo\ ()',\ no\ ctor\ called ! 130: .br ! 131: A\ y\ =\ foo\ ();\ \ \ //\ call\ to\ `foo\ ()'\ heads\ to\ temporary, ! 132: .br ! 133: \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ //\ y\ is\ initialized\ from\ the\ temporary. ! 134: .br ! 135: .sp ! 136: Note the difference! With this flag, GNU C++ initializes `\|\c ! 137: .B y\c ! 138: \&\|' directly ! 139: from the call to ! 140: .B foo () ! 141: without going through a temporary. ! 142: .TP ! 143: .B \-fenum\-int\-equiv ! 144: Normally GNU C++ allows conversion of ! 145: .B enum ! 146: to ! 147: .B int\c ! 148: \&, but not the other way around. Use this option if you want GNU C++ ! 149: to allow conversion of ! 150: .B int ! 151: to ! 152: .B enum ! 153: as well. ! 154: .TP ! 155: .B \-fexternal\-templates ! 156: Produce smaller code for template declarations, by generating only a ! 157: single copy of each template function where it is defined. ! 158: To use this option successfully, you must also mark all files that ! 159: use templates with either `\|\c ! 160: .B #pragma implementation\c ! 161: \&\|' (the definition) or ! 162: `\|\c ! 163: .B #pragma interface\c ! 164: \&\|' (declarations). ! 165: ! 166: When your code is compiled with `\|\c ! 167: .B \-fexternal\-templates\c ! 168: \&\|', all ! 169: template instantiations are external. You must arrange for all ! 170: necessary instantiations to appear in the implementation file; you can ! 171: do this with a \c ! 172: .B typedef\c ! 173: \& that references each instantiation needed. ! 174: Conversely, when you compile using the default option ! 175: `\|\c ! 176: .B \-fno\-external\-templates\c ! 177: \&\|', all template instantiations are ! 178: explicitly internal. ! 179: .TP ! 180: .B \-fno\-gnu\-linker ! 181: Do not output global initializations (such as C++ constructors and ! 182: destructors) in the form used by the GNU linker (on systems where the GNU ! 183: linker is the standard method of handling them). Use this option when ! 184: you want to use a non-GNU linker, which also requires using the ! 185: .B collect2 ! 186: program to make sure the system linker includes ! 187: constructors and destructors. (\c ! 188: .B collect2 ! 189: is included in the GNU CC distribution.) For systems which ! 190: .I must ! 191: use ! 192: .B collect2\c ! 193: \&, the compiler driver ! 194: .B gcc ! 195: is configured to do this automatically. ! 196: .TP ! 197: .B \-fmemoize\-lookups ! 198: .TP ! 199: .B \-fsave\-memoized ! 200: These flags are used to get the compiler to compile programs faster ! 201: using heuristics. They are not on by default since they are only effective ! 202: about half the time. The other half of the time programs compile more ! 203: slowly (and take more memory). ! 204: ! 205: The first time the compiler must build a call to a member function (or ! 206: reference to a data member), it must (1) determine whether the class ! 207: implements member functions of that name; (2) resolve which member ! 208: function to call (which involves figuring out what sorts of type ! 209: conversions need to be made); and (3) check the visibility of the member ! 210: function to the caller. All of this adds up to slower compilation. ! 211: Normally, the second time a call is made to that member function (or ! 212: reference to that data member), it must go through the same lengthy ! 213: process again. This means that code like this ! 214: .sp ! 215: .br ! 216: \ \ cout\ <<\ "This\ "\ <<\ p\ <<\ "\ has\ "\ <<\ n\ <<\ "\ legs.\en"; ! 217: .br ! 218: .sp ! 219: makes six passes through all three steps. By using a software cache, ! 220: a ``hit'' significantly reduces this cost. Unfortunately, using the ! 221: cache introduces another layer of mechanisms which must be implemented, ! 222: and so incurs its own overhead. `\|\c ! 223: .B \-fmemoize\-lookups\c ! 224: \&\|' enables ! 225: the software cache. ! 226: ! 227: Because access privileges (visibility) to members and member functions ! 228: may differ from one function context to the next, ! 229: .B g++ ! 230: may need to flush the cache. With the `\|\c ! 231: .B \-fmemoize\-lookups\c ! 232: \&\|' flag, the cache is flushed after every ! 233: function that is compiled. The `\|\c ! 234: \-fsave\-memoized\c ! 235: \&\|' flag enables the same software cache, but when the compiler ! 236: determines that the context of the last function compiled would yield ! 237: the same access privileges of the next function to compile, it ! 238: preserves the cache. ! 239: This is most helpful when defining many member functions for the same ! 240: class: with the exception of member functions which are friends of ! 241: other classes, each member function has exactly the same access ! 242: privileges as every other, and the cache need not be flushed. ! 243: .TP ! 244: .B \-fno\-default\-inline ! 245: Do not make member functions inline by default merely because they are ! 246: defined inside the class scope. Otherwise, when you specify ! 247: .B \-O\c ! 248: \&, member functions defined inside class scope are compiled ! 249: inline by default; i.e., you don't need to add `\|\c ! 250: .B inline\c ! 251: \&\|' in front of ! 252: the member function name. ! 253: .TP ! 254: .B \-fno\-strict\-prototype ! 255: Consider the declaration \c ! 256: .B int foo ();\c ! 257: \&. In C++, this means that the ! 258: function \c ! 259: .B foo\c ! 260: \& takes no arguments. In ANSI C, this is declared ! 261: .B int foo(void);\c ! 262: \&. With the flag `\|\c ! 263: .B \-fno\-strict\-prototype\c ! 264: \&\|', ! 265: declaring functions with no arguments is equivalent to declaring its ! 266: argument list to be untyped, i.e., \c ! 267: .B int foo ();\c ! 268: \& is equivalent to ! 269: saying \c ! 270: .B int foo (...);\c ! 271: \&. ! 272: .TP ! 273: .B \-fnonnull\-objects ! 274: Normally, GNU C++ makes conservative assumptions about objects reached ! 275: through references. For example, the compiler must check that `\|\c ! 276: .B a\c ! 277: \&\|' is not null in code like the following: ! 278: .br ! 279: \ \ \ \ obj\ &a\ =\ g\ (); ! 280: .br ! 281: \ \ \ \ a.f\ (2); ! 282: .br ! 283: Checking that references of this sort have non-null values requires ! 284: extra code, however, and it is unnecessary for many programs. You can ! 285: use `\|\c ! 286: .B \-fnonnull\-objects\c ! 287: \&\|' to omit the checks for null, if your program doesn't require the ! 288: default checking. ! 289: .TP ! 290: .B \-fhandle\-signatures ! 291: .TP ! 292: .B \-fno\-handle\-signatures ! 293: These options control the recognition of the \c ! 294: .B signature\c ! 295: \& and \c ! 296: .B sigof\c ! 297: \& constructs for specifying abstract types. By default, these ! 298: constructs are not recognized. ! 299: .TP ! 300: .B \-fthis\-is\-variable ! 301: The incorporation of user-defined free store management into C++ has ! 302: made assignment to \c ! 303: .B this\c ! 304: \& an anachronism. Therefore, by default GNU ! 305: C++ treats the type of \c ! 306: .B this\c ! 307: \& in a member function of \c ! 308: .B class X\c ! 309: \& ! 310: to be \c ! 311: .B X *const\c ! 312: \&. In other words, it is illegal to assign to ! 313: \c ! 314: .B this\c ! 315: \& within a class member function. However, for backwards ! 316: compatibility, you can invoke the old behavior by using ! 317: \&`\|\c ! 318: .B \-fthis\-is\-variable\c ! 319: \&\|'. ! 320: .TP ! 321: .B \-g ! 322: Produce debugging information in the operating system's native format ! 323: (for DBX or SDB or DWARF). GDB also can work with this debugging ! 324: information. On most systems that use DBX format, `\|\c ! 325: .B \-g\c ! 326: \&\|' enables use ! 327: of extra debugging information that only GDB can use. ! 328: ! 329: Unlike most other C compilers, GNU CC allows you to use `\|\c ! 330: .B \-g\c ! 331: \&\|' with ! 332: `\|\c ! 333: .B \-O\c ! 334: \&\|'. The shortcuts taken by optimized code may occasionally ! 335: produce surprising results: some variables you declared may not exist ! 336: at all; flow of control may briefly move where you did not expect it; ! 337: some statements may not be executed because they compute constant ! 338: results or their values were already at hand; some statements may ! 339: execute in different places because they were moved out of loops. ! 340: ! 341: Nevertheless it proves possible to debug optimized output. This makes ! 342: it reasonable to use the optimizer for programs that might have bugs. ! 343: .TP ! 344: .BI "\-I" "dir"\c ! 345: \& ! 346: Append directory \c ! 347: .I dir\c ! 348: \& to the list of directories searched for include files. ! 349: .TP ! 350: .BI "\-L" "dir"\c ! 351: \& ! 352: Add directory \c ! 353: .I dir\c ! 354: \& to the list of directories to be searched ! 355: for `\|\c ! 356: .B \-l\c ! 357: \&\|'. ! 358: .TP ! 359: .BI \-l library\c ! 360: \& ! 361: Use the library named \c ! 362: .I library\c ! 363: \& when linking. (C++ programs often require `\|\c ! 364: \-lg++\c ! 365: \&\|' for successful linking.) ! 366: .TP ! 367: .B \-nostdinc ! 368: Do not search the standard system directories for header files. Only ! 369: the directories you have specified with ! 370: .B \-I ! 371: options (and the current directory, if appropriate) are searched. ! 372: .TP ! 373: .B \-nostdinc++ ! 374: Do not search for header files in the standard directories specific to ! 375: C++, but do still search the other standard directories. (This option ! 376: is used when building libg++.) ! 377: .TP ! 378: .B \-O ! 379: Optimize. Optimizing compilation takes somewhat more time, and a lot ! 380: more memory for a large function. ! 381: .TP ! 382: .BI "\-o " file\c ! 383: \& ! 384: Place output in file \c ! 385: .I file\c ! 386: \&. ! 387: .TP ! 388: .B \-S ! 389: Stop after the stage of compilation proper; do not assemble. The output ! 390: is an assembler code file for each non-assembler input ! 391: file specified. ! 392: .TP ! 393: .B \-traditional ! 394: Attempt to support some aspects of traditional C compilers. ! 395: ! 396: Specifically, for both C and C++ programs: ! 397: .TP ! 398: \ \ \ \(bu ! 399: In the preprocessor, comments convert to nothing at all, rather than ! 400: to a space. This allows traditional token concatenation. ! 401: .TP ! 402: \ \ \ \(bu ! 403: In the preprocessor, macro arguments are recognized within string ! 404: constants in a macro definition (and their values are stringified, ! 405: though without additional quote marks, when they appear in such a ! 406: context). The preprocessor always considers a string constant to end ! 407: at a newline. ! 408: .TP ! 409: \ \ \ \(bu ! 410: The preprocessor does not predefine the macro \c ! 411: .B __STDC__\c ! 412: \& when you use ! 413: `\|\c ! 414: .B \-traditional\c ! 415: \&\|', but still predefines\c ! 416: .B __GNUC__\c ! 417: \& (since the GNU extensions indicated by ! 418: .B __GNUC__\c ! 419: \& are not affected by ! 420: `\|\c ! 421: .B \-traditional\c ! 422: \&\|'). If you need to write header files that work ! 423: differently depending on whether `\|\c ! 424: .B \-traditional\c ! 425: \&\|' is in use, by ! 426: testing both of these predefined macros you can distinguish four ! 427: situations: GNU C, traditional GNU C, other ANSI C compilers, and ! 428: other old C compilers. ! 429: .TP ! 430: \ \ \ \(bu ! 431: In the preprocessor, comments convert to nothing at all, rather than ! 432: to a space. This allows traditional token concatenation. ! 433: .TP ! 434: \ \ \ \(bu ! 435: In the preprocessor, macro arguments are recognized within string ! 436: constants in a macro definition (and their values are stringified, ! 437: though without additional quote marks, when they appear in such a ! 438: context). The preprocessor always considers a string constant to end ! 439: at a newline. ! 440: .TP ! 441: \ \ \ \(bu ! 442: The preprocessor does not predefine the macro \c ! 443: .B __STDC__\c ! 444: \& when you use ! 445: `\|\c ! 446: .B \-traditional\c ! 447: \&\|', but still predefines\c ! 448: .B __GNUC__\c ! 449: \& (since the GNU extensions indicated by ! 450: .B __GNUC__\c ! 451: \& are not affected by ! 452: `\|\c ! 453: .B \-traditional\c ! 454: \&\|'). If you need to write header files that work ! 455: differently depending on whether `\|\c ! 456: .B \-traditional\c ! 457: \&\|' is in use, by ! 458: testing both of these predefined macros you can distinguish four ! 459: situations: GNU C, traditional GNU C, other ANSI C compilers, and ! 460: other old C compilers. ! 461: .PP ! 462: .TP ! 463: \ \ \ \(bu ! 464: String ``constants'' are not necessarily constant; they are stored in ! 465: writable space, and identical looking constants are allocated ! 466: separately. ! 467: ! 468: For C++ programs only (not C), `\|\c ! 469: .B \-traditional\c ! 470: \&\|' has one additional effect: assignment to ! 471: .B this ! 472: is permitted. This is the same as the effect of `\|\c ! 473: .B \-fthis\-is\-variable\c ! 474: \&\|'. ! 475: .TP ! 476: .BI \-U macro ! 477: Undefine macro \c ! 478: .I macro\c ! 479: \&. ! 480: .TP ! 481: .B \-Wall ! 482: Issue warnings for conditions which pertain to usage that we recommend ! 483: avoiding and that we believe is easy to avoid, even in conjunction ! 484: with macros. ! 485: .TP ! 486: .B \-Wenum\-clash ! 487: Warn when converting between different enumeration types. ! 488: .TP ! 489: .B \-Woverloaded\-virtual ! 490: In a derived class, the definitions of virtual functions must match ! 491: the type signature of a virtual function declared in the base class. ! 492: Use this option to request warnings when a derived class declares a ! 493: function that may be an erroneous attempt to define a virtual ! 494: function: that is, warn when a function with the same name as a ! 495: virtual function in the base class, but with a type signature that ! 496: doesn't match any virtual functions from the base class. ! 497: .TP ! 498: .B \-Wtemplate\-debugging ! 499: When using templates in a C++ program, warn if debugging is not yet ! 500: fully available. ! 501: .TP ! 502: .B \-w ! 503: Inhibit all warning messages. ! 504: .TP ! 505: .BI +e N ! 506: Control how virtual function definitions are used, in a fashion ! 507: compatible with ! 508: .B cfront ! 509: 1.x. ! 510: .PP ! 511: ! 512: .SH PRAGMAS ! 513: Two `\|\c ! 514: .B #pragma\c ! 515: \&\|' directives are supported for GNU C++, to permit using the same ! 516: header file for two purposes: as a definition of interfaces to a given ! 517: object class, and as the full definition of the contents of that object class. ! 518: .TP ! 519: .B #pragma interface ! 520: Use this directive in header files that define object classes, to save ! 521: space in most of the object files that use those classes. Normally, ! 522: local copies of certain information (backup copies of inline member ! 523: functions, debugging information, and the internal tables that ! 524: implement virtual functions) must be kept in each object file that ! 525: includes class definitions. You can use this pragma to avoid such ! 526: duplication. When a header file containing `\|\c ! 527: .B #pragma interface\c ! 528: \&\|' is included in a compilation, this auxiliary information ! 529: will not be generated (unless the main input source file itself uses ! 530: `\|\c ! 531: .B #pragma implementation\c ! 532: \&\|'). Instead, the object files will contain references to be ! 533: resolved at link time. ! 534: .tr !" ! 535: .TP ! 536: .B #pragma implementation ! 537: .TP ! 538: .BI "#pragma implementation !" objects .h! ! 539: Use this pragma in a main input file, when you want full output from ! 540: included header files to be generated (and made globally visible). ! 541: The included header file, in turn, should use `\|\c ! 542: .B #pragma interface\c ! 543: \&\|'. ! 544: Backup copies of inline member functions, debugging information, and ! 545: the internal tables used to implement virtual functions are all ! 546: generated in implementation files. ! 547: ! 548: If you use `\|\c ! 549: .B #pragma implementation\c ! 550: \&\|' with no argument, it applies to an include file with the same ! 551: basename as your source file; for example, in `\|\c ! 552: .B allclass.cc\c ! 553: \&\|', `\|\c ! 554: .B #pragma implementation\c ! 555: \&\|' by itself is equivalent to `\|\c ! 556: .B ! 557: #pragma implementation "allclass.h"\c ! 558: \&\|'. Use the string argument if you want a single implementation ! 559: file to include code from multiple header files. ! 560: ! 561: There is no way to split up the contents of a single header file into ! 562: multiple implementation files. ! 563: .SH FILES ! 564: .ta \w'LIBDIR/g++\-include 'u ! 565: file.h C header (preprocessor) file ! 566: .br ! 567: file.i preprocessed C source file ! 568: .br ! 569: file.C C++ source file ! 570: .br ! 571: file.cc C++ source file ! 572: .br ! 573: file.cxx C++ source file ! 574: .br ! 575: file.s assembly language file ! 576: .br ! 577: file.o object file ! 578: .br ! 579: a.out link edited output ! 580: .br ! 581: \fITMPDIR\fR/cc\(** temporary files ! 582: .br ! 583: \fILIBDIR\fR/cpp preprocessor ! 584: .br ! 585: \fILIBDIR\fR/cc1plus compiler ! 586: .br ! 587: \fILIBDIR\fR/collect linker front end needed on some machines ! 588: .br ! 589: \fILIBDIR\fR/libgcc.a GCC subroutine library ! 590: .br ! 591: /lib/crt[01n].o start-up routine ! 592: .br ! 593: \fILIBDIR\fR/ccrt0 additional start-up routine for C++ ! 594: .br ! 595: /lib/libc.a standard C library, see ! 596: .IR intro (3) ! 597: .br ! 598: /usr/include standard directory for ! 599: .B #include ! 600: files ! 601: .br ! 602: \fILIBDIR\fR/include standard gcc directory for ! 603: .B #include ! 604: files ! 605: .br ! 606: \fILIBDIR\fR/g++\-include additional g++ directory for ! 607: .B #include ! 608: .sp ! 609: .I LIBDIR ! 610: is usually ! 611: .B /usr/local/lib/\c ! 612: .IR machine / version . ! 613: .br ! 614: .I TMPDIR ! 615: comes from the environment variable ! 616: .B TMPDIR ! 617: (default ! 618: .B /usr/tmp ! 619: if available, else ! 620: .B /tmp\c ! 621: \&). ! 622: .SH "SEE ALSO" ! 623: gcc(1), cpp(1), as(1), ld(1), gdb(1), adb(1), dbx(1), sdb(1). ! 624: .br ! 625: .RB "`\|" gcc "\|', `\|" cpp \|', ! 626: .RB `\| as \|', `\| ld \|', ! 627: and ! 628: .RB `\| gdb \|' ! 629: entries in ! 630: .B info\c ! 631: \&. ! 632: .br ! 633: .I ! 634: Using and Porting GNU CC (for version 2.0)\c ! 635: , Richard M. Stallman; ! 636: .I ! 637: The C Preprocessor\c ! 638: , Richard M. Stallman; ! 639: .I ! 640: Debugging with GDB: the GNU Source-Level Debugger\c ! 641: , Richard M. Stallman and Roland H. Pesch; ! 642: .I ! 643: Using as: the GNU Assembler\c ! 644: , Dean Elsner, Jay Fenlason & friends; ! 645: .I ! 646: gld: the GNU linker\c ! 647: , Steve Chamberlain and Roland Pesch. ! 648: ! 649: .SH BUGS ! 650: For instructions on how to report bugs, see the GCC manual. ! 651: ! 652: .SH COPYING ! 653: Copyright (c) 1991, 1992, 1993 Free Software Foundation, Inc. ! 654: .PP ! 655: Permission is granted to make and distribute verbatim copies of ! 656: this manual provided the copyright notice and this permission notice ! 657: are preserved on all copies. ! 658: .PP ! 659: Permission is granted to copy and distribute modified versions of this ! 660: manual under the conditions for verbatim copying, provided that the ! 661: entire resulting derived work is distributed under the terms of a ! 662: permission notice identical to this one. ! 663: .PP ! 664: Permission is granted to copy and distribute translations of this ! 665: manual into another language, under the above conditions for modified ! 666: versions, except that this permission notice may be included in ! 667: translations approved by the Free Software Foundation instead of in ! 668: the original English. ! 669: .SH AUTHORS ! 670: See the GNU CC Manual for the contributors to GNU CC.
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.