-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
funds for GNU development.
\1f
-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.
\1f
-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
+<law@redhat.com> 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.
-\1f
-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.
-\1f
-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 <limits> :-) 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.
+
+\1f
+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.
+
+\0\b[index\0\b]
* 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)
\1f
-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
+*****
+
+\0\b[index\0\b]
+* 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)
+
projects / msp430-gcc.git / blobdiff