--- gcc/internals-1 2018/04/24 16:37:52 1.1.1.1 +++ gcc/internals-1 2018/04/24 16:39:30 1.1.1.3 @@ -1,1172 +1,1132 @@ -Info file internals, produced by texinfo-format-buffer -*-Text-*- -from file internals.texinfo - - -This file documents the internals of the GNU compiler. - -Copyright (C) 1987 Richard M. Stallman. - -Permission is granted to make and distribute verbatim copies of -this manual provided the copyright notice and this permission notice -are preserved on all copies. - -Permission is granted to copy and distribute modified versions of this -manual under the conditions for verbatim copying, provided also that the -section entitled "GNU CC General Public License" is included exactly as -in the original, and provided that the entire resulting derived work is -distributed under the terms of a permission notice identical to this one. - -Permission is granted to copy and distribute translations of this manual -into another language, under the above conditions for modified versions, -except that the section entitled "GNU CC General Public License" may be -included in a translation approved by the author instead of in the original -English. - - -  -File: internals Node: Top, Up: (DIR), Next: Switches +File: internals, Node: Top, Next: Copying, Up: (DIR) Introduction ************ -This manual documents how to install and port the GNU C compiler. +This manual documents how to run, install and port the GNU C compiler, as +well as its new features and incompatibilities, and how to report bugs. * Menu: * Copying:: GNU CC General Public License says how you can copy and share GNU CC. -* Switches:: Command switches supported by `gcc'. +* Contributors:: People who have contributed to GNU CC. +* Options:: Command options supported by `gcc'. * Installation:: How to configure, compile and install GNU CC. +* Trouble:: If you have trouble installing GNU CC. +* Incompatibilities:: Incompatibilities of GNU CC. +* Extensions:: GNU extensions to the C language. +* Bugs:: How to report bugs (if you want to get them fixed). * Portability:: Goals of GNU CC's portability features. +* Interface:: Function-call interface of GNU CC output. * Passes:: Order of passes, what they do, and what each file is for. * RTL:: The intermediate representation that most passes work on. * Machine Desc:: How to write machine description instruction patterns. * Machine Macros:: How to write the machine description C macros. +  -File: internals Node: Copying, Prev: Top, Up: Top, Next: Switches +File: internals, Node: Copying, Next: Contributors, Prev: Top, Up: Top GNU CC GENERAL PUBLIC LICENSE ***************************** - The license agreements of most software companies keep you at the -mercy of those companies. By contrast, our general public license is -intended to give everyone the right to share GNU CC. To make sure that -you get the rights we want you to have, we need to make restrictions -that forbid anyone to deny you these rights or to ask you to surrender -the rights. Hence this license agreement. - - Specifically, we want to make sure that you have the right to give -away copies of GNU CC, that you receive source code or else can get it -if you want it, that you can change GNU CC or use pieces of it in new -free programs, and that you know you can do these things. + (Clarified 11 Feb 1988) - To make sure that everyone has such rights, we have to forbid you to -deprive anyone else of these rights. For example, if you distribute -copies of GNU CC, you must give the recipients all the rights that you -have. You must make sure that they, too, receive or can get the -source code. And you must tell them their rights. - - Also, for our own protection, we must make certain that everyone -finds out that there is no warranty for GNU CC. If GNU CC is modified by -someone else and passed on, we want its recipients to know that what -they have is not what we distributed, so that any problems introduced -by others will not reflect on our reputation. - - Therefore we (Richard Stallman and the Free Software Fundation, -Inc.) make the following terms which say what you must do to be -allowed to distribute or change GNU CC. + The license agreements of most software companies keep you at the mercy +of those companies. By contrast, our general public license is intended to +give everyone the right to share GNU CC. To make sure that you get the +rights we want you to have, we need to make restrictions that forbid anyone +to deny you these rights or to ask you to surrender the rights. Hence this +license agreement. + + Specifically, we want to make sure that you have the right to give away +copies of GNU CC, that you receive source code or else can get it if you +want it, that you can change GNU CC or use pieces of it in new free +programs, and that you know you can do these things. + To make sure that everyone has such rights, we have to forbid you to +deprive anyone else of these rights. For example, if you distribute copies +of GNU CC, you must give the recipients all the rights that you have. You +must make sure that they, too, receive or can get the source code. And you +must tell them their rights. + + Also, for our own protection, we must make certain that everyone finds +out that there is no warranty for GNU CC. If GNU CC is modified by someone +else and passed on, we want its recipients to know that what they have is +not what we distributed, so that any problems introduced by others will not +reflect on our reputation. + + Therefore we (Richard Stallman and the Free Software Foundation, Inc.) +make the following terms which say what you must do to be allowed to +distribute or change GNU CC. COPYING POLICIES ================ - 1. You may copy and distribute verbatim copies of GNU CC source code as - you receive it, in any medium, provided that you conspicuously and + 1. You may copy and distribute verbatim copies of GNU CC source code as you + receive it, in any medium, provided that you conspicuously and appropriately publish on each copy a valid copyright notice - "Copyright (C) 1987 Free Software Foundation, Inc." (or - with the year updated if that is appropriate); keep intact the notices - on all files that refer to this License Agreement and to the absence - of any warranty; and give any other recipients of the GNU CC program a - copy of this License Agreement along with the program. You may charge - a distribution fee for the physical act of transferring a copy. - - 2. You may modify your copy or copies of GNU CC or any portion of it, - and copy and distribute such modifications under the terms of - Paragraph 1 above, provided that you also do the following: - - * cause the modified files to carry prominent notices stating - that you changed the files and the date of any change; and - - * cause the whole of any work that you distribute or publish, - that in whole or in part contains or is a derivative of GNU CC or - any part thereof, to be licensed at no charge to all third - parties on terms identical to those contained in this License - Agreement (except that you may choose to grant more extensive - warranty protection to some or all third parties, at your - option). - + ``Copyright (C) 1988 Free Software Foundation, Inc.'' (or with + whatever year is appropriate); keep intact the notices on all files + that refer to this License Agreement and to the absence of any + warranty; and give any other recipients of the GNU CC program a copy + of this License Agreement along with the program. You may charge a + distribution fee for the physical act of transferring a copy. + + 2. You may modify your copy or copies of GNU CC or any portion of it, and + copy and distribute such modifications under the terms of Paragraph 1 + above, provided that you also do the following: + + * cause the modified files to carry prominent notices stating that + you changed the files and the date of any change; and + + * cause the whole of any work that you distribute or publish, that + in whole or in part contains or is a derivative of GNU CC or any + part thereof, to be licensed at no charge to all third parties on + terms identical to those contained in this License Agreement + (except that you may choose to grant more extensive warranty + protection to some or all third parties, at your option). + * You may charge a distribution fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee. - - 3. You may copy and distribute GNU CC or any portion of it in - compiled, executable or object code form under the terms of Paragraphs - 1 and 2 above provided that you do the following: - - * cause each such copy to be accompanied by the - corresponding machine-readable source code, which must - be distributed under the terms of Paragraphs 1 and 2 above; or, - - * cause each such copy to be accompanied by a - written offer, with no time limit, to give any third party - free (except for a nominal shipping charge) a machine readable - copy of the corresponding source code, to be distributed - under the terms of Paragraphs 1 and 2 above; or, - - * in the case of a recipient of GNU CC in compiled, executable - or object code form (without the corresponding source code) you - shall cause copies you distribute to be accompanied by a copy - of the written offer of source code which you received along - with the copy you received. - - 4. You may not copy, sublicense, distribute or transfer GNU CC - except as expressly provided under this License Agreement. Any attempt - otherwise to copy, sublicense, distribute or transfer GNU CC is void and - your rights to use the program under this License agreement shall be - automatically terminated. However, parties who have received computer - software programs from you with this License Agreement will not have - their licenses terminated so long as such parties remain in full compliance. - - 5. If you wish to incorporate parts of GNU CC into other free programs - whose distribution conditions are different, write to the Free Software - Foundation at 1000 Mass Ave, Cambridge, MA 02138. We have not yet worked - out a simple rule that can be stated here, but we will often permit this. - We will be guided by the two goals of preserving the free status of all - derivatives our free software and of promoting the sharing and reuse of - software. - -Your comments and suggestions about our licensing policies and our -software are welcome! Please contact the Free Software Foundation, Inc., -1000 Mass Ave, Cambridge, MA 02138, or call (617) 876-3296. + Mere aggregation of another unrelated program with this program (or + its derivative) on a volume of a storage or distribution medium does + not bring the other program under the scope of these terms. + + 3. You may copy and distribute GNU CC (or a portion or derivative of it, + under Paragraph 2) in object code or executable form under the terms + of Paragraphs 1 and 2 above provided that you also do one of the + following: + + * accompany it with the complete corresponding machine-readable + source code, which must be distributed under the terms of + Paragraphs 1 and 2 above; or, + + * accompany it with a written offer, valid for at least three + years, to give any third party free (except for a nominal + shipping charge) a complete machine-readable copy of the + corresponding source code, to be distributed under the terms of + Paragraphs 1 and 2 above; or, + + * accompany it with the information you received as to where the + corresponding source code may be obtained. (This alternative is + allowed only for noncommercial distribution and only if you + received the program in object code or executable form alone.) + + For an executable file, complete source code means all the source code + for all modules it contains; but, as a special exception, it need not + include source code for modules which are standard libraries that + accompany the operating system on which the executable file runs. + + 4. You may not copy, sublicense, distribute or transfer GNU CC except as + expressly provided under this License Agreement. Any attempt + otherwise to copy, sublicense, distribute or transfer GNU CC is void + and your rights to use the program under this License agreement shall + be automatically terminated. However, parties who have received + computer software programs from you with this License Agreement will + not have their licenses terminated so long as such parties remain in + full compliance. + + 5. If you wish to incorporate parts of GNU CC into other free programs + whose distribution conditions are different, write to the Free + Software Foundation at 675 Mass Ave, Cambridge, MA 02139. We have not + yet worked out a simple rule that can be stated here, but we will + often permit this. We will be guided by the two goals of preserving + the free status of all derivatives of our free software and of + promoting the sharing and reuse of software. + +Your comments and suggestions about our licensing policies and our software +are welcome! Please contact the Free Software Foundation, Inc., 675 Mass +Ave, Cambridge, MA 02139, or call (617) 876-3296. NO WARRANTY =========== BECAUSE GNU CC IS LICENSED FREE OF CHARGE, WE PROVIDE ABSOLUTELY NO -WARRANTY, TO THE EXTENT PERMITTED BY APPLICABLE STATE LAW. EXCEPT -WHEN OTHERWISE STATED IN WRITING, FREE SOFTWARE FOUNDATION, INC, -RICHARD M. STALLMAN AND/OR OTHER PARTIES PROVIDE GNU CC "AS IS" WITHOUT -WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT -LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND -PERFORMANCE OF GNU CC IS WITH YOU. SHOULD GNU CC PROVE DEFECTIVE, YOU -ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. - - IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW WILL RICHARD M. -STALLMAN, THE FREE SOFTWARE FOUNDATION, INC., AND/OR ANY OTHER PARTY -WHO MAY MODIFY AND REDISTRIBUTE GNU CC AS PERMITTED ABOVE, BE LIABLE TO -YOU FOR DAMAGES, INCLUDING ANY LOST PROFITS, LOST MONIES, OR OTHER -SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR -INABILITY TO USE (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA -BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY THIRD PARTIES OR A -FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS) GNU CC, EVEN -IF YOU HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES, OR FOR -ANY CLAIM BY ANY OTHER PARTY. +WARRANTY, TO THE EXTENT PERMITTED BY APPLICABLE STATE LAW. EXCEPT WHEN +OTHERWISE STATED IN WRITING, FREE SOFTWARE FOUNDATION, INC, RICHARD M. +STALLMAN AND/OR OTHER PARTIES PROVIDE GNU CC "AS IS" WITHOUT WARRANTY OF +ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. + THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF GNU CC IS WITH YOU. +SHOULD GNU CC PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY +SERVICING, REPAIR OR CORRECTION. + + IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW WILL RICHARD M. STALLMAN, +THE FREE SOFTWARE FOUNDATION, INC., AND/OR ANY OTHER PARTY WHO MAY MODIFY +AND REDISTRIBUTE GNU CC AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, +INCLUDING ANY LOST PROFITS, LOST MONIES, OR OTHER SPECIAL, INCIDENTAL OR +CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE (INCLUDING +BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES +SUSTAINED BY THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY +OTHER PROGRAMS) GNU CC, EVEN IF YOU HAVE BEEN ADVISED OF THE POSSIBILITY OF +SUCH DAMAGES, OR FOR ANY CLAIM BY ANY OTHER PARTY.  -File: internals Node: Switches, Prev: Copying, Up: Top, Next: Installation +File: internals, Node: Contributors, Next: Options, Prev: Copying, Up: Top + +Contributors to GNU CC +********************** + +In addition to Richard Stallman, several people have written parts of GNU CC. + + * The idea of using RTL and some of the optimization ideas came from the + U. of Arizona Portable Optimizer, written by Jack Davidson and + Christopher Fraser. See ``Register Allocation and Exhaustive Peephole + Optimization'', Software Practice and Experience 14 (9), Sept. 1984, + 857-866. + + * Paul Rubin wrote most of the preprocessor. + + * Leonard Tower wrote parts of the parser, RTL generator, RTL + definitions, and of the Vax machine description. + + * Ted Lemon wrote parts of the RTL reader and printer. + + * Nobuyuki Hikichi of Software Research Associates, Tokyo, contributed + the support for the SONY NEWS machine. + + * Charles LaBrec contributed the support for the Integrated Solutions + 68020 system. + + * Michael Tiemann of MCC wrote the description of the National + Semiconductor 32000 series cpu, with some contributions from Jan Stein + of the Chalmers Computer Club. Tiemann also wrote the code for inline + function integration. + + * Robert Brown implemented the support for Encore 32000 systems. + + * Michael Kashtan of SRI adapted GNU CC to the Vomit-Making System. -GNU CC Switches -*************** + * Alex Crain provided changes for the 3b1. -`-O' - Do optimize. - -`-g' + * Chris Hanson and another person who should remind me of his name + assisted in making GNU CC work on HP-UX for the 9000 series 300. + + +File: internals, Node: Options, Next: Installation, Prev: Contributors, Up: Top + +GNU CC Command Options +********************** + +The GNU C compiler uses a command syntax much like the Unix C compiler. +The `gcc' program accepts options and file names as operands. Multiple +single-letter options may *not* be grouped: `-dr' is very different from +`-d -r'. + +When you invoke GNU CC, it normally does preprocessing, compilation, +assembly and linking. File names which end in `.c' are taken as C source +to be preprocessed and compiled; compiler output files plus any input files +with names ending in `.s' are assembled; then the resulting object files, +plus any other input files, are linked together to produce an executable. + +Command options allow you to stop this process at an intermediate stage. +For example, the `-c' option says not to run the linker. Then the output +consists of object files output by the assembler. + +Other command options are passed on to one stage. Some options control the +preprocessor and others the compiler itself. Yet other options control the +assembler and linker; these are not documented here because the GNU +assembler and linker are not yet released. + +Here are the options to control the overall compilation process, including +those that say whether to link, whether to assemble, and so on. + +`-o FILE' + Place output in file FILE. This applies regardless to whatever sort + of output is being produced, whether it be an executable file, an + object file, an assembler file or preprocessed C code. + + If `-o' is not specified, the default is to put an executable file in + `a.out', the object file `SOURCE.c' in `SOURCE.o', an assembler file + in `SOURCE.s', and preprocessed C on standard output. + +`-c' + Compile or assemble the source files, but do not link. Produce object + files with names made by replacing `.c' or `.s' with `.o' at the end + of the input file names. Do nothing at all for object files specified + as input. + +`-S' + Compile into assembler code but do not assemble. The assembler output + file name is made by replacing `.c' with `.s' at the end of the input + file name. Do nothing at all for assembler source files or object + files specified as input. + +`-E' + Run only the C preprocessor. Preprocess all the C source files + specified and output the results to standard output. + +`-v' + Compiler driver program prints the commands it executes as it runs the + preprocessor, compiler proper, assembler and linker. Some of these + are directed to print their own version numbers. + +`-BPREFIX' + Compiler driver program tries PREFIX as a prefix for each program it + tries to run. These programs are `cpp', `cc1', `as' and `ld'. + + For each subprogram to be run, the compiler driver first tries the + `-B' prefix, if any. If that name is not found, or if `-B' was not + specified, the driver tries two standard prefixes, which are + `/usr/lib/gcc-' and `/usr/local/lib/gcc-'. If neither of those + results in a file name that is found, the unmodified program name is + searched for using the directories specified in your `PATH' + environment variable. + + The run-time support file `gnulib' is also searched for using the `-B' + prefix, if needed. If it is not found there, the two standard + prefixes above are tried, and that is all. The file is left out of + the link if it is not found by those means. Most of the time, on most + machines, you can do without it. + +These options control the details of C compilation itself. + +`-ansi' + Support all ANSI standard C programs. + + This turns off certain features of GNU C that are incompatible with + ANSI C, such as the `asm', `inline' and `typeof' keywords, and + predefined macros such as `unix' and `vax' that identify the type of + system you are using. It also enables the undesirable and rarely used + ANSI trigraph feature. + + The `-ansi' option does not cause non-ANSI programs to be rejected + gratuitously. For that, `-pedantic' is required in addition to `-ansi'. + + The macro `__STRICT_ANSI__' is predefined when the `-ansi' option is + used. Some header files may notice this macro and refrain from + declaring certain functions or defining certain macros that the ANSI + standard doesn't call for; this is to avoid interfering with any + programs that might use these names for other things. + +`-traditional' + Attempt to support some aspects of traditional C compilers. + Specifically: + + * All `extern' declarations take effect globally even if they are + written inside of a function definition. This includes implicit + declarations of functions. + + * The keywords `typeof', `inline', `signed', `const' and `volatile' + are not recognized. + + * Comparisons between pointers and integers are always allowed. + + * Integer types `unsigned short' and `unsigned char' promote to + `unsigned int'. + + * In the preprocessor, comments convert to nothing at all, rather + than to a space. This allows traditional token concatenation. + + * In the preprocessor, single and double quote characters are + ignored when scanning macro definitions, so that macro arguments + can be replaced even within a string or character constant. + Quote characters are also ignored when skipping text inside a + failing conditional directive. + +`-O' + Optimize. Optimizing compilation takes somewhat more time, and a lot + more memory for a large function. + + Without `-O', the compiler's goal is to reduce the cost of compilation + and to make debugging produce the expected results. Statements are + independent: if you stop the program with a breakpoint between + statements, you can then assign a new value to any variable or change + the program counter to any other statement in the function and get + exactly the results you would expect from the source code. + + Without `-O', only variables declared `register' are allocated in + registers. The resulting compiled code is a little worse than + produced by PCC without `-O'. + + With `-O', the compiler tries to reduce code size and execution time. + + Some of the `-f' options described below turn specific kinds of + optimization on or off. + +`-g' Produce debugging information in DBX format. - -`-c' - Compile but do not link the object files. - -`-o FILE' - Place linker output in file FILE. - -`-S' - Compile into assembler code but do not assemble. - -`-mMACHINESPEC' - Machine-dependent switch specifying something about the type - of target machine. For example, using the 68000 machine description, - `-m68000' specifies do not use the 68020 instructions, - and `-msoft-float' specifies do not use the 68881 floating point - instructions. - -`-dLETTERS' - Says to make debugging dumps at times specified by LETTERS. - Here are the possible letters: - - `t' - Dump syntax-tree. - `r' + + Unlike most other C compilers, GNU CC allows you to use `-g' with + `-O'. The shortcuts taken by optimized code may occasionally produce + surprising results: some variables you declared may not exist at all; + flow of control may briefly move where you did not expect it; some + statements may not be executed because they compute constant results + or their values were already at hand; some statements may execute in + different places because they were moved out of loops. Nevertheless + it proves possible to debug optimized output. This makes it + reasonable to use the optimizer for programs that might have bugs. + +`-gg' + Produce debugging information in GDB's own format. This requires the + GNU assembler and linker in order to work. + +`-w' + Inhibit all warning messages. + +`-W' + Print extra warning messages for these events: + + * An automatic variable is used without first being initialized. + + These warnings are possible only in optimizing compilation, + because they require data flow information that is computed only + when optimizing. They occur only for variables that are + candidates for register allocation. Therefore, they do not occur + for a variable that is declared `volatile', or whose address is + taken, or whose size is other than 1, 2, 4 or 8 bytes. Also, + they do not occur for structures, unions or arrays, even when + they are in registers. + + Note that there may be no warning about a variable that is used + only to compute a value that itself is never used, because such + computations may be deleted by the flow analysis pass before the + warnings are printed. + + These warnings are made optional because GNU CC is not smart + enough to see all the reasons why the code might be correct + despite appearing to have an error. Here is one example of how + this can happen: + + { + int x; + switch (y) + { + case 1: x = 1; + break; + case 2: x = 4; + break; + case 3: x = 5; + } + foo (x); + } + + If the value of `y' is always 1, 2 or 3, then `x' is always + initialized, but GNU CC doesn't know this. Here is another + common case: + + { + int save_y; + if (change_y) save_y = y, y = new_y; + ... + if (change_y) y = save_y; + } + + This has no bug because `x' is used only if it is set. + + * A nonvolatile automatic variable might be changed by a call to + `longjmp'. These warnings as well are possible only in + optimizing compilation. + + The compiler sees only the calls to `setjmp'. It cannot know + where `longjmp' will be called; in fact, a signal handler could + call it at any point in the code. As a result, you may get a + warning even when there is in fact no problem because `longjmp' + cannot in fact be called at the place which would cause a problem. + + * A function can return either with or without a value. (Falling + off the end of the function body is considered returning without + a value.) For example, this function would inspire such a warning: + + foo (a) + { + if (a > 0) + return a; + } + + Spurious warnings can occur because GNU CC does not realize that + certain functions (including `abort' and `longjmp') will never + return. + + In the future, other useful warnings may also be enabled by this option. + +`-Wimplicit' + Warn whenever a function is implicitly declared. + +`-Wreturn-type' + Warn whenever a function is defined with a return-type that defaults + to `int'. Also warn about any `return' statement with no return-value + in a function whose return-type is not `void'. + +`-Wcomment' + Warn whenever a comment-start sequence `/*' appears in a comment. + +`-Wall' + All of the above `-W' options combined. + +`-p' + Generate extra code to write profile information suitable for the + analysis program `prof'. + +`-pg' + Generate extra code to write profile information suitable for the + analysis program `gprof'. + +`-lLIBRARY' + Search a standard list of directories for a library named LIBRARY, + which is actually a file named `libLIBRARY.a'. The linker uses this + file as if it had been specified precisely by name. + + The directories searched include several standard system directories + plus any that you specify with `-L'. + + Normally the files found this way are library files---archive files + whose members are object files. The linker handles an archive file by + through it for members which define symbols that have so far been + referenced but not defined. But if the file that is found is an + ordinary object file, it is linked in the usual fashion. The only + difference between an `-l' option and the full file name of the file + that is found is syntactic and the fact that several directories are + searched. + +`-LDIR' + Add directory DIR to the list of directories to be searched for `-l'. + +`-nostdlib' + Don't use the standard system libraries and startup files when + linking. Only the files you specify (plus `gnulib') will be passed to + the linker. + +`-mMACHINESPEC' + Machine-dependent option specifying something about the type of target + machine. These options are defined by the macro `TARGET_SWITCHES' in + the machine description. The default for the options is also defined + by that macro, which enables you to change the defaults. + + These are the `-m' options defined in the 68000 machine description: + + `-m68020' + Generate output for a 68020 (rather than a 68000). This is the + default if you use the unmodified sources. + + `-m68000' + Generate output for a 68000 (rather than a 68020). + + `-m68881' + Generate output containing 68881 instructions for floating point. + This is the default if you use the unmodified sources. + + `-msoft-float' + Generate output containing library calls for floating point. + + `-mshort' + Consider type `int' to be 16 bits wide, like `short int'. + + `-mnobitfield' + Do not use the bit-field instructions. `-m68000' implies + `-mnobitfield'. + + `-mbitfield' + Do use the bit-field instructions. `-m68020' implies + `-mbitfield'. This is the default if you use the unmodified + sources. + + `-mrtd' + Use a different function-calling convention, in which functions + that take a fixed number of arguments return with the `rtd' + instruction, which pops their arguments while returning. This + saves one instruction in the caller since there is no need to pop + the arguments there. + + This calling convention is incompatible with the one normally + used on Unix, so you cannot use it if you need to call libraries + compiled with the Unix compiler. + + Also, you must provide function prototypes for all functions that + take variable numbers of arguments (including `printf'); + otherwise incorrect code will be generated for calls to those + functions. + + In addition, seriously incorrect code will result if you call a + function with too many arguments. (Normally, extra arguments are + harmlessly ignored.) + + The `rtd' instruction is supported by the 68010 and 68020 + processors, but not by the 68000. + + These `-m' options are defined in the Vax machine description: + + `-munix' + Do not output certain jump instructions (`aobleq' and so on) that + the Unix assembler for the Vax cannot handle across long ranges. + + `-mgnu' + Do output those jump instructions, on the assumption that you + will assemble with the GNU assembler. + + `-mg' + Output code for g-format floating point numbers instead of + d-format. + +`-fFLAG' + Specify machine-independent flags. These are the flags: + + `-ffloat-store' + Do not store floating-point variables in registers. This + prevents undesirable excess precision on machines such as the + 68000 where the floating registers (of the 68881) keep more + precision than a `double' is supposed to have. + + For most programs, the excess precision does only good, but a few + programs rely on the precise definition of IEEE floating point. + Use `-ffloat-store' for such programs. + + `-fno-asm' + Do not recognize `asm', `inline' or `typeof' as a keyword. These + words may then be used as identifiers. + + `-fno-defer-pop' + Always pop the arguments to each function call as soon as that + function returns. Normally the compiler (when optimizing) lets + arguments accumulate on the stack for several function calls and + pops them all at once. + + `-fcombine-regs' + Allow the combine pass to combine an instruction that copies one + register into another. This might or might not produce better + code when used in addition to `-O'. I am interested in hearing + about the difference this makes. + + `-fforce-mem' + Force memory operands to be copied into registers before doing + arithmetic on them. This may produce better code by making all + memory references potential common subexpressions. When they are + not common subexpressions, instruction combination should + eliminate the separate register-load. I am interested in hearing + about the difference this makes. + + `-fforce-addr' + Force memory address constants to be copied into registers before + doing arithmetic on them. This may produce better code just as + `-fforce-mem' may. I am interested in hearing about the + difference this makes. + + `-fomit-frame-pointer' + Don't keep the frame pointer in a register for functions that + don't need one. This avoids the instructions to save, set up and + restore frame pointers; it also makes an extra register available + in many functions. *It also makes debugging impossible.* + + On some machines, such as the Vax, this flag has no effect, + because the standard calling sequence automatically handles the + frame pointer and nothing is saved by pretending it doesn't + exist. The machine-description macro `FRAME_POINTER_REQUIRED' + controls whether a target machine supports this flag. *note + Registers::. + + `-finline-functions' + Integrate all simple functions into their callers. The compiler + heuristically decides which functions are simple enough to be + worth integrating in this way. + + If all calls to a given function are integrated, and the function + is declared `static', then the function is normally not output as + assembler code in its own right. + + `-fkeep-inline-functions' + Even if all calls to a given function are integrated, and the + function is declared `static', nevertheless output a separate + run-time callable version of the function. + + `-fwritable-strings' + Store string constants in the writable data segment and don't + uniquize them. This is for compatibility with old programs which + assume they can write into string constants. Writing into string + constants is a very bad idea; ``constants'' should be constant. + + `-fno-function-cse' + Do not put function addresses in registers; make each instruction + that calls a constant function contain the function's address + explicitly. + + This option results in less efficient code, but some strange + hacks that alter the assembler output may be confused by the + optimizations performed when this option is not used. + + `-fvolatile' + Consider all memory references through pointers to be volatile. + + `-funsigned-char' + Let the type `char' be the unsigned, like `unsigned char'. + + Each kind of machine has a default for what `char' should be. It + is either like `unsigned char' by default or like `signed char' + by default. (Actually, at present, the default is always signed.) + + The type `char' is always a distinct type from either `signed + char' or `unsigned char', even though its behavior is always just + like one of those two. + + `-fsigned-char' + Let the type `char' be signed, like `signed char'. + + `-ffixed-REG' + Treat the register named REG as a fixed register; generated code + should never refer to it (except perhaps as a stack pointer, + frame pointer or in some other fixed role). + + REG must be the name of a register. The register names accepted + are machine-specific and are defined in the `REGISTER_NAMES' + macro in the machine description macro file. + + `-fcall-used-REG' + Treat the register named REG as an allocatable register that is + clobbered by function calls. It may be allocated for temporaries + or variables that do not live across a call. Functions compiled + this way will not save and restore the register REG. + + Use of this flag for a register that has a fixed pervasive role + in the machine's execution model, such as the stack pointer or + frame pointer, will produce disastrous results. + + `-fcall-saved-REG' + Treat the register named REG as an allocatable register saved by + functions. It may be allocated even for temporaries or variables + that live across a call. Functions compiled this way will save + and restore the register REG if they use it. + + Use of this flag for a register that has a fixed pervasive role + in the machine's execution model, such as the stack pointer or + frame pointer, will produce disastrous results. + + A different sort of disaster will result from the use of this + flag for a register in which function values are may be returned. + +`-dLETTERS' + Says to make debugging dumps at times specified by LETTERS. Here are + the possible letters: + + `r' Dump after RTL generation. - `j' + `j' Dump after first jump optimization. - `s' - Dump after CSE. - `L' + `J' + Dump after last jump optimization. + `s' + Dump after CSE (including the jump optimization that sometimes + follows CSE). + `L' Dump after loop optimization. - `f' + `f' Dump after flow analysis. - `c' + `c' Dump after instruction combination. - `l' + `l' Dump after local register allocation. - `g' + `g' Dump after global register allocation. - -`-pedantic' - Attempt to support strict ANSI standard C. Valid ANSI standard C - programs should compile properly with or without this switch. - However, without this switch, certain useful or traditional constructs - banned by the standard are supported. With this switch, they are - rejected. There is no reason to use this switch; it exists only - to satisfy pedants. - -`E' - Preprocess the input files and output the results to standard output. - -`C' + `m' + Print statistics on memory usage, at the end of the run. + +`-pedantic' + Issue all the warnings demanded by strict ANSI standard C; reject all + programs that use forbidden extensions. + + Valid ANSI standard C programs should compile properly with or without + this option (though a rare few will require `-ansi'). However, + without this option, certain GNU extensions and traditional C features + are supported as well. With this option, they are rejected. There is + no reason to use this option; it exists only to satisfy pedants. + +These options control the C preprocessor, which is run on each C source +file before actual compilation. If you use the `-E' option, nothing is +done except C preprocessing. Some of these options make sense only +together with `-E' because they request preprocessor output that is not +suitable for actual compilation. + +`-C' Tell the preprocessor not to discard comments. Used with the `-E' - switch. - -`IDIR' + option. + +`-IDIR' Search directory DIR for include files. - -`DMACRO' + +`-I-' + Any directories specified with `-I' options before the `-I-' option + are searched only for the case of `#include "FILE"'; they are not + searched for `#include '. + + If additional directories are specified with `-I' options after the + `-I-', these directories are searched for all `#include' directives. + (Ordinarily *all* `-I' directories are used this way.) + + In addition, the `-I-' option inhibits the use of the current + directory as the first search directory for `#include "FILE"'. + Therefore, the current directory is searched only if it is requested + explicitly with `-I.'. Specifying both `-I-' and `-I.' allows you to + control precisely which directories are searched before the current + one and which are searched after. + +`-nostdinc' + Do not search the standard system directories for header files. Only + the directories you have specified with `-I' options (and the current + directory, if appropriate) are searched. + + Between `-nostdinc' and `-I-', you can eliminate all directories from + the search path except those you specify. + +`-M' + Tell the preprocessor to output a rule suitable for `make' describing + the dependencies of each source file. For each source file, the + preprocessor outputs one `make'-rule whose target is the object file + name for that source file and whose dependencies are all the files + `#include'd in it. This rule may be a single line or may be continued + with `\'-newline if it is long. + + `-M' implies `-E'. + +`-MM' + Like `-M' but the output mentions only the user-header files included + with `#include "FILE"'. System header files included with `#include + ' are omitted. + + `-MM' implies `-E'. + +`-DMACRO' Define macro MACRO with the empty string as its definition. - -`DMACRO=DEFN' + +`-DMACRO=DEFN' Define macro MACRO as DEFN. - -`UMACRO' + +`-UMACRO' Undefine macro MACRO. - -`w' - Inhibit warning messages. - -`v' - Compiler driver program prints the commands it executes as it runs - the preprocessor, compiler proper, assembler and linker. - -`BPREFIX' - Compiler driver program tries PREFIX as a prefix for each program - it tries to run. These programs are `cpp', `cc1', - `as' and `ld'. - - For each subprogram to be run, the compiler driver first tries the - `-B' prefix, if any. If that name is not found, or if `-B' - was not specified, the driver tries two standard prefixes, which are - `/usr/lib/gcc-' and `/usr/local/lib/gcc-'. If neither of - those results in a file name that is found, the unmodified program - name is searched for using the `PATH' environment variable. + +`-T' + Support ANSI C trigraphs. You don't want to know about this + brain-damage. The `-ansi' option also has this effect.  -File: internals Node: Installation, Prev: Switches, Up: Top, Next: Portability +File: internals, Node: Installation, Next: Trouble, Prev: Options, Up: Top Installing GNU CC ***************** - 1. Choose configuration files. - - * Make a symbolic link from file `config.h' to the top-level - config file for the machine you are using. Its name should be - `config-MACHINE.h'. This file is responsible for - defining information about the host machine. It includes - `tm.h'. - - * Make a symbolic link from `tm.h' to the machine-description - macro file for your machine (its name should be - `tm-MACHINE.h'). - - * Make a symbolic link from `md' to the - machine description pattern file (its name should be - `MACHINE.md'). - - * Make a symbolic link from - `aux-output.c' to the output-subroutine file for your machine - (its name should be `MACHINE-output.c'). - - 2. Make sure the Bison parser generator is installed. - - 3. Build the compiler. Just type `make' in the compiler directory. - - 4. Delete `*.o' in the compiler directory. The executables from - the previous step remain for the next step. - - 5. Remake the compiler with - - make CC=./gcc CFLAGS="-g -O -I." - - 6. Install the compiler's passes. Copy the file `cc1' just made - to `/usr/local/lib/gcc-cc1'. - - Make the file `/usr/local/lib/gcc-cpp' either a link to `/lib/cpp' - or a copy of the file `cpp' generated by `make'. - - *Warning: the GNU CPP may not work for @file{ioctl.h}.* This - cannot be fixed in the GNU CPP because the bug is in `ioctl.h': - at least on some machines, it relies on behavior that is incompatible - with ANSI C. This behavior consists of substituting for macro - argument names when they appear inside of character constants. - - 7. Install the compiler driver. This is the file `gcc' generated - by `make'. +Here is the procedure for installing GNU CC on a Unix system. - -File: internals Node: Portability, Prev: Installation, Up: Top, Next: Passes +* Menu: -GNU CC and Portability -********************** +* VMS Install:: See below for installation on VMS. -The main goal of GNU CC was to make a good, fast compiler for machines in -the class that the GNU system aims to run on: 32-bit machines that address -8-bit bytes and have several general registers. Elegance, theoretical -power and simplicity are only secondary. - -GNU CC gets most of the information about the target machine from a machine -description which gives an algebraic formula for each of the machine's -instructions. This is a very clean way to describe the target. But when -the compiler needs information that is difficult to express in this -fashion, I have not hesitated to define an ad-hoc parameter to the machine -description. The purpose of portability is to reduce the total work needed -on the compiler; it was not of interest for its own sake. - -GNU CC does not contain machine dependent code, but it does contain code -that depends on machine parameters such as endianness (whether the most -significant byte has the highest or lowest address of the bytes in a word) -and the availability of autoincrement addressing. In the RTL-generation -pass, it is often necessary to have multiple strategies for generating code -for a particular kind of syntax tree, strategies that are usable for different -combinations of parameters. Often I have not tried to address all possible -cases, but only the common ones or only the ones that I have encountered. -As a result, a new target may require additional strategies. You will know -if this happens because the compiler will call `abort'. Fortunately, -the new strategies can be added to all versions of the compiler, and will -be relevant only for target machines that need them. - -File: internals Node: Passes, Prev: Portability, Up: Top, Next: RTL + 1. Edit `Makefile'. If you are using HPUX, you must make a few changes + described in comments at the beginning of the file. -Passes and Files of the Compiler -******************************** + 2. Choose configuration files. -The overall control structure of the compiler is in `toplev.c'. This -file is responsible for initialization, decoding arguments, opening and -closing files, and sequencing the passes. - -The parsing pass is invoked only once, to parse the entire input. Each -time a complete function definition or top-level data definition is read, -the parsing pass calls the function `rest_of_compilation' in -`toplev.c', which is responsible for all further processing necessary, -ending with output of the assembler language. All other compiler passes -run, in sequence, within `rest_of_compilation'. After -`rest_of_compilation' returns from compiling a function definition, -the storage used for its compilation is entirely freed. - -Here is a list of all the passes of the compiler and their source files. -Also included is a description of where debugging dumps can be requested -with `-d' switches. - - * Parsing. This pass reads the entire text of a function definition, - constructing a syntax tree. The tree representation does not entirely - follow C syntax, because it is intended to support other languages as well. - - C data type analysis is also done in this pass, and every tree node that - represents an expression has a data type attached. Variables are represented - as declaration nodes. - - Constant folding and associative-law simplifications are also done during - this pass. - - The source files of the parsing pass are `parse.y', `decl.c', - `typecheck.c', `stor-layout.c', `fold-const.c', and - `tree.c'. The last three are intended to be language-independent. - There are also header files `parse.h', `c-tree.h', - `tree.h' and `tree.def'. The last two define the format of - the tree representation. - - * RTL generation. This pass converts the tree structure for one - function into RTL code. - - This is where the bulk of target-parameter-dependent code is found, - since often it is necessary for strategies to apply only when certain - standard kinds of instructions are available. The purpose of named - instruction patterns is to provide this information to the RTL - generation pass. - - Optimization is done in this pass for `if'-conditions that are - comparisons, boolean operations or conditional expressions. Tail - recursion is detected at this time also. Decisions are made about how - best to arrange loops and how to output `switch' statements. - - The files of the RTL generation pass are `stmt.c', `expr.c', - `explow.c', `expmed.c', `optabs.c' and `emit-rtl.c'. - Also, the file `insn-emit.c', generated from the machine description - by the program `genemit', is used in this pass. The header files - `expr.h' is used for communication within this pass. - - The header files `insn-flags.h' and `insn-codes.h', generated from - the machine description by the programs `genflags' and `gencodes', - tell this pass which standard names are available for use and which patterns - correspond to them. - - Aside from debugging information output, none of the following passes - refers to the tree structure representation of the function. - - The switch `-dr' causes a debugging dump of the RTL code after this - pass. This dump file's name is made by appending `.rtl' to the - input file name. - - * Jump optimization. This pass simplifies jumps to the following instruction, - jumps across jumps, and jumps to jumps. It deletes unreferenced labels - and unreachable code, except that unreachable code that contains a loop - is not recognized as unreachable in this pass. (Such loops are deleted - later in the basic block analysis.) - - Jump optimization is performed two or three times. The first time is - immediately following RTL generation. - - The source file of this pass is `jump.c'. - - The switch `-dj' causes a debugging dump of the RTL code after this - pass is run for the first time. This dump file's name is made by appending - `.jump' to the input file name. - - * Register scan. This pass finds the first and last use of each - register, as a guide for common subexpression elimination. Its source - is in `regclass.c'. - - * Common subexpression elimination. This pass also does constant - propagation. Its source file is `cse.c'. If constant - propagation causes conditional jumps to become unconditional or to - become no-ops, jump optimization is run again when cse is finished. - - The switch `-ds' causes a debugging dump of the RTL code after - this pass. This dump file's name is made by appending `.cse' to - the input file name. - - * Loop optimization. This pass moves constant expressions out of loops. - Its source file is `loop.c'. - - The switch `-dL' causes a debugging dump of the RTL code after - this pass. This dump file's name is made by appending `.loop' to - the input file name. - - * Stupid register allocation is performed at this point in a - nonoptimizing compilation. It does a little data flow analysis as - well. When stupid register allocation is in use, the next pass - executed is the reloading pass; the others in between are skipped. - The source file is `stupid.c', with header file `stupid.h' - used for communication with the RTL generation pass. - - * Data flow analysis (`flow.c'). This pass divides the program - into basic blocks (and in the process deletes unreachable loops); then - it computes which pseudo-registers are live at each point in the - program, and makes the first instruction that uses a value point at - the instruction that computed the value. - - This pass also deletes computations whose results are never used, and - combines memory references with add or subtract instructions to make - autoincrement or autodecrement addressing. - - The switch `-df' causes a debugging dump of the RTL code after - this pass. This dump file's name is made by appending `.flow' to - the input file name. If stupid register allocation is in use, this - dump file reflects the full results of such allocation. - - * Instruction combination (`combine.c'). This pass attempts to - combine groups of two or three instructions that are related by data - flow into single instructions. It combines the RTL expressions for - the instructions by substitution, simplifies the result using algebra, - and then attempts to match the result against the machine description. - - The switch `-dc' causes a debugging dump of the RTL code after - this pass. This dump file's name is made by appending `.combine' - to the input file name. - - * Register class preferencing. The RTL code is scanned to find out - which register class is best for each pseudo register. The source file - is `regclass.c'. - - * Local register allocation (`local-alloc.c'). This pass allocates - hard registers to pseudo registers that are used only within one basic - block. Because the basic block is linear, it can use fast and powerful - techniques to do a very good job. - - The switch `-dl' causes a debugging dump of the RTL code after - this pass. This dump file's name is made by appending `.lreg' to - the input file name. - - * Global register allocation (`global-alloc.c'). This pass - allocates hard registers for the remaining pseudo registers (those - whose life spans are not contained in one basic block). - - * Reloading. This pass finds instructions that are invalid because a - value has failed to end up in a register, or has ended up in a - register of the wrong kind. It fixes up these instructions by - reloading the problematical values into registers temporarily. - Additional instructions are generated to do the copying. - - Source files are `reload.c' and `reload1.c', plus the header - `reload.h' used for communication between them. - - The switch `-dg' causes a debugging dump of the RTL code after - this pass. This dump file's name is made by appending `.greg' to - the input file name. - - * Jump optimization is repeated, this time including cross-jumping. - - * Final. This pass outputs the assembler code for the function. It is - also responsible for identifying no-op move instructions and spurious - test and compare instructions. The function entry and exit sequences - are generated directly as assembler code in this pass; they never - exist as RTL. Pseudo registers that did not get hard registers are - given stack slots in this pass. - - The source files are `final.c' plus `insn-output.c'; the - latter is generated automatically from the machine description by the - tool `genoutput'. The header file `conditions.h' is used - for communication between these files. - - * Debugging information output. This is run after final because it must - output the stack slot offsets for pseudo registers that did not get - hard registers. Source files are `dbxout.c' for DBX symbol table - format and `symout.c' for GDB's own symbol table format. - -Some additional files are used by all or many passes: - - * Every pass uses `machmode.def', which defines the machine modes. - - * All the passes that work with RTL use the header files `rtl.h' - and `rtl.def', and subroutines in file `rtl.c'. The - tools `gen*' also use these files to read and work with the - machine description RTL. - - * Several passes refer to the header file `insn-config.h' which - contains a few parameters (C macro definitions) generated - automatically from the machine description RTL by the tool - `genconfig'. - - * Several passes use the instruction recognizer, which consists of - `recog.c' and `recog.h', plus the files `insn-recog.c' - and `insn-extract.c' that are generated automatically from the - machine description by the tools `genrecog' and `genextract'. - - * Several passes use the header file `regs.h' which defines the - information recorded about pseudo register usage, `basic-block.h' - which defines the information recorded about basic blocks. - - * `hard-reg-set.h' defines the type `HARD_REG_SET', a bit-vector - with a bit for each hard register, and some macros to manipulate it. - This type is just `int' if the machine has few enough hard registers; - otherwise it is an array of `int' and some of the macros expand - into loops. + * Make a symbolic link named `config.h' to the top-level config + file for the machine you are using (*Note Config::.). This file + is responsible for defining information about the host machine. + It includes `tm.h'. - -File: internals Node: RTL, Prev: Passes, Up: Top, Next: Machine Desc + The file's name should be `config-MACHINE.h'. On VMS, use + `config-vms.h' rather than `config-vax.h'. On the HP 9000 series + 300, use `config-hp9k3.h' rather than `config-m68k.h'. -RTL Representation -****************** + If your system does not support symbolic links, you might want to + set up `config.h' to contain a `#include' command which refers to + the appropriate file. -Most of the work of the compiler is done on an intermediate representation -called register tranfer language. In this language, the instructions to be -output are described, pretty much one by one, in an algebraic form that -describes what the instruction does. - -RTL is inspired by Lisp lists. It has both an internal form, made up of -structures that point at other structures, and a textual form that is used -in the machine description and in printed debugging dumps. The textual -form uses nested parentheses to indicate the pointers in the internal form. + * Make a symbolic link named `tm.h' to the machine-description + macro file for your machine (its name should be `tm-MACHINE.h'). -* Menu: + For the 68000/68020, do not use `tm-m68k.h' directly; instead use + one of the files `tm-sun3.h', `tm-sun2.h', `tm-isi68.h', + `tm-news800.h' or `tm-3b1.h'. Each of those files includes + `tm-m68k.h' but sets up a few things differently as appropriate + to the specific model of machine. -* RTL Objects:: Expressions vs vectors vs strings vs integers. -* Accessors:: Macros to access expression operands or vector elts. -* Machine Modes:: Describing the size and format of a datum. -* Constants:: Expressions with constant values. -* Regs and Memory:: Expressions representing register contents or memory. -* Arithmetic:: Expressions representing arithmetic on other expressions. -* Comparisons:: Expressions representing comparison of expressions. -* Bit Fields:: Expressions representing bit-fields in memory or reg. -* Conversions:: Extending, truncating, floating or fixing. -* RTL Declarations:: Declaring volatility, constancy, etc. -* Side Effects:: Expressions for storing in registers, etc. -* Incdec:: Embedded side-effects for autoincrement addressing. -* Insns:: Expression types for entire insns. -* Sharing:: Some expressions are unique; others *must* be copied. + There are two files you can use for a 680x0 running HPUX: + `tm-hp9k320.h' and `tm-hp9k320g.h'. Use the former if you are + installing GNU CC alone. The latter is for another option where + GNU CC together with the GNU assembler, linker, debugger and + other utilities are used to replace all of HPUX that deals with + compilation. Not all of the pieces of GNU software needed for + this mode of operation are as yet in distribution; full + instructions will appear here in the future. - -File: internals Node: RTL Objects, Prev: RTL, Up: RTL, Next: Accessors + For the 32000, use `tm-sequent.h' if you are using a Sequent + machine, or `tm-encore.h' for an Encore machine; otherwise, + perhaps `tm-ns32k.h' will work for you. -RTL Object Types -================ + For the vax, use `tm-vax.h' on Unix, or `tm-vms.h' on VMS. -RTL uses four kinds of objects: expressions, integers, strings and vectors. -Expressions are the most important ones. An RTL expression is a C -structure, but it is usually referred to with a pointer; a type that is -given the typedef name `rtx'. - -An integer is simply an `int', and a string is a `char *'. -Within rtl code, strings appear only inside `symbol_ref' expressions, -but they appear in other contexts in the rtl expressions that make up -machine descriptions. Their written form uses decimal digits. - -A string is a sequence of characters. In core it is represented as a -`char *' in usual C fashion, and they are written in C syntax as well. -However, strings in RTL may never be null. If you write an empty string in -a machine description, it is represented in core as a null pointer rather -than as a pointer to a null character. In certain contexts, these null -pointers instead of strings are valid. - -A vector contains an arbitrary, specified number of pointers to -expressions. The number of elements in the vector is explicitly present in -the vector. The written form of a vector consists of square brackets -(`[...]') surrounding the elements, in sequence and with -whitespace separating them. Vectors of length zero are not created; null -pointers are used instead. - -Expressions are classified by "expression code". The expression code -is a name defined in `rtl.def', which is also (in upper case) a C -enumeration constant. The possible expression codes and their meanings are -machine-independent. The code of an rtx can be extracted with the macro -`GET_CODE (X)' and altered with `PUT_CODE (X, -NEWCODE)'. - -The expression code determines how many operands the expression contains, -and what kinds of objects they are. In RTL, unlike Lisp, you cannot tell -by looking at an operand what kind of object it is. Instead, you must know -from its context---from the expression code of the containing expression. -For example, in an expression of code `subreg', the first operand is -to be regarded as an expression and the second operand as an integer. In -an expression of code `plus', there are two operands, both of which -are to be regarded as expressions. In a `symbol_ref' expression, -there is one operand, which is to be regarded as a string. - -Expressions are written as parentheses containing the name of the -expression type, its flags and machine mode if any, and then the operands -of the expression (separated by spaces). + * Make a symbolic link named `md' to the machine description + pattern file (its name should be `MACHINE.md'). -In a few contexts a null pointer is valid where an expression is normally -wanted. The written form of this is `(nil)'. + * Make a symbolic link named `aux-output.c' to the output + subroutine file for your machine (its name should be + `OUTPUT-MACHINE.c'). - -File: internals Node: Accessors, Prev: RTL Objects, Up: RTL, Next: Machine Modes + 3. Make sure the Bison parser generator is installed. (This is unnecessary + if the Bison output file `parse.tab.c' is more recent than `parse.y' + and you do not plan to change `parse.y'.) -Access to Operands -================== + Note that if you have an old version of Bison you may get an error + from the line with the `%expect' directive. If so, simply remove that + line from `parse.y' and proceed. -For each expression type `rtl.def' specifies the number of contained -objects and their kinds, with four possibilities: `e' for expression -(actually a pointer to an expression), `i' for integer, `s' for -string, and `E' for vector of expressions. The sequence of letters -for an expression code is called its "format". Thus, the format of -`subreg' is `ei'. - -Two other format characters are used occasionally: `u' and `0'. -`u' is equivalent to `e' except that it is printed differently in -debugging dumps, and `0' means a slot whose contents do not fit any -normal category. `0' slots are not printed at all in dumps, and are -often used in special ways by small parts of the compiler. - -There are macros to get the number of operands and the format of an -expression code: - -`GET_RTX_LENGTH (CODE)' - Number of operands of an rtx of code CODE. - -`GET_RTX_FORMAT (CODE)' - The format of an rtx of code CODE, as a C string. - -Operands of expressions are accessed using the macros `XEXP', -`XINT' and `XSTR'. Each of these macros takes two arguments: an -expression-pointer (rtx) and an operand number (counting from zero). Thus, - - XEXP (x, 2) - -accesses operand 2 of expression X, as an expression. - - XINT (x, 2) - -accesses the same operand as an integer. `XSTR', used in the same -fashion, would access it as a string. - -Any operand can be accessed as an integer, as an expression or as a string. -You must choose the correct method of access for the kind of value actually -stored in the operand. You would do this based on the expression code of -the containing expression. That is also how you would know how many -operands there are. - -For example, if X is a `subreg' expression, you know that it has -two operands which can be correctly accessed as `XEXP (x, 0)' and -`XINT (x, 1)'. If you did `XINT (x, 0)', you would get the -address of the expression operand but cast as an integer; that might -occasionally be useful, but it would be cleaner to write `(int) XEXP -(x, 0)'. `XEXP (x, 1)' would also compile without error, and would -return the second, integer operand cast as an expression pointer, which -would probably result in a crash when accessed. Nothing stops you from -writing `XEXP (x, 28)' either, but this will access memory past the -end of the expression with unpredictable results. - -Access to operands which are vectors is more complicated. You can use the -macro `XVEC' to get the vector-pointer itself, or the macros -`XVECEXP' and `XVECLEN' to access the elements and length of a -vector. - -`XVEC (EXP, IDX)' - Access the vector-pointer which is operand number IDX in EXP. - -`XVECLEN (EXP, IDX)' - Access the length (number of elements) in the vector which is - in operand number IDX in EXP. This value is an `int'. - -`XVECLEN (EXP, IDX, ELTNUM)' - Access element number ELTNUM in the vector which is - in operand number IDX in EXP. This value is an `rtx'. - - It is up to you to make sure that ELTNUM is not negative - and is less than `XVECLEN (EXP, IDX)'. - -All the macros defined in this section expand into lvalues and therefore -can be used to assign the operands, lengths and vector elements as well as -to access them. + 4. If you are using a Sun, make sure the environment variable + `FLOAT_OPTION' is not set. If this option were set to `f68881' when + `gnulib' is compiled, the resulting code would demand to be linked + with a special startup file and will not link properly without special + pains. - -File: internals Node: Machine Modes, Prev: Accessors, Up: RTL, Next: Constants + 5. Build the compiler. Just type `make' in the compiler directory. + + 6. Move the first-stage object files and executables into a subdirectory + with this command: + + make stage1 + + The files are moved into a subdirectory named `stage1'. Once + installation is complete, you may wish to delete these files with `rm + -r stage1'. + + 7. Recompile the compiler with itself, with this command: + + make CC=stage1/gcc CFLAGS="-g -O -Bstage1/" + + On a 68000 or 68020 system lacking floating point hardware, unless you + have selected a `tm.h' file that expects by default that there is no + such hardware, do this instead: + + make CC=stage1/gcc CFLAGS="-g -O -Bstage1/ -msoft-float" + + 8. If you wish to test the compiler by compiling it with itself one more + time, do this: + + make stage2 + make CC=stage2/gcc CFLAGS="-g -O -Bstage2/" + foreach file (*.o) + cmp $file stage2/$file + end + + This will notify you if any of these stage 3 object files differs from + those of stage 2. Any difference, no matter how innocuous, indicates + that the stage 2 compiler has compiled GNU CC incorrectly, and is + therefore a potentially serious bug which you should investigate and + report (*Note Bugs::.). + + 9. Install the compiler driver, the compiler's passes and run-time support. + You can use the following command: + + make install -Machine Modes -============= + This copies the files `cc1', `cpp' and `gnulib' to files `gcc-cc1', + `gcc-cpp' and `gcc-gnulib' in directory `/usr/local/lib', which is + where the compiler driver program looks for them. It also copies the + driver program `gcc' into the directory `/usr/local', so that it + appears in typical execution search paths. -A machine mode describes a size of data object and the representation used -for it. In the C code, machine modes are represented by an enumeration -type, `enum machine_mode'. Each rtl expression has room for a machine -mode and so do certain kinds of tree expressions (declarations and types, -to be precise). - -In debugging dumps and machine descriptions, the machine mode of an RTL -expression is written after the expression code with a colon to separate -them. The letters `mode' which appear at the end of each machine mode -name are omitted. For example, `(reg:SI 38)' is a `reg' -expression with machine mode `SImode'. If the mode is -`VOIDmode', it is not written at all. - -Here is a table of machine modes. - -`QImode' - "Quarter-Integer" mode represents a single byte treated as an integer. - -`HImode' - "Half-Integer" mode represents a two-byte integer. - -`SImode' - "Single Integer" mode represents a four-byte integer. - -`DImode' - "Double Integer" mode represents an eight-byte integer. - -`TImode' - "Tetra Integer" (?) mode represents a sixteen-byte integer. - -`SFmode' - "Single Floating" mode represents a single-precision (four byte) floating - point number. - -`DFmode' - "Double Floating" mode represents a double-precision (eight byte) floating - point number. - -`TFmode' - "Tetra Floating" mode represents a quadruple-precision (sixteen byte) - floating point number. - -`BLKmode' - "Block" mode represents values that are aggregates to which none of - the other modes apply. In rtl, only memory references can have this mode, - and only if they appear in string-move or vector instructions. On machines - which have no such instructions, `BLKmode' will not appear in RTL. - -`VOIDmode' - Void mode means the absence of a mode or an unspecified mode. - For example, RTL expresslons of code `const_int' have mode - `VOIDmode' because they can be taken to have whatever mode the context - requires. In debugging dumps of RTL, `VOIDmode' is expressed by - the absence of any mode. - -`EPmode' - "Entry Pointer" mode is intended to be used for function variables in - Pascal and other block structured languages. Such values contain - both a function address and a static chain pointer for access to - automatic variables of outer levels. This mode is only partially - implemented since C does not use it. - -`CSImode, ...' - "Complex Single Integer" mode stands for a complex number represented - as a pair of `SImode' integers. Any of the integer and floating modes - may have `C' prefixed to its name to obtain a complex number mode. - For example, there are `CQImode', `CSFmode', and `CDFmode'. - Since C does not support complex numbers, these machine modes are only - partially implemented. - -`BImode' - This is the machine mode of a bit-field in a structure. It is used - only in the syntax tree, never in RTL, and in the syntax tree it appears - only in declaration nodes. In C, it appears only in `FIELD_DECL' - nodes for structure fields defined with a bit size. - -The machine description defines `Pmode' as a C macro which expands -into the machine mode used for addresses. Normally this is `SImode'. - -The only modes which a machine description must support are -`QImode', `SImode', `SFmode' and `DFmode'. The -compiler will attempt to use `DImode' for two-word structures and -unions, but it would not be hard to program it to avoid this. Likewise, -you can arrange for the C type `short int' to avoid using -`HImode'. In the long term it would be desirable to make the set of -available machine modes machine-dependent and eliminate all assumptions -about specific machine modes or their uses from the machine-independent -code of the compiler. - -Here are some C macros that relate to machine modes: - -`GET_MODE (X)' - Returns the machine mode of the rtx X. - -`PUT_MODE (X, NEWMODE)' - Alters the machine mode of the rtx X to be NEWMODE. - -`GET_MODE_SIZE (M)' - Returns the size in bytes of a datum of mode M. - -`GET_MODE_BITSIZE (M)' - Returns the size in bits of a datum of mode M. - -`GET_MODE_UNIT_SIZE (M)' - Returns the size in bits of the subunits of a datum of mode M. - This is the same as `GET_MODE_SIZE' except in the case of - complex modes and `EPmode'. For them, the unit size ithe - size of the real or imaginary part, or the size of the function - pointer or the context pointer. + *Warning: the GNU CPP may not work for `ioctl.h', `ttychars.h' and + other system header files unless the `-traditional' option is used.* + The bug is in the header files: at least on some machines, they rely + on behavior that is incompatible with ANSI C. This behavior consists + of substituting for macro argument names when they appear inside of + character constants. The `-traditional' option tells GNU CC to behave + the way these headers expect. + + Because of this problem, you might prefer to configure GNU CC to use + the system's own C preprocessor. To do so, make the file + `/usr/local/lib/gcc-cpp' a link to `/lib/cpp'. + + Alternatively, on Sun systems and 4.3BSD at least, you can correct the + include files by running the shell script `fixincludes'. This + installs modified, corrected copies of the files `ioctl.h' and + `ttychars.h' in a special directory where only GNU CC will normally + look for them. + + The file `/usr/include/vaxuba/qvioctl.h' used in the X window system + needs a similar correction. + +If you cannot install the compiler's passes and run-time support in +`/usr/local/lib', you can alternatively use the `-B' option to specify a +prefix by which they may be found. The compiler concatenates the prefix +with the names `cpp', `cc1' and `gnulib'. Thus, you can put the files in +a directory `/usr/foo/gcc' and specify `-B/usr/foo/gcc/' when you run GNU CC.  -File: internals Node: Constants, Prev: Machine Modes, Up: RTL, Next: Regs and Memory +File: internals, Node: VMS Install, Prev: Installation, Up: Installation + +Installing GNU CC on VMS +======================== + +The VMS version of GNU CC is distributed in an unusual tape format which +consists of several tape files. The first is a command file; the second is +an executable program which reads Unix tar format; the third is another +command file which uses this program to read the remainder of the tape. + +To load the tape, it suffices to mount it `/foreign' and then do `@mta0:' +to execute the command file at the beginning of the tape. + +The tape contains executables and object files as well as sources, so no +compilation is necessary unless you change the sources. (This is a good +thing, since you probably don't have any other C compiler.) If you must +recompile, here is how: -Constant Expression Types -========================= + 1. Copy the file `tm-vms.h' to `tm.h', `config-vms.h' to `config.h', + `vax.md' to `md.' and `output-vax.c' to `aux-output.c'. -The simplest RTL expressions are those that represent constant values. + 2. Type `@make' to do recompile everything. -`(const_int I)' - This type of expression represents the integer value I. I - is customarily accessed with the macro `INTVAL' as in - `INTVAL (exp)', which is equivalent to `XINT (exp, 0)'. - - There is only one expression object for the integer value zero; - it is the value of the variable `const0_rtx'. Likewise, the - only expression for integer value one is found in `const1_rtx'. - Any attempt to create an expression of code `const_int' and - value zero or one will return `const0_rtx' or `const1_rtx' - as appropriate. - -`(const_double:M I0 I1)' - Represents a floating point constant value of mode M. The two - integers I0 and I1 together contain the bits of a - `double' value. To convert them to a `double', do - - union { double d; int i[2];} u; - u.i[0] = XINT (x, 0); - u.i[1] = XINT (x, 1); - - and then refer to `u.d'. The value of the constant is - represented as a double in this fashion even if the value represented - is single-precision. - - `dconst0_rtx' and `fconst0_rtx' are `CONST_DOUBLE' - expressions with value 0 and modes `DFmode' and `SFmode'. - -`(symbol_ref SYMBOL)' - Represents the value of an assembler label for data. SYMBOL is - a string that describes the name of the assembler label. If it starts - with a `*', the label is the rest of SYMBOL not including - the `*'. Otherwise, the label is SYMBOL, prefixed with - `_'. - -`(label_ref LABEL)' - Represents the value of an assembler label for code. It contains one - operand, an expression, which must be a `code_label' that appears - in the instruction sequence to identify the place where the label - should go. - - The reason for using a distinct expression type for code label - references is so that jump optimization can distinguish them. - -`(const EXP)' - Represents a constant that is the result of an assembly-time - arithmetic computation. The operand, EXP, is an expression that - contains only constants (`const_int', `symbol_ref' and - `label_ref' expressions) combined with `plus' and - `minus'. However, not all combinations are valid, since the - assembler cannot do arbitrary arithmetic on relocatable symbols. +To install the `GCC' command so you can use the compiler easily, in the +same manner as you use the VMS C compiler, you must install the VMS CLD +file for GNU CC as follows: + + 1. Define the VMS logical names `GNU_CC' and `GNU_CC_INCLUDE' to point to + the directories where the GNU CC executables (`gcc-cpp', `gcc-cc1', + etc.) and the C include files are kept. This should be done with the + commands: + + $ assign /super /system disk:[gcc] gnu_cc + $ assign /super /system disk:[gcc.include] gnu_cc_include + + with the appropriate disk and directory names. These commands can be + placed in your system startup file so they will be executed whenever + the machine is rebooted. + + 2. Install the `GCC' command with the command line: + + $ set command /table=sys$library:dcltables gnu_cc:gcc + + Now you can invoke the compiler with a command like `gcc /verbose + file.c', which is equivalent to the command `gcc -v -c file.c' in Unix.  -File: internals Node: Regs and Memory, Prev: Constants, Up: RTL, Next: Arithmetic +File: internals, Node: Trouble, Next: Incompatibilities, Prev: Installation, Up: Top + +Trouble in Installation +*********************** -Registers and Memory -==================== +Here are some of the things that have caused trouble for people installing +GNU CC. -Here are the RTL expression types for describing access to machine -registers and to main memory. -`(reg:M N)' - For small values of the integer N (less than - `FIRST_PSEUDO_REGISTER'), this stands for a reference to machine - register number N: a "hard register". For larger values of - N, it stands for a temporary value or "pseudo register". - The compiler's strategy is to generate code assuming an unlimited - number of such pseudo registers, and later convert them into hard - registers or into memory references. - - The symbol `FIRST_PSEUDO_REGISTER' is defined by the machine - description, since the number of hard registers on the machine is an - invariant characteristic of the machine. Note, however, that not - all of the machine registers must be general registers. All the - machine registers that can be used for storage of data are given - hard register numbers, even those that can be used only in certain - instructions or can hold only certain types of data. - - Each pseudo register number used in a function's rtl code is - represented by a unique `reg' expression. - - M is the machine mode of the reference. It is necessary because - machines can generally refer to each register in more than one mode. - For example, a register may contain a full word but there may be - instructions to refer to it as a half word or as a single byte, as - well as instructions to refer to it as a floating point number of - various precisions. - - Even for a register that the machine can access in only one mode, - the mode must always be specified. - - A hard register may be accessed in various modes throughout one - function, but each pseudo register is given a natural mode - and is accessed only in that mode. When it is necessary to describe - an access to a pseudo register using a nonnatural mode, a `subreg' - expression is used. - - A `reg' expression with a machine mode that specifies more than - one word of data may actually stand for several consecutive registers. - If in addition the register number specifies a hardware register, then - it actually represents several consecutive hardware registers starting - with the specified one. - - Such multi-word hardware register `reg' expressions may not be live - across the boundary of a basic block. The lifetime analysis pass does not - know how to record properly that several consecutive registers are - actually live there, and therefore register allocation would be confused. - The CSE pass must go out of its way to make sure the situation does - not arise. - -`(subreg:M REG WORDNUM)' - `subreg' expressions are used to refer to a register in a machine - mode other than its natural one, or to refer to one register of - a multi-word `reg' that actually refers to several registers. - - Each pseudo-register has a natural mode. If it is necessary to - operate on it in a different mode---for example, to perform a fullword - move instruction on a pseudo-register that contains a single byte--- - the pseudo-register must be enclosed in a `subreg'. In such - a case, WORDNUM is zero. - - The other use of `subreg' is to extract the individual registers - of a multi-register value. Machine modes such as `DImode' and - `EPmode' indicate values longer than a word, values which usually - require two consecutive registers. To access one of the registers, - use a `subreg' with mode `SImode' and a WORDNUM that - says which register. - - The compilation parameter `WORDS_BIG_ENDIAN', if defined, says - that word number zero is the most significant part; otherwise, it is - the least significant part. - - Note that it is not valid to access a `DFmode' value in `SFmode' - using a `subreg'. On some machines the most significant part of a - `DFmode' value does not have the same format as a single-precision - floating value. - -`(cc0)' - This refers to the machine's condition code register. It has no - operands and may not have a machine mode. It may be validly used in - only two contexts: as the destination of an assignment (in test and - compare instructions) and in comparison operators comparing against - zero (`const_int' with value zero; that is to say, - `const0_rtx'. - - There is only one expression object of code `cc0'; it is the - value of the variable `cc0_rtx'. Any attempt to create an - expression of code `cc0' will return `cc0_rtx'. - - One special thing about the condition code register is that instructions - can set it implicitly. On many machines, nearly all instructions set - the condition code based on the value that they compute or store. - It is not necessary to record these actions explicitly in the RTL - because the machine description includes a prescription for recognizing - the instructions that do so (by means of the macro `NOTICE_UPDATE_CC'). - Only instructions whose sole purpose is to set the condition code, - and instructions that use the condition code, need mention `(cc0)'. - -`(pc)' - This represents the machine's program counter. It has no operands and - may not have a machine mode. `(pc)' may be validly used only in - certain specific contexts in jump instructions. - - There is only one expression object of code `pc'; it is the value of - the variable `pc_rtx'. Any attempt to create an expression of code - `pc' will return `pc_rtx'. - - All instructions that do not jump alter the program counter implicitly, - but there is no need to mention this in the RTL. - -`(mem:M ADDR)' - This rtx represents a reference to main memory at an address - represented by the expression ADDR. M specifies how - large a unit of memory is accessed. + + On certain systems, defining certain environment variables such as + `CC' can interfere with the functioning of `make'.  -File: internals Node: Arithmetic, Prev: Regs and Memory, Up: RTL, Next: Comparisons +File: internals, Node: Incompatibilities, Next: Extensions, Prev: Trouble, Up: Top + +Incompatibilities of GNU CC +*************************** + +There are several noteworthy incompatibilities between GNU C and most +existing (non-ANSI) versions of C. + +Ultimately our intention is that the `-traditional' option will eliminate +most of these incompatibilities by telling GNU C to behave like the other C +compilers. + + * GNU CC normally makes string constants read-only. If several + identical-looking string constants are used, GNU CC stores only one + copy of the string. + + One consequence is that you cannot call `mktemp' with a string + constant argument. The function `mktemp' always alters the string its + argument points to. + + Another consequence is that `sscanf' does not work on some systems + when passed a string constant as its format control string. This is + because `sscanf' incorrectly tries to write into the string constant. + + The best solution to these problems is to change the program to use + `char'-array variables with initialization strings for these purposes + instead of string constants. But if this is not possible, you can use + the `-fwritable-strings' flag, which directs GNU CC to handle string + constants the same way most C compilers do. + + * GNU CC does not substitute macro arguments when they appear inside of + string constants. For example, the following macro in GNU CC + + #define foo(a) "a" + + will produce output `"a"' regardless of what the argument A is. + + The `-traditional' option directs GNU CC to handle such cases (among + others) in the old-fashioned (non-ANSI) fashion. + + * When you use `setjmp' and `longjmp', the only automatic variables + guaranteed to remain valid are those declared `volatile'. This is a + consequence of automatic register allocation. Consider this function: + + jmp_buf j; + + foo () + { + int a, b; + + a = fun1 (); + if (setjmp (j)) + return a; + + a = fun2 (); + /* `longjmp (j)' may be occur in `fun3'. */ + return a + fun3 (); + } + + Here `a' may or may not be restored to its first value when the + `longjmp' occurs. If `a' is allocated in a register, then its first + value is restored; otherwise, it keeps the last value stored in it. + + If you use the `-W' option with the `-O' option, you will get a + warning when GNU CC thinks such a problem might be possible. + + * Declarations of external variables and functions within a block apply + only to the block containing the declaration. In other words, they + have the same scope as any other declaration in the same place. + + In some other C compilers, a `extern' declaration affects all the rest + of the file even if it happens within a block. + + The `-traditional' option directs GNU C to treat all `extern' + declarations as global, like traditional compilers. + + * In traditional C, you can combine `long', etc., with a typedef name, + as shown here: + + typedef int foo; + typedef long foo bar; + + In ANSI C, this is not allowed: `long' and other type modifiers + require an explicit `int'. Because this criterion is expressed by + Bison grammar rules rather than C code, the `-traditional' flag cannot + alter it. + + * When compiling functions that return structures or unions, GNU CC + output code uses a method different from that used on most versions of + Unix. As a result, code compiled with GNU CC cannot call a + structure-returning function compiled with PCC, and vice versa. + + The method used by GCC is as follows: a structure or union which is 1, + 2, 4 or 8 bytes long is returned like a scalar. A structure or union + with any other size is stored into an address supplied by the caller + in a special, fixed register. + + PCC usually handles all sizes of structures and unions by returning + the address of a block of static storage containing the value. This + method is not used in GCC because it is slower and nonreentrant. + + On systems where PCC works this way, you may be able to make + GCC-compiled code call such functions that were compiled with PCC by + declaring them to return a pointer to the structure or union instead + of the structure or union itself. For example, instead of this: + + struct foo nextfoo (); + + write this: -RTL Expressions for Arithmetic -============================== + struct foo *nextfoo (); + #define nextfoo *nextfoo -`(plus:M X Y)' - Represents the sum of the values represented by X and Y - carried out in machine mode M. This is valid only if - X and Y both are valid for mode M. - -`(minus:M X Y)' - Like `plus' but represents subtraction. - -`(minus X Y)' - Represents the result of subtracting Y from X - for purposes of comparison. The absence of a machine mode - in the `minus' expression indicates that the result is - computed without overflow, as if with infinite precision. - - Of course, machines can't really subtract with infinite precision. - However, they can pretend to do so when only the sign of the - result will be used, which is the case when the result is stored - in `(cc0)'. And that is the only was this kind of expression - may validly be used: as a value to be stored in the condition codes. - -`(neg:M X)' - Represents the negation (subtraction from zero) of the value - represented by X, carried out in mode M. X must be - valid for mode M. - -`(mult:M X Y)' - Represents the signed product of the values represented by X and - Y carried out in machine mode M. If - X and Y are both valid for mode M, this is ordinary - size-preserving multiplication. Alteratively, both X and Y - may be valid for a different, narrower mode. This represents the - kind of multiplication that generates a product wider than the operands. - Widening multiplication and same-size multiplication are completely - distinct and supported by different machine instructions; machines may - support one but not the other. - - `mult' may be used for floating point division as well. - Then M is a floating point machine mode. - -`(umult:M X Y)' - Like `mult' but represents unsigned multiplication. It may be - used in both same-size and widening forms, like `mult'. - `umult' is used only for fixed-point division. - -`(div:M X Y)' - Represents the quotient in signed division of X by Y, - carried out in machine mode M. If M is a floating-point - mode, it represents the exact quotient; otherwise, the integerized - quotient. If X and Y are both valid for mode M, - this is ordinary size-preserving division. Some machines have - division instructions in which the operands and quotient widths are - not all the same; such instructions are represented by `div' - expressions in which the machine modes are not all the same. - -`(udiv:M X Y)' - Like `div' but represents unsigned division. - -`(mod:M X Y)' -`(umod:M X Y)' - Like `div' and `udiv' but represent the remainder instead of - the quotient. - -`(not:M X)' - Represents the bitwise complement of the value represented by X, - carried out in mode M, which must be a fixed-point machine mode. - X must be valid for mode M, which must be a fixed-point mode. - -`(and:M X Y)' - Represents the bitwise logical-and of the values represented by - X and Y, carried out in machine mode M. This is - valid only if X and Y both are valid for mode M, - which must be a fixed-point mode. - -`(ior:M X Y)' - Represents the bitwise inclusive-or of the values represented by - X and Y, carried out in machine mode M. This is - valid only if X and Y both are valid for mode M, - which must be a fixed-point mode. - -`(xor:M X Y)' - Represents the bitwise exclusive-or of the values represented by - X and Y, carried out in machine mode M. This is - valid only if X and Y both are valid for mode M, - which must be a fixed-point mode. - -`(lshift:M X C)' - Represents the result of logically shifting X left by C - places. X must be valid for the mode M, a fixed-point - machine mode. C must be valid for a fixed-point mode; - which mode is determined by the mode called for in the machine - description entry for the left-shift instruction. For example, - on the Vax, the mode of C is `QImode' regardless of M. - - On some machines, negative values of C may be meaningful; this - is why logical left shift an arithmetic left shift are distinguished. - For example, Vaxes have no right-shift instructions, and right shifts - are represented as left-shift instructions whose counts happen - to be negative constants or else computed (in a previous instruction) - by negation. - -`(ashift:M X C)' - Like `lshift' but for arithmetic left shift. - -`(lshiftrt:M X C)' -`(ashiftrt:M X C)' - Like `lshift' and `ashift' but for right shift. - -`(rotate:M X C)' -`(rotatert:M X C)' - Similar but represent left and right rotate. - -`(abs:M X)' - Represents the absolute value of X, computed in mode M. - X must be valid for M. - -`(sqrt:M X)' - Represents the square root of X, computed in mode M. - X must be valid for M. Most often M will be - a floating point mode. + (Note that this assumes you are using the GNU preprocessor, so that + the ANSI antirecursion rules for macro expansions are effective.)  \ No newline at end of file