X-Git-Url: https://oss.titaniummirror.com/gitweb?a=blobdiff_plain;f=gcc%2Fdoc%2Fgccint.info-4;h=db5c475712dac6b10785a4085704ad0513839c15;hb=5a5369932a08c074943c94407697a5813002fd31;hp=764893fcdf5717e19ba72a4943d03c75f04fb320;hpb=aaf7afc53d3ed4f6c811f6ec493d857ea0459573;p=msp430-gcc.git diff --git a/gcc/doc/gccint.info-4 b/gcc/doc/gccint.info-4 index 764893fc..db5c4757 100644 --- a/gcc/doc/gccint.info-4 +++ b/gcc/doc/gccint.info-4 @@ -1,4 +1,4 @@ -This is doc/gccint.info, produced by makeinfo version 4.5 from +This is doc/gccint.info, produced by makeinfo version 4.11 from doc/gccint.texi. INFO-DIR-SECTION Programming @@ -33,982 +33,3391 @@ software. Copies published by the Free Software Foundation raise funds for GNU development.  -File: gccint.info, Node: Function Bodies, Prev: Function Basics, Up: Functions - -Function Bodies ---------------- - - A function that has a definition in the current translation unit will -have a non-`NULL' `DECL_INITIAL'. However, back ends should not make -use of the particular value given by `DECL_INITIAL'. - - The `DECL_SAVED_TREE' macro will give the complete body of the -function. This node will usually be a `COMPOUND_STMT' representing the -outermost block of the function, but it may also be a `TRY_BLOCK', a -`RETURN_INIT', or any other valid statement. - -Statements -.......... - - There are tree nodes corresponding to all of the source-level -statement constructs. These are enumerated here, together with a list -of the various macros that can be used to obtain information about -them. There are a few macros that can be used with all statements: - -`STMT_LINENO' - This macro returns the line number for the statement. If the - statement spans multiple lines, this value will be the number of - the first line on which the statement occurs. Although we mention - `CASE_LABEL' below as if it were a statement, they do not allow - the use of `STMT_LINENO'. There is no way to obtain the line - number for a `CASE_LABEL'. - - Statements do not contain information about the file from which - they came; that information is implicit in the `FUNCTION_DECL' - from which the statements originate. - -`STMT_IS_FULL_EXPR_P' - In C++, statements normally constitute "full expressions"; - temporaries created during a statement are destroyed when the - statement is complete. However, G++ sometimes represents - expressions by statements; these statements will not have - `STMT_IS_FULL_EXPR_P' set. Temporaries created during such - statements should be destroyed when the innermost enclosing - statement with `STMT_IS_FULL_EXPR_P' set is exited. - - - Here is the list of the various statement nodes, and the macros used -to access them. This documentation describes the use of these nodes in -non-template functions (including instantiations of template functions). -In template functions, the same nodes are used, but sometimes in -slightly different ways. - - Many of the statements have substatements. For example, a `while' -loop will have a body, which is itself a statement. If the substatement -is `NULL_TREE', it is considered equivalent to a statement consisting -of a single `;', i.e., an expression statement in which the expression -has been omitted. A substatement may in fact be a list of statements, -connected via their `TREE_CHAIN's. So, you should always process the -statement tree by looping over substatements, like this: - void process_stmt (stmt) - tree stmt; - { - while (stmt) - { - switch (TREE_CODE (stmt)) - { - case IF_STMT: - process_stmt (THEN_CLAUSE (stmt)); - /* More processing here. */ - break; - - ... - } - - stmt = TREE_CHAIN (stmt); - } - } - In other words, while the `then' clause of an `if' statement in C++ -can be only one statement (although that one statement may be a -compound statement), the intermediate representation will sometimes use -several statements chained together. - -`ASM_STMT' - Used to represent an inline assembly statement. For an inline - assembly statement like: - asm ("mov x, y"); - The `ASM_STRING' macro will return a `STRING_CST' node for `"mov - x, y"'. If the original statement made use of the - extended-assembly syntax, then `ASM_OUTPUTS', `ASM_INPUTS', and - `ASM_CLOBBERS' will be the outputs, inputs, and clobbers for the - statement, represented as `STRING_CST' nodes. The - extended-assembly syntax looks like: - asm ("fsinx %1,%0" : "=f" (result) : "f" (angle)); - The first string is the `ASM_STRING', containing the instruction - template. The next two strings are the output and inputs, - respectively; this statement has no clobbers. As this example - indicates, "plain" assembly statements are merely a special case - of extended assembly statements; they have no cv-qualifiers, - outputs, inputs, or clobbers. All of the strings will be - `NUL'-terminated, and will contain no embedded `NUL'-characters. - - If the assembly statement is declared `volatile', or if the - statement was not an extended assembly statement, and is therefore - implicitly volatile, then the predicate `ASM_VOLATILE_P' will hold - of the `ASM_STMT'. - -`BREAK_STMT' - Used to represent a `break' statement. There are no additional - fields. - -`CASE_LABEL' - Use to represent a `case' label, range of `case' labels, or a - `default' label. If `CASE_LOW' is `NULL_TREE', then this is a - `default' label. Otherwise, if `CASE_HIGH' is `NULL_TREE', then - this is an ordinary `case' label. In this case, `CASE_LOW' is an - expression giving the value of the label. Both `CASE_LOW' and - `CASE_HIGH' are `INTEGER_CST' nodes. These values will have the - same type as the condition expression in the switch statement. - - Otherwise, if both `CASE_LOW' and `CASE_HIGH' are defined, the - statement is a range of case labels. Such statements originate - with the extension that allows users to write things of the form: - case 2 ... 5: - The first value will be `CASE_LOW', while the second will be - `CASE_HIGH'. - -`CLEANUP_STMT' - Used to represent an action that should take place upon exit from - the enclosing scope. Typically, these actions are calls to - destructors for local objects, but back ends cannot rely on this - fact. If these nodes are in fact representing such destructors, - `CLEANUP_DECL' will be the `VAR_DECL' destroyed. Otherwise, - `CLEANUP_DECL' will be `NULL_TREE'. In any case, the - `CLEANUP_EXPR' is the expression to execute. The cleanups - executed on exit from a scope should be run in the reverse order - of the order in which the associated `CLEANUP_STMT's were - encountered. - -`COMPOUND_STMT' - Used to represent a brace-enclosed block. The first substatement - is given by `COMPOUND_BODY'. Subsequent substatements are found by - following the `TREE_CHAIN' link from one substatement to the next. - The `COMPOUND_BODY' will be `NULL_TREE' if there are no - substatements. - -`CONTINUE_STMT' - Used to represent a `continue' statement. There are no additional - fields. - -`CTOR_STMT' - Used to mark the beginning (if `CTOR_BEGIN_P' holds) or end (if - `CTOR_END_P' holds of the main body of a constructor. See also - `SUBOBJECT' for more information on how to use these nodes. - -`DECL_STMT' - Used to represent a local declaration. The `DECL_STMT_DECL' macro - can be used to obtain the entity declared. This declaration may - be a `LABEL_DECL', indicating that the label declared is a local - label. (As an extension, GCC allows the declaration of labels - with scope.) In C, this declaration may be a `FUNCTION_DECL', - indicating the use of the GCC nested function extension. For more - information, *note Functions::. - -`DO_STMT' - Used to represent a `do' loop. The body of the loop is given by - `DO_BODY' while the termination condition for the loop is given by - `DO_COND'. The condition for a `do'-statement is always an - expression. - -`EMPTY_CLASS_EXPR' - Used to represent a temporary object of a class with no data whose - address is never taken. (All such objects are interchangeable.) - The `TREE_TYPE' represents the type of the object. - -`EXPR_STMT' - Used to represent an expression statement. Use `EXPR_STMT_EXPR' to - obtain the expression. - -`FILE_STMT' - Used to record a change in filename within the body of a function. - Use `FILE_STMT_FILENAME' to obtain the new filename. - -`FOR_STMT' - Used to represent a `for' statement. The `FOR_INIT_STMT' is the - initialization statement for the loop. The `FOR_COND' is the - termination condition. The `FOR_EXPR' is the expression executed - right before the `FOR_COND' on each loop iteration; often, this - expression increments a counter. The body of the loop is given by - `FOR_BODY'. Note that `FOR_INIT_STMT' and `FOR_BODY' return - statements, while `FOR_COND' and `FOR_EXPR' return expressions. - -`GOTO_STMT' - Used to represent a `goto' statement. The `GOTO_DESTINATION' will - usually be a `LABEL_DECL'. However, if the "computed goto" - extension has been used, the `GOTO_DESTINATION' will be an - arbitrary expression indicating the destination. This expression - will always have pointer type. Additionally the `GOTO_FAKE_P' - flag is set whenever the goto statement does not come from source - code, but it is generated implicitly by the compiler. This is - used for branch prediction. - -`HANDLER' - Used to represent a C++ `catch' block. The `HANDLER_TYPE' is the - type of exception that will be caught by this handler; it is equal - (by pointer equality) to `CATCH_ALL_TYPE' if this handler is for - all types. `HANDLER_PARMS' is the `DECL_STMT' for the catch - parameter, and `HANDLER_BODY' is the `COMPOUND_STMT' for the block - itself. - -`IF_STMT' - Used to represent an `if' statement. The `IF_COND' is the - expression. - - If the condition is a `TREE_LIST', then the `TREE_PURPOSE' is a - statement (usually a `DECL_STMT'). Each time the condition is - evaluated, the statement should be executed. Then, the - `TREE_VALUE' should be used as the conditional expression itself. - This representation is used to handle C++ code like this: - - if (int i = 7) ... - - where there is a new local variable (or variables) declared within - the condition. - - The `THEN_CLAUSE' represents the statement given by the `then' - condition, while the `ELSE_CLAUSE' represents the statement given - by the `else' condition. - -`LABEL_STMT' - Used to represent a label. The `LABEL_DECL' declared by this - statement can be obtained with the `LABEL_STMT_LABEL' macro. The - `IDENTIFIER_NODE' giving the name of the label can be obtained from - the `LABEL_DECL' with `DECL_NAME'. - -`RETURN_INIT' - If the function uses the G++ "named return value" extension, - meaning that the function has been defined like: - S f(int) return s {...} - then there will be a `RETURN_INIT'. There is never a named - returned value for a constructor. The first argument to the - `RETURN_INIT' is the name of the object returned; the second - argument is the initializer for the object. The object is - initialized when the `RETURN_INIT' is encountered. The object - referred to is the actual object returned; this extension is a - manual way of doing the "return-value optimization." Therefore, - the object must actually be constructed in the place where the - object will be returned. - -`RETURN_STMT' - Used to represent a `return' statement. The `RETURN_EXPR' is the - expression returned; it will be `NULL_TREE' if the statement was - just - return; - -`SCOPE_STMT' - A scope-statement represents the beginning or end of a scope. If - `SCOPE_BEGIN_P' holds, this statement represents the beginning of a - scope; if `SCOPE_END_P' holds this statement represents the end of - a scope. On exit from a scope, all cleanups from `CLEANUP_STMT's - occurring in the scope must be run, in reverse order to the order - in which they were encountered. If `SCOPE_NULLIFIED_P' or - `SCOPE_NO_CLEANUPS_P' holds of the scope, back ends should behave - as if the `SCOPE_STMT' were not present at all. - -`SUBOBJECT' - In a constructor, these nodes are used to mark the point at which a - subobject of `this' is fully constructed. If, after this point, an - exception is thrown before a `CTOR_STMT' with `CTOR_END_P' set is - encountered, the `SUBOBJECT_CLEANUP' must be executed. The - cleanups must be executed in the reverse order in which they - appear. - -`SWITCH_STMT' - Used to represent a `switch' statement. The `SWITCH_COND' is the - expression on which the switch is occurring. See the documentation - for an `IF_STMT' for more information on the representation used - for the condition. The `SWITCH_BODY' is the body of the switch - statement. The `SWITCH_TYPE' is the original type of switch - expression as given in the source, before any compiler conversions. - -`TRY_BLOCK' - Used to represent a `try' block. The body of the try block is - given by `TRY_STMTS'. Each of the catch blocks is a `HANDLER' - node. The first handler is given by `TRY_HANDLERS'. Subsequent - handlers are obtained by following the `TREE_CHAIN' link from one - handler to the next. The body of the handler is given by - `HANDLER_BODY'. - - If `CLEANUP_P' holds of the `TRY_BLOCK', then the `TRY_HANDLERS' - will not be a `HANDLER' node. Instead, it will be an expression - that should be executed if an exception is thrown in the try - block. It must rethrow the exception after executing that code. - And, if an exception is thrown while the expression is executing, - `terminate' must be called. - -`USING_STMT' - Used to represent a `using' directive. The namespace is given by - `USING_STMT_NAMESPACE', which will be a NAMESPACE_DECL. This node - is needed inside template functions, to implement using directives - during instantiation. - -`WHILE_STMT' - Used to represent a `while' loop. The `WHILE_COND' is the - termination condition for the loop. See the documentation for an - `IF_STMT' for more information on the representation used for the - condition. - - The `WHILE_BODY' is the body of the loop. - +File: gccint.info, Node: GNU Free Documentation License, Next: Contributors, Prev: Copying, Up: Top + +GNU Free Documentation License +****************************** + + Version 1.1, March 2000 + + Copyright (C) 2000 Free Software Foundation, Inc. + 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA + + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + 0. PREAMBLE + + The purpose of this License is to make a manual, textbook, or other + written document "free" in the sense of freedom: to assure everyone + the effective freedom to copy and redistribute it, with or without + modifying it, either commercially or noncommercially. Secondarily, + this License preserves for the author and publisher a way to get + credit for their work, while not being considered responsible for + modifications made by others. + + This License is a kind of "copyleft", which means that derivative + works of the document must themselves be free in the same sense. + It complements the GNU General Public License, which is a copyleft + license designed for free software. + + We have designed this License in order to use it for manuals for + free software, because free software needs free documentation: a + free program should come with manuals providing the same freedoms + that the software does. But this License is not limited to + software manuals; it can be used for any textual work, regardless + of subject matter or whether it is published as a printed book. + We recommend this License principally for works whose purpose is + instruction or reference. + + 1. APPLICABILITY AND DEFINITIONS + + This License applies to any manual or other work that contains a + notice placed by the copyright holder saying it can be distributed + under the terms of this License. The "Document", below, refers to + any such manual or work. Any member of the public is a licensee, + and is addressed as "you". + + A "Modified Version" of the Document means any work containing the + Document or a portion of it, either copied verbatim, or with + modifications and/or translated into another language. + + A "Secondary Section" is a named appendix or a front-matter + section of the Document that deals exclusively with the + relationship of the publishers or authors of the Document to the + Document's overall subject (or to related matters) and contains + nothing that could fall directly within that overall subject. + (For example, if the Document is in part a textbook of + mathematics, a Secondary Section may not explain any mathematics.) + The relationship could be a matter of historical connection with + the subject or with related matters, or of legal, commercial, + philosophical, ethical or political position regarding them. + + The "Invariant Sections" are certain Secondary Sections whose + titles are designated, as being those of Invariant Sections, in + the notice that says that the Document is released under this + License. + + The "Cover Texts" are certain short passages of text that are + listed, as Front-Cover Texts or Back-Cover Texts, in the notice + that says that the Document is released under this License. + + A "Transparent" copy of the Document means a machine-readable copy, + represented in a format whose specification is available to the + general public, whose contents can be viewed and edited directly + and straightforwardly with generic text editors or (for images + composed of pixels) generic paint programs or (for drawings) some + widely available drawing editor, and that is suitable for input to + text formatters or for automatic translation to a variety of + formats suitable for input to text formatters. A copy made in an + otherwise Transparent file format whose markup has been designed + to thwart or discourage subsequent modification by readers is not + Transparent. A copy that is not "Transparent" is called "Opaque". + + Examples of suitable formats for Transparent copies include plain + ASCII without markup, Texinfo input format, LaTeX input format, + SGML or XML using a publicly available DTD, and + standard-conforming simple HTML designed for human modification. + Opaque formats include PostScript, PDF, proprietary formats that + can be read and edited only by proprietary word processors, SGML + or XML for which the DTD and/or processing tools are not generally + available, and the machine-generated HTML produced by some word + processors for output purposes only. + + The "Title Page" means, for a printed book, the title page itself, + plus such following pages as are needed to hold, legibly, the + material this License requires to appear in the title page. For + works in formats which do not have any title page as such, "Title + Page" means the text near the most prominent appearance of the + work's title, preceding the beginning of the body of the text. + + 2. VERBATIM COPYING + + You may copy and distribute the Document in any medium, either + commercially or noncommercially, provided that this License, the + copyright notices, and the license notice saying this License + applies to the Document are reproduced in all copies, and that you + add no other conditions whatsoever to those of this License. You + may not use technical measures to obstruct or control the reading + or further copying of the copies you make or distribute. However, + you may accept compensation in exchange for copies. If you + distribute a large enough number of copies you must also follow + the conditions in section 3. + + You may also lend copies, under the same conditions stated above, + and you may publicly display copies. + + 3. COPYING IN QUANTITY + + If you publish printed copies of the Document numbering more than + 100, and the Document's license notice requires Cover Texts, you + must enclose the copies in covers that carry, clearly and legibly, + all these Cover Texts: Front-Cover Texts on the front cover, and + Back-Cover Texts on the back cover. Both covers must also clearly + and legibly identify you as the publisher of these copies. The + front cover must present the full title with all words of the + title equally prominent and visible. You may add other material + on the covers in addition. Copying with changes limited to the + covers, as long as they preserve the title of the Document and + satisfy these conditions, can be treated as verbatim copying in + other respects. + + If the required texts for either cover are too voluminous to fit + legibly, you should put the first ones listed (as many as fit + reasonably) on the actual cover, and continue the rest onto + adjacent pages. + + If you publish or distribute Opaque copies of the Document + numbering more than 100, you must either include a + machine-readable Transparent copy along with each Opaque copy, or + state in or with each Opaque copy a publicly-accessible + computer-network location containing a complete Transparent copy + of the Document, free of added material, which the general + network-using public has access to download anonymously at no + charge using public-standard network protocols. If you use the + latter option, you must take reasonably prudent steps, when you + begin distribution of Opaque copies in quantity, to ensure that + this Transparent copy will remain thus accessible at the stated + location until at least one year after the last time you + distribute an Opaque copy (directly or through your agents or + retailers) of that edition to the public. + + It is requested, but not required, that you contact the authors of + the Document well before redistributing any large number of + copies, to give them a chance to provide you with an updated + version of the Document. + + 4. MODIFICATIONS + + You may copy and distribute a Modified Version of the Document + under the conditions of sections 2 and 3 above, provided that you + release the Modified Version under precisely this License, with + the Modified Version filling the role of the Document, thus + licensing distribution and modification of the Modified Version to + whoever possesses a copy of it. In addition, you must do these + things in the Modified Version: + + A. Use in the Title Page (and on the covers, if any) a title + distinct from that of the Document, and from those of + previous versions (which should, if there were any, be listed + in the History section of the Document). You may use the + same title as a previous version if the original publisher of + that version gives permission. + + B. List on the Title Page, as authors, one or more persons or + entities responsible for authorship of the modifications in + the Modified Version, together with at least five of the + principal authors of the Document (all of its principal + authors, if it has less than five). + + C. State on the Title page the name of the publisher of the + Modified Version, as the publisher. + + D. Preserve all the copyright notices of the Document. + + E. Add an appropriate copyright notice for your modifications + adjacent to the other copyright notices. + + F. Include, immediately after the copyright notices, a license + notice giving the public permission to use the Modified + Version under the terms of this License, in the form shown in + the Addendum below. + + G. Preserve in that license notice the full lists of Invariant + Sections and required Cover Texts given in the Document's + license notice. + + H. Include an unaltered copy of this License. + + I. Preserve the section entitled "History", and its title, and + add to it an item stating at least the title, year, new + authors, and publisher of the Modified Version as given on + the Title Page. If there is no section entitled "History" in + the Document, create one stating the title, year, authors, + and publisher of the Document as given on its Title Page, + then add an item describing the Modified Version as stated in + the previous sentence. + + J. Preserve the network location, if any, given in the Document + for public access to a Transparent copy of the Document, and + likewise the network locations given in the Document for + previous versions it was based on. These may be placed in + the "History" section. You may omit a network location for a + work that was published at least four years before the + Document itself, or if the original publisher of the version + it refers to gives permission. + + K. In any section entitled "Acknowledgments" or "Dedications", + preserve the section's title, and preserve in the section all + the substance and tone of each of the contributor + acknowledgments and/or dedications given therein. + + L. Preserve all the Invariant Sections of the Document, + unaltered in their text and in their titles. Section numbers + or the equivalent are not considered part of the section + titles. + + M. Delete any section entitled "Endorsements". Such a section + may not be included in the Modified Version. + + N. Do not retitle any existing section as "Endorsements" or to + conflict in title with any Invariant Section. + + If the Modified Version includes new front-matter sections or + appendices that qualify as Secondary Sections and contain no + material copied from the Document, you may at your option + designate some or all of these sections as invariant. To do this, + add their titles to the list of Invariant Sections in the Modified + Version's license notice. These titles must be distinct from any + other section titles. + + You may add a section entitled "Endorsements", provided it contains + nothing but endorsements of your Modified Version by various + parties--for example, statements of peer review or that the text + has been approved by an organization as the authoritative + definition of a standard. + + You may add a passage of up to five words as a Front-Cover Text, + and a passage of up to 25 words as a Back-Cover Text, to the end + of the list of Cover Texts in the Modified Version. Only one + passage of Front-Cover Text and one of Back-Cover Text may be + added by (or through arrangements made by) any one entity. If the + Document already includes a cover text for the same cover, + previously added by you or by arrangement made by the same entity + you are acting on behalf of, you may not add another; but you may + replace the old one, on explicit permission from the previous + publisher that added the old one. + + The author(s) and publisher(s) of the Document do not by this + License give permission to use their names for publicity for or to + assert or imply endorsement of any Modified Version. + + 5. COMBINING DOCUMENTS + + You may combine the Document with other documents released under + this License, under the terms defined in section 4 above for + modified versions, provided that you include in the combination + all of the Invariant Sections of all of the original documents, + unmodified, and list them all as Invariant Sections of your + combined work in its license notice. + + The combined work need only contain one copy of this License, and + multiple identical Invariant Sections may be replaced with a single + copy. If there are multiple Invariant Sections with the same name + but different contents, make the title of each such section unique + by adding at the end of it, in parentheses, the name of the + original author or publisher of that section if known, or else a + unique number. Make the same adjustment to the section titles in + the list of Invariant Sections in the license notice of the + combined work. + + In the combination, you must combine any sections entitled + "History" in the various original documents, forming one section + entitled "History"; likewise combine any sections entitled + "Acknowledgments", and any sections entitled "Dedications". You + must delete all sections entitled "Endorsements." + + 6. COLLECTIONS OF DOCUMENTS + + You may make a collection consisting of the Document and other + documents released under this License, and replace the individual + copies of this License in the various documents with a single copy + that is included in the collection, provided that you follow the + rules of this License for verbatim copying of each of the + documents in all other respects. + + You may extract a single document from such a collection, and + distribute it individually under this License, provided you insert + a copy of this License into the extracted document, and follow + this License in all other respects regarding verbatim copying of + that document. + + 7. AGGREGATION WITH INDEPENDENT WORKS + + A compilation of the Document or its derivatives with other + separate and independent documents or works, in or on a volume of + a storage or distribution medium, does not as a whole count as a + Modified Version of the Document, provided no compilation + copyright is claimed for the compilation. Such a compilation is + called an "aggregate", and this License does not apply to the + other self-contained works thus compiled with the Document, on + account of their being thus compiled, if they are not themselves + derivative works of the Document. + + If the Cover Text requirement of section 3 is applicable to these + copies of the Document, then if the Document is less than one + quarter of the entire aggregate, the Document's Cover Texts may be + placed on covers that surround only the Document within the + aggregate. Otherwise they must appear on covers around the whole + aggregate. + + 8. TRANSLATION + + Translation is considered a kind of modification, so you may + distribute translations of the Document under the terms of section + 4. Replacing Invariant Sections with translations requires special + permission from their copyright holders, but you may include + translations of some or all Invariant Sections in addition to the + original versions of these Invariant Sections. You may include a + translation of this License provided that you also include the + original English version of this License. In case of a + disagreement between the translation and the original English + version of this License, the original English version will prevail. + + 9. TERMINATION + + You may not copy, modify, sublicense, or distribute the Document + except as expressly provided for under this License. Any other + attempt to copy, modify, sublicense or distribute the Document is + void, and will automatically terminate your rights under this + License. However, parties who have received copies, or rights, + from you under this License will not have their licenses + terminated so long as such parties remain in full compliance. + + 10. FUTURE REVISIONS OF THIS LICENSE + + The Free Software Foundation may publish new, revised versions of + the GNU Free Documentation License from time to time. Such new + versions will be similar in spirit to the present version, but may + differ in detail to address new problems or concerns. See + `http://www.gnu.org/copyleft/'. + + Each version of the License is given a distinguishing version + number. If the Document specifies that a particular numbered + version of this License "or any later version" applies to it, you + have the option of following the terms and conditions either of + that specified version or of any later version that has been + published (not as a draft) by the Free Software Foundation. If + the Document does not specify a version number of this License, + you may choose any version ever published (not as a draft) by the + Free Software Foundation. + +ADDENDUM: How to use this License for your documents +==================================================== + +To use this License in a document you have written, include a copy of +the License in the document and put the following copyright and license +notices just after the title page: + + Copyright (C) YEAR YOUR NAME. + Permission is granted to copy, distribute and/or modify this document + under the terms of the GNU Free Documentation License, Version 1.1 + or any later version published by the Free Software Foundation; + with the Invariant Sections being LIST THEIR TITLES, with the + Front-Cover Texts being LIST, and with the Back-Cover Texts being LIST. + A copy of the license is included in the section entitled ``GNU + Free Documentation License''. + + If you have no Invariant Sections, write "with no Invariant Sections" +instead of saying which ones are invariant. If you have no Front-Cover +Texts, write "no Front-Cover Texts" instead of "Front-Cover Texts being +LIST"; likewise for Back-Cover Texts. + + If your document contains nontrivial examples of program code, we +recommend releasing these examples in parallel under your choice of +free software license, such as the GNU General Public License, to +permit their use in free software.  -File: gccint.info, Node: Attributes, Next: Expression trees, Prev: Declarations, Up: Trees +File: gccint.info, Node: Contributors, Next: Option Index, Prev: GNU Free Documentation License, Up: Top -Attributes in trees -=================== +Contributors to GCC +******************* - Attributes, as specified using the `__attribute__' keyword, are -represented internally as a `TREE_LIST'. The `TREE_PURPOSE' is the -name of the attribute, as an `IDENTIFIER_NODE'. The `TREE_VALUE' is a -`TREE_LIST' of the arguments of the attribute, if any, or `NULL_TREE' -if there are no arguments; the arguments are stored as the `TREE_VALUE' -of successive entries in the list, and may be identifiers or -expressions. The `TREE_CHAIN' of the attribute is the next attribute -in a list of attributes applying to the same declaration or type, or -`NULL_TREE' if there are no further attributes in the list. +The GCC project would like to thank its many contributors. Without +them the project would not have been nearly as successful as it has +been. Any omissions in this list are accidental. Feel free to contact + if you have been left out or some of your +contributions are not listed. Please keep this list in alphabetical +order. - Attributes may be attached to declarations and to types; these -attributes may be accessed with the following macros. All attributes -are stored in this way, and many also cause other changes to the -declaration or type or to other internal compiler data structures. + * Analog Devices helped implement the support for complex data types + and iterators. - - Tree Macro: tree DECL_ATTRIBUTES (tree DECL) - This macro returns the attributes on the declaration DECL. + * John David Anglin for threading-related fixes and improvements to + libstdc++-v3, and the HP-UX port. - - Tree Macro: tree TYPE_ATTRIBUTES (tree TYPE) - This macro returns the attributes on the type TYPE. + * James van Artsdalen wrote the code that makes efficient use of the + Intel 80387 register stack. - -File: gccint.info, Node: Expression trees, Prev: Attributes, Up: Trees - -Expressions -=========== - - The internal representation for expressions is for the most part -quite straightforward. However, there are a few facts that one must -bear in mind. In particular, the expression "tree" is actually a -directed acyclic graph. (For example there may be many references to -the integer constant zero throughout the source program; many of these -will be represented by the same expression node.) You should not rely -on certain kinds of node being shared, nor should rely on certain kinds -of nodes being unshared. - - The following macros can be used with all expression nodes: - -`TREE_TYPE' - Returns the type of the expression. This value may not be - precisely the same type that would be given the expression in the - original program. - - In what follows, some nodes that one might expect to always have type -`bool' are documented to have either integral or boolean type. At some -point in the future, the C front end may also make use of this same -intermediate representation, and at this point these nodes will -certainly have integral type. The previous sentence is not meant to -imply that the C++ front end does not or will not give these nodes -integral type. - - Below, we list the various kinds of expression nodes. Except where -noted otherwise, the operands to an expression are accessed using the -`TREE_OPERAND' macro. For example, to access the first operand to a -binary plus expression `expr', use: - - TREE_OPERAND (expr, 0) - -As this example indicates, the operands are zero-indexed. - - The table below begins with constants, moves on to unary expressions, -then proceeds to binary expressions, and concludes with various other -kinds of expressions: - -`INTEGER_CST' - These nodes represent integer constants. Note that the type of - these constants is obtained with `TREE_TYPE'; they are not always - of type `int'. In particular, `char' constants are represented - with `INTEGER_CST' nodes. The value of the integer constant `e' is - given by - ((TREE_INT_CST_HIGH (e) << HOST_BITS_PER_WIDE_INT) - + TREE_INST_CST_LOW (e)) - - HOST_BITS_PER_WIDE_INT is at least thirty-two on all platforms. - Both `TREE_INT_CST_HIGH' and `TREE_INT_CST_LOW' return a - `HOST_WIDE_INT'. The value of an `INTEGER_CST' is interpreted as - a signed or unsigned quantity depending on the type of the - constant. In general, the expression given above will overflow, - so it should not be used to calculate the value of the constant. - - The variable `integer_zero_node' is an integer constant with value - zero. Similarly, `integer_one_node' is an integer constant with - value one. The `size_zero_node' and `size_one_node' variables are - analogous, but have type `size_t' rather than `int'. - - The function `tree_int_cst_lt' is a predicate which holds if its - first argument is less than its second. Both constants are - assumed to have the same signedness (i.e., either both should be - signed or both should be unsigned.) The full width of the - constant is used when doing the comparison; the usual rules about - promotions and conversions are ignored. Similarly, - `tree_int_cst_equal' holds if the two constants are equal. The - `tree_int_cst_sgn' function returns the sign of a constant. The - value is `1', `0', or `-1' according on whether the constant is - greater than, equal to, or less than zero. Again, the signedness - of the constant's type is taken into account; an unsigned constant - is never less than zero, no matter what its bit-pattern. - -`REAL_CST' - FIXME: Talk about how to obtain representations of this constant, - do comparisons, and so forth. - -`COMPLEX_CST' - These nodes are used to represent complex number constants, that - is a `__complex__' whose parts are constant nodes. The - `TREE_REALPART' and `TREE_IMAGPART' return the real and the - imaginary parts respectively. - -`VECTOR_CST' - These nodes are used to represent vector constants, whose parts are - constant nodes. Each individual constant node is either an - integer or a double constant node. The first operand is a - `TREE_LIST' of the constant nodes and is accessed through - `TREE_VECTOR_CST_ELTS'. - -`STRING_CST' - These nodes represent string-constants. The `TREE_STRING_LENGTH' - returns the length of the string, as an `int'. The - `TREE_STRING_POINTER' is a `char*' containing the string itself. - The string may not be `NUL'-terminated, and it may contain - embedded `NUL' characters. Therefore, the `TREE_STRING_LENGTH' - includes the trailing `NUL' if it is present. - - For wide string constants, the `TREE_STRING_LENGTH' is the number - of bytes in the string, and the `TREE_STRING_POINTER' points to an - array of the bytes of the string, as represented on the target - system (that is, as integers in the target endianness). Wide and - non-wide string constants are distinguished only by the `TREE_TYPE' - of the `STRING_CST'. - - FIXME: The formats of string constants are not well-defined when - the target system bytes are not the same width as host system - bytes. - -`PTRMEM_CST' - These nodes are used to represent pointer-to-member constants. The - `PTRMEM_CST_CLASS' is the class type (either a `RECORD_TYPE' or - `UNION_TYPE' within which the pointer points), and the - `PTRMEM_CST_MEMBER' is the declaration for the pointed to object. - Note that the `DECL_CONTEXT' for the `PTRMEM_CST_MEMBER' is in - general different from the `PTRMEM_CST_CLASS'. For example, given: - struct B { int i; }; - struct D : public B {}; - int D::*dp = &D::i; - - The `PTRMEM_CST_CLASS' for `&D::i' is `D', even though the - `DECL_CONTEXT' for the `PTRMEM_CST_MEMBER' is `B', since `B::i' is - a member of `B', not `D'. - -`VAR_DECL' - These nodes represent variables, including static data members. - For more information, *note Declarations::. - -`NEGATE_EXPR' - These nodes represent unary negation of the single operand, for - both integer and floating-point types. The type of negation can be - determined by looking at the type of the expression. - -`BIT_NOT_EXPR' - These nodes represent bitwise complement, and will always have - integral type. The only operand is the value to be complemented. - -`TRUTH_NOT_EXPR' - These nodes represent logical negation, and will always have - integral (or boolean) type. The operand is the value being - negated. - -`PREDECREMENT_EXPR' -`PREINCREMENT_EXPR' -`POSTDECREMENT_EXPR' -`POSTINCREMENT_EXPR' - These nodes represent increment and decrement expressions. The - value of the single operand is computed, and the operand - incremented or decremented. In the case of `PREDECREMENT_EXPR' and - `PREINCREMENT_EXPR', the value of the expression is the value - resulting after the increment or decrement; in the case of - `POSTDECREMENT_EXPR' and `POSTINCREMENT_EXPR' is the value before - the increment or decrement occurs. The type of the operand, like - that of the result, will be either integral, boolean, or - floating-point. - -`ADDR_EXPR' - These nodes are used to represent the address of an object. (These - expressions will always have pointer or reference type.) The - operand may be another expression, or it may be a declaration. - - As an extension, GCC allows users to take the address of a label. - In this case, the operand of the `ADDR_EXPR' will be a - `LABEL_DECL'. The type of such an expression is `void*'. - - If the object addressed is not an lvalue, a temporary is created, - and the address of the temporary is used. - -`INDIRECT_REF' - These nodes are used to represent the object pointed to by a - pointer. The operand is the pointer being dereferenced; it will - always have pointer or reference type. - -`FIX_TRUNC_EXPR' - These nodes represent conversion of a floating-point value to an - integer. The single operand will have a floating-point type, - while the the complete expression will have an integral (or - boolean) type. The operand is rounded towards zero. - -`FLOAT_EXPR' - These nodes represent conversion of an integral (or boolean) value - to a floating-point value. The single operand will have integral - type, while the complete expression will have a floating-point - type. - - FIXME: How is the operand supposed to be rounded? Is this - dependent on `-mieee'? - -`COMPLEX_EXPR' - These nodes are used to represent complex numbers constructed from - two expressions of the same (integer or real) type. The first - operand is the real part and the second operand is the imaginary - part. - -`CONJ_EXPR' - These nodes represent the conjugate of their operand. - -`REALPART_EXPR' - -`IMAGPART_EXPR' - These nodes represent respectively the real and the imaginary parts - of complex numbers (their sole argument). - -`NON_LVALUE_EXPR' - These nodes indicate that their one and only operand is not an - lvalue. A back end can treat these identically to the single - operand. - -`NOP_EXPR' - These nodes are used to represent conversions that do not require - any code-generation. For example, conversion of a `char*' to an - `int*' does not require any code be generated; such a conversion is - represented by a `NOP_EXPR'. The single operand is the expression - to be converted. The conversion from a pointer to a reference is - also represented with a `NOP_EXPR'. - -`CONVERT_EXPR' - These nodes are similar to `NOP_EXPR's, but are used in those - situations where code may need to be generated. For example, if an - `int*' is converted to an `int' code may need to be generated on - some platforms. These nodes are never used for C++-specific - conversions, like conversions between pointers to different - classes in an inheritance hierarchy. Any adjustments that need to - be made in such cases are always indicated explicitly. Similarly, - a user-defined conversion is never represented by a - `CONVERT_EXPR'; instead, the function calls are made explicit. - -`THROW_EXPR' - These nodes represent `throw' expressions. The single operand is - an expression for the code that should be executed to throw the - exception. However, there is one implicit action not represented - in that expression; namely the call to `__throw'. This function - takes no arguments. If `setjmp'/`longjmp' exceptions are used, the - function `__sjthrow' is called instead. The normal GCC back end - uses the function `emit_throw' to generate this code; you can - examine this function to see what needs to be done. - -`LSHIFT_EXPR' -`RSHIFT_EXPR' - These nodes represent left and right shifts, respectively. The - first operand is the value to shift; it will always be of integral - type. The second operand is an expression for the number of bits - by which to shift. Right shift should be treated as arithmetic, - i.e., the high-order bits should be zero-filled when the - expression has unsigned type and filled with the sign bit when the - expression has signed type. Note that the result is undefined if - the second operand is larger than the first operand's type size. - -`BIT_IOR_EXPR' -`BIT_XOR_EXPR' -`BIT_AND_EXPR' - These nodes represent bitwise inclusive or, bitwise exclusive or, - and bitwise and, respectively. Both operands will always have - integral type. - -`TRUTH_ANDIF_EXPR' -`TRUTH_ORIF_EXPR' - These nodes represent logical and and logical or, respectively. - These operators are not strict; i.e., the second operand is - evaluated only if the value of the expression is not determined by - evaluation of the first operand. The type of the operands, and - the result type, is always of boolean or integral type. - -`TRUTH_AND_EXPR' -`TRUTH_OR_EXPR' -`TRUTH_XOR_EXPR' - These nodes represent logical and, logical or, and logical - exclusive or. They are strict; both arguments are always - evaluated. There are no corresponding operators in C or C++, but - the front end will sometimes generate these expressions anyhow, if - it can tell that strictness does not matter. - -`PLUS_EXPR' -`MINUS_EXPR' -`MULT_EXPR' -`TRUNC_DIV_EXPR' -`TRUNC_MOD_EXPR' -`RDIV_EXPR' - These nodes represent various binary arithmetic operations. - Respectively, these operations are addition, subtraction (of the - second operand from the first), multiplication, integer division, - integer remainder, and floating-point division. The operands to - the first three of these may have either integral or floating - type, but there will never be case in which one operand is of - floating type and the other is of integral type. - - The result of a `TRUNC_DIV_EXPR' is always rounded towards zero. - The `TRUNC_MOD_EXPR' of two operands `a' and `b' is always `a - - a/b' where the division is as if computed by a `TRUNC_DIV_EXPR'. - -`ARRAY_REF' - These nodes represent array accesses. The first operand is the - array; the second is the index. To calculate the address of the - memory accessed, you must scale the index by the size of the type - of the array elements. The type of these expressions must be the - type of a component of the array. - -`ARRAY_RANGE_REF' - These nodes represent access to a range (or "slice") of an array. - The operands are the same as that for `ARRAY_REF' and have the same - meanings. The type of these expressions must be an array whose - component type is the same as that of the first operand. The - range of that array type determines the amount of data these - expressions access. - -`EXACT_DIV_EXPR' - Document. - -`LT_EXPR' -`LE_EXPR' -`GT_EXPR' -`GE_EXPR' -`EQ_EXPR' -`NE_EXPR' - These nodes represent the less than, less than or equal to, greater - than, greater than or equal to, equal, and not equal comparison - operators. The first and second operand with either be both of - integral type or both of floating type. The result type of these - expressions will always be of integral or boolean type. - -`MODIFY_EXPR' - These nodes represent assignment. The left-hand side is the first - operand; the right-hand side is the second operand. The left-hand - side will be a `VAR_DECL', `INDIRECT_REF', `COMPONENT_REF', or - other lvalue. - - These nodes are used to represent not only assignment with `=' but - also compound assignments (like `+='), by reduction to `=' - assignment. In other words, the representation for `i += 3' looks - just like that for `i = i + 3'. - -`INIT_EXPR' - These nodes are just like `MODIFY_EXPR', but are used only when a - variable is initialized, rather than assigned to subsequently. - -`COMPONENT_REF' - These nodes represent non-static data member accesses. The first - operand is the object (rather than a pointer to it); the second - operand is the `FIELD_DECL' for the data member. - -`COMPOUND_EXPR' - These nodes represent comma-expressions. The first operand is an - expression whose value is computed and thrown away prior to the - evaluation of the second operand. The value of the entire - expression is the value of the second operand. - -`COND_EXPR' - These nodes represent `?:' expressions. The first operand is of - boolean or integral type. If it evaluates to a nonzero value, the - second operand should be evaluated, and returned as the value of - the expression. Otherwise, the third operand is evaluated, and - returned as the value of the expression. As a GNU extension, the - middle operand of the `?:' operator may be omitted in the source, - like this: - - x ? : 3 - - which is equivalent to - - x ? x : 3 - - assuming that `x' is an expression without side-effects. However, - in the case that the first operation causes side effects, the - side-effects occur only once. Consumers of the internal - representation do not need to worry about this oddity; the second - operand will be always be present in the internal representation. - -`CALL_EXPR' - These nodes are used to represent calls to functions, including - non-static member functions. The first operand is a pointer to the - function to call; it is always an expression whose type is a - `POINTER_TYPE'. The second argument is a `TREE_LIST'. The - arguments to the call appear left-to-right in the list. The - `TREE_VALUE' of each list node contains the expression - corresponding to that argument. (The value of `TREE_PURPOSE' for - these nodes is unspecified, and should be ignored.) For non-static - member functions, there will be an operand corresponding to the - `this' pointer. There will always be expressions corresponding to - all of the arguments, even if the function is declared with default - arguments and some arguments are not explicitly provided at the - call sites. - -`STMT_EXPR' - These nodes are used to represent GCC's statement-expression - extension. The statement-expression extension allows code like - this: - int f() { return ({ int j; j = 3; j + 7; }); } - In other words, an sequence of statements may occur where a single - expression would normally appear. The `STMT_EXPR' node represents - such an expression. The `STMT_EXPR_STMT' gives the statement - contained in the expression; this is always a `COMPOUND_STMT'. The - value of the expression is the value of the last sub-statement in - the `COMPOUND_STMT'. More precisely, the value is the value - computed by the last `EXPR_STMT' in the outermost scope of the - `COMPOUND_STMT'. For example, in: - ({ 3; }) - the value is `3' while in: - ({ if (x) { 3; } }) - (represented by a nested `COMPOUND_STMT'), there is no value. If - the `STMT_EXPR' does not yield a value, it's type will be `void'. - -`BIND_EXPR' - These nodes represent local blocks. The first operand is a list of - temporary variables, connected via their `TREE_CHAIN' field. These - will never require cleanups. The scope of these variables is just - the body of the `BIND_EXPR'. The body of the `BIND_EXPR' is the - second operand. - -`LOOP_EXPR' - These nodes represent "infinite" loops. The `LOOP_EXPR_BODY' - represents the body of the loop. It should be executed forever, - unless an `EXIT_EXPR' is encountered. - -`EXIT_EXPR' - These nodes represent conditional exits from the nearest enclosing - `LOOP_EXPR'. The single operand is the condition; if it is - nonzero, then the loop should be exited. An `EXIT_EXPR' will only - appear within a `LOOP_EXPR'. - -`CLEANUP_POINT_EXPR' - These nodes represent full-expressions. The single operand is an - expression to evaluate. Any destructor calls engendered by the - creation of temporaries during the evaluation of that expression - should be performed immediately after the expression is evaluated. - -`CONSTRUCTOR' - These nodes represent the brace-enclosed initializers for a - structure or array. The first operand is reserved for use by the - back end. The second operand is a `TREE_LIST'. If the - `TREE_TYPE' of the `CONSTRUCTOR' is a `RECORD_TYPE' or - `UNION_TYPE', then the `TREE_PURPOSE' of each node in the - `TREE_LIST' will be a `FIELD_DECL' and the `TREE_VALUE' of each - node will be the expression used to initialize that field. You - should not depend on the fields appearing in any particular order, - nor should you assume that all fields will be represented. - Unrepresented fields may be assigned any value. - - If the `TREE_TYPE' of the `CONSTRUCTOR' is an `ARRAY_TYPE', then - the `TREE_PURPOSE' of each element in the `TREE_LIST' will be an - `INTEGER_CST'. This constant indicates which element of the array - (indexed from zero) is being assigned to; again, the `TREE_VALUE' - is the corresponding initializer. If the `TREE_PURPOSE' is - `NULL_TREE', then the initializer is for the next available array - element. - - Conceptually, before any initialization is done, the entire area of - storage is initialized to zero. - -`COMPOUND_LITERAL_EXPR' - These nodes represent ISO C99 compound literals. The - `COMPOUND_LITERAL_EXPR_DECL_STMT' is a `DECL_STMT' containing an - anonymous `VAR_DECL' for the unnamed object represented by the - compound literal; the `DECL_INITIAL' of that `VAR_DECL' is a - `CONSTRUCTOR' representing the brace-enclosed list of initializers - in the compound literal. That anonymous `VAR_DECL' can also be - accessed directly by the `COMPOUND_LITERAL_EXPR_DECL' macro. - -`SAVE_EXPR' - A `SAVE_EXPR' represents an expression (possibly involving - side-effects) that is used more than once. The side-effects should - occur only the first time the expression is evaluated. Subsequent - uses should just reuse the computed value. The first operand to - the `SAVE_EXPR' is the expression to evaluate. The side-effects - should be executed where the `SAVE_EXPR' is first encountered in a - depth-first preorder traversal of the expression tree. - -`TARGET_EXPR' - A `TARGET_EXPR' represents a temporary object. The first operand - is a `VAR_DECL' for the temporary variable. The second operand is - the initializer for the temporary. The initializer is evaluated, - and copied (bitwise) into the temporary. - - Often, a `TARGET_EXPR' occurs on the right-hand side of an - assignment, or as the second operand to a comma-expression which is - itself the right-hand side of an assignment, etc. In this case, - we say that the `TARGET_EXPR' is "normal"; otherwise, we say it is - "orphaned". For a normal `TARGET_EXPR' the temporary variable - should be treated as an alias for the left-hand side of the - assignment, rather than as a new temporary variable. - - The third operand to the `TARGET_EXPR', if present, is a - cleanup-expression (i.e., destructor call) for the temporary. If - this expression is orphaned, then this expression must be executed - when the statement containing this expression is complete. These - cleanups must always be executed in the order opposite to that in - which they were encountered. Note that if a temporary is created - on one branch of a conditional operator (i.e., in the second or - third operand to a `COND_EXPR'), the cleanup must be run only if - that branch is actually executed. - - See `STMT_IS_FULL_EXPR_P' for more information about running these - cleanups. - -`AGGR_INIT_EXPR' - An `AGGR_INIT_EXPR' represents the initialization as the return - value of a function call, or as the result of a constructor. An - `AGGR_INIT_EXPR' will only appear as the second operand of a - `TARGET_EXPR'. The first operand to the `AGGR_INIT_EXPR' is the - address of a function to call, just as in a `CALL_EXPR'. The - second operand are the arguments to pass that function, as a - `TREE_LIST', again in a manner similar to that of a `CALL_EXPR'. - The value of the expression is that returned by the function. - - If `AGGR_INIT_VIA_CTOR_P' holds of the `AGGR_INIT_EXPR', then the - initialization is via a constructor call. The address of the third - operand of the `AGGR_INIT_EXPR', which is always a `VAR_DECL', is - taken, and this value replaces the first argument in the argument - list. In this case, the value of the expression is the `VAR_DECL' - given by the third operand to the `AGGR_INIT_EXPR'; constructors do - not return a value. - -`VTABLE_REF' - A `VTABLE_REF' indicates that the interior expression computes a - value that is a vtable entry. It is used with `-fvtable-gc' to - track the reference through to front end to the middle end, at - which point we transform this to a `REG_VTABLE_REF' note, which - survives the balance of code generation. - - The first operand is the expression that computes the vtable - reference. The second operand is the `VAR_DECL' of the vtable. - The third operand is an `INTEGER_CST' of the byte offset into the - vtable. + * Alasdair Baird for various bugfixes. + * Gerald Baumgartner added the signature extension to the C++ front + end. - -File: gccint.info, Node: RTL, Next: Machine Desc, Prev: Trees, Up: Top + * Godmar Back for his Java improvements and encouragement. + + * Scott Bambrough for help porting the Java compiler. + + * Jon Beniston for his Win32 port of Java. + + * Geoff Berry for his Java object serialization work and various + patches. + + * Eric Blake for helping to make GCJ and libgcj conform to the + specifications. + + * Hans-J. Boehm for his garbage collector, IA-64 libffi port, and + other Java work. + + * Neil Booth for work on cpplib, lang hooks, debug hooks and other + miscellaneous clean-ups. + + * Per Bothner for his direction via the steering committee and + various improvements to our infrastructure for supporting new + languages. Chill front end implementation. Initial + implementations of cpplib, fix-header, config.guess, libio, and + past C++ library (libg++) maintainer. Dreaming up, designing and + implementing much of GCJ. + + * Devon Bowen helped port GCC to the Tahoe. + + * Don Bowman for mips-vxworks contributions. + + * Dave Brolley for work on cpplib and Chill. + + * Robert Brown implemented the support for Encore 32000 systems. + + * Christian Bruel for improvements to local store elimination. + + * Herman A.J. ten Brugge for various fixes. + + * Joerg Brunsmann for Java compiler hacking and help with the GCJ + FAQ. + + * Joe Buck for his direction via the steering committee. + + * Craig Burley for leadership of the Fortran effort. + + * Stephan Buys for contributing Doxygen notes for libstdc++. + + * Paolo Carlini for libstdc++ work: lots of efficiency improvements + to the string class, hard detective work on the frustrating + localization issues, and keeping up with the problem reports. + + * John Carr for his alias work, SPARC hacking, infrastructure + improvements, previous contributions to the steering committee, + loop optimizations, etc. + + * Steve Chamberlain for support for the Hitachi SH and H8 processors + and the PicoJava processor, and for GCJ config fixes. + + * Glenn Chambers for help with the GCJ FAQ. + + * John-Marc Chandonia for various libgcj patches. + + * Scott Christley for his Objective-C contributions. + + * Eric Christopher for his Java porting help and clean-ups. + + * Branko Cibej for more warning contributions. + + * The GNU Classpath project for all of their merged runtime code. + + * Nick Clifton for arm, mcore, fr30, v850, m32r work, `--help', and + other random hacking. + + * Michael Cook for libstdc++ cleanup patches to reduce warnings. + + * Ralf Corsepius for SH testing and minor bugfixing. + + * Stan Cox for care and feeding of the x86 port and lots of behind + the scenes hacking. + + * Alex Crain provided changes for the 3b1. + + * Ian Dall for major improvements to the NS32k port. + + * Dario Dariol contributed the four varieties of sample programs + that print a copy of their source. + + * Russell Davidson for fstream and stringstream fixes in libstdc++. + + * Mo DeJong for GCJ and libgcj bug fixes. + + * Gabriel Dos Reis for contributions to g++, contributions and + maintenance of GCC diagnostics infrastructure, libstdc++-v3, + including valarray<>, complex<>, maintaining the numerics library + (including that pesky :-) and keeping up-to-date anything + to do with numbers. + + * Ulrich Drepper for his work on glibc, testing of GCC using glibc, + ISO C99 support, CFG dumping support, etc., plus support of the + C++ runtime libraries including for all kinds of C interface + issues, contributing and maintaining complex<>, sanity checking + and disbursement, configuration architecture, libio maintenance, + and early math work. + + * Richard Earnshaw for his ongoing work with the ARM. + + * David Edelsohn for his direction via the steering committee, + ongoing work with the RS6000/PowerPC port, help cleaning up Haifa + loop changes, and for doing the entire AIX port of libstdc++ with + his bare hands. + + * Kevin Ediger for the floating point formatting of num_put::do_put + in libstdc++. + + * Phil Edwards for libstdc++ work including configuration hackery, + documentation maintainer, chief breaker of the web pages, the + occasional iostream bugfix, and work on shared library symbol + versioning. + + * Paul Eggert for random hacking all over GCC. + + * Mark Elbrecht for various DJGPP improvements, and for libstdc++ + configuration support for locales and fstream-related fixes. + + * Vadim Egorov for libstdc++ fixes in strings, streambufs, and + iostreams. + + * Ben Elliston for his work to move the Objective-C runtime into its + own subdirectory and for his work on autoconf. + + * Marc Espie for OpenBSD support. + + * Doug Evans for much of the global optimization framework, arc, + m32r, and SPARC work. + + * Fred Fish for BeOS support and Ada fixes. + + * Ivan Fontes Garcia for the Portugese translation of the GCJ FAQ. + + * Peter Gerwinski for various bugfixes and the Pascal front end. + + * Kaveh Ghazi for his direction via the steering committee and + amazing work to make `-W -Wall' useful. + + * John Gilmore for a donation to the FSF earmarked improving GNU + Java. + + * Judy Goldberg for c++ contributions. + + * Torbjorn Granlund for various fixes and the c-torture testsuite, + multiply- and divide-by-constant optimization, improved long long + support, improved leaf function register allocation, and his + direction via the steering committee. + + * Anthony Green for his `-Os' contributions and Java front end work. + + * Stu Grossman for gdb hacking, allowing GCJ developers to debug our + code. + + * Michael K. Gschwind contributed the port to the PDP-11. + + * Ron Guilmette implemented the `protoize' and `unprotoize' tools, + the support for Dwarf symbolic debugging information, and much of + the support for System V Release 4. He has also worked heavily on + the Intel 386 and 860 support. + + * Bruno Haible for improvements in the runtime overhead for EH, new + warnings and assorted bugfixes. + + * Andrew Haley for his amazing Java compiler and library efforts. + + * Chris Hanson assisted in making GCC work on HP-UX for the 9000 + series 300. + + * Michael Hayes for various thankless work he's done trying to get + the c30/c40 ports functional. Lots of loop and unroll + improvements and fixes. + + * Kate Hedstrom for staking the g77 folks with an initial testsuite. + + * Richard Henderson for his ongoing SPARC, alpha, and ia32 work, loop + opts, and generally fixing lots of old problems we've ignored for + years, flow rewrite and lots of further stuff, including reviewing + tons of patches. + + * Nobuyuki Hikichi of Software Research Associates, Tokyo, + contributed the support for the Sony NEWS machine. + + * Manfred Hollstein for his ongoing work to keep the m88k alive, lots + of testing an bugfixing, particularly of our configury code. + + * Steve Holmgren for MachTen patches. + + * Jan Hubicka for his x86 port improvements. + + * Christian Iseli for various bugfixes. + + * Kamil Iskra for general m68k hacking. + + * Lee Iverson for random fixes and MIPS testing. + + * Andreas Jaeger for various fixes to the MIPS port + + * Jakub Jelinek for his SPARC work and sibling call optimizations as + well as lots of bug fixes and test cases, and for improving the + Java build system. + + * Janis Johnson for ia64 testing and fixes and for her quality + improvement sidetracks. + + * J. Kean Johnston for OpenServer support. + + * Tim Josling for the sample language treelang based originally on + Richard Kenner's ""toy" language". + + * Nicolai Josuttis for additional libstdc++ documentation. + + * Klaus Kaempf for his ongoing work to make alpha-vms a viable + target. + + * David Kashtan of SRI adapted GCC to VMS. + + * Ryszard Kabatek for many, many libstdc++ bugfixes and + optimizations of strings, especially member functions, and for + auto_ptr fixes. + + * Geoffrey Keating for his ongoing work to make the PPC work for + GNU/Linux and his automatic regression tester. + + * Brendan Kehoe for his ongoing work with g++ and for a lot of early + work in just about every part of libstdc++. + + * Oliver M. Kellogg of Deutsche Aerospace contributed the port to the + MIL-STD-1750A. + + * Richard Kenner of the New York University Ultracomputer Research + Laboratory wrote the machine descriptions for the AMD 29000, the + DEC Alpha, the IBM RT PC, and the IBM RS/6000 as well as the + support for instruction attributes. He also made changes to + better support RISC processors including changes to common + subexpression elimination, strength reduction, function calling + sequence handling, and condition code support, in addition to + generalizing the code for frame pointer elimination and delay slot + scheduling. Richard Kenner was also the head maintainer of GCC + for several years. + + * Mumit Khan for various contributions to the Cygwin and Mingw32 + ports and maintaining binary releases for Windows hosts, and for + massive libstdc++ porting work to Cygwin/Mingw32. + + * Robin Kirkham for cpu32 support. + + * Mark Klein for PA improvements. + + * Thomas Koenig for various bugfixes. + + * Bruce Korb for the new and improved fixincludes code. + + * Benjamin Kosnik for his g++ work and for leading the libstdc++-v3 + effort. + + * Charles LaBrec contributed the support for the Integrated Solutions + 68020 system. + + * Jeff Law for his direction via the steering committee, + coordinating the entire egcs project and GCC 2.95, rolling out + snapshots and releases, handling merges from GCC2, reviewing tons + of patches that might have fallen through the cracks else, and + random but extensive hacking. + + * Marc Lehmann for his direction via the steering committee and + helping with analysis and improvements of x86 performance. + + * Ted Lemon wrote parts of the RTL reader and printer. + + * Kriang Lerdsuwanakij for improvements to demangler and various c++ + fixes. + + * Warren Levy for tremendous work on libgcj (Java Runtime Library) + and random work on the Java front end. + + * Alain Lichnewsky ported GCC to the MIPS CPU. + + * Oskar Liljeblad for hacking on AWT and his many Java bug reports + and patches. + + * Robert Lipe for OpenServer support, new testsuites, testing, etc. + + * Weiwen Liu for testing and various bugfixes. + + * Dave Love for his ongoing work with the Fortran front end and + runtime libraries. + + * Martin von Lo"wis for internal consistency checking infrastructure, + various C++ improvements including namespace support, and tons of + assistance with libstdc++/compiler merges. + + * H.J. Lu for his previous contributions to the steering committee, + many x86 bug reports, prototype patches, and keeping the GNU/Linux + ports working. + + * Greg McGary for random fixes and (someday) bounded pointers. + + * Andrew MacLeod for his ongoing work in building a real EH system, + various code generation improvements, work on the global + optimizer, etc. + + * Vladimir Makarov for hacking some ugly i960 problems, PowerPC + hacking improvements to compile-time performance, overall + knowledge and direction in the area of instruction scheduling, and + design and implementation of the automaton based instruction + scheduler. + + * Bob Manson for his behind the scenes work on dejagnu. + + * Philip Martin for lots of libstdc++ string and vector iterator + fixes and improvements, and string clean up and testsuites. + + * All of the Mauve project contributors, for Java test code. + + * Bryce McKinlay for numerous GCJ and libgcj fixes and improvements. + + * Adam Megacz for his work on the Win32 port of GCJ. + + * Michael Meissner for LRS framework, ia32, m32r, v850, m88k, MIPS, + powerpc, haifa, ECOFF debug support, and other assorted hacking. + + * Jason Merrill for his direction via the steering committee and + leading the g++ effort. + + * David Miller for his direction via the steering committee, lots of + SPARC work, improvements in jump.c and interfacing with the Linux + kernel developers. + + * Gary Miller ported GCC to Charles River Data Systems machines. + + * Alfred Minarik for libstdc++ string and ios bugfixes, and turning + the entire libstdc++ testsuite namespace-compatible. + + * Mark Mitchell for his direction via the steering committee, + mountains of C++ work, load/store hoisting out of loops, alias + analysis improvements, ISO C `restrict' support, and serving as + release manager for GCC 3.x. + + * Alan Modra for various GNU/Linux bits and testing. + + * Toon Moene for his direction via the steering committee, Fortran + maintenance, and his ongoing work to make us make Fortran run fast. + + * Jason Molenda for major help in the care and feeding of all the + services on the gcc.gnu.org (formerly egcs.cygnus.com) + machine--mail, web services, ftp services, etc etc. Doing all + this work on scrap paper and the backs of envelopes would have + been... difficult. + + * Catherine Moore for fixing various ugly problems we have sent her + way, including the haifa bug which was killing the Alpha & PowerPC + Linux kernels. + + * Mike Moreton for his various Java patches. + + * David Mosberger-Tang for various Alpha improvements. + + * Stephen Moshier contributed the floating point emulator that + assists in cross-compilation and permits support for floating + point numbers wider than 64 bits and for ISO C99 support. + + * Bill Moyer for his behind the scenes work on various issues. + + * Philippe De Muyter for his work on the m68k port. + + * Joseph S. Myers for his work on the PDP-11 port, format checking + and ISO C99 support, and continuous emphasis on (and contributions + to) documentation. + + * Nathan Myers for his work on libstdc++-v3: architecture and + authorship through the first three snapshots, including + implementation of locale infrastructure, string, shadow C headers, + and the initial project documentation (DESIGN, CHECKLIST, and so + forth). Later, more work on MT-safe string and shadow headers. + + * Felix Natter for documentation on porting libstdc++. + + * NeXT, Inc. donated the front end that supports the Objective-C + language. + + * Hans-Peter Nilsson for the CRIS and MMIX ports, improvements to + the search engine setup, various documentation fixes and other + small fixes. + + * Geoff Noer for this work on getting cygwin native builds working. + + * David O'Brien for the FreeBSD/alpha, FreeBSD/AMD x86-64, + FreeBSD/ARM, FreeBSD/PowerPC, and FreeBSD/SPARC64 ports and + related infrastructure improvements. + + * Alexandre Oliva for various build infrastructure improvements, + scripts and amazing testing work, including keeping libtool issues + sane and happy. + + * Melissa O'Neill for various NeXT fixes. + + * Rainer Orth for random MIPS work, including improvements to our o32 + ABI support, improvements to dejagnu's MIPS support, Java + configuration clean-ups and porting work, etc. + + * Paul Petersen wrote the machine description for the Alliant FX/8. + + * Alexandre Petit-Bianco for implementing much of the Java compiler + and continued Java maintainership. + + * Matthias Pfaller for major improvements to the NS32k port. + + * Gerald Pfeifer for his direction via the steering committee, + pointing out lots of problems we need to solve, maintenance of the + web pages, and taking care of documentation maintenance in general. + + * Ovidiu Predescu for his work on the Objective-C front end and + runtime libraries. + + * Ken Raeburn for various improvements to checker, MIPS ports and + various cleanups in the compiler. + + * Rolf W. Rasmussen for hacking on AWT. + + * David Reese of Sun Microsystems contributed to the Solaris on + PowerPC port. + + * Joern Rennecke for maintaining the sh port, loop, regmove & reload + hacking. + + * Loren J. Rittle for improvements to libstdc++-v3 including the + FreeBSD port, threading fixes, thread-related configury changes, + critical threading documentation, and solutions to really tricky + I/O problems. + + * Craig Rodrigues for processing tons of bug reports. + + * Gavin Romig-Koch for lots of behind the scenes MIPS work. + + * Ken Rose for fixes to our delay slot filling code. + + * Paul Rubin wrote most of the preprocessor. + + * Chip Salzenberg for libstdc++ patches and improvements to locales, + traits, Makefiles, libio, libtool hackery, and "long long" support. + + * Juha Sarlin for improvements to the H8 code generator. -RTL Representation -****************** + * Greg Satz assisted in making GCC work on HP-UX for the 9000 series + 300. - Most of the work of the compiler is done on an intermediate -representation called register transfer 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. + * Bradley Schatz for his work on the GCJ FAQ. - 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. + * Peter Schauer wrote the code to allow debugging to work on the + Alpha. + * William Schelter did most of the work on the Intel 80386 support. + + * Bernd Schmidt for various code generation improvements and major + work in the reload pass as well a serving as release manager for + GCC 2.95.3. + + * Peter Schmid for constant testing of libstdc++ - especially + application testing, going above and beyond what was requested for + the release criteria - and libstdc++ header file tweaks. + + * Jason Schroeder for jcf-dump patches. + + * Andreas Schwab for his work on the m68k port. + + * Joel Sherrill for his direction via the steering committee, RTEMS + contributions and RTEMS testing. + + * Nathan Sidwell for many C++ fixes/improvements. + + * Jeffrey Siegal for helping RMS with the original design of GCC, + some code which handles the parse tree and RTL data structures, + constant folding and help with the original VAX & m68k ports. + + * Kenny Simpson for prompting libstdc++ fixes due to defect reports + from the LWG (thereby keeping us in line with updates from the + ISO). + + * Franz Sirl for his ongoing work with making the PPC port stable + for linux. + + * Andrey Slepuhin for assorted AIX hacking. + + * Christopher Smith did the port for Convex machines. + + * Randy Smith finished the Sun FPA support. + + * Scott Snyder for queue, iterator, istream, and string fixes and + libstdc++ testsuite entries. + + * Brad Spencer for contributions to the GLIBCPP_FORCE_NEW technique. + + * Richard Stallman, for writing the original gcc and launching the + GNU project. + + * Jan Stein of the Chalmers Computer Society provided support for + Genix, as well as part of the 32000 machine description. + + * Nigel Stephens for various mips16 related fixes/improvements. + + * Jonathan Stone wrote the machine description for the Pyramid + computer. + + * Graham Stott for various infrastructure improvements. + + * John Stracke for his Java HTTP protocol fixes. + + * Mike Stump for his Elxsi port, g++ contributions over the years + and more recently his vxworks contributions + + * Jeff Sturm for Java porting help, bug fixes, and encouragement. + + * Shigeya Suzuki for this fixes for the bsdi platforms. + + * Ian Lance Taylor for his mips16 work, general configury hacking, + fixincludes, etc. + + * Holger Teutsch provided the support for the Clipper CPU. + + * Gary Thomas for his ongoing work to make the PPC work for + GNU/Linux. + + * Philipp Thomas for random bugfixes throughout the compiler + + * Jason Thorpe for thread support in libstdc++ on NetBSD. + + * Kresten Krab Thorup wrote the run time support for the Objective-C + language and the fantastic Java bytecode interpreter. + + * Michael Tiemann for random bugfixes, the first instruction + scheduler, initial C++ support, function integration, NS32k, SPARC + and M88k machine description work, delay slot scheduling. + + * Andreas Tobler for his work porting libgcj to Darwin. + + * Teemu Torma for thread safe exception handling support. + + * Leonard Tower wrote parts of the parser, RTL generator, and RTL + definitions, and of the VAX machine description. + + * Tom Tromey for internationalization support and for his many Java + contributions and libgcj maintainership. + + * Lassi Tuura for improvements to config.guess to determine HP + processor types. + + * Petter Urkedal for libstdc++ CXXFLAGS, math, and algorithms fixes. + + * Brent Verner for work with the libstdc++ cshadow files and their + associated configure steps. + + * Todd Vierling for contributions for NetBSD ports. + + * Jonathan Wakely for contributing libstdc++ Doxygen notes and XHTML + guidance. + + * Dean Wakerley for converting the install documentation from HTML + to texinfo in time for GCC 3.0. + + * Krister Walfridsson for random bugfixes. + + * Stephen M. Webb for time and effort on making libstdc++ shadow + files work with the tricky Solaris 8+ headers, and for pushing the + build-time header tree. + + * John Wehle for various improvements for the x86 code generator, + related infrastructure improvements to help x86 code generation, + value range propagation and other work, WE32k port. + + * Zack Weinberg for major work on cpplib and various other bugfixes. + + * Matt Welsh for help with Linux Threads support in GCJ. + + * Urban Widmark for help fixing java.io. + + * Mark Wielaard for new Java library code and his work integrating + with Classpath. + + * Dale Wiles helped port GCC to the Tahoe. + + * Bob Wilson from Tensilica, Inc. for the Xtensa port. + + * Jim Wilson for his direction via the steering committee, tackling + hard problems in various places that nobody else wanted to work + on, strength reduction and other loop optimizations. + + * Carlo Wood for various fixes. + + * Tom Wood for work on the m88k port. + + * Masanobu Yuhara of Fujitsu Laboratories implemented the machine + description for the Tron architecture (specifically, the Gmicro). + + * Kevin Zachmann helped ported GCC to the Tahoe. + + * Gilles Zunino for help porting Java to Irix. + + + We'd also like to thank the folks who have contributed time and +energy in testing GCC: + + * Michael Abd-El-Malek + + * Thomas Arend + + * Bonzo Armstrong + + * Steven Ashe + + * Chris Baldwin + + * David Billinghurst + + * Jim Blandy + + * Stephane Bortzmeyer + + * Horst von Brand + + * Frank Braun + + * Rodney Brown + + * Joe Buck + + * Craig Burley + + * Sidney Cadot + + * Bradford Castalia + + * Ralph Doncaster + + * Ulrich Drepper + + * David Edelsohn + + * Richard Emberson + + * Levente Farkas + + * Graham Fawcett + + * Robert A. French + + * Jo"rgen Freyh + + * Mark K. Gardner + + * Charles-Antoine Gauthier + + * Yung Shing Gene + + * Kaveh Ghazi + + * David Gilbert + + * Simon Gornall + + * Fred Gray + + * John Griffin + + * Patrik Hagglund + + * Phil Hargett + + * Amancio Hasty + + * Bryan W. Headley + + * Kate Hedstrom + + * Richard Henderson + + * Kevin B. Hendricks + + * Manfred Hollstein + + * Kamil Iskra + + * Joep Jansen + + * Christian Joensson + + * David Kidd + + * Tobias Kuipers + + * Anand Krishnaswamy + + * Jeff Law + + * Robert Lipe + + * llewelly + + * Damon Love + + * Dave Love + + * H.J. Lu + + * Brad Lucier + + * Mumit Khan + + * Matthias Klose + + * Martin Knoblauch + + * Jesse Macnish + + * David Miller + + * Toon Moene + + * Stefan Morrell + + * Anon A. Mous + + * Matthias Mueller + + * Pekka Nikander + + * Alexandre Oliva + + * Jon Olson + + * Magnus Persson + + * Chris Pollard + + * Richard Polton + + * David Rees + + * Paul Reilly + + * Tom Reilly + + * Loren J. Rittle + + * Torsten Rueger + + * Danny Sadinoff + + * Marc Schifer + + * Peter Schmid + + * David Schuler + + * Vin Shelton + + * Franz Sirl + + * Tim Souder + + * Mike Stump + + * Adam Sulmicki + + * George Talbot + + * Gregory Warnes + + * Carlo Wood + + * David E. Young + + * And many others + + And finally we'd like to thank everyone who uses the compiler, +submits bug reports and generally reminds us why we're doing this work +in the first place. + + +File: gccint.info, Node: Option Index, Next: Index, Prev: Contributors, Up: Top + +Option Index +************ + +GCC's command line options are indexed here without any initial `-' or +`--'. Where an option has both positive and negative forms (such as +`-fOPTION' and `-fno-OPTION'), relevant entries in the manual are +indexed under the most appropriate form; it may sometimes be useful to +look up both forms. + +[index] * Menu: -* RTL Objects:: Expressions vs vectors vs strings vs integers. -* RTL Classes:: Categories of RTL expression objects, and their structure. -* Accessors:: Macros to access expression operands or vector elts. -* Flags:: Other flags in an RTL expression. -* 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. -* Vector Operations:: Expressions involving vector datatypes. -* 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. -* Assembler:: Representing `asm' with operands. -* Insns:: Expression types for entire insns. -* Calls:: RTL representation of function call insns. -* Sharing:: Some expressions are unique; others *must* be copied. -* Reading RTL:: Reading textual RTL from a file. +* dB: Passes. (line 377) +* dc: Passes. (line 286) +* dd: Passes. (line 386) +* dE: Passes. (line 295) +* de: Passes. (line 187) +* df: Passes. (line 274) +* dg: Passes. (line 358) +* dG: Passes. (line 239) +* di: Passes. (line 142) +* dj: Passes. (line 164) +* dk: Passes. (line 402) +* dl: Passes. (line 334) +* dL: Passes. (line 251) +* dN: Passes. (line 305) +* dR: Passes. (line 365) +* dr: Passes. (line 131) +* dS: Passes. (line 321) +* ds: Passes. (line 216) +* dt: Passes. (line 260) +* dW: Passes. (line 197) +* dX: Passes. (line 206) +* frerun-cse-after-loop: Passes. (line 255) +* fssa: Passes. (line 178) +* fssa-ccp: Passes. (line 190) +* fssa-dce: Passes. (line 201) +* fthread-jumps: Passes. (line 172) +* msoft-float: Interface. (line 72)  -File: gccint.info, Node: RTL Objects, Next: RTL Classes, Up: RTL - -RTL Object Types -================ - - RTL uses five kinds of objects: expressions, integers, wide integers, -strings and vectors. Expressions are the most important ones. An RTL -expression ("RTX", for short) 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'; their written form uses decimal -digits. A wide integer is an integral object whose type is -`HOST_WIDE_INT'; 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 it is 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. Within RTL -code, strings are most commonly found inside `symbol_ref' expressions, -but they appear in other contexts in the RTL expressions that make up -machine descriptions. - - In a machine description, strings are normally written with double -quotes, as you would in C. However, strings in machine descriptions may -extend over many lines, which is invalid C, and adjacent string -constants are not concatenated as they are in C. Any string constant -may be surrounded with a single set of parentheses. Sometimes this -makes the machine description easier to read. - - There is also a special syntax for strings, which can be useful when -C code is embedded in a machine description. Wherever a string can -appear, it is also valid to write a C-style brace block. The entire -brace block, including the outermost pair of braces, is considered to be -the string constant. Double quote characters inside the braces are not -special. Therefore, if you write string constants in the C code, you -need not escape each quote character with a backslash. - - A vector contains an arbitrary 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 codes" (also called RTX -codes). 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). - - Expression code names in the `md' file are written in lower case, -but when they appear in C code they are written in upper case. In this -manual, they are shown as follows: `const_int'. - - In a few contexts a null pointer is valid where an expression is -normally wanted. The written form of this is `(nil)'. +File: gccint.info, Node: Index, Prev: Option Index, Up: Top + +Index +***** + +[index] +* Menu: + +* ! in constraint: Multi-Alternative. (line 47) +* # in constraint: Modifiers. (line 60) +* # in template: Output Template. (line 67) +* #pragma: Misc. (line 298) +* % in constraint: Modifiers. (line 45) +* % in template: Output Template. (line 6) +* & in constraint: Modifiers. (line 25) +* (nil): RTL Objects. (line 73) +* * in constraint: Modifiers. (line 65) +* * in template: Output Statement. (line 29) +* + in constraint: Modifiers. (line 12) +* /c in RTL dump: Flags. (line 216) +* /f in RTL dump: Flags. (line 222) +* /i in RTL dump: Flags. (line 272) +* /j in RTL dump: Flags. (line 285) +* /s in RTL dump: Flags. (line 237) +* /u in RTL dump: Flags. (line 299) +* /v in RTL dump: Flags. (line 330) +* 0 in constraint: Simple Constraints. (line 118) +* < in constraint: Simple Constraints. (line 46) +* = in constraint: Modifiers. (line 8) +* > in constraint: Simple Constraints. (line 50) +* ? in constraint: Multi-Alternative. (line 41) +* \: Output Template. (line 47) +* __builtin_args_info: Varargs. (line 41) +* __builtin_classify_type: Varargs. (line 75) +* __builtin_next_arg: Varargs. (line 65) +* __builtin_saveregs: Varargs. (line 23) +* __CTOR_LIST__: Initialization. (line 25) +* __DTOR_LIST__: Initialization. (line 25) +* __main: Collect2. (line 15) +* abort: Portability. (line 20) +* abs: Arithmetic. (line 165) +* abs and attributes: Expressions. (line 64) +* absM2 instruction pattern: Standard Names. (line 231) +* absolute value: Arithmetic. (line 165) +* access to operands: Accessors. (line 6) +* accessors: Accessors. (line 6) +* ACCUMULATE_OUTGOING_ARGS: Stack Arguments. (line 40) +* ACCUMULATE_OUTGOING_ARGS and stack frames: Function Entry. (line 138) +* ADA_LONG_TYPE_SIZE: Type Layout. (line 25) +* ADDITIONAL_REGISTER_NAMES: Instruction Output. (line 14) +* addM3 instruction pattern: Standard Names. (line 161) +* addr_diff_vec: Side Effects. (line 293) +* addr_diff_vec, length of: Insn Lengths. (line 26) +* ADDR_EXPR: Expression trees. (line 6) +* addr_vec: Side Effects. (line 288) +* addr_vec, length of: Insn Lengths. (line 26) +* address constraints: Simple Constraints. (line 152) +* ADDRESS_COST: Costs. (line 48) +* address_operand: Simple Constraints. (line 156) +* addressing modes: Addressing Modes. (line 6) +* addressof: Regs and Memory. (line 256) +* ADJUST_FIELD_ALIGN: Storage Layout. (line 180) +* ADJUST_INSN_LENGTH: Insn Lengths. (line 40) +* aggregates as return values: Aggregate Return. (line 6) +* ALL_REGS: Register Classes. (line 17) +* ALLOCATE_INITIAL_VALUE: Misc. (line 556) +* allocate_stack instruction pattern: Standard Names. (line 729) +* ALLOCATE_TRAMPOLINE: Trampolines. (line 71) +* analysis, data flow: Passes. (line 264) +* and: Arithmetic. (line 132) +* and and attributes: Expressions. (line 50) +* and, canonicalization of: Insn Canonicalizations. + (line 42) +* andM3 instruction pattern: Standard Names. (line 167) +* APPLY_RESULT_SIZE: Scalar Return. (line 88) +* ARG_POINTER_CFA_OFFSET: Frame Layout. (line 136) +* ARG_POINTER_REGNUM: Frame Registers. (line 40) +* ARG_POINTER_REGNUM and virtual registers: Regs and Memory. (line 65) +* arg_pointer_rtx: Frame Registers. (line 85) +* ARGS_GROW_DOWNWARD: Frame Layout. (line 34) +* argument passing: Interface. (line 37) +* arguments in registers: Register Arguments. (line 6) +* arguments on stack: Stack Arguments. (line 6) +* arithmetic libraries: Interface. (line 72) +* arithmetic shift: Arithmetic. (line 147) +* arithmetic simplifications: Passes. (line 86) +* arithmetic, in RTL: Arithmetic. (line 6) +* ARITHMETIC_TYPE_P: Types. (line 77) +* array: Types. (line 6) +* ARRAY_REF: Expression trees. (line 6) +* ARRAY_TYPE: Types. (line 6) +* ashift: Arithmetic. (line 147) +* ashift and attributes: Expressions. (line 64) +* ashiftrt: Arithmetic. (line 155) +* ashiftrt and attributes: Expressions. (line 64) +* ashlM3 instruction pattern: Standard Names. (line 217) +* ashrM3 instruction pattern: Standard Names. (line 224) +* ASM_APP_OFF: File Framework. (line 43) +* ASM_APP_ON: File Framework. (line 36) +* ASM_CLOBBERS: Function Bodies. (line 6) +* ASM_COMMENT_START: File Framework. (line 31) +* ASM_CV_QUAL: Function Bodies. (line 6) +* ASM_DECLARE_CLASS_REFERENCE: Label Output. (line 298) +* ASM_DECLARE_FUNCTION_NAME: Label Output. (line 15) +* ASM_DECLARE_FUNCTION_SIZE: Label Output. (line 26) +* ASM_DECLARE_OBJECT_NAME: Label Output. (line 36) +* ASM_DECLARE_REGISTER_GLOBAL: Label Output. (line 47) +* ASM_DECLARE_UNRESOLVED_REFERENCE: Label Output. (line 304) +* ASM_FILE_END: File Framework. (line 20) +* ASM_FILE_START: File Framework. (line 8) +* ASM_FINAL_SPEC: Driver. (line 144) +* ASM_FINISH_DECLARE_OBJECT: Label Output. (line 55) +* ASM_FORMAT_PRIVATE_NAME: Label Output. (line 221) +* asm_fprintf: Instruction Output. (line 129) +* ASM_FPRINTF_EXTENSIONS: Instruction Output. (line 140) +* ASM_GENERATE_INTERNAL_LABEL: Label Output. (line 205) +* ASM_GLOBALIZE_LABEL: Label Output. (line 65) +* asm_input: Side Effects. (line 275) +* ASM_INPUTS: Function Bodies. (line 6) +* ASM_MAYBE_OUTPUT_ENCODED_ADDR_RTX: Exception Handling. (line 69) +* ASM_NO_SKIP_IN_TEXT: Alignment Output. (line 71) +* asm_noperands: Insns. (line 260) +* asm_operands, RTL sharing: Sharing. (line 45) +* asm_operands, usage: Assembler. (line 6) +* ASM_OUTPUT_ADDR_DIFF_ELT: Dispatch Tables. (line 8) +* ASM_OUTPUT_ADDR_VEC_ELT: Dispatch Tables. (line 25) +* ASM_OUTPUT_ALIGN: Alignment Output. (line 78) +* ASM_OUTPUT_ALIGNED_BSS: Uninitialized Data. (line 62) +* ASM_OUTPUT_ALIGNED_COMMON: Uninitialized Data. (line 22) +* ASM_OUTPUT_ALIGNED_DECL_COMMON: Uninitialized Data. (line 29) +* ASM_OUTPUT_ALIGNED_DECL_LOCAL: Uninitialized Data. (line 97) +* ASM_OUTPUT_ALIGNED_LOCAL: Uninitialized Data. (line 90) +* ASM_OUTPUT_ALTERNATE_LABEL_NAME: Label Output. (line 197) +* ASM_OUTPUT_ASCII: Data Output. (line 49) +* ASM_OUTPUT_BSS: Uninitialized Data. (line 42) +* ASM_OUTPUT_CASE_END: Dispatch Tables. (line 50) +* ASM_OUTPUT_CASE_LABEL: Dispatch Tables. (line 37) +* ASM_OUTPUT_COMMON: Uninitialized Data. (line 9) +* ASM_OUTPUT_DEBUG_LABEL: Label Output. (line 185) +* ASM_OUTPUT_DEF: Label Output. (line 239) +* ASM_OUTPUT_DEF_FROM_DECLS: Label Output. (line 246) +* ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL: Label Output. (line 253) +* ASM_OUTPUT_EXTERNAL: Label Output. (line 124) +* ASM_OUTPUT_EXTERNAL_LIBCALL: Label Output. (line 134) +* ASM_OUTPUT_FDESC: Data Output. (line 58) +* ASM_OUTPUT_IDENT: File Framework. (line 73) +* ASM_OUTPUT_INTERNAL_LABEL: Label Output. (line 167) +* ASM_OUTPUT_LABEL: Label Output. (line 8) +* ASM_OUTPUT_LABEL_REF: Label Output. (line 158) +* ASM_OUTPUT_LABELREF: Label Output. (line 144) +* ASM_OUTPUT_LOCAL: Uninitialized Data. (line 77) +* ASM_OUTPUT_MAX_SKIP_ALIGN: Alignment Output. (line 83) +* ASM_OUTPUT_MI_THUNK: Function Entry. (line 200) +* ASM_OUTPUT_OPCODE: Instruction Output. (line 20) +* ASM_OUTPUT_POOL_EPILOGUE: Data Output. (line 113) +* ASM_OUTPUT_POOL_PROLOGUE: Data Output. (line 71) +* ASM_OUTPUT_REG_POP: Instruction Output. (line 183) +* ASM_OUTPUT_REG_PUSH: Instruction Output. (line 178) +* ASM_OUTPUT_SHARED_BSS: Uninitialized Data. (line 72) +* ASM_OUTPUT_SHARED_COMMON: Uninitialized Data. (line 37) +* ASM_OUTPUT_SHARED_LOCAL: Uninitialized Data. (line 105) +* ASM_OUTPUT_SKIP: Alignment Output. (line 65) +* ASM_OUTPUT_SOURCE_FILENAME: File Framework. (line 50) +* ASM_OUTPUT_SOURCE_LINE: File Framework. (line 65) +* ASM_OUTPUT_SPECIAL_POOL_ENTRY: Data Output. (line 82) +* ASM_OUTPUT_SYMBOL_REF: Label Output. (line 151) +* ASM_OUTPUT_WEAK_ALIAS: Label Output. (line 264) +* ASM_OUTPUTS: Function Bodies. (line 6) +* ASM_PREFERRED_EH_DATA_FORMAT: Exception Handling. (line 55) +* ASM_SPEC: Driver. (line 136) +* ASM_STABD_OP: DBX Options. (line 35) +* ASM_STABN_OP: DBX Options. (line 42) +* ASM_STABS_OP: DBX Options. (line 28) +* ASM_STMT: Function Bodies. (line 6) +* ASM_STRING: Function Bodies. (line 6) +* ASM_WEAKEN_DECL: Label Output. (line 86) +* ASM_WEAKEN_LABEL: Label Output. (line 73) +* assemble_name: Label Output. (line 8) +* assembler format: File Framework. (line 6) +* assembler instructions in RTL: Assembler. (line 6) +* ASSEMBLER_DIALECT: Instruction Output. (line 151) +* assigning attribute values to insns: Tagging Insns. (line 6) +* assignment operator: Function Basics. (line 6) +* asterisk in template: Output Statement. (line 29) +* atof: Cross-compilation. (line 12) +* attr <1>: Tagging Insns. (line 54) +* attr: Expressions. (line 154) +* attr_flag: Expressions. (line 119) +* attribute expressions: Expressions. (line 6) +* attribute specifications: Attr Example. (line 6) +* attribute specifications example: Attr Example. (line 6) +* attributes: Attributes. (line 6) +* attributes, defining: Defining Attributes. (line 6) +* attributes, target-specific: Target Attributes. (line 6) +* autoincrement addressing, availability: Portability. (line 20) +* autoincrement/decrement addressing: Simple Constraints. (line 28) +* autoincrement/decrement analysis: Passes. (line 270) +* AVOID_CCMODE_COPIES: Values in Registers. (line 98) +* backslash: Output Template. (line 47) +* barrier: Insns. (line 150) +* BASE_REG_CLASS: Register Classes. (line 106) +* basic block reordering: Passes. (line 369) +* basic blocks: Passes. (line 264) +* bCOND instruction pattern: Standard Names. (line 444) +* bcopy, implicit usage: Library Calls. (line 99) +* BIGGEST_ALIGNMENT: Storage Layout. (line 162) +* BIGGEST_FIELD_ALIGNMENT: Storage Layout. (line 173) +* BImode: Machine Modes. (line 22) +* BIND_EXPR: Expression trees. (line 6) +* BINFO_TYPE: Classes. (line 6) +* bit-fields: Bit-Fields. (line 6) +* BIT_AND_EXPR: Expression trees. (line 6) +* BIT_IOR_EXPR: Expression trees. (line 6) +* BIT_NOT_EXPR: Expression trees. (line 6) +* BIT_XOR_EXPR: Expression trees. (line 6) +* BITFIELD_NBYTES_LIMITED: Storage Layout. (line 315) +* BITS_BIG_ENDIAN: Storage Layout. (line 11) +* BITS_BIG_ENDIAN, effect on sign_extract: Bit-Fields. (line 11) +* BITS_PER_UNIT: Storage Layout. (line 51) +* BITS_PER_WORD: Storage Layout. (line 55) +* bitwise complement: Arithmetic. (line 128) +* bitwise exclusive-or: Arithmetic. (line 142) +* bitwise inclusive-or: Arithmetic. (line 137) +* bitwise logical-and: Arithmetic. (line 132) +* BLKmode: Machine Modes. (line 97) +* BLKmode, and function return values: Calls. (line 23) +* BOOL_TYPE_SIZE: Type Layout. (line 57) +* BOOLEAN_TYPE: Types. (line 6) +* branch shortening: Passes. (line 390) +* BRANCH_COST: Costs. (line 132) +* break_out_memory_refs: Addressing Modes. (line 156) +* BREAK_STMT: Function Bodies. (line 6) +* BSS_SECTION_ASM_OP: Sections. (line 39) +* builtin_longjmp instruction pattern: Standard Names. (line 826) +* BUILTIN_SETJMP_FRAME_VALUE: Frame Layout. (line 89) +* builtin_setjmp_receiver instruction pattern: Standard Names. + (line 816) +* builtin_setjmp_setup instruction pattern: Standard Names. (line 805) +* byte_mode: Machine Modes. (line 223) +* BYTES_BIG_ENDIAN: Storage Layout. (line 23) +* BYTES_BIG_ENDIAN, effect on subreg: Regs and Memory. (line 136) +* bzero, implicit usage: Library Calls. (line 99) +* C statements for assembler output: Output Statement. (line 6) +* C/C++ Internal Representation: Trees. (line 6) +* C4X_FLOAT_FORMAT: Storage Layout. (line 410) +* call <1>: Side Effects. (line 81) +* call: Flags. (line 216) +* call instruction pattern: Standard Names. (line 471) +* call usage: Calls. (line 10) +* call, in insn_list: Flags. (line 64) +* call-clobbered register: Register Basics. (line 35) +* call-saved register: Register Basics. (line 35) +* call-used register: Register Basics. (line 35) +* CALL_EXPR: Expression trees. (line 6) +* call_insn: Insns. (line 94) +* call_insn and /j: Flags. (line 176) +* call_insn and /u: Flags. (line 19) +* CALL_INSN_FUNCTION_USAGE: Insns. (line 100) +* call_pop instruction pattern: Standard Names. (line 499) +* CALL_POPS_ARGS: Stack Arguments. (line 149) +* CALL_REALLY_USED_REGISTERS: Register Basics. (line 45) +* CALL_USED_REGISTERS: Register Basics. (line 34) +* call_used_regs: Register Basics. (line 59) +* call_value instruction pattern: Standard Names. (line 491) +* call_value_pop instruction pattern: Standard Names. (line 499) +* CALLER_SAVE_PROFITABLE: Caller Saves. (line 18) +* calling conventions: Stack and Calling. (line 6) +* calling functions in RTL: Calls. (line 6) +* CAN_DEBUG_WITHOUT_FP: Run-time Target. (line 161) +* CAN_ELIMINATE: Elimination. (line 70) +* canadian: Configure Terms. (line 6) +* canonicalization of instructions: Insn Canonicalizations. + (line 6) +* CANONICALIZE_COMPARISON: Condition Code. (line 99) +* canonicalize_funcptr_for_compare instruction pattern: Standard Names. + (line 660) +* CASE_DROPS_THROUGH: Misc. (line 64) +* CASE_VALUES_THRESHOLD: Misc. (line 69) +* CASE_VECTOR_MODE: Misc. (line 46) +* CASE_VECTOR_PC_RELATIVE: Misc. (line 59) +* CASE_VECTOR_SHORTEN_MODE: Misc. (line 50) +* casesi instruction pattern: Standard Names. (line 579) +* cc0: Regs and Memory. (line 182) +* cc0, RTL sharing: Sharing. (line 27) +* cc0_rtx: Regs and Memory. (line 208) +* CC1_SPEC: Driver. (line 118) +* CC1PLUS_SPEC: Driver. (line 126) +* cc_status: Condition Code. (line 8) +* CC_STATUS_MDEP: Condition Code. (line 18) +* CC_STATUS_MDEP_INIT: Condition Code. (line 24) +* CCmode: Machine Modes. (line 90) +* CDImode: Machine Modes. (line 116) +* change_address: Standard Names. (line 47) +* CHAR_TYPE_SIZE: Type Layout. (line 45) +* CHECK_FLOAT_VALUE: Storage Layout. (line 382) +* check_stack instruction pattern: Standard Names. (line 758) +* CHImode: Machine Modes. (line 116) +* class: Classes. (line 6) +* class definitions, register: Register Classes. (line 6) +* class preference constraints: Class Preferences. (line 6) +* CLASS_LIKELY_SPILLED_P: Register Classes. (line 325) +* CLASS_MAX_NREGS: Register Classes. (line 342) +* CLASS_TYPE_P: Types. (line 81) +* classes of RTX codes: RTL Classes. (line 6) +* CLASSTYPE_DECLARED_CLASS: Classes. (line 6) +* CLASSTYPE_HAS_MUTABLE: Classes. (line 78) +* CLASSTYPE_NON_POD_P: Classes. (line 84) +* CLEANUP_DECL: Function Bodies. (line 6) +* CLEANUP_EXPR: Function Bodies. (line 6) +* CLEANUP_POINT_EXPR: Expression trees. (line 6) +* CLEANUP_STMT: Function Bodies. (line 6) +* CLEAR_INSN_CACHE: Trampolines. (line 124) +* clobber: Side Effects. (line 95) +* clrstrM instruction pattern: Standard Names. (line 299) +* cmpM instruction pattern: Standard Names. (line 253) +* cmpstrM instruction pattern: Standard Names. (line 312) +* code generation RTL sequences: Expander Definitions. + (line 6) +* code motion: Passes. (line 243) +* code_label: Insns. (line 125) +* code_label and /i: Flags. (line 53) +* CODE_LABEL_NUMBER: Insns. (line 125) +* codes, RTL expression: RTL Objects. (line 47) +* COImode: Machine Modes. (line 116) +* COLLECT2_HOST_INITIALIZATION: Host Config. (line 87) +* COLLECT_EXPORT_LIST: Misc. (line 584) +* combiner pass: Regs and Memory. (line 148) +* common subexpression elimination: Passes. (line 210) +* compare: Arithmetic. (line 42) +* compare, canonicalization of: Insn Canonicalizations. + (line 25) +* compiler passes and files: Passes. (line 6) +* complement, bitwise: Arithmetic. (line 128) +* COMPLEX_CST: Expression trees. (line 6) +* COMPLEX_EXPR: Expression trees. (line 6) +* COMPLEX_TYPE: Types. (line 6) +* COMPONENT_REF: Expression trees. (line 6) +* COMPOUND_BODY: Function Bodies. (line 6) +* COMPOUND_EXPR: Expression trees. (line 6) +* COMPOUND_LITERAL_EXPR: Expression trees. (line 6) +* COMPOUND_LITERAL_EXPR_DECL: Expression trees. (line 449) +* COMPOUND_LITERAL_EXPR_DECL_STMT: Expression trees. (line 449) +* COMPOUND_STMT: Function Bodies. (line 6) +* computing the length of an insn: Insn Lengths. (line 6) +* cond: Comparisons. (line 87) +* cond and attributes: Expressions. (line 37) +* cond_exec: Side Effects. (line 239) +* COND_EXPR: Expression trees. (line 6) +* condition code register: Regs and Memory. (line 182) +* condition code status: Condition Code. (line 6) +* condition codes: Comparisons. (line 17) +* conditional constant propagation: Passes. (line 190) +* Conditional Constant Propagation, SSA based: Passes. (line 190) +* conditional execution: Conditional Execution. + (line 6) +* CONDITIONAL_REGISTER_USAGE: Register Basics. (line 59) +* conditional_trap instruction pattern: Standard Names. (line 893) +* conditions, in patterns: Patterns. (line 44) +* configuration file: Host Config. (line 6) +* configure terms: Configure Terms. (line 6) +* CONJ_EXPR: Expression trees. (line 6) +* CONST0_RTX: Constants. (line 70) +* const0_rtx: Constants. (line 13) +* CONST1_RTX: Constants. (line 70) +* const1_rtx: Constants. (line 13) +* CONST2_RTX: Constants. (line 70) +* const2_rtx: Constants. (line 13) +* CONST_COSTS: Costs. (line 9) +* CONST_DECL: Declarations. (line 6) +* const_double: Constants. (line 29) +* const_double, RTL sharing: Sharing. (line 29) +* CONST_DOUBLE_CHAIN: Constants. (line 48) +* CONST_DOUBLE_LOW: Constants. (line 57) +* CONST_DOUBLE_MEM: Constants. (line 48) +* CONST_DOUBLE_OK_FOR_LETTER_P: Register Classes. (line 387) +* const_int: Constants. (line 8) +* const_int and attribute tests: Expressions. (line 47) +* const_int and attributes: Expressions. (line 10) +* const_int, RTL sharing: Sharing. (line 23) +* CONST_OK_FOR_LETTER_P: Register Classes. (line 378) +* CONST_OR_PURE_CALL_P: Flags. (line 19) +* const_string: Constants. (line 79) +* const_string and attributes: Expressions. (line 20) +* const_true_rtx: Constants. (line 23) +* const_vector: Constants. (line 36) +* const_vector, RTL sharing: Sharing. (line 32) +* constant attributes: Constant Attributes. (line 6) +* constant definitions: Constant Definitions. + (line 6) +* constant folding: Passes. (line 86) +* constant folding and floating point: Cross-compilation. (line 93) +* constant propagation: Passes. (line 210) +* CONSTANT_ADDRESS_P: Addressing Modes. (line 28) +* CONSTANT_AFTER_FUNCTION_P: Data Output. (line 107) +* CONSTANT_ALIGNMENT: Storage Layout. (line 207) +* CONSTANT_P: Addressing Modes. (line 34) +* CONSTANT_POOL_ADDRESS_P: Flags. (line 10) +* CONSTANT_POOL_BEFORE_FUNCTION: Data Output. (line 63) +* constants in constraints: Simple Constraints. (line 58) +* constm1_rtx: Constants. (line 13) +* constraint modifier characters: Modifiers. (line 6) +* constraint, matching: Simple Constraints. (line 130) +* constraints: Constraints. (line 6) +* constraints, machine specific: Machine Constraints. (line 6) +* CONSTRUCTOR: Expression trees. (line 6) +* constructor: Function Basics. (line 6) +* constructors, automatic calls: Collect2. (line 15) +* constructors, output of: Initialization. (line 6) +* container: Containers. (line 6) +* CONTINUE_STMT: Function Bodies. (line 6) +* contributors: Contributors. (line 6) +* controlling register usage: Register Basics. (line 76) +* controlling the compilation driver: Driver. (line 6) +* conventions, run-time: Interface. (line 6) +* conversions: Conversions. (line 6) +* CONVERT_EXPR: Expression trees. (line 6) +* copy constructor: Function Basics. (line 6) +* copy propagation: Passes. (line 220) +* copy_rtx: Addressing Modes. (line 207) +* copy_rtx_if_shared: Sharing. (line 64) +* costs of instructions: Costs. (line 6) +* COSTS_N_INSNS: Costs. (line 23) +* CP_INTEGRAL_TYPE: Types. (line 73) +* cp_namespace_decls: Namespaces. (line 44) +* CP_TYPE_CONST_NON_VOLATILE_P: Types. (line 46) +* CP_TYPE_CONST_P: Types. (line 37) +* CP_TYPE_QUALS: Types. (line 6) +* CP_TYPE_RESTRICT_P: Types. (line 43) +* CP_TYPE_VOLATILE_P: Types. (line 40) +* CPLUSPLUS_CPP_SPEC: Driver. (line 77) +* CPP_PREDEFINES: Run-time Target. (line 8) +* cpp_register_pragma: Misc. (line 322) +* CPP_SPEC: Driver. (line 70) +* CQImode: Machine Modes. (line 116) +* cross compilation and floating point: Cross-compilation. (line 6) +* CRT_CALL_STATIC_FUNCTION: Sections. (line 66) +* CRTSTUFF_T_CFLAGS: Target Fragment. (line 35) +* CRTSTUFF_T_CFLAGS_S: Target Fragment. (line 39) +* CSImode: Machine Modes. (line 116) +* CTImode: Machine Modes. (line 116) +* CUMULATIVE_ARGS: Register Arguments. (line 131) +* current_function_epilogue_delay_list: Function Entry. (line 189) +* current_function_is_leaf: Leaf Functions. (line 51) +* current_function_outgoing_args_size: Stack Arguments. (line 40) +* current_function_pops_args: Function Entry. (line 106) +* current_function_pretend_args_size: Function Entry. (line 112) +* current_function_uses_only_leaf_regs: Leaf Functions. (line 51) +* current_insn_predicate: Conditional Execution. + (line 26) +* cycle_display instruction pattern: Standard Names. (line 922) +* data flow analysis: Passes. (line 264) +* data structures: Per-Function Data. (line 6) +* DATA_ALIGNMENT: Storage Layout. (line 194) +* data_section: Sections. (line 88) +* DATA_SECTION_ASM_OP: Sections. (line 28) +* DBR_OUTPUT_SEQEND: Instruction Output. (line 111) +* dbr_sequence_length: Instruction Output. (line 111) +* DBX_BLOCKS_FUNCTION_RELATIVE: DBX Options. (line 112) +* DBX_CONTIN_CHAR: DBX Options. (line 65) +* DBX_CONTIN_LENGTH: DBX Options. (line 55) +* DBX_DEBUGGING_INFO: DBX Options. (line 8) +* DBX_FUNCTION_FIRST: DBX Options. (line 100) +* DBX_LBRAC_FIRST: DBX Options. (line 106) +* DBX_MEMPARM_STABS_LETTER: DBX Options. (line 96) +* DBX_NO_XREFS: DBX Options. (line 49) +* DBX_OUTPUT_ENUM: DBX Hooks. (line 21) +* DBX_OUTPUT_FUNCTION_END: DBX Hooks. (line 27) +* DBX_OUTPUT_LBRAC: DBX Hooks. (line 8) +* DBX_OUTPUT_MAIN_SOURCE_DIRECTORY: File Names and DBX. (line 24) +* DBX_OUTPUT_MAIN_SOURCE_FILE_END: File Names and DBX. (line 32) +* DBX_OUTPUT_MAIN_SOURCE_FILENAME: File Names and DBX. (line 15) +* DBX_OUTPUT_NFUN: DBX Hooks. (line 17) +* DBX_OUTPUT_RBRAC: DBX Hooks. (line 14) +* DBX_OUTPUT_SOURCE_FILENAME: File Names and DBX. (line 39) +* DBX_OUTPUT_STANDARD_TYPES: DBX Hooks. (line 34) +* DBX_REGISTER_NUMBER: All Debuggers. (line 8) +* DBX_REGPARM_STABS_CODE: DBX Options. (line 86) +* DBX_REGPARM_STABS_LETTER: DBX Options. (line 91) +* DBX_STATIC_CONST_VAR_CODE: DBX Options. (line 81) +* DBX_STATIC_STAB_DATA_SECTION: DBX Options. (line 72) +* DBX_TYPE_DECL_STABS_CODE: DBX Options. (line 77) +* DBX_USE_BINCL: DBX Options. (line 117) +* DBX_WORKING_DIRECTORY: File Names and DBX. (line 8) +* DCE, SSA based: Passes. (line 201) +* DCmode: Machine Modes. (line 111) +* De Morgan's law: Insn Canonicalizations. + (line 42) +* dead code: Passes. (line 146) +* dead code elimination: Passes. (line 201) +* dead_or_set_p: define_peephole. (line 65) +* DEBUG_SYMS_TEXT: DBX Options. (line 24) +* DEBUGGER_ARG_OFFSET: All Debuggers. (line 36) +* DEBUGGER_AUTO_OFFSET: All Debuggers. (line 27) +* debugging information generation: Passes. (line 418) +* DECL_ALIGN: Declarations. (line 6) +* DECL_ANTICIPATED: Function Basics. (line 41) +* DECL_ARGUMENTS: Function Basics. (line 156) +* DECL_ARRAY_DELETE_OPERATOR_P: Function Basics. (line 177) +* DECL_ARTIFICIAL <1>: Function Basics. (line 6) +* DECL_ARTIFICIAL: Declarations. (line 29) +* DECL_ASSEMBLER_NAME: Function Basics. (line 6) +* DECL_ATTRIBUTES: Attributes. (line 22) +* DECL_BASE_CONSTRUCTOR_P: Function Basics. (line 87) +* DECL_CLASS_SCOPE_P: Declarations. (line 46) +* DECL_COMPLETE_CONSTRUCTOR_P: Function Basics. (line 83) +* DECL_COMPLETE_DESTRUCTOR_P: Function Basics. (line 97) +* DECL_CONST_MEMFUNC_P: Function Basics. (line 70) +* DECL_CONSTRUCTOR_P: Function Basics. (line 6) +* DECL_CONTEXT: Namespaces. (line 26) +* DECL_CONV_FN_P: Function Basics. (line 6) +* DECL_COPY_CONSTRUCTOR_P: Function Basics. (line 91) +* DECL_DESTRUCTOR_P: Function Basics. (line 6) +* DECL_EXTERN_C_FUNCTION_P: Function Basics. (line 45) +* DECL_EXTERNAL <1>: Function Basics. (line 31) +* DECL_EXTERNAL: Declarations. (line 6) +* DECL_FUNCTION_MEMBER_P: Function Basics. (line 6) +* DECL_FUNCTION_SCOPE_P: Declarations. (line 49) +* DECL_GLOBAL_CTOR_P: Function Basics. (line 6) +* DECL_GLOBAL_DTOR_P: Function Basics. (line 6) +* DECL_INITIAL: Declarations. (line 6) +* DECL_LINKONCE_P: Function Basics. (line 6) +* DECL_LOCAL_FUNCTION_P: Function Basics. (line 37) +* DECL_MAIN_P: Function Basics. (line 7) +* DECL_NAME <1>: Function Basics. (line 6) +* DECL_NAME <2>: Declarations. (line 12) +* DECL_NAME: Namespaces. (line 15) +* DECL_NAMESPACE_ALIAS: Namespaces. (line 30) +* DECL_NAMESPACE_SCOPE_P: Declarations. (line 42) +* DECL_NAMESPACE_STD_P: Namespaces. (line 40) +* DECL_NON_THUNK_FUNCTION_P: Function Basics. (line 137) +* DECL_NONCONVERTING_P: Function Basics. (line 79) +* DECL_NONSTATIC_MEMBER_FUNCTION_P: Function Basics. (line 67) +* DECL_OVERLOADED_OPERATOR_P: Function Basics. (line 6) +* DECL_RESULT: Function Basics. (line 161) +* DECL_SIZE: Declarations. (line 6) +* DECL_SOURCE_FILE: Declarations. (line 19) +* DECL_SOURCE_LINE: Declarations. (line 25) +* DECL_STATIC_FUNCTION_P: Function Basics. (line 64) +* DECL_STMT: Function Bodies. (line 6) +* DECL_STMT_DECL: Function Bodies. (line 6) +* DECL_THUNK_P: Function Basics. (line 115) +* DECL_VOLATILE_MEMFUNC_P: Function Basics. (line 73) +* declaration: Declarations. (line 6) +* declarations, RTL: RTL Declarations. (line 6) +* decrement_and_branch_until_zero instruction pattern: Standard Names. + (line 622) +* DEFAULT_CALLER_SAVES: Caller Saves. (line 10) +* DEFAULT_GDB_EXTENSIONS: DBX Options. (line 17) +* DEFAULT_MAIN_RETURN: Misc. (line 396) +* DEFAULT_PCC_STRUCT_RETURN: Aggregate Return. (line 33) +* DEFAULT_RTX_COSTS: Costs. (line 34) +* DEFAULT_SHORT_ENUMS: Type Layout. (line 99) +* DEFAULT_SIGNED_CHAR: Type Layout. (line 93) +* define_asm_attributes: Tagging Insns. (line 73) +* define_attr: Defining Attributes. (line 6) +* define_cond_exec: Conditional Execution. + (line 13) +* define_constants: Constant Definitions. + (line 6) +* define_delay: Delay Slots. (line 25) +* define_expand: Expander Definitions. + (line 11) +* define_function_unit: Function Units. (line 33) +* define_insn: Patterns. (line 6) +* define_insn example: Example. (line 6) +* define_insn_and_split: Insn Splitting. (line 170) +* define_peephole: define_peephole. (line 6) +* define_peephole2: define_peephole2. (line 6) +* define_split: Insn Splitting. (line 32) +* defining attributes and their values: Defining Attributes. (line 6) +* defining jump instruction patterns: Jump Patterns. (line 6) +* defining looping instruction patterns: Looping Patterns. (line 6) +* defining peephole optimizers: Peephole Definitions. + (line 6) +* defining RTL sequences for code generation: Expander Definitions. + (line 6) +* delay slots, defining: Delay Slots. (line 6) +* DELAY_SLOTS_FOR_EPILOGUE: Function Entry. (line 170) +* delayed branch scheduling: Passes. (line 381) +* Dependent Patterns: Dependent Patterns. (line 6) +* destructor: Function Basics. (line 6) +* destructors, output of: Initialization. (line 6) +* DFmode: Machine Modes. (line 73) +* digits in constraint: Simple Constraints. (line 118) +* DImode: Machine Modes. (line 45) +* DIR_SEPARATOR: Host Config. (line 58) +* DIR_SEPARATOR_2: Host Config. (line 59) +* directory options .md: Including Patterns. (line 45) +* disabling certain registers: Register Basics. (line 76) +* dispatch table: Dispatch Tables. (line 8) +* div: Arithmetic. (line 99) +* div and attributes: Expressions. (line 64) +* DIVDI3_LIBCALL: Library Calls. (line 44) +* division: Arithmetic. (line 99) +* divM3 instruction pattern: Standard Names. (line 167) +* divmodM4 instruction pattern: Standard Names. (line 197) +* DIVSI3_LIBCALL: Library Calls. (line 14) +* DO_BODY: Function Bodies. (line 6) +* DO_COND: Function Bodies. (line 6) +* DO_STMT: Function Bodies. (line 6) +* DOLLARS_IN_IDENTIFIERS: Misc. (line 377) +* doloop_begin instruction pattern: Standard Names. (line 653) +* doloop_end instruction pattern: Standard Names. (line 632) +* DONE: Expander Definitions. + (line 74) +* DONT_REDUCE_ADDR: Costs. (line 171) +* DOUBLE_TYPE_SIZE: Type Layout. (line 66) +* driver: Driver. (line 6) +* DUMPFILE_FORMAT: Host Config. (line 104) +* DWARF2_ASM_LINE_DEBUG_INFO: SDB and DWARF. (line 46) +* DWARF2_DEBUGGING_INFO: SDB and DWARF. (line 16) +* DWARF2_FRAME_INFO: SDB and DWARF. (line 26) +* DWARF2_GENERATE_TEXT_SECTION_LABEL: SDB and DWARF. (line 39) +* DWARF2_UNWIND_INFO: Exception Region Output. + (line 33) +* DWARF_CIE_DATA_ALIGNMENT: Exception Region Output. + (line 48) +* DWARF_DEBUGGING_INFO: SDB and DWARF. (line 12) +* DWARF_FRAME_REGISTERS: Frame Registers. (line 92) +* DYNAMIC_CHAIN_ADDRESS: Frame Layout. (line 72) +* E in constraint: Simple Constraints. (line 77) +* earlyclobber operand: Modifiers. (line 25) +* EDOM, implicit usage: Library Calls. (line 81) +* EH_FRAME_IN_DATA_SECTION: Exception Region Output. + (line 19) +* EH_FRAME_SECTION_NAME: Exception Region Output. + (line 9) +* eh_return instruction pattern: Standard Names. (line 832) +* EH_RETURN_DATA_REGNO: Exception Handling. (line 6) +* EH_RETURN_HANDLER_RTX: Exception Handling. (line 34) +* EH_RETURN_STACKADJ_RTX: Exception Handling. (line 21) +* EH_USES: Function Entry. (line 165) +* ELIGIBLE_FOR_EPILOGUE_DELAY: Function Entry. (line 176) +* ELIMINABLE_REGS: Elimination. (line 43) +* ELSE_CLAUSE: Function Bodies. (line 6) +* EMIT_MODE_SET: Mode Switching. (line 62) +* EMPTY_CLASS_EXPR: Function Bodies. (line 6) +* EMPTY_FIELD_BOUNDARY: Storage Layout. (line 231) +* ENCODE_SECTION_INFO: Sections. (line 137) +* ENCODE_SECTION_INFO and address validation: Addressing Modes. + (line 89) +* ENCODE_SECTION_INFO usage: Instruction Output. (line 105) +* ENDFILE_SPEC: Driver. (line 183) +* endianness: Portability. (line 20) +* enum machine_mode: Machine Modes. (line 6) +* enum reg_class: Register Classes. (line 64) +* ENUMERAL_TYPE: Types. (line 6) +* epilogue: Function Entry. (line 6) +* epilogue instruction pattern: Standard Names. (line 865) +* EPILOGUE_USES: Function Entry. (line 159) +* eq: Comparisons. (line 49) +* eq and attributes: Expressions. (line 64) +* eq_attr: Expressions. (line 85) +* EQ_EXPR: Expression trees. (line 6) +* equal: Comparisons. (line 49) +* errno, implicit usage: Library Calls. (line 93) +* escape sequences: Escape Sequences. (line 6) +* exception handling: Exception Handling. (line 6) +* exception_receiver instruction pattern: Standard Names. (line 796) +* exclamation point: Multi-Alternative. (line 47) +* exclusive-or, bitwise: Arithmetic. (line 142) +* EXIT_BODY: Misc. (line 420) +* EXIT_EXPR: Expression trees. (line 6) +* EXIT_IGNORE_STACK: Function Entry. (line 148) +* EXPAND_BUILTIN_SAVEREGS: Varargs. (line 91) +* expander definitions: Expander Definitions. + (line 6) +* expr_list: Insns. (line 525) +* EXPR_STMT: Function Bodies. (line 6) +* EXPR_STMT_EXPR: Function Bodies. (line 6) +* expression: Expression trees. (line 6) +* expression codes: RTL Objects. (line 47) +* extendMN2 instruction pattern: Standard Names. (line 365) +* extensible constraints: Simple Constraints. (line 161) +* extern int target_flags: Run-time Target. (line 28) +* EXTRA_CC_MODES: Condition Code. (line 67) +* EXTRA_CONSTRAINT: Register Classes. (line 402) +* EXTRA_SECTION_FUNCTIONS: Sections. (line 88) +* EXTRA_SECTIONS: Sections. (line 83) +* EXTRA_SPECS: Driver. (line 199) +* extv instruction pattern: Standard Names. (line 374) +* extzv instruction pattern: Standard Names. (line 388) +* F in constraint: Simple Constraints. (line 82) +* FAIL: Expander Definitions. + (line 80) +* FATAL_EXIT_CODE: Host Config. (line 18) +* FDL, GNU Free Documentation License: GNU Free Documentation License. + (line 6) +* features, optional, in system conventions: Run-time Target. (line 31) +* ffs: Arithmetic. (line 172) +* ffsM2 instruction pattern: Standard Names. (line 240) +* FIELD_DECL: Declarations. (line 6) +* FILE_STMT: Function Bodies. (line 6) +* FILE_STMT_FILENAME: Function Bodies. (line 6) +* files and passes of the compiler: Passes. (line 6) +* final pass: Passes. (line 406) +* FINAL_PRESCAN_INSN: Instruction Output. (line 45) +* FINAL_PRESCAN_LABEL: Instruction Output. (line 67) +* FINAL_REG_PARM_STACK_SPACE: Stack Arguments. (line 64) +* final_scan_insn: Function Entry. (line 189) +* final_sequence: Instruction Output. (line 122) +* FINALIZE_PIC: PIC. (line 30) +* FIND_BASE_TERM: Addressing Modes. (line 137) +* FINI_SECTION_ASM_OP: Sections. (line 60) +* FIRST_INSN_ADDRESS: Insn Lengths. (line 35) +* FIRST_PARM_OFFSET: Frame Layout. (line 56) +* FIRST_PARM_OFFSET and virtual registers: Regs and Memory. (line 65) +* FIRST_PSEUDO_REGISTER: Register Basics. (line 8) +* FIRST_STACK_REG: Stack Registers. (line 17) +* FIRST_VIRTUAL_REGISTER: Regs and Memory. (line 51) +* fix: Conversions. (line 67) +* FIX_TRUNC_EXPR: Expression trees. (line 6) +* fix_truncMN2 instruction pattern: Standard Names. (line 352) +* fixed register: Register Basics. (line 15) +* FIXED_REGISTERS: Register Basics. (line 15) +* fixed_regs: Register Basics. (line 59) +* fixMN2 instruction pattern: Standard Names. (line 335) +* FIXUNS_TRUNC_LIKE_FIX_TRUNC: Misc. (line 100) +* fixuns_truncMN2 instruction pattern: Standard Names. (line 356) +* fixunsMN2 instruction pattern: Standard Names. (line 341) +* flags in RTL expression: Flags. (line 6) +* float: Conversions. (line 59) +* FLOAT_EXPR: Expression trees. (line 6) +* float_extend: Conversions. (line 34) +* FLOAT_LIB_COMPARE_RETURNS_BOOL (MODE, COMPARISON): Library Calls. + (line 73) +* FLOAT_STORE_FLAG_VALUE: Misc. (line 240) +* float_truncate: Conversions. (line 54) +* FLOAT_TYPE_SIZE: Type Layout. (line 62) +* FLOAT_WORDS_BIG_ENDIAN: Storage Layout. (line 42) +* FLOAT_WORDS_BIG_ENDIAN, (lack of) effect on subreg: Regs and Memory. + (line 140) +* floating point and cross compilation: Cross-compilation. (line 6) +* Floating Point Emulation: Target Fragment. (line 15) +* floatMN2 instruction pattern: Standard Names. (line 327) +* floatunsMN2 instruction pattern: Standard Names. (line 331) +* FOR_BODY: Function Bodies. (line 6) +* FOR_COND: Function Bodies. (line 6) +* FOR_EXPR: Function Bodies. (line 6) +* FOR_INIT_STMT: Function Bodies. (line 6) +* FOR_STMT: Function Bodies. (line 6) +* FORCE_CODE_SECTION_ALIGN: Sections. (line 77) +* FORCE_PREFERRED_STACK_BOUNDARY_IN_MAIN: Storage Layout. (line 149) +* force_reg: Standard Names. (line 36) +* frame layout: Frame Layout. (line 6) +* FRAME_GROWS_DOWNWARD: Frame Layout. (line 30) +* FRAME_GROWS_DOWNWARD and virtual registers: Regs and Memory. + (line 69) +* frame_pointer_needed: Function Entry. (line 34) +* FRAME_POINTER_REGNUM: Frame Registers. (line 13) +* FRAME_POINTER_REGNUM and virtual registers: Regs and Memory. + (line 74) +* FRAME_POINTER_REQUIRED: Elimination. (line 8) +* frame_pointer_rtx: Frame Registers. (line 85) +* frame_related: Flags. (line 222) +* frame_related, in insn: Flags. (line 128) +* frame_related, in mem: Flags. (line 91) +* frame_related, in reg: Flags. (line 115) +* frame_related, in symbol_ref: Flags. (line 180) +* free_machine_status: Per-Function Data. (line 55) +* ftruncM2 instruction pattern: Standard Names. (line 347) +* function: Functions. (line 6) +* function body: Function Bodies. (line 6) +* function call conventions: Interface. (line 6) +* function entry and exit: Function Entry. (line 6) +* function units, for scheduling: Function Units. (line 6) +* function-call insns: Calls. (line 6) +* FUNCTION_ARG: Register Arguments. (line 10) +* FUNCTION_ARG_ADVANCE: Register Arguments. (line 178) +* FUNCTION_ARG_BOUNDARY: Register Arguments. (line 214) +* FUNCTION_ARG_CALLEE_COPIES: Register Arguments. (line 112) +* FUNCTION_ARG_PADDING: Register Arguments. (line 189) +* FUNCTION_ARG_PARTIAL_NREGS: Register Arguments. (line 80) +* FUNCTION_ARG_PASS_BY_REFERENCE: Register Arguments. (line 99) +* FUNCTION_ARG_REG_LITTLE_ENDIAN: Register Arguments. (line 123) +* FUNCTION_ARG_REGNO_P: Register Arguments. (line 219) +* FUNCTION_BOUNDARY: Storage Layout. (line 159) +* FUNCTION_DECL: Functions. (line 6) +* FUNCTION_INCOMING_ARG: Register Arguments. (line 66) +* FUNCTION_MODE: Misc. (line 259) +* FUNCTION_OK_FOR_SIBCALL: Tail Calls. (line 6) +* FUNCTION_OUTGOING_VALUE: Scalar Return. (line 39) +* FUNCTION_PROFILER: Profiling. (line 8) +* FUNCTION_TYPE: Types. (line 6) +* FUNCTION_VALUE: Scalar Return. (line 13) +* FUNCTION_VALUE_REGNO_P: Scalar Return. (line 73) +* functions, leaf: Leaf Functions. (line 6) +* fundamental type: Types. (line 6) +* g in constraint: Simple Constraints. (line 108) +* G in constraint: Simple Constraints. (line 86) +* GCC and portability: Portability. (line 6) +* GCC_DRIVER_HOST_INITIALIZATION: Host Config. (line 91) +* GCOV_TYPE_SIZE: Type Layout. (line 151) +* ge: Comparisons. (line 69) +* ge and attributes: Expressions. (line 64) +* GE_EXPR: Expression trees. (line 6) +* GEN_ERRNO_RTX: Library Calls. (line 93) +* gencodes: Passes. (line 111) +* genconfig: Passes. (line 442) +* general_operand: RTL Template. (line 57) +* GENERAL_REGS: Register Classes. (line 23) +* generating assembler output: Output Statement. (line 6) +* generating insns: RTL Template. (line 6) +* genflags: Passes. (line 111) +* get_attr: Expressions. (line 80) +* get_attr_length: Insn Lengths. (line 51) +* GET_CLASS_NARROWEST_MODE: Machine Modes. (line 220) +* GET_CODE: RTL Objects. (line 47) +* get_frame_size: Elimination. (line 31) +* get_insns: Insns. (line 34) +* get_last_insn: Insns. (line 34) +* GET_MODE: Machine Modes. (line 175) +* GET_MODE_ALIGNMENT: Machine Modes. (line 207) +* GET_MODE_BITSIZE: Machine Modes. (line 199) +* GET_MODE_CLASS: Machine Modes. (line 189) +* GET_MODE_MASK: Machine Modes. (line 202) +* GET_MODE_NAME: Machine Modes. (line 186) +* GET_MODE_NUNITS: Machine Modes. (line 216) +* GET_MODE_SIZE: Machine Modes. (line 196) +* GET_MODE_UNIT_SIZE: Machine Modes. (line 210) +* GET_MODE_WIDER_MODE: Machine Modes. (line 192) +* GET_RTX_CLASS: RTL Classes. (line 6) +* GET_RTX_FORMAT: RTL Classes. (line 119) +* GET_RTX_LENGTH: RTL Classes. (line 116) +* geu: Comparisons. (line 69) +* geu and attributes: Expressions. (line 64) +* global common subexpression elimination: Passes. (line 220) +* global register allocation: Passes. (line 338) +* GLOBAL_INIT_PRIORITY: Function Basics. (line 6) +* GO_IF_LEGITIMATE_ADDRESS: Addressing Modes. (line 45) +* GO_IF_MODE_DEPENDENT_ADDRESS: Addressing Modes. (line 214) +* GOTO_DESTINATION: Function Bodies. (line 6) +* GOTO_FAKE_P: Function Bodies. (line 6) +* GOTO_STMT: Function Bodies. (line 6) +* greater than: Comparisons. (line 57) +* gt: Comparisons. (line 57) +* gt and attributes: Expressions. (line 64) +* GT_EXPR: Expression trees. (line 6) +* gtu: Comparisons. (line 61) +* gtu and attributes: Expressions. (line 64) +* H in constraint: Simple Constraints. (line 86) +* HANDLE_PRAGMA: Misc. (line 294) +* HANDLE_PRAGMA_PACK_PUSH_POP: Misc. (line 366) +* HANDLE_SYSV_PRAGMA: Misc. (line 352) +* HANDLER: Function Bodies. (line 6) +* HANDLER_BODY: Function Bodies. (line 6) +* HANDLER_PARMS: Function Bodies. (line 6) +* hard registers: Regs and Memory. (line 9) +* HARD_FRAME_POINTER_REGNUM: Frame Registers. (line 19) +* HARD_REGNO_CALL_PART_CLOBBERED: Register Basics. (line 52) +* HARD_REGNO_CALLER_SAVE_MODE: Caller Saves. (line 27) +* HARD_REGNO_MODE_OK: Values in Registers. (line 22) +* HARD_REGNO_NREGS: Values in Registers. (line 10) +* HAS_INIT_SECTION: Macros for Initialization. + (line 19) +* HAVE_DOS_BASED_FILE_SYSTEM: Host Config. (line 44) +* HAVE_POST_DECREMENT: Addressing Modes. (line 8) +* HAVE_POST_INCREMENT: Addressing Modes. (line 8) +* HAVE_POST_MODIFY_DISP: Addressing Modes. (line 16) +* HAVE_POST_MODIFY_REG: Addressing Modes. (line 22) +* HAVE_PRE_DECREMENT: Addressing Modes. (line 8) +* HAVE_PRE_INCREMENT: Addressing Modes. (line 8) +* HAVE_PRE_MODIFY_DISP: Addressing Modes. (line 16) +* HAVE_PRE_MODIFY_REG: Addressing Modes. (line 22) +* HCmode: Machine Modes. (line 111) +* HFmode: Machine Modes. (line 58) +* high: Constants. (line 114) +* HImode: Machine Modes. (line 29) +* HImode, in insn: Insns. (line 225) +* host makefile fragment: Host Fragment. (line 6) +* HOST_BIT_BUCKET: Host Config. (line 79) +* HOST_EXECUTABLE_SUFFIX: Host Config. (line 73) +* HOST_OBJECT_SUFFIX: Host Config. (line 68) +* I in constraint: Simple Constraints. (line 69) +* i in constraint: Simple Constraints. (line 58) +* IBM_FLOAT_FORMAT: Storage Layout. (line 407) +* identifier: Identifiers. (line 6) +* IDENTIFIER_LENGTH: Identifiers. (line 20) +* IDENTIFIER_NODE: Identifiers. (line 6) +* IDENTIFIER_OPNAME_P: Identifiers. (line 25) +* IDENTIFIER_POINTER: Identifiers. (line 15) +* IDENTIFIER_TYPENAME_P: Identifiers. (line 31) +* IEEE_FLOAT_FORMAT: Storage Layout. (line 400) +* if conversion: Passes. (line 290) +* IF_COND: Function Bodies. (line 6) +* IF_STMT: Function Bodies. (line 6) +* if_then_else: Comparisons. (line 77) +* if_then_else and attributes: Expressions. (line 32) +* if_then_else usage: Side Effects. (line 51) +* IFCVT_MODIFY_CANCEL: Misc. (line 517) +* IFCVT_MODIFY_FINAL: Misc. (line 512) +* IFCVT_MODIFY_INSN: Misc. (line 508) +* IFCVT_MODIFY_TESTS: Misc. (line 501) +* IMAGPART_EXPR: Expression trees. (line 6) +* immediate_operand: RTL Template. (line 72) +* IMMEDIATE_PREFIX: Instruction Output. (line 129) +* in_data: Sections. (line 83) +* in_struct: Flags. (line 237) +* in_struct, in code_label: Flags. (line 53) +* in_struct, in insn: Flags. (line 30) +* in_struct, in label_ref: Flags. (line 48) +* in_struct, in mem: Flags. (line 76) +* in_struct, in reg: Flags. (line 110) +* in_struct, in subreg: Flags. (line 191) +* in_text: Sections. (line 83) +* include: Including Patterns. (line 6) +* INCLUDE_DEFAULTS: Driver. (line 383) +* inclusive-or, bitwise: Arithmetic. (line 137) +* INCOMING_FRAME_SP_OFFSET: Frame Layout. (line 125) +* INCOMING_REGNO: Register Basics. (line 96) +* INCOMING_RETURN_ADDR_RTX: Frame Layout. (line 112) +* INDEX_REG_CLASS: Register Classes. (line 117) +* indirect_jump instruction pattern: Standard Names. (line 575) +* INDIRECT_REF: Expression trees. (line 6) +* INIT_CUMULATIVE_ARGS: Register Arguments. (line 144) +* INIT_CUMULATIVE_INCOMING_ARGS: Register Arguments. (line 169) +* INIT_CUMULATIVE_LIBCALL_ARGS: Register Arguments. (line 163) +* INIT_ENVIRONMENT: Driver. (line 322) +* INIT_EXPANDERS: Per-Function Data. (line 41) +* INIT_EXPR: Expression trees. (line 6) +* init_machine_status: Per-Function Data. (line 47) +* INIT_SECTION_ASM_OP <1>: Macros for Initialization. + (line 9) +* INIT_SECTION_ASM_OP: Sections. (line 54) +* INIT_TARGET_OPTABS: Library Calls. (line 68) +* INITIAL_ELIMINATION_OFFSET: Elimination. (line 78) +* INITIAL_FRAME_POINTER_OFFSET: Elimination. (line 31) +* initialization routines: Initialization. (line 6) +* INITIALIZE_TRAMPOLINE: Trampolines. (line 55) +* inline on rtx, automatic: Passes. (line 120) +* inline on trees, automatic: Passes. (line 80) +* inlining: Target Attributes. (line 69) +* insn: Insns. (line 64) +* insn and /f: Flags. (line 128) +* insn and /i: Flags. (line 154) +* insn and /j: Flags. (line 172) +* insn and /s: Flags. (line 30) +* insn and /u: Flags. (line 24) +* insn and /v: Flags. (line 34) +* insn attributes: Insn Attributes. (line 6) +* insn canonicalization: Insn Canonicalizations. + (line 6) +* insn includes: Including Patterns. (line 6) +* insn lengths, computing: Insn Lengths. (line 6) +* insn splitting: Insn Splitting. (line 6) +* insn-attr.h: Defining Attributes. (line 24) +* INSN_ANNULLED_BRANCH_P: Flags. (line 24) +* INSN_CACHE_DEPTH: Trampolines. (line 116) +* INSN_CACHE_LINE_WIDTH: Trampolines. (line 109) +* INSN_CACHE_SIZE: Trampolines. (line 106) +* INSN_CODE: Insns. (line 251) +* INSN_DEAD_CODE_P: Flags. (line 30) +* INSN_DELETED_P: Flags. (line 34) +* INSN_FROM_TARGET_P: Flags. (line 38) +* insn_list: Insns. (line 525) +* insn_list and /c: Flags. (line 64) +* insn_list and /j: Flags. (line 70) +* INSN_REFERENCES_ARE_DELAYED: Misc. (line 436) +* INSN_SETS_ARE_DELAYED: Misc. (line 425) +* INSN_UID: Insns. (line 23) +* insns: Insns. (line 6) +* insns, generating: RTL Template. (line 6) +* insns, recognizing: RTL Template. (line 6) +* instruction attributes: Insn Attributes. (line 6) +* instruction combination: Passes. (line 279) +* instruction patterns: Patterns. (line 6) +* instruction recognizer: Passes. (line 447) +* instruction scheduling: Passes. (line 309) +* instruction splitting: Insn Splitting. (line 6) +* insv instruction pattern: Standard Names. (line 391) +* INT_TYPE_SIZE: Type Layout. (line 11) +* INTEGER_CST: Expression trees. (line 6) +* INTEGER_TYPE: Types. (line 6) +* INTEGRATE_THRESHOLD: Misc. (line 264) +* integrated: Flags. (line 272) +* integrated, in insn: Flags. (line 154) +* integrated, in reg: Flags. (line 105) +* integrated, in symbol_ref: Flags. (line 210) +* INTEL_EXTENDED_IEEE_FORMAT: Type Layout. (line 82) +* Interdependence of Patterns: Dependent Patterns. (line 6) +* interfacing to GCC output: Interface. (line 6) +* INTMAX_TYPE: Type Layout. (line 167) +* introduction: Top. (line 6) +* INVOKE__main: Macros for Initialization. + (line 51) +* ior: Arithmetic. (line 137) +* ior and attributes: Expressions. (line 50) +* ior, canonicalization of: Insn Canonicalizations. + (line 42) +* iorM3 instruction pattern: Standard Names. (line 167) +* IS_ASM_LOGICAL_LINE_SEPARATOR: Data Output. (line 124) +* isinf: Cross-compilation. (line 83) +* isnan: Cross-compilation. (line 88) +* jump: Flags. (line 285) +* jump instruction pattern: Standard Names. (line 466) +* jump instruction patterns: Jump Patterns. (line 6) +* jump instructions and set: Side Effects. (line 51) +* jump optimization: Passes. (line 146) +* jump threading: Passes. (line 172) +* jump, in call_insn: Flags. (line 176) +* jump, in insn: Flags. (line 172) +* jump, in insn_list: Flags. (line 70) +* jump, in mem: Flags. (line 85) +* JUMP_ALIGN: Alignment Output. (line 8) +* jump_insn: Insns. (line 74) +* JUMP_LABEL: Insns. (line 80) +* JUMP_TABLES_IN_TEXT_SECTION: Sections. (line 128) +* LABEL_ALIGN: Alignment Output. (line 51) +* LABEL_ALIGN_AFTER_BARRIER: Alignment Output. (line 21) +* LABEL_ALIGN_AFTER_BARRIER_MAX_SKIP: Alignment Output. (line 29) +* LABEL_ALIGN_MAX_SKIP: Alignment Output. (line 61) +* LABEL_ALTERNATE_NAME: Insns. (line 146) +* LABEL_DECL: Declarations. (line 6) +* LABEL_NUSES: Insns. (line 142) +* LABEL_OUTSIDE_LOOP_P: Flags. (line 48) +* LABEL_PRESERVE_P: Flags. (line 53) +* label_ref: Constants. (line 94) +* label_ref and /s: Flags. (line 48) +* label_ref and /v: Flags. (line 59) +* label_ref, RTL sharing: Sharing. (line 35) +* LABEL_REF_NONLOCAL_P: Flags. (line 59) +* LABEL_STMT: Function Bodies. (line 6) +* LABEL_STMT_LABEL: Function Bodies. (line 6) +* large return values: Aggregate Return. (line 6) +* LAST_STACK_REG: Stack Registers. (line 21) +* LAST_VIRTUAL_REGISTER: Regs and Memory. (line 51) +* LD_FINI_SWITCH: Macros for Initialization. + (line 29) +* LD_INIT_SWITCH: Macros for Initialization. + (line 25) +* LDD_SUFFIX: Macros for Initialization. + (line 120) +* ldexp: Cross-compilation. (line 45) +* le: Comparisons. (line 73) +* le and attributes: Expressions. (line 64) +* LE_EXPR: Expression trees. (line 6) +* leaf functions: Leaf Functions. (line 6) +* leaf_function_p: Standard Names. (line 537) +* LEAF_REG_REMAP: Leaf Functions. (line 38) +* LEAF_REGISTERS: Leaf Functions. (line 24) +* left rotate: Arithmetic. (line 160) +* left shift: Arithmetic. (line 147) +* LEGITIMATE_CONSTANT_P: Addressing Modes. (line 229) +* LEGITIMATE_PIC_OPERAND_P: PIC. (line 46) +* LEGITIMIZE_ADDRESS: Addressing Modes. (line 147) +* LEGITIMIZE_RELOAD_ADDRESS: Addressing Modes. (line 169) +* less than: Comparisons. (line 65) +* less than or equal: Comparisons. (line 73) +* leu: Comparisons. (line 73) +* leu and attributes: Expressions. (line 64) +* LIB2FUNCS_EXTRA: Target Fragment. (line 11) +* LIB_SPEC: Driver. (line 158) +* LIBCALL_VALUE: Scalar Return. (line 56) +* libgcc.a: Library Calls. (line 6) +* LIBGCC2_CFLAGS: Target Fragment. (line 8) +* LIBGCC2_WORDS_BIG_ENDIAN: Storage Layout. (line 35) +* LIBGCC_NEEDS_DOUBLE: Library Calls. (line 104) +* LIBGCC_SPEC: Driver. (line 166) +* library subroutine names: Library Calls. (line 6) +* LIBRARY_PATH_ENV: Misc. (line 481) +* LIMIT_RELOAD_CLASS: Register Classes. (line 185) +* LINK_COMMAND_SPEC: Driver. (line 262) +* LINK_COST_FREE: Flags. (line 64) +* LINK_COST_ZERO: Flags. (line 70) +* LINK_ELIMINATE_DUPLICATE_LDIRECTORIES: Driver. (line 272) +* LINK_GCC_C_SEQUENCE_SPEC: Driver. (line 258) +* LINK_LIBGCC_SPECIAL: Driver. (line 244) +* LINK_LIBGCC_SPECIAL_1: Driver. (line 251) +* LINK_SPEC: Driver. (line 151) +* linkage: Function Basics. (line 6) +* LINKER_DOES_NOT_WORK_WITH_DWARF2: SDB and DWARF. (line 32) +* list: Containers. (line 6) +* lo_sum: Arithmetic. (line 18) +* load address instruction: Simple Constraints. (line 152) +* LOAD_ARGS_REVERSED: Register Arguments. (line 227) +* LOAD_EXTEND_OP: Misc. (line 82) +* load_multiple instruction pattern: Standard Names. (line 125) +* local register allocation: Passes. (line 329) +* LOCAL_ALIGNMENT: Storage Layout. (line 220) +* LOCAL_CLASS_P: Classes. (line 66) +* LOCAL_INCLUDE_DIR: Driver. (line 329) +* LOCAL_LABEL_PREFIX: Instruction Output. (line 129) +* LOCAL_REGNO: Register Basics. (line 110) +* LOG_LINKS: Insns. (line 270) +* logical-and, bitwise: Arithmetic. (line 132) +* LONG_DOUBLE_TYPE_SIZE: Type Layout. (line 71) +* LONG_LONG_TYPE_SIZE: Type Layout. (line 39) +* LONG_TYPE_SIZE: Type Layout. (line 21) +* longjmp and automatic variables: Interface. (line 53) +* loop optimization: Passes. (line 243) +* LOOP_ALIGN: Alignment Output. (line 34) +* LOOP_ALIGN_MAX_SKIP: Alignment Output. (line 47) +* LOOP_EXPR: Expression trees. (line 6) +* looping instruction patterns: Looping Patterns. (line 6) +* LSHIFT_EXPR: Expression trees. (line 6) +* lshiftrt: Arithmetic. (line 155) +* lshiftrt and attributes: Expressions. (line 64) +* lshrM3 instruction pattern: Standard Names. (line 224) +* lt: Comparisons. (line 65) +* lt and attributes: Expressions. (line 64) +* LT_EXPR: Expression trees. (line 6) +* ltu: Comparisons. (line 65) +* m in constraint: Simple Constraints. (line 17) +* machine attributes: Target Attributes. (line 6) +* machine description macros: Target Macros. (line 6) +* machine descriptions: Machine Desc. (line 6) +* machine mode conversions: Conversions. (line 6) +* machine modes: Machine Modes. (line 6) +* machine specific constraints: Machine Constraints. (line 6) +* MACHINE_DEPENDENT_REORG: Misc. (line 449) +* macros, target description: Target Macros. (line 6) +* MAKE_DECL_ONE_ONLY (DECL): Label Output. (line 104) +* make_safe_from: Expander Definitions. + (line 148) +* makefile fragment: Fragments. (line 6) +* makefile targets: Makefile. (line 6) +* mark_machine_status: Per-Function Data. (line 62) +* MASK_RETURN_ADDR: Exception Region Output. + (line 28) +* match_dup <1>: define_peephole2. (line 28) +* match_dup: RTL Template. (line 94) +* match_dup and attributes: Insn Lengths. (line 16) +* match_insn: RTL Template. (line 244) +* match_insn2: RTL Template. (line 253) +* match_op_dup: RTL Template. (line 184) +* match_operand: RTL Template. (line 16) +* match_operand and attributes: Expressions. (line 55) +* match_operator: RTL Template. (line 116) +* match_par_dup: RTL Template. (line 240) +* match_parallel: RTL Template. (line 193) +* match_scratch <1>: define_peephole2. (line 28) +* match_scratch: RTL Template. (line 79) +* matching constraint: Simple Constraints. (line 130) +* matching operands: Output Template. (line 50) +* math libraries: Interface. (line 72) +* math, in RTL: Arithmetic. (line 6) +* MATH_LIBRARY: Misc. (line 474) +* MAX_BITS_PER_WORD: Storage Layout. (line 58) +* MAX_CHAR_TYPE_SIZE: Type Layout. (line 50) +* MAX_CONDITIONAL_EXECUTE: Misc. (line 495) +* MAX_FIXED_MODE_SIZE: Storage Layout. (line 349) +* MAX_INTEGER_COMPUTATION_MODE: Misc. (line 466) +* MAX_LONG_DOUBLE_TYPE_SIZE: Type Layout. (line 76) +* MAX_LONG_TYPE_SIZE: Type Layout. (line 32) +* MAX_MOVE_MAX: Misc. (line 110) +* MAX_OFILE_ALIGNMENT: Storage Layout. (line 188) +* MAX_REGS_PER_ADDRESS: Addressing Modes. (line 39) +* MAX_WCHAR_TYPE_SIZE: Type Layout. (line 144) +* maxM3 instruction pattern: Standard Names. (line 171) +* MAYBE_REG_PARM_STACK_SPACE: Stack Arguments. (line 64) +* mcount: Profiling. (line 12) +* MD_ASM_CLOBBERS: Misc. (line 462) +* MD_CAN_REDIRECT_BRANCH: Misc. (line 548) +* MD_EXEC_PREFIX: Driver. (line 299) +* MD_FALLBACK_FRAME_STATE_FOR: Exception Handling. (line 81) +* MD_STARTFILE_PREFIX: Driver. (line 311) +* MD_STARTFILE_PREFIX_1: Driver. (line 317) +* mem: Regs and Memory. (line 249) +* mem and /f: Flags. (line 91) +* mem and /j: Flags. (line 85) +* mem and /s: Flags. (line 76) +* mem and /u: Flags. (line 159) +* mem and /v: Flags. (line 100) +* mem, RTL sharing: Sharing. (line 40) +* MEM_IN_STRUCT_P: Flags. (line 76) +* MEM_KEEP_ALIAS_SET_P: Flags. (line 85) +* MEM_SCALAR_P: Flags. (line 91) +* MEM_VOLATILE_P: Flags. (line 100) +* MEMBER_TYPE_FORCES_BLK: Storage Layout. (line 319) +* memcpy, implicit usage: Library Calls. (line 99) +* memmove, implicit usage: Library Calls. (line 99) +* memory reference, nonoffsettable: Simple Constraints. (line 251) +* memory references in constraints: Simple Constraints. (line 17) +* MEMORY_MOVE_COST: Costs. (line 109) +* memset, implicit usage: Library Calls. (line 99) +* METHOD_TYPE: Types. (line 6) +* MIN_UNITS_PER_WORD: Storage Layout. (line 67) +* MINIMUM_ATOMIC_ALIGNMENT: Storage Layout. (line 166) +* minM3 instruction pattern: Standard Names. (line 171) +* minus: Arithmetic. (line 27) +* minus and attributes: Expressions. (line 64) +* minus, canonicalization of: Insn Canonicalizations. + (line 21) +* MINUS_EXPR: Expression trees. (line 6) +* mod: Arithmetic. (line 113) +* mod and attributes: Expressions. (line 64) +* MODDI3_LIBCALL: Library Calls. (line 56) +* mode classes: Machine Modes. (line 134) +* mode switching: Mode Switching. (line 6) +* MODE_BASE_REG_CLASS: Register Classes. (line 111) +* MODE_CC: Machine Modes. (line 163) +* MODE_COMPLEX_FLOAT: Machine Modes. (line 155) +* MODE_COMPLEX_INT: Machine Modes. (line 152) +* MODE_FLOAT: Machine Modes. (line 148) +* MODE_FUNCTION: Machine Modes. (line 159) +* MODE_INT: Machine Modes. (line 140) +* MODE_NEEDED: Mode Switching. (line 41) +* MODE_PARTIAL_INT: Machine Modes. (line 144) +* MODE_PRIORITY_TO_MODE: Mode Switching. (line 54) +* MODE_RANDOM: Machine Modes. (line 168) +* MODES_TIEABLE_P: Values in Registers. (line 83) +* modifiers in constraints: Modifiers. (line 6) +* MODIFY_EXPR: Expression trees. (line 6) +* MODIFY_TARGET_NAME: Driver. (line 338) +* modM3 instruction pattern: Standard Names. (line 167) +* MODSI3_LIBCALL: Library Calls. (line 26) +* MOVE_BY_PIECES_P: Costs. (line 189) +* MOVE_MAX: Misc. (line 105) +* MOVE_MAX_PIECES: Costs. (line 195) +* MOVE_RATIO: Costs. (line 176) +* movM instruction pattern: Standard Names. (line 11) +* movMODEcc instruction pattern: Standard Names. (line 401) +* movstrictM instruction pattern: Standard Names. (line 119) +* movstrM instruction pattern: Standard Names. (line 271) +* MULDI3_LIBCALL: Library Calls. (line 38) +* mulhisi3 instruction pattern: Standard Names. (line 178) +* mulM3 instruction pattern: Standard Names. (line 167) +* mulqihi3 instruction pattern: Standard Names. (line 182) +* MULSI3_LIBCALL: Library Calls. (line 8) +* mulsidi3 instruction pattern: Standard Names. (line 182) +* mult: Arithmetic. (line 84) +* mult and attributes: Expressions. (line 64) +* mult, canonicalization of: Insn Canonicalizations. + (line 21) +* MULT_EXPR: Expression trees. (line 6) +* MULTILIB_DEFAULTS: Driver. (line 278) +* MULTILIB_DIRNAMES: Target Fragment. (line 64) +* MULTILIB_EXCEPTIONS: Target Fragment. (line 84) +* MULTILIB_EXTRA_OPTS: Target Fragment. (line 96) +* MULTILIB_MATCHES: Target Fragment. (line 77) +* MULTILIB_OPTIONS: Target Fragment. (line 44) +* multiple alternative constraints: Multi-Alternative. (line 6) +* MULTIPLE_SYMBOL_SPACES: Misc. (line 455) +* multiplication: Arithmetic. (line 84) +* MUST_PASS_IN_STACK: Register Arguments. (line 60) +* MUST_PASS_IN_STACK, and FUNCTION_ARG: Register Arguments. (line 52) +* n in constraint: Simple Constraints. (line 63) +* N_REG_CLASSES: Register Classes. (line 75) +* name: Identifiers. (line 6) +* named patterns and conditions: Patterns. (line 48) +* names, pattern: Standard Names. (line 6) +* namespace: Namespaces. (line 6) +* namespace, class, scope: Scopes. (line 6) +* NAMESPACE_DECL <1>: Declarations. (line 6) +* NAMESPACE_DECL: Namespaces. (line 6) +* ne: Comparisons. (line 53) +* ne and attributes: Expressions. (line 64) +* NE_EXPR: Expression trees. (line 6) +* NEED_ATEXIT: Misc. (line 406) +* neg: Arithmetic. (line 80) +* neg and attributes: Expressions. (line 64) +* neg, canonicalization of: Insn Canonicalizations. + (line 21) +* NEGATE_EXPR: Expression trees. (line 6) +* negM2 instruction pattern: Standard Names. (line 228) +* nested functions, trampolines for: Trampolines. (line 6) +* next_cc0_user: Jump Patterns. (line 64) +* NEXT_INSN: Insns. (line 30) +* NEXT_OBJC_RUNTIME: Library Calls. (line 112) +* nil: RTL Objects. (line 73) +* NO_BUILTIN_PTRDIFF_TYPE: Driver. (line 91) +* NO_BUILTIN_SIZE_TYPE: Driver. (line 82) +* NO_BUILTIN_WCHAR_TYPE: Driver. (line 100) +* NO_BUILTIN_WINT_TYPE: Driver. (line 109) +* NO_DBX_FUNCTION_END: DBX Hooks. (line 85) +* NO_DOLLAR_IN_LABEL: Misc. (line 384) +* NO_DOT_IN_LABEL: Misc. (line 390) +* NO_FUNCTION_CSE: Costs. (line 240) +* NO_IMPLICIT_EXTERN_C: Misc. (line 288) +* no_new_pseudos: Standard Names. (line 77) +* NO_PROFILE_COUNTERS: Profiling. (line 27) +* NO_RECURSIVE_FUNCTION_CSE: Costs. (line 244) +* NO_REGS: Register Classes. (line 17) +* NON_SAVING_SETJMP: Register Basics. (line 89) +* nonlocal_goto instruction pattern: Standard Names. (line 768) +* nonlocal_goto_receiver instruction pattern: Standard Names. (line 785) +* nonoffsettable memory reference: Simple Constraints. (line 251) +* nop instruction pattern: Standard Names. (line 570) +* NOP_EXPR: Expression trees. (line 6) +* NORMAL_MODE: Mode Switching. (line 48) +* not: Arithmetic. (line 128) +* not and attributes: Expressions. (line 50) +* not equal: Comparisons. (line 53) +* not, canonicalization of: Insn Canonicalizations. + (line 21) +* note: Insns. (line 158) +* NOTE_INSN_BLOCK_BEG: Insns. (line 183) +* NOTE_INSN_BLOCK_END: Insns. (line 183) +* NOTE_INSN_DELETED: Insns. (line 173) +* NOTE_INSN_DELETED_LABEL: Insns. (line 178) +* NOTE_INSN_EH_REGION_BEG: Insns. (line 189) +* NOTE_INSN_EH_REGION_END: Insns. (line 189) +* NOTE_INSN_FUNCTION_END: Insns. (line 213) +* NOTE_INSN_LOOP_BEG: Insns. (line 197) +* NOTE_INSN_LOOP_CONT: Insns. (line 203) +* NOTE_INSN_LOOP_END: Insns. (line 197) +* NOTE_INSN_LOOP_VTOP: Insns. (line 207) +* NOTE_INSN_SETJMP: Insns. (line 219) +* NOTE_LINE_NUMBER: Insns. (line 158) +* NOTE_SOURCE_FILE: Insns. (line 158) +* NOTICE_UPDATE_CC: Condition Code. (line 32) +* NUM_MACHINE_MODES: Machine Modes. (line 181) +* NUM_MODES_FOR_MODE_SWITCHING: Mode Switching. (line 29) +* o in constraint: Simple Constraints. (line 21) +* OBJC_GEN_METHOD_LABEL: Label Output. (line 273) +* OBJC_PROLOGUE: File Framework. (line 78) +* OBJECT_FORMAT_COFF: Macros for Initialization. + (line 96) +* OBJECT_FORMAT_ROSE: Macros for Initialization. + (line 102) +* OFFSET_TYPE: Types. (line 6) +* offsettable address: Simple Constraints. (line 21) +* OImode: Machine Modes. (line 51) +* ON_EXIT: Misc. (line 412) +* one_cmplM2 instruction pattern: Standard Names. (line 250) +* operand access: Accessors. (line 6) +* operand constraints: Constraints. (line 6) +* operand substitution: Output Template. (line 6) +* operands: Patterns. (line 54) +* OPTIMIZATION_OPTIONS: Run-time Target. (line 140) +* OPTIMIZE_MODE_SWITCHING: Mode Switching. (line 8) +* optional hardware or system features: Run-time Target. (line 31) +* options, directory search: Including Patterns. (line 45) +* order of register allocation: Allocation Order. (line 6) +* ORDER_REGS_FOR_LOCAL_ALLOC: Allocation Order. (line 22) +* Ordering of Patterns: Pattern Ordering. (line 6) +* other register constraints: Simple Constraints. (line 161) +* OUTGOING_REG_PARM_STACK_SPACE: Stack Arguments. (line 92) +* OUTGOING_REGNO: Register Basics. (line 103) +* output of assembler code: File Framework. (line 6) +* output statements: Output Statement. (line 6) +* output templates: Output Template. (line 6) +* OUTPUT_ADDR_CONST_EXTRA: Data Output. (line 38) +* output_asm_insn: Output Statement. (line 53) +* OUTPUT_QUOTED_STRING: File Framework. (line 58) +* overflow while constant folding: Cross-compilation. (line 109) +* OVERLOAD: Functions. (line 6) +* OVERRIDE_OPTIONS: Run-time Target. (line 130) +* OVL_CURRENT: Functions. (line 6) +* OVL_NEXT: Functions. (line 6) +* p in constraint: Simple Constraints. (line 152) +* PAD_VARARGS_DOWN: Register Arguments. (line 206) +* parallel: Side Effects. (line 195) +* parameters, miscellaneous: Misc. (line 6) +* PARM_BOUNDARY: Storage Layout. (line 128) +* PARM_DECL: Declarations. (line 6) +* PARSE_LDD_OUTPUT: Macros for Initialization. + (line 125) +* parsing pass: Passes. (line 10) +* passes and files of the compiler: Passes. (line 6) +* passing arguments: Interface. (line 37) +* PATH_SEPARATOR: Host Config. (line 52) +* PATTERN: Insns. (line 241) +* pattern conditions: Patterns. (line 44) +* pattern names: Standard Names. (line 6) +* Pattern Ordering: Pattern Ordering. (line 6) +* patterns: Patterns. (line 6) +* pc: Regs and Memory. (line 236) +* pc and attributes: Insn Lengths. (line 20) +* pc, RTL sharing: Sharing. (line 25) +* pc_rtx: Regs and Memory. (line 241) +* PCC_BITFIELD_TYPE_MATTERS: Storage Layout. (line 251) +* PCC_STATIC_STRUCT_RETURN: Aggregate Return. (line 70) +* PDImode: Machine Modes. (line 40) +* peephole optimization: Passes. (line 406) +* peephole optimization, RTL representation: Side Effects. (line 229) +* peephole optimizer definitions: Peephole Definitions. + (line 6) +* per-function data: Per-Function Data. (line 6) +* percent sign: Output Template. (line 6) +* PIC: PIC. (line 6) +* PIC_OFFSET_TABLE_REG_CALL_CLOBBERED: PIC. (line 25) +* PIC_OFFSET_TABLE_REGNUM: PIC. (line 15) +* plus: Arithmetic. (line 14) +* plus and attributes: Expressions. (line 64) +* plus, canonicalization of: Insn Canonicalizations. + (line 21) +* PLUS_EXPR: Expression trees. (line 6) +* Pmode: Misc. (line 247) +* pointer: Types. (line 6) +* POINTER_SIZE: Storage Layout. (line 73) +* POINTER_TYPE: Types. (line 6) +* POINTERS_EXTEND_UNSIGNED: Storage Layout. (line 78) +* portability: Portability. (line 6) +* position independent code: PIC. (line 6) +* post_dec: Incdec. (line 25) +* post_inc: Incdec. (line 30) +* post_modify: Incdec. (line 33) +* pragma: Misc. (line 298) +* pre_dec: Incdec. (line 8) +* PRE_GCC3_DWARF_FRAME_REGISTERS: Frame Registers. (line 109) +* pre_inc: Incdec. (line 22) +* predefined macros: Run-time Target. (line 6) +* PREDICATE_CODES: Misc. (line 9) +* predication: Conditional Execution. + (line 6) +* PREFERRED_DEBUGGING_TYPE: All Debuggers. (line 41) +* PREFERRED_OUTPUT_RELOAD_CLASS: Register Classes. (line 180) +* PREFERRED_RELOAD_CLASS: Register Classes. (line 160) +* PREFERRED_STACK_BOUNDARY: Storage Layout. (line 142) +* prefetch: Side Effects. (line 303) +* prefetch instruction pattern: Standard Names. (line 906) +* PRETEND_OUTGOING_VARARGS_NAMED: Varargs. (line 147) +* prev_active_insn: define_peephole. (line 60) +* prev_cc0_setter: Jump Patterns. (line 64) +* PREV_INSN: Insns. (line 26) +* PRINT_OPERAND: Instruction Output. (line 72) +* PRINT_OPERAND_ADDRESS: Instruction Output. (line 100) +* PRINT_OPERAND_PUNCT_VALID_P: Instruction Output. (line 93) +* probe instruction pattern: Standard Names. (line 747) +* product: Arithmetic. (line 84) +* PROFILE_BEFORE_PROLOGUE: Profiling. (line 34) +* PROFILE_HOOK: Profiling. (line 22) +* profiling, code generation: Profiling. (line 6) +* program counter: Regs and Memory. (line 237) +* prologue: Function Entry. (line 6) +* prologue instruction pattern: Standard Names. (line 852) +* PROMOTE_FOR_CALL_ONLY: Storage Layout. (line 122) +* PROMOTE_FUNCTION_ARGS: Storage Layout. (line 111) +* PROMOTE_FUNCTION_RETURN: Storage Layout. (line 115) +* PROMOTE_MODE: Storage Layout. (line 88) +* PROMOTE_PROTOTYPES: Stack Arguments. (line 10) +* pseudo registers: Regs and Memory. (line 9) +* PSImode: Machine Modes. (line 32) +* PTRDIFF_TYPE: Type Layout. (line 123) +* PTRMEM_CST: Expression trees. (line 6) +* PTRMEM_CST_CLASS: Expression trees. (line 6) +* PTRMEM_CST_MEMBER: Expression trees. (line 6) +* push address instruction: Simple Constraints. (line 152) +* PUSH_ARGS: Stack Arguments. (line 18) +* push_reload: Addressing Modes. (line 194) +* PUSH_ROUNDING: Stack Arguments. (line 26) +* PUSH_ROUNDING, interaction with PREFERRED_STACK_BOUNDARY: Storage Layout. + (line 154) +* pushM instruction pattern: Standard Names. (line 154) +* PUT_CODE: RTL Objects. (line 47) +* PUT_MODE: Machine Modes. (line 178) +* PUT_REG_NOTE_KIND: Insns. (line 307) +* PUT_SDB_...: SDB and DWARF. (line 52) +* QCmode: Machine Modes. (line 111) +* QFmode: Machine Modes. (line 54) +* QImode: Machine Modes. (line 25) +* QImode, in insn: Insns. (line 225) +* qualified type: Types. (line 6) +* question mark: Multi-Alternative. (line 41) +* quotient: Arithmetic. (line 99) +* r in constraint: Simple Constraints. (line 54) +* RDIV_EXPR: Expression trees. (line 6) +* READONLY_DATA_SECTION: Sections. (line 94) +* REAL_ARITHMETIC: Cross-compilation. (line 98) +* REAL_CST: Expression trees. (line 6) +* REAL_INFINITY: Cross-compilation. (line 79) +* REAL_NM_FILE_NAME: Macros for Initialization. + (line 110) +* REAL_TYPE: Types. (line 6) +* REAL_VALUE_ATOF: Cross-compilation. (line 73) +* REAL_VALUE_FIX: Cross-compilation. (line 51) +* REAL_VALUE_FROM_INT: Cross-compilation. (line 141) +* REAL_VALUE_ISINF: Cross-compilation. (line 83) +* REAL_VALUE_ISNAN: Cross-compilation. (line 88) +* REAL_VALUE_LDEXP: Cross-compilation. (line 45) +* REAL_VALUE_NEGATE: Cross-compilation. (line 114) +* REAL_VALUE_RNDZINT: Cross-compilation. (line 61) +* REAL_VALUE_TO_DECIMAL: Data Output. (line 157) +* REAL_VALUE_TO_INT: Cross-compilation. (line 135) +* REAL_VALUE_TO_TARGET_DOUBLE: Data Output. (line 144) +* REAL_VALUE_TO_TARGET_LONG_DOUBLE: Data Output. (line 144) +* REAL_VALUE_TO_TARGET_SINGLE: Data Output. (line 144) +* REAL_VALUE_TRUNCATE: Cross-compilation. (line 123) +* REAL_VALUE_TYPE: Cross-compilation. (line 31) +* REAL_VALUE_UNSIGNED_FIX: Cross-compilation. (line 56) +* REAL_VALUE_UNSIGNED_RNDZINT: Cross-compilation. (line 67) +* REAL_VALUES_EQUAL: Cross-compilation. (line 36) +* REAL_VALUES_LESS: Cross-compilation. (line 40) +* REALPART_EXPR: Expression trees. (line 6) +* recog_data.operand: Instruction Output. (line 39) +* recognizing insns: RTL Template. (line 6) +* RECORD_TYPE <1>: Classes. (line 6) +* RECORD_TYPE: Types. (line 6) +* reference: Types. (line 6) +* REFERENCE_TYPE: Types. (line 6) +* reg: Regs and Memory. (line 9) +* reg and /f: Flags. (line 115) +* reg and /i: Flags. (line 105) +* reg and /s: Flags. (line 110) +* reg and /u: Flags. (line 159) +* reg and /v: Flags. (line 119) +* reg, RTL sharing: Sharing. (line 17) +* REG_ALLOC_ORDER: Allocation Order. (line 8) +* REG_BR_PRED: Insns. (line 511) +* REG_BR_PROB: Insns. (line 505) +* REG_CC_SETTER: Insns. (line 475) +* REG_CC_USER: Insns. (line 475) +* REG_CLASS_CONTENTS: Register Classes. (line 85) +* REG_CLASS_FROM_LETTER: Register Classes. (line 123) +* REG_CLASS_NAMES: Register Classes. (line 80) +* REG_DEAD: Insns. (line 318) +* REG_DEP_ANTI: Insns. (line 490) +* REG_DEP_OUTPUT: Insns. (line 493) +* REG_EQUAL: Insns. (line 374) +* REG_EQUIV: Insns. (line 374) +* REG_EXEC_COUNT: Insns. (line 500) +* REG_FRAME_RELATED_EXPR: Insns. (line 517) +* REG_FUNCTION_VALUE_P: Flags. (line 105) +* REG_INC: Insns. (line 334) +* REG_LABEL: Insns. (line 364) +* REG_LIBCALL: Insns. (line 468) +* REG_LOOP_TEST_P: Flags. (line 110) +* REG_MODE_OK_FOR_BASE_P: Addressing Modes. (line 116) +* reg_names: Instruction Output. (line 85) +* REG_NO_CONFLICT: Insns. (line 348) +* REG_NONNEG: Insns. (line 340) +* REG_NOTE_KIND: Insns. (line 307) +* REG_NOTES: Insns. (line 275) +* REG_OK_FOR_BASE_P: Addressing Modes. (line 107) +* REG_OK_FOR_INDEX_P: Addressing Modes. (line 124) +* REG_OK_STRICT: Addressing Modes. (line 65) +* REG_PARM_STACK_SPACE: Stack Arguments. (line 50) +* REG_PARM_STACK_SPACE, and FUNCTION_ARG: Register Arguments. (line 52) +* REG_POINTER: Flags. (line 115) +* REG_RETVAL: Insns. (line 452) +* REG_UNUSED: Insns. (line 327) +* REG_USERVAR_P: Flags. (line 119) +* REG_WAS_0: Insns. (line 442) +* register allocation: Passes. (line 329) +* register allocation order: Allocation Order. (line 6) +* register class definitions: Register Classes. (line 6) +* register class preference constraints: Class Preferences. (line 6) +* register class preference pass: Passes. (line 325) +* register movement: Passes. (line 299) +* register pairs: Values in Registers. (line 34) +* Register Transfer Language (RTL): RTL. (line 6) +* register usage: Registers. (line 6) +* register use analysis: Passes. (line 168) +* register-to-stack conversion: Passes. (line 397) +* REGISTER_MOVE_COST: Costs. (line 90) +* REGISTER_NAMES: Instruction Output. (line 8) +* register_operand: RTL Template. (line 62) +* REGISTER_PREFIX: Instruction Output. (line 129) +* REGISTER_TARGET_PRAGMAS: Misc. (line 298) +* registers arguments: Register Arguments. (line 6) +* registers in constraints: Simple Constraints. (line 54) +* REGNO_MODE_OK_FOR_BASE_P: Register Classes. (line 137) +* REGNO_OK_FOR_BASE_P: Register Classes. (line 131) +* REGNO_OK_FOR_INDEX_P: Register Classes. (line 145) +* REGNO_REG_CLASS: Register Classes. (line 100) +* regs_ever_live: Function Entry. (line 21) +* relative costs: Costs. (line 6) +* RELATIVE_PREFIX_NOT_LINKDIR: Driver. (line 288) +* reload pass: Regs and Memory. (line 148) +* reload_completed: Standard Names. (line 537) +* reload_in instruction pattern: Standard Names. (line 101) +* reload_in_progress: Standard Names. (line 57) +* reload_out instruction pattern: Standard Names. (line 101) +* reloading: Passes. (line 342) +* remainder: Arithmetic. (line 113) +* reordering, block: Passes. (line 369) +* representation of RTL: RTL. (line 6) +* rest_of_compilation: Passes. (line 19) +* rest_of_decl_compilation: Passes. (line 19) +* restore_stack_block instruction pattern: Standard Names. (line 676) +* restore_stack_function instruction pattern: Standard Names. (line 676) +* restore_stack_nonlocal instruction pattern: Standard Names. (line 676) +* RESULT_DECL: Declarations. (line 6) +* return: Side Effects. (line 67) +* return instruction pattern: Standard Names. (line 524) +* return values in registers: Scalar Return. (line 6) +* RETURN_ADDR_IN_PREVIOUS_FRAME: Frame Layout. (line 108) +* RETURN_ADDR_RTX: Frame Layout. (line 97) +* RETURN_ADDRESS_POINTER_REGNUM: Frame Registers. (line 50) +* RETURN_EXPR: Function Bodies. (line 6) +* RETURN_IN_MEMORY: Aggregate Return. (line 15) +* RETURN_INIT: Function Bodies. (line 6) +* RETURN_POPS_ARGS: Stack Arguments. (line 109) +* RETURN_STMT: Function Bodies. (line 6) +* returning aggregate values: Aggregate Return. (line 6) +* returning structures and unions: Interface. (line 10) +* REVERSE_CONDEXEC_PREDICATES_P: Condition Code. (line 143) +* REVERSE_CONDITION (CODE, MODE): Condition Code. (line 131) +* REVERSIBLE_CC_MODE: Condition Code. (line 117) +* right rotate: Arithmetic. (line 160) +* right shift: Arithmetic. (line 155) +* rotate: Arithmetic. (line 160) +* rotatert: Arithmetic. (line 160) +* rotlM3 instruction pattern: Standard Names. (line 224) +* rotrM3 instruction pattern: Standard Names. (line 224) +* ROUND_TYPE_ALIGN: Storage Layout. (line 340) +* ROUND_TYPE_SIZE: Storage Layout. (line 327) +* ROUND_TYPE_SIZE_UNIT: Storage Layout. (line 334) +* RSHIFT_EXPR: Expression trees. (line 6) +* RTL addition: Arithmetic. (line 14) +* RTL addition with signed saturation: Arithmetic. (line 30) +* RTL addition with unsigned saturation: Arithmetic. (line 33) +* RTL classes: RTL Classes. (line 6) +* RTL comparison: Arithmetic. (line 42) +* RTL comparison operations: Comparisons. (line 6) +* RTL constant expression types: Constants. (line 6) +* RTL constants: Constants. (line 6) +* RTL declarations: RTL Declarations. (line 6) +* RTL difference: Arithmetic. (line 27) +* RTL expression: RTL Objects. (line 6) +* RTL expressions for arithmetic: Arithmetic. (line 6) +* RTL format: RTL Classes. (line 63) +* RTL format characters: RTL Classes. (line 68) +* RTL function-call insns: Calls. (line 6) +* RTL generation: Passes. (line 90) +* RTL insn template: RTL Template. (line 6) +* RTL integers: RTL Objects. (line 6) +* RTL memory expressions: Regs and Memory. (line 6) +* RTL object types: RTL Objects. (line 6) +* RTL postdecrement: Incdec. (line 6) +* RTL postincrement: Incdec. (line 6) +* RTL predecrement: Incdec. (line 6) +* RTL preincrement: Incdec. (line 6) +* RTL register expressions: Regs and Memory. (line 6) +* RTL representation: RTL. (line 6) +* RTL side effect expressions: Side Effects. (line 6) +* RTL strings: RTL Objects. (line 6) +* RTL structure sharing assumptions: Sharing. (line 6) +* RTL subtraction: Arithmetic. (line 27) +* RTL sum: Arithmetic. (line 14) +* RTL vectors: RTL Objects. (line 6) +* RTX (See RTL): RTL Objects. (line 6) +* RTX codes, classes of: RTL Classes. (line 6) +* RTX_COSTS: Costs. (line 23) +* RTX_FRAME_RELATED_P: Flags. (line 128) +* RTX_INTEGRATED_P: Flags. (line 154) +* RTX_UNCHANGING_P: Flags. (line 159) +* run-time conventions: Interface. (line 6) +* run-time target specification: Run-time Target. (line 6) +* s in constraint: Simple Constraints. (line 90) +* same_type_p: Types. (line 103) +* save_stack_block instruction pattern: Standard Names. (line 676) +* save_stack_function instruction pattern: Standard Names. (line 676) +* save_stack_nonlocal instruction pattern: Standard Names. (line 676) +* saveable_obstack: Addressing Modes. (line 96) +* scalars, returned as values: Scalar Return. (line 6) +* SCCS_DIRECTIVE: Misc. (line 284) +* SCHED_GROUP_P: Flags. (line 164) +* scheduling, delayed branch: Passes. (line 381) +* scheduling, instruction: Passes. (line 309) +* SCmode: Machine Modes. (line 111) +* sCOND instruction pattern: Standard Names. (line 414) +* SCOPE_BEGIN_P: Function Bodies. (line 6) +* SCOPE_END_P: Function Bodies. (line 6) +* SCOPE_NULLIFIED_P: Function Bodies. (line 6) +* SCOPE_STMT: Function Bodies. (line 6) +* scratch: Regs and Memory. (line 173) +* scratch operands: Regs and Memory. (line 173) +* scratch, RTL sharing: Sharing. (line 35) +* SDB_ALLOW_FORWARD_REFERENCES: SDB and DWARF. (line 75) +* SDB_ALLOW_UNKNOWN_REFERENCES: SDB and DWARF. (line 70) +* SDB_DEBUGGING_INFO: SDB and DWARF. (line 8) +* SDB_DELIM: SDB and DWARF. (line 58) +* SDB_GENERATE_FAKE: SDB and DWARF. (line 65) +* search options: Including Patterns. (line 45) +* SECONDARY_INPUT_RELOAD_CLASS: Register Classes. (line 201) +* SECONDARY_MEMORY_NEEDED: Register Classes. (line 264) +* SECONDARY_MEMORY_NEEDED_MODE: Register Classes. (line 283) +* SECONDARY_MEMORY_NEEDED_RTX: Register Classes. (line 274) +* SECONDARY_OUTPUT_RELOAD_CLASS: Register Classes. (line 201) +* SECONDARY_RELOAD_CLASS: Register Classes. (line 201) +* SELECT_CC_MODE: Condition Code. (line 84) +* SELECT_RTX_SECTION: Sections. (line 117) +* SELECT_SECTION: Sections. (line 104) +* sequence: Side Effects. (line 245) +* set: Side Effects. (line 15) +* SET_ASM_OP: Label Output. (line 243) +* set_attr: Tagging Insns. (line 31) +* set_attr_alternative: Tagging Insns. (line 49) +* SET_DEST: Side Effects. (line 64) +* SET_IS_RETURN_P: Flags. (line 172) +* SET_SRC: Side Effects. (line 64) +* SETUP_FRAME_ADDRESSES: Frame Layout. (line 82) +* SETUP_INCOMING_VARARGS: Varargs. (line 98) +* SFmode: Machine Modes. (line 66) +* SHARED_BSS_SECTION_ASM_OP: Sections. (line 48) +* SHARED_SECTION_ASM_OP: Sections. (line 33) +* sharing of RTL components: Sharing. (line 6) +* shift: Arithmetic. (line 147) +* SHIFT_COUNT_TRUNCATED: Misc. (line 117) +* SHORT_IMMEDIATES_SIGN_EXTEND: Misc. (line 96) +* SHORT_TYPE_SIZE: Type Layout. (line 15) +* sibcall_epilogue instruction pattern: Standard Names. (line 878) +* sibling call optimization: Passes. (line 135) +* SIBLING_CALL_P: Flags. (line 176) +* sign_extend: Conversions. (line 24) +* sign_extract: Bit-Fields. (line 11) +* sign_extract, canonicalization of: Insn Canonicalizations. + (line 81) +* signed division: Arithmetic. (line 99) +* signed maximum: Arithmetic. (line 118) +* signed minimum: Arithmetic. (line 118) +* SImode: Machine Modes. (line 37) +* simple constraints: Simple Constraints. (line 6) +* simplifications, arithmetic: Passes. (line 86) +* Single Static Assignment optimizations: Passes. (line 178) +* SIZE_TYPE: Type Layout. (line 107) +* SLOW_BYTE_ACCESS: Costs. (line 140) +* SLOW_UNALIGNED_ACCESS: Costs. (line 155) +* SMALL_ARG_MAX: Host Config. (line 116) +* SMALL_REGISTER_CLASSES: Register Classes. (line 306) +* SMALL_STACK: Frame Layout. (line 154) +* smax: Arithmetic. (line 118) +* smaxM3 instruction pattern: Standard Names. (line 167) +* smin: Arithmetic. (line 118) +* sminM3 instruction pattern: Standard Names. (line 167) +* smulM3_highpart instruction pattern: Standard Names. (line 189) +* SPECIAL_MODE_PREDICATES: Misc. (line 34) +* speed of instructions: Costs. (line 6) +* splitting instructions: Insn Splitting. (line 6) +* sqrt: Arithmetic. (line 168) +* sqrtM2 instruction pattern: Standard Names. (line 234) +* square root: Arithmetic. (line 168) +* ss_minus: Arithmetic. (line 36) +* ss_plus: Arithmetic. (line 30) +* ss_truncate: Conversions. (line 44) +* SSA Conditional Constant Propagation: Passes. (line 190) +* SSA DCE: Passes. (line 201) +* SSA optimizations: Passes. (line 178) +* stack arguments: Stack Arguments. (line 6) +* stack frame layout: Frame Layout. (line 6) +* STACK_BOUNDARY: Storage Layout. (line 134) +* STACK_CHECK_BUILTIN: Stack Checking. (line 28) +* STACK_CHECK_FIXED_FRAME_SIZE: Stack Checking. (line 63) +* STACK_CHECK_MAX_FRAME_SIZE: Stack Checking. (line 54) +* STACK_CHECK_MAX_VAR_SIZE: Stack Checking. (line 70) +* STACK_CHECK_PROBE_INTERVAL: Stack Checking. (line 36) +* STACK_CHECK_PROBE_LOAD: Stack Checking. (line 43) +* STACK_CHECK_PROTECT: Stack Checking. (line 49) +* STACK_DYNAMIC_OFFSET: Frame Layout. (line 64) +* STACK_DYNAMIC_OFFSET and virtual registers: Regs and Memory. + (line 83) +* STACK_GROWS_DOWNWARD: Frame Layout. (line 8) +* STACK_PARMS_IN_REG_PARM_AREA: Stack Arguments. (line 100) +* STACK_POINTER_OFFSET: Frame Layout. (line 47) +* STACK_POINTER_OFFSET and virtual registers: Regs and Memory. + (line 93) +* STACK_POINTER_REGNUM: Frame Registers. (line 8) +* STACK_POINTER_REGNUM and virtual registers: Regs and Memory. + (line 83) +* stack_pointer_rtx: Frame Registers. (line 85) +* STACK_PUSH_CODE: Frame Layout. (line 16) +* STACK_REGS: Stack Registers. (line 14) +* STACK_SAVEAREA_MODE: Storage Layout. (line 361) +* STACK_SIZE_MODE: Storage Layout. (line 373) +* standard pattern names: Standard Names. (line 6) +* STANDARD_EXEC_PREFIX: Driver. (line 293) +* STANDARD_INCLUDE_COMPONENT: Driver. (line 378) +* STANDARD_INCLUDE_DIR: Driver. (line 370) +* STANDARD_STARTFILE_PREFIX: Driver. (line 306) +* STARTFILE_SPEC: Driver. (line 175) +* STARTING_FRAME_OFFSET: Frame Layout. (line 38) +* STARTING_FRAME_OFFSET and virtual registers: Regs and Memory. + (line 74) +* statements: Function Bodies. (line 6) +* STATIC_CHAIN: Frame Registers. (line 76) +* STATIC_CHAIN_INCOMING: Frame Registers. (line 76) +* STATIC_CHAIN_INCOMING_REGNUM: Frame Registers. (line 62) +* STATIC_CHAIN_REGNUM: Frame Registers. (line 62) +* stdarg.h and register arguments: Register Arguments. (line 47) +* STDC_0_IN_SYSTEM_HEADERS: Misc. (line 273) +* STMT_EXPR: Expression trees. (line 6) +* STMT_IS_FULL_EXPR_P: Function Bodies. (line 35) +* STMT_LINENO: Function Bodies. (line 23) +* storage layout: Storage Layout. (line 6) +* STORE_FLAG_VALUE: Misc. (line 156) +* store_multiple instruction pattern: Standard Names. (line 148) +* strcpy: Storage Layout. (line 202) +* strength-reduction: Passes. (line 243) +* STRICT_ALIGNMENT: Storage Layout. (line 246) +* STRICT_ARGUMENT_NAMING: Varargs. (line 132) +* strict_low_part: RTL Declarations. (line 9) +* strict_memory_address_p: Addressing Modes. (line 204) +* STRING_CST: Expression trees. (line 6) +* STRING_POOL_ADDRESS_P: Flags. (line 180) +* STRIP_NAME_ENCODING: Sections. (line 156) +* strlenM instruction pattern: Standard Names. (line 320) +* STRUCT_VALUE: Aggregate Return. (line 47) +* STRUCT_VALUE_INCOMING: Aggregate Return. (line 62) +* STRUCT_VALUE_INCOMING_REGNUM: Aggregate Return. (line 53) +* STRUCT_VALUE_REGNUM: Aggregate Return. (line 43) +* structure value address: Aggregate Return. (line 6) +* STRUCTURE_SIZE_BOUNDARY: Storage Layout. (line 238) +* structures, returning: Interface. (line 10) +* subM3 instruction pattern: Standard Names. (line 167) +* SUBOBJECT: Function Bodies. (line 6) +* SUBOBJECT_CLEANUP: Function Bodies. (line 6) +* subreg: Regs and Memory. (line 97) +* subreg and /s: Flags. (line 191) +* subreg and /u: Flags. (line 185) +* subreg, in strict_low_part: RTL Declarations. (line 9) +* subreg, special reload handling: Regs and Memory. (line 148) +* SUBREG_BYTE: Regs and Memory. (line 169) +* SUBREG_PROMOTED_UNSIGNED_P: Flags. (line 185) +* SUBREG_PROMOTED_VAR_P: Flags. (line 191) +* SUBREG_REG: Regs and Memory. (line 169) +* SUCCESS_EXIT_CODE: Host Config. (line 24) +* SUPPORTS_INIT_PRIORITY: Macros for Initialization. + (line 58) +* SUPPORTS_ONE_ONLY: Label Output. (line 113) +* SUPPORTS_WEAK: Label Output. (line 94) +* SWITCH_BODY: Function Bodies. (line 6) +* SWITCH_COND: Function Bodies. (line 6) +* SWITCH_CURTAILS_COMPILATION: Driver. (line 32) +* SWITCH_STMT: Function Bodies. (line 6) +* SWITCH_TAKES_ARG: Driver. (line 8) +* SWITCHES_NEED_SPACES: Driver. (line 46) +* symbol_ref: Constants. (line 84) +* symbol_ref and /f: Flags. (line 180) +* symbol_ref and /i: Flags. (line 210) +* symbol_ref and /u: Flags. (line 10) +* symbol_ref and /v: Flags. (line 201) +* symbol_ref, RTL sharing: Sharing. (line 20) +* SYMBOL_REF_FLAG: Flags. (line 201) +* SYMBOL_REF_FLAG, in ENCODE_SECTION_INFO: Sections. (line 151) +* SYMBOL_REF_USED: Flags. (line 205) +* SYMBOL_REF_WEAK: Flags. (line 210) +* symbolic label: Sharing. (line 20) +* SYSTEM_INCLUDE_DIR: Driver. (line 361) +* t-TARGET: Target Fragment. (line 6) +* tablejump instruction pattern: Standard Names. (line 604) +* tagging insns: Tagging Insns. (line 6) +* tail calls: Tail Calls. (line 6) +* tail recursion optimization: Passes. (line 99) +* target attributes: Target Attributes. (line 6) +* target description macros: Target Macros. (line 6) +* target functions: Target Structure. (line 6) +* target hooks: Target Structure. (line 6) +* target makefile fragment: Target Fragment. (line 6) +* target specifications: Run-time Target. (line 6) +* target-parameter-dependent code: Passes. (line 93) +* TARGET_ALLOWS_PROFILING_WITHOUT_FRAME_POINTER: Profiling. (line 39) +* TARGET_ASM_ALIGNED_DI_OP: Data Output. (line 10) +* TARGET_ASM_ALIGNED_HI_OP: Data Output. (line 8) +* TARGET_ASM_ALIGNED_SI_OP: Data Output. (line 9) +* TARGET_ASM_ALIGNED_TI_OP: Data Output. (line 11) +* TARGET_ASM_BYTE_OP: Data Output. (line 7) +* TARGET_ASM_CLOSE_PAREN: Data Output. (line 133) +* TARGET_ASM_CONSTRUCTOR: Macros for Initialization. + (line 69) +* TARGET_ASM_DESTRUCTOR: Macros for Initialization. + (line 83) +* TARGET_ASM_EH_FRAME_SECTION: Exception Region Output. + (line 67) +* TARGET_ASM_EXCEPTION_SECTION: Exception Region Output. + (line 59) +* TARGET_ASM_FUNCTION_BEGIN_EPILOGUE: Function Entry. (line 61) +* TARGET_ASM_FUNCTION_END_PROLOGUE: Function Entry. (line 55) +* TARGET_ASM_FUNCTION_EPILOGUE: Function Entry. (line 68) +* TARGET_ASM_FUNCTION_EPILOGUE and trampolines: Trampolines. (line 76) +* TARGET_ASM_FUNCTION_PROLOGUE: Function Entry. (line 11) +* TARGET_ASM_FUNCTION_PROLOGUE and trampolines: Trampolines. (line 76) +* TARGET_ASM_INTEGER: Data Output. (line 27) +* TARGET_ASM_NAMED_SECTION: File Framework. (line 86) +* TARGET_ASM_OPEN_PAREN: Data Output. (line 132) +* TARGET_ASM_UNALIGNED_DI_OP: Data Output. (line 14) +* TARGET_ASM_UNALIGNED_HI_OP: Data Output. (line 12) +* TARGET_ASM_UNALIGNED_SI_OP: Data Output. (line 13) +* TARGET_ASM_UNALIGNED_TI_OP: Data Output. (line 15) +* TARGET_ATTRIBUTE_TABLE: Target Attributes. (line 11) +* TARGET_BELL: Escape Sequences. (line 10) +* TARGET_BS: Escape Sequences. (line 19) +* TARGET_CANNOT_MODIFY_JUMPS_P: Misc. (line 593) +* TARGET_COMP_TYPE_ATTRIBUTES: Target Attributes. (line 19) +* TARGET_CR: Escape Sequences. (line 25) +* TARGET_DLLIMPORT_DECL_ATTRIBUTES: Target Attributes. (line 47) +* TARGET_EDOM: Library Calls. (line 81) +* TARGET_ESC: Escape Sequences. (line 14) +* TARGET_EXECUTABLE_SUFFIX: Misc. (line 578) +* TARGET_EXPAND_BUILTIN: Misc. (line 540) +* TARGET_FF: Escape Sequences. (line 25) +* TARGET_FLOAT_FORMAT: Storage Layout. (line 396) +* TARGET_FUNCTION_ATTRIBUTE_INLINABLE_P: Target Attributes. (line 69) +* TARGET_HAS_F_SETLKW: Misc. (line 488) +* TARGET_HAVE_CTORS_DTORS: Macros for Initialization. + (line 64) +* TARGET_HAVE_NAMED_SECTIONS: File Framework. (line 96) +* TARGET_INIT_BUILTINS: Misc. (line 523) +* TARGET_INSERT_ATTRIBUTES: Target Attributes. (line 56) +* TARGET_MEM_FUNCTIONS: Library Calls. (line 99) +* TARGET_MERGE_DECL_ATTRIBUTES: Target Attributes. (line 39) +* TARGET_MERGE_TYPE_ATTRIBUTES: Target Attributes. (line 31) +* TARGET_MS_BITFIELD_LAYOUT_P: Storage Layout. (line 427) +* TARGET_NEWLINE: Escape Sequences. (line 19) +* TARGET_OBJECT_SUFFIX: Misc. (line 573) +* TARGET_OPTION_TRANSLATE_TABLE: Driver. (line 52) +* TARGET_OPTIONS: Run-time Target. (line 90) +* TARGET_PTRMEMFUNC_VBIT_LOCATION: Type Layout. (line 189) +* TARGET_SCHED_ADJUST_COST: Scheduling. (line 32) +* TARGET_SCHED_ADJUST_PRIORITY: Scheduling. (line 41) +* TARGET_SCHED_CYCLE_DISPLAY: Scheduling. (line 96) +* TARGET_SCHED_FINISH: Scheduling. (line 88) +* TARGET_SCHED_INIT: Scheduling. (line 78) +* TARGET_SCHED_ISSUE_RATE: Scheduling. (line 12) +* TARGET_SCHED_REORDER: Scheduling. (line 49) +* TARGET_SCHED_REORDER2: Scheduling. (line 66) +* TARGET_SCHED_VARIABLE_ISSUE: Scheduling. (line 20) +* TARGET_SECTION_TYPE_FLAGS: File Framework. (line 101) +* TARGET_SET_DEFAULT_TYPE_ATTRIBUTES: Target Attributes. (line 26) +* TARGET_SWITCHES: Run-time Target. (line 55) +* TARGET_TAB: Escape Sequences. (line 19) +* TARGET_VERSION: Run-time Target. (line 117) +* TARGET_VT: Escape Sequences. (line 25) +* TARGET_VTABLE_USES_DESCRIPTORS: Type Layout. (line 225) +* targetm: Target Structure. (line 7) +* targets, makefile: Makefile. (line 6) +* TCmode: Machine Modes. (line 111) +* TEMPLATE_DECL: Declarations. (line 6) +* termination routines: Initialization. (line 6) +* text_section: Sections. (line 88) +* TEXT_SECTION: Sections. (line 22) +* TEXT_SECTION_ASM_OP: Sections. (line 17) +* TFmode: Machine Modes. (line 84) +* THEN_CLAUSE: Function Bodies. (line 6) +* THREAD_MODEL_SPEC: Driver. (line 190) +* THROW_EXPR: Expression trees. (line 6) +* THUNK_DECL: Declarations. (line 6) +* THUNK_DELTA: Declarations. (line 6) +* TImode: Machine Modes. (line 48) +* TImode, in insn: Insns. (line 225) +* tm.h macros: Target Macros. (line 6) +* top level of compiler: Passes. (line 6) +* TQFmode: Machine Modes. (line 62) +* TRADITIONAL_RETURN_FLOAT: Scalar Return. (line 9) +* TRAMPOLINE_ADJUST_ADDRESS: Trampolines. (line 62) +* TRAMPOLINE_ALIGNMENT: Trampolines. (line 49) +* TRAMPOLINE_SECTION: Trampolines. (line 39) +* TRAMPOLINE_SIZE: Trampolines. (line 45) +* TRAMPOLINE_TEMPLATE: Trampolines. (line 28) +* trampolines for nested functions: Trampolines. (line 6) +* TRANSFER_FROM_TRAMPOLINE: Trampolines. (line 138) +* trap instruction pattern: Standard Names. (line 888) +* tree <1>: Macros and Functions. + (line 6) +* tree: Tree overview. (line 6) +* Tree optimization: Passes. (line 77) +* TREE_CODE: Tree overview. (line 6) +* tree_int_cst_equal: Expression trees. (line 6) +* TREE_INT_CST_HIGH: Expression trees. (line 6) +* TREE_INT_CST_LOW: Expression trees. (line 6) +* tree_int_cst_lt: Expression trees. (line 6) +* TREE_LIST: Containers. (line 6) +* TREE_OPERAND: Expression trees. (line 6) +* TREE_PUBLIC: Function Basics. (line 6) +* TREE_PURPOSE: Containers. (line 6) +* TREE_STRING_LENGTH: Expression trees. (line 6) +* TREE_STRING_POINTER: Expression trees. (line 6) +* TREE_TYPE <1>: Expression trees. (line 17) +* TREE_TYPE <2>: Function Basics. (line 164) +* TREE_TYPE <3>: Declarations. (line 16) +* TREE_TYPE: Types. (line 6) +* TREE_VALUE: Containers. (line 6) +* TREE_VEC: Containers. (line 6) +* TREE_VEC_ELT: Containers. (line 6) +* TREE_VEC_LENGTH: Containers. (line 6) +* TREE_VIA_PRIVATE: Classes. (line 6) +* TREE_VIA_PROTECTED: Classes. (line 6) +* TREE_VIA_PUBLIC: Classes. (line 6) +* Trees: Trees. (line 6) +* TRULY_NOOP_TRUNCATION: Misc. (line 143) +* TRUNC_DIV_EXPR: Expression trees. (line 6) +* TRUNC_MOD_EXPR: Expression trees. (line 6) +* truncate: Conversions. (line 39) +* truncMN2 instruction pattern: Standard Names. (line 360) +* TRUTH_AND_EXPR: Expression trees. (line 6) +* TRUTH_ANDIF_EXPR: Expression trees. (line 6) +* TRUTH_NOT_EXPR: Expression trees. (line 6) +* TRUTH_OR_EXPR: Expression trees. (line 6) +* TRUTH_ORIF_EXPR: Expression trees. (line 6) +* TRUTH_XOR_EXPR: Expression trees. (line 6) +* TRY_BLOCK: Function Bodies. (line 6) +* TRY_HANDLERS: Function Bodies. (line 6) +* TRY_STMTS: Function Bodies. (line 6) +* tstM instruction pattern: Standard Names. (line 260) +* type: Types. (line 6) +* type declaration: Declarations. (line 6) +* TYPE_ALIGN: Types. (line 6) +* TYPE_ARG_TYPES: Types. (line 6) +* TYPE_ATTRIBUTES: Attributes. (line 25) +* TYPE_BINFO: Classes. (line 6) +* TYPE_BUILT_IN: Types. (line 84) +* TYPE_CONTEXT: Types. (line 6) +* TYPE_DECL: Declarations. (line 6) +* TYPE_FIELDS <1>: Classes. (line 6) +* TYPE_FIELDS: Types. (line 6) +* TYPE_HAS_ARRAY_NEW_OPERATOR: Classes. (line 90) +* TYPE_HAS_DEFAULT_CONSTRUCTOR: Classes. (line 74) +* TYPE_HAS_MUTABLE_P: Classes. (line 80) +* TYPE_HAS_NEW_OPERATOR: Classes. (line 87) +* TYPE_MAIN_VARIANT: Types. (line 6) +* TYPE_MAX_VALUE: Types. (line 6) +* TYPE_METHOD_BASETYPE: Types. (line 6) +* TYPE_METHODS: Classes. (line 6) +* TYPE_MIN_VALUE: Types. (line 6) +* TYPE_NAME: Types. (line 6) +* TYPE_NOTHROW_P: Function Basics. (line 173) +* TYPE_OFFSET_BASETYPE: Types. (line 6) +* TYPE_OVERLOADS_ARRAY_REF: Classes. (line 98) +* TYPE_OVERLOADS_ARROW: Classes. (line 101) +* TYPE_OVERLOADS_CALL_EXPR: Classes. (line 94) +* TYPE_POLYMORPHIC_P: Classes. (line 70) +* TYPE_PRECISION: Types. (line 6) +* TYPE_PTR_P: Types. (line 90) +* TYPE_PTRFN_P: Types. (line 94) +* TYPE_PTRMEM_P: Types. (line 6) +* TYPE_PTROB_P: Types. (line 97) +* TYPE_PTROBV_P: Types. (line 6) +* TYPE_QUAL_CONST: Types. (line 6) +* TYPE_QUAL_RESTRICT: Types. (line 6) +* TYPE_QUAL_VOLATILE: Types. (line 6) +* TYPE_RAISES_EXCEPTIONS: Function Basics. (line 168) +* TYPE_SIZE: Types. (line 6) +* TYPE_UNQUALIFIED: Types. (line 6) +* TYPE_VFIELD: Classes. (line 6) +* TYPENAME_TYPE: Types. (line 6) +* TYPENAME_TYPE_FULLNAME: Types. (line 6) +* TYPEOF_TYPE: Types. (line 6) +* udiv: Arithmetic. (line 110) +* UDIVDI3_LIBCALL: Library Calls. (line 50) +* udivM3 instruction pattern: Standard Names. (line 167) +* udivmodM4 instruction pattern: Standard Names. (line 214) +* UDIVSI3_LIBCALL: Library Calls. (line 20) +* UINTMAX_TYPE: Type Layout. (line 178) +* umax: Arithmetic. (line 123) +* umaxM3 instruction pattern: Standard Names. (line 167) +* umin: Arithmetic. (line 123) +* uminM3 instruction pattern: Standard Names. (line 167) +* umod: Arithmetic. (line 113) +* UMODDI3_LIBCALL: Library Calls. (line 62) +* umodM3 instruction pattern: Standard Names. (line 167) +* UMODSI3_LIBCALL: Library Calls. (line 32) +* umulhisi3 instruction pattern: Standard Names. (line 185) +* umulM3_highpart instruction pattern: Standard Names. (line 194) +* umulqihi3 instruction pattern: Standard Names. (line 185) +* umulsidi3 instruction pattern: Standard Names. (line 185) +* unchanging: Flags. (line 299) +* unchanging, in call_insn: Flags. (line 19) +* unchanging, in insn: Flags. (line 24) +* unchanging, in reg and mem: Flags. (line 159) +* unchanging, in subreg: Flags. (line 185) +* unchanging, in symbol_ref: Flags. (line 10) +* UNION_TYPE <1>: Classes. (line 6) +* UNION_TYPE: Types. (line 6) +* unions, returning: Interface. (line 10) +* UNIQUE_SECTION: Sections. (line 161) +* UNITS_PER_WORD: Storage Layout. (line 64) +* UNKNOWN_FLOAT_FORMAT: Storage Layout. (line 413) +* UNKNOWN_TYPE: Types. (line 6) +* unreachable code: Passes. (line 146) +* unshare_all_rtl: Sharing. (line 58) +* unsigned division: Arithmetic. (line 110) +* unsigned greater than: Comparisons. (line 61) +* unsigned less than: Comparisons. (line 65) +* unsigned minimum and maximum: Arithmetic. (line 123) +* unsigned_fix: Conversions. (line 73) +* unsigned_float: Conversions. (line 63) +* unspec: Side Effects. (line 278) +* unspec_volatile: Side Effects. (line 278) +* untyped_call instruction pattern: Standard Names. (line 509) +* untyped_return instruction pattern: Standard Names. (line 559) +* UPDATE_PATH_HOST_CANONICALIZE (PATH): Host Config. (line 96) +* us_minus: Arithmetic. (line 39) +* us_plus: Arithmetic. (line 33) +* us_truncate: Conversions. (line 49) +* use: Side Effects. (line 153) +* USE_C_ALLOCA: Host Config. (line 31) +* USE_LOAD_POST_DECREMENT: Costs. (line 205) +* USE_LOAD_POST_INCREMENT: Costs. (line 200) +* USE_LOAD_PRE_DECREMENT: Costs. (line 215) +* USE_LOAD_PRE_INCREMENT: Costs. (line 210) +* USE_STORE_POST_DECREMENT: Costs. (line 225) +* USE_STORE_POST_INCREMENT: Costs. (line 220) +* USE_STORE_PRE_DECREMENT: Costs. (line 235) +* USE_STORE_PRE_INCREMENT: Costs. (line 230) +* used: Flags. (line 316) +* used, in symbol_ref: Flags. (line 205) +* USER_LABEL_PREFIX: Instruction Output. (line 129) +* USING_DECL: Declarations. (line 6) +* USING_STMT: Function Bodies. (line 6) +* V in constraint: Simple Constraints. (line 41) +* values, returned by functions: Scalar Return. (line 6) +* VAR_DECL <1>: Expression trees. (line 6) +* VAR_DECL: Declarations. (line 6) +* varargs implementation: Varargs. (line 6) +* variable: Declarations. (line 6) +* VAX_FLOAT_FORMAT: Storage Layout. (line 404) +* vec_concat: Vector Operations. (line 25) +* vec_const: Vector Operations. (line 30) +* vec_duplicate: Vector Operations. (line 34) +* vec_merge: Vector Operations. (line 11) +* vec_select: Vector Operations. (line 19) +* vector: Containers. (line 6) +* vector operations: Vector Operations. (line 6) +* VECTOR_CST: Expression trees. (line 6) +* VECTOR_MODE_SUPPORTED_P: Storage Layout. (line 356) +* VIRTUAL_INCOMING_ARGS_REGNUM: Regs and Memory. (line 59) +* VIRTUAL_OUTGOING_ARGS_REGNUM: Regs and Memory. (line 87) +* VIRTUAL_STACK_DYNAMIC_REGNUM: Regs and Memory. (line 78) +* VIRTUAL_STACK_VARS_REGNUM: Regs and Memory. (line 69) +* VMS: Host Config. (line 15) +* VMS_DEBUGGING_INFO: VMS Debug. (line 8) +* VOID_TYPE: Types. (line 6) +* VOIDmode: Machine Modes. (line 104) +* volatil: Flags. (line 330) +* volatil, in insn: Flags. (line 34) +* volatil, in label_ref: Flags. (line 59) +* volatil, in mem: Flags. (line 100) +* volatil, in reg: Flags. (line 119) +* volatil, in symbol_ref: Flags. (line 201) +* volatile memory references: Flags. (line 331) +* voting between constraint alternatives: Class Preferences. (line 6) +* VTABLE_REF: Expression trees. (line 6) +* WCHAR_TYPE: Type Layout. (line 131) +* WCHAR_TYPE_SIZE: Type Layout. (line 139) +* which_alternative: Output Statement. (line 59) +* WHILE_BODY: Function Bodies. (line 6) +* WHILE_COND: Function Bodies. (line 6) +* WHILE_STMT: Function Bodies. (line 6) +* WIDEST_HARDWARE_FP_SIZE: Type Layout. (line 86) +* WINT_TYPE: Type Layout. (line 159) +* word_mode: Machine Modes. (line 223) +* WORD_REGISTER_OPERATIONS: Misc. (line 76) +* WORD_SWITCH_TAKES_ARG: Driver. (line 19) +* WORDS_BIG_ENDIAN: Storage Layout. (line 28) +* WORDS_BIG_ENDIAN, effect on subreg: Regs and Memory. (line 132) +* X in constraint: Simple Constraints. (line 112) +* x-HOST: Host Fragment. (line 6) +* XCmode: Machine Modes. (line 111) +* XCOFF_DEBUGGING_INFO: DBX Options. (line 12) +* XEXP: Accessors. (line 6) +* XFmode: Machine Modes. (line 79) +* XINT: Accessors. (line 6) +* xm-MACHINE.h: Host Config. (line 6) +* xor: Arithmetic. (line 142) +* xor, canonicalization of: Insn Canonicalizations. + (line 69) +* xorM3 instruction pattern: Standard Names. (line 167) +* XSTR: Accessors. (line 6) +* XVEC: Accessors. (line 41) +* XVECEXP: Accessors. (line 48) +* XVECLEN: Accessors. (line 44) +* XWINT: Accessors. (line 6) +* zero_extend: Conversions. (line 29) +* zero_extendMN2 instruction pattern: Standard Names. (line 370) +* zero_extract: Bit-Fields. (line 30) +* zero_extract, canonicalization of: Insn Canonicalizations. + (line 81) +