Return to tree.def CVS log

Up to [GCC 2.x] / gcc

Annotation of gcc/tree.def, revision 1.1

1.1     ! root        1: /* This file contains the definitions and documentation for the
        !             2:    tree codes used in the GNU C compiler.
        !             3:    Copyright (C) 1987, 1988 Free Software Foundation, Inc.
        !             4: 
        !             5: This file is part of GNU CC.
        !             6: 
        !             7: GNU CC is free software; you can redistribute it and/or modify
        !             8: it under the terms of the GNU General Public License as published by
        !             9: the Free Software Foundation; either version 2, or (at your option)
        !            10: any later version.
        !            11: 
        !            12: GNU CC is distributed in the hope that it will be useful,
        !            13: but WITHOUT ANY WARRANTY; without even the implied warranty of
        !            14: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
        !            15: GNU General Public License for more details.
        !            16: 
        !            17: You should have received a copy of the GNU General Public License
        !            18: along with GNU CC; see the file COPYING.  If not, write to
        !            19: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
        !            20: 
        !            21:  
        !            22: /* The third argument can be:
        !            23:    "x" for an exceptional code (fits no category).
        !            24:    "t" for a type object code.
        !            25: 
        !            26:    "c" for codes for constants.
        !            27:    "d" for codes for declarations (also serving as variable refs).
        !            28:    "r" for codes for references to storage.
        !            29:    "<" for codes for comparison expressions.
        !            30:    "1" for codes for unary arithmetic expressions.
        !            31:    "2" for codes for binary arithmetic expressions.
        !            32:    "s" for codes for expressions with inherent side effects.
        !            33:    "e" for codes for other kinds of expressions.  */
        !            34: 
        !            35: /* For `r', `e', `<', `1', `2', `s' and `x' nodes,
        !            36:    the 4th element is the number of argument slots to allocate.
        !            37:    This determines the size of the tree node object.  */
        !            38: 
        !            39: /* Any erroneous construct is parsed into a node of this type.
        !            40:    This type of node is accepted without complaint in all contexts
        !            41:    by later parsing activities, to avoid multiple error messages
        !            42:    for one error.
        !            43:    No fields in these nodes are used except the TREE_CODE.  */
        !            44: DEFTREECODE (ERROR_MARK, "error_mark", "x", 0)
        !            45: 
        !            46: /* Used to represent a name (such as, in the DECL_NAME of a decl node).
        !            47:    Internally it looks like a STRING_CST node.
        !            48:    There is only one IDENTIFIER_NODE ever made for any particular name.
        !            49:    Use `get_identifier' to get it (or create it, the first time).  */
        !            50: DEFTREECODE (IDENTIFIER_NODE, "identifier_node", "x", -1)
        !            51: 
        !            52: /* Used to hold information to identify an operator (or combination
        !            53:    of two operators) considered as a `noun' rather than a `verb'.
        !            54:    The first operand is encoded in the TREE_TYPE field.  */
        !            55: DEFTREECODE (OP_IDENTIFIER, "op_identifier", "x", 2)
        !            56: 
        !            57: /* Has the TREE_VALUE and TREE_PURPOSE fields.  */
        !            58: /* These nodes are made into lists by chaining through the
        !            59:    TREE_CHAIN field.  The elements of the list live in the
        !            60:    TREE_VALUE fields, while TREE_PURPOSE fields are occasionally
        !            61:    used as well to get the effect of Lisp association lists.  */
        !            62: DEFTREECODE (TREE_LIST, "tree_list", "x", 2)
        !            63: 
        !            64: /* These nodes contain an array of tree nodes.  */
        !            65: DEFTREECODE (TREE_VEC, "tree_vec", "x", 2)
        !            66: 
        !            67: /* A symbol binding block.  These are arranged in a tree,
        !            68:    where the BLOCK_SUBBLOCKS field contains a chain of subblocks
        !            69:    chained through the BLOCK_CHAIN field.
        !            70:    BLOCK_SUPERCONTEXT points to the parent block.
        !            71:    BLOCK_VARS points to a chain of decl nodes.
        !            72:    BLOCK_TYPE_TAGS points to a chain of types which have their own names.
        !            73:    BLOCK_CHAIN points to the next BLOCK at the same level.  */
        !            74: DEFTREECODE (BLOCK, "block", "e", 4)
        !            75: 
        !            76: /* Each data type is represented by a tree node whose code is one of
        !            77:    the following:  */
        !            78: /* Each node that represents a data type has a component TYPE_SIZE
        !            79:    containing a tree that is an expression for the size in bits.
        !            80:    The TYPE_MODE contains the machine mode for values of this type.
        !            81:    The TYPE_POINTER_TO field contains a type for a pointer to this type,
        !            82:      or zero if no such has been created yet.
        !            83:    The TYPE_NEXT_VARIANT field is used to chain together types
        !            84:      that are variants made by type modifiers such as "const" and "volatile".
        !            85:    The TYPE_MAIN_VARIANT field, in any member of such a chain,
        !            86:      points to the start of the chain.
        !            87:    The TYPE_NONCOPIED_PARTS field is a list specifying which parts
        !            88:      of an object of this type should *not* be copied by assignment.
        !            89:      The TREE_PURPOSE of each element is the offset of the part
        !            90:      and the TREE_VALUE is the size in bits of the part.
        !            91:    The TYPE_NAME field contains info on the name used in the program
        !            92:      for this type (for GDB symbol table output).  It is either a
        !            93:      TYPE_DECL node, for types that are typedefs, or an IDENTIFIER_NODE
        !            94:      in the case of structs, unions or enums that are known with a tag,
        !            95:      or zero for types that have no special name.
        !            96:    The TYPE_CONTEXT for any sort of type which could have a name (i.e.
        !            97:     tagged types in C/C++) will point to the node which represents
        !            98:     the scope of the given type.  For most types, this will be a
        !            99:     BLOCK node or a FUNCTION_DECL node, but it could also be a
        !           100:     FUNCTION_TYPE node (for types whose scope is limited to the
        !           101:     formal parameter list of some function type specification) or it
        !           102:     could be a RECORD_TYPE or UNION_TYPE node (for C++ "member" types).
        !           103:     For non-tagged-types, TYPE_CONTEXT need not be set to anything in
        !           104:     particular (since an anonymous type doesn't really have a "scope").  */
        !           105: /* TREE_CHAIN is used for ENUMERAL_TYPE, RECORD_TYPE and UNION_TYPE
        !           106:    nodes used as forward-references to names; see below.  */
        !           107: 
        !           108: DEFTREECODE (VOID_TYPE, "void_type", "t", 0)   /* The void type in C */
        !           109: 
        !           110: /* Integer types in all languages, including char in C.  */
        !           111: /* Has components TYPE_MIN_VALUE, TYPE_MAX_VALUE (expressions, inclusive)
        !           112:    and TYPE_PRECISION (number of bits used by this type).
        !           113:    In the case of a subrange type in Pascal, the TREE_TYPE
        !           114:    of this will point at the supertype (another INTEGER_TYPE).
        !           115:    Otherwise, the TREE_TYPE is zero.  */
        !           116: DEFTREECODE (INTEGER_TYPE, "integer_type", "t", 0)
        !           117: 
        !           118: /* C's float and double.  Different floating types are distinguished
        !           119:    by machine mode and by the TYPE_SIZE and the TYPE_PRECISION.  */
        !           120: DEFTREECODE (REAL_TYPE, "real_type", "t", 0)
        !           121: 
        !           122: /* Complex number types.  The TREE_TYPE field is the data type
        !           123:    of the real and imaginary parts.  */
        !           124: DEFTREECODE (COMPLEX_TYPE, "complex_type", "t", 0)
        !           125: 
        !           126: /* C enums.  The type node looks just like an INTEGER_TYPE node.
        !           127:    The symbols for the values of the enum type are defined by
        !           128:    CONST_DECL nodes, but the type does not point to them;
        !           129:    however, the TREE_VALUES is a list in which each elements' TREE_PURPOSE
        !           130:    is a name and the TREE_VALUE is the value (an INTEGER_CST node).  */
        !           131: /* A forward reference `enum foo' when no enum named foo is defined yet
        !           132:    has zero (a null pointer) in its TYPE_SIZE.  The tag name is in
        !           133:    the TYPE_NAME field.  If the type is later defined, the normal
        !           134:    fields are filled in.
        !           135:    RECORD_TYPE and UNION_TYPE forward refs are treated similarly.  */
        !           136: DEFTREECODE (ENUMERAL_TYPE, "enumeral_type", "t", 0)
        !           137: 
        !           138: /* Pascal's boolean type (true or false are the only values);
        !           139:    no special fields needed.  */
        !           140: DEFTREECODE (BOOLEAN_TYPE, "boolean_type", "t", 0)
        !           141: 
        !           142: /* CHAR in Pascal; not used in C.
        !           143:    No special fields needed.  */
        !           144: DEFTREECODE (CHAR_TYPE, "char_type", "t", 0)
        !           145: 
        !           146: /* All pointer-to-x types have code POINTER_TYPE.
        !           147:    The TREE_TYPE points to the node for the type pointed to.  */
        !           148: DEFTREECODE (POINTER_TYPE, "pointer_type", "t", 0)
        !           149: 
        !           150: /* An offset is a pointer relative to an object.
        !           151:    The TREE_TYPE field is the type of the object at the offset.
        !           152:    The TYPE_OFFSET_BASETYPE points to the node for the type of object
        !           153:    that the offset is relative to.  */
        !           154: DEFTREECODE (OFFSET_TYPE, "offset_type", "t", 0)
        !           155: 
        !           156: /* A reference is like a pointer except that it is coerced
        !           157:    automatically to the value it points to.  Used in C++.  */
        !           158: DEFTREECODE (REFERENCE_TYPE, "reference_type", "t", 0)
        !           159: 
        !           160: /* METHOD_TYPE is the type of a function which takes an extra first
        !           161:    argument for "self", which is not present in the declared argument list.
        !           162:    The TREE_TYPE is the return type of the method.  The TYPE_METHOD_BASETYPE
        !           163:    is the type of "self".  TYPE_ARG_TYPES is the real argument list, which
        !           164:    includes the hidden argument for "self".  */
        !           165: DEFTREECODE (METHOD_TYPE, "method_type", "t", 0)
        !           166: 
        !           167: /* Used for Pascal; details not determined right now.  */
        !           168: DEFTREECODE (FILE_TYPE, "file_type", "t", 0)
        !           169: 
        !           170: /* Types of arrays.  Special fields:
        !           171:    TREE_TYPE             Type of an array element.
        !           172:    TYPE_DOMAIN           Type to index by.
        !           173:                            Its range of values specifies the array length.
        !           174:    TYPE_SEP              Expression for units from one elt to the next.
        !           175:    TYPE_SEP_UNIT         Number of bits in a unit for previous.
        !           176:  The field TYPE_POINTER_TO (TREE_TYPE (array_type)) is always nonzero
        !           177:  and holds the type to coerce a value of that array type to in C.  */
        !           178: /* Array types in C or Pascal */
        !           179: DEFTREECODE (ARRAY_TYPE, "array_type", "t", 0)
        !           180: 
        !           181: /* Types of sets for Pascal.  Special fields are the same as
        !           182:    in an array type.  The target type is always a boolean type.  */
        !           183: DEFTREECODE (SET_TYPE, "set_type", "t", 0)
        !           184: 
        !           185: /* Not known whether Pascal really needs this
        !           186:    or what it should contain.  */
        !           187: DEFTREECODE (STRING_TYPE, "string_type", "t", 0)
        !           188: 
        !           189: /* Struct in C, or record in Pascal.  */
        !           190: /* Special fields:
        !           191:    TYPE_FIELDS  chain of FIELD_DECLs for the fields of the struct.
        !           192:    A few may need to be added for Pascal.  */
        !           193: /* See the comment above, before ENUMERAL_TYPE, for how
        !           194:    forward references to struct tags are handled in C.  */
        !           195: DEFTREECODE (RECORD_TYPE, "record_type", "t", 0)
        !           196: 
        !           197: /* Union in C.  Like a struct, except that the offsets of the fields
        !           198:    will all be zero.  */
        !           199: /* See the comment above, before ENUMERAL_TYPE, for how
        !           200:    forward references to union tags are handled in C.  */
        !           201: DEFTREECODE (UNION_TYPE, "union_type", "t", 0) /* C union type */
        !           202: 
        !           203: /* Type of functions.  Special fields:
        !           204:    TREE_TYPE               type of value returned.
        !           205:    TYPE_ARG_TYPES      list of types of arguments expected.
        !           206:        this list is made of TREE_LIST nodes.
        !           207:    Types of "Procedures" in languages where they are different from functions
        !           208:    have code FUNCTION_TYPE also, but then TREE_TYPE is zero or void type.  */
        !           209: DEFTREECODE (FUNCTION_TYPE, "function_type", "t", 0)
        !           210: 
        !           211: /* This is a language-specific kind of type.
        !           212:    Its meaning is defined by the language front end.
        !           213:    layout_type does not know how to lay this out,
        !           214:    so the front-end must do so manually.  */
        !           215: DEFTREECODE (LANG_TYPE, "lang_type", "t", 0)
        !           216: 
        !           217: /* Expressions */
        !           218: 
        !           219: /* First, the constants.  */
        !           220: 
        !           221: /* Contents are in TREE_INT_CST_LOW and TREE_INT_CST_HIGH fields,
        !           222:    32 bits each, giving us a 64 bit constant capability.
        !           223:    Note: constants of type char in Pascal are INTEGER_CST,
        !           224:    and so are pointer constants such as nil in Pascal or NULL in C.
        !           225:    `(int *) 1' in C also results in an INTEGER_CST.  */
        !           226: DEFTREECODE (INTEGER_CST, "integer_cst", "c", 2)
        !           227: 
        !           228: /* Contents are in TREE_REAL_CST field.  Also there is TREE_CST_RTL.  */
        !           229: DEFTREECODE (REAL_CST, "real_cst", "c", 3)
        !           230: 
        !           231: /* Contents are in TREE_REALPART and TREE_IMAGPART fields,
        !           232:    whose contents are other constant nodes.
        !           233:    Also there is TREE_CST_RTL.  */
        !           234: DEFTREECODE (COMPLEX_CST, "complex_cst", "c", 3)
        !           235: 
        !           236: /* Contents are TREE_STRING_LENGTH and TREE_STRING_POINTER fields.
        !           237:    Also there is TREE_CST_RTL.  */
        !           238: DEFTREECODE (STRING_CST, "string_cst", "c", 3)
        !           239: 
        !           240: /* Declarations.  All references to names are represented as ..._DECL nodes.
        !           241:    The decls in one binding context are chained through the TREE_CHAIN field.
        !           242:    Each DECL has a DECL_NAME field which contains an IDENTIFIER_NODE.
        !           243:     (Some decls, most often labels, may have zero as the DECL_NAME).
        !           244:    DECL_CONTEXT points to the node representing the context in which
        !           245:     this declaration has its scope.  For FIELD_DECLs, this is the
        !           246:     RECORD_TYPE or UNION_TYPE node that the field belongs to;
        !           247:     for VAR_DECL, PARM_DECL, FUNCTION_DECL and LABEL_DECL, this
        !           248:     is the FUNCTION_DECL for the containing function, or 0 if global.
        !           249:    The TREE_TYPE field holds the data type of the object, when relevant.
        !           250:     LABEL_DECLs have no data type.  For TYPE_DECL, the TREE_TYPE field
        !           251:     contents are the type whose name is being declared.
        !           252:    The DECL_ALIGN, DECL_SIZE,
        !           253:     and DECL_MODE fields exist in decl nodes just as in type nodes.
        !           254:     They are unused in LABEL_DECL, TYPE_DECL and CONST_DECL nodes.
        !           255: 
        !           256:    DECL_OFFSET holds an integer number of bits offset for the location.
        !           257:    DECL_VOFFSET holds an expression for a variable offset; it is
        !           258:    to be multiplied by DECL_VOFFSET_UNIT (an integer).
        !           259:    These fields are relevant only in FIELD_DECLs and PARM_DECLs.
        !           260: 
        !           261:    DECL_INITIAL holds the value to initialize a variable to,
        !           262:    or the value of a constant.  For a function, it holds the body
        !           263:    (a node of type BLOCK representing the function's binding contour
        !           264:    and whose body contains the function's statements.)  For a LABEL_DECL
        !           265:    in C, it is a flag, nonzero if the label's definition has been seen.
        !           266: 
        !           267:    PARM_DECLs use a special field:
        !           268:    DECL_ARG_TYPE is the type in which the argument is actually
        !           269:     passed, which may be different from its type within the function.
        !           270: 
        !           271:    FUNCTION_DECLs use four special fields:
        !           272:    DECL_ARGUMENTS holds a chain of PARM_DECL nodes for the arguments.
        !           273:    DECL_RESULT holds a RESULT_DECL node for the value of a function,
        !           274:     or it is 0 for a function that returns no value.
        !           275:     (C functions returning void have zero here.)
        !           276:    DECL_RESULT_TYPE holds the type in which the result is actually
        !           277:     returned.  This is usually the same as the type of DECL_RESULT,
        !           278:     but (1) it may be a wider integer type and
        !           279:     (2) it remains valid, for the sake of inlining, even after the
        !           280:     function's compilation is done.
        !           281:    DECL_FUNCTION_CODE is a code number that is nonzero for
        !           282:     built-in functions.  Its value is an enum built_in_function
        !           283:     that says which built-in function it is.
        !           284: 
        !           285:    DECL_SOURCE_FILE holds a filename string and DECL_SOURCE_LINE
        !           286:    holds a line number.  In some cases these can be the location of
        !           287:    a reference, if no definition has been seen.  */
        !           288: 
        !           289: DEFTREECODE (FUNCTION_DECL, "function_decl", "d", 0)
        !           290: DEFTREECODE (LABEL_DECL, "label_decl", "d", 0)
        !           291: DEFTREECODE (CONST_DECL, "const_decl", "d", 0)
        !           292: DEFTREECODE (TYPE_DECL, "type_decl", "d", 0)
        !           293: DEFTREECODE (VAR_DECL, "var_decl", "d", 0)
        !           294: DEFTREECODE (PARM_DECL, "parm_decl", "d", 0)
        !           295: DEFTREECODE (RESULT_DECL, "result_decl", "d", 0)
        !           296: DEFTREECODE (FIELD_DECL, "field_decl", "d", 0)
        !           297: 
        !           298: /* References to storage.  */
        !           299: 
        !           300: /* Value is structure or union component.
        !           301:    Operand 0 is the structure or union (an expression);
        !           302:    operand 1 is the field (a node of type FIELD_DECL).  */
        !           303: DEFTREECODE (COMPONENT_REF, "component_ref", "r", 2)
        !           304: 
        !           305: /* Reference to a group of bits within an object.  Similar to COMPONENT_REF
        !           306:    except the position is given explicitly rather than via a FIELD_DECL.
        !           307:    Operand 0 is the structure or union expression;
        !           308:    operand 1 is a tree giving the number of bits being referenced;
        !           309:    operand 2 is a tree giving the position of the first referenced bit.
        !           310:    The field can be either a signed or unsigned field;
        !           311:    TREE_UNSIGNED says which.  */
        !           312: DEFTREECODE (BIT_FIELD_REF, "bit_field_ref", "r", 3)
        !           313:    
        !           314: /* C unary `*' or Pascal `^'.  One operand, an expression for a pointer.  */
        !           315: DEFTREECODE (INDIRECT_REF, "indirect_ref", "r", 1)
        !           316: 
        !           317: /* Reference to the contents of an offset
        !           318:    (a value whose type is an OFFSET_TYPE).
        !           319:    Operand 0 is the object within which the offset is taken.
        !           320:    Operand 1 is the offset.  */
        !           321: DEFTREECODE (OFFSET_REF, "offset_ref", "r", 2)
        !           322: 
        !           323: /* Pascal `^` on a file.  One operand, an expression for the file.  */
        !           324: DEFTREECODE (BUFFER_REF, "buffer_ref", "r", 1)
        !           325: 
        !           326: /* Array indexing in languages other than C.
        !           327:    Operand 0 is the array; operand 1 is a list of indices
        !           328:    stored as a chain of TREE_LIST nodes.  */
        !           329: DEFTREECODE (ARRAY_REF, "array_ref", "r", 2)
        !           330: 
        !           331: /* Constructor: return an aggregate value made from specified components.
        !           332:    In C, this is used only for structure and array initializers.
        !           333:    The first "operand" is really a pointer to the RTL,
        !           334:    for constant constructors only.
        !           335:    The second operand is a list of component values
        !           336:    made out of a chain of TREE_LIST nodes.  */
        !           337: DEFTREECODE (CONSTRUCTOR, "constructor", "e", 2)
        !           338: 
        !           339: /* The expression types are mostly straightforward,
        !           340:    with the fourth argument of DEFTREECODE saying
        !           341:    how many operands there are.
        !           342:    Unless otherwise specified, the operands are expressions.  */
        !           343: 
        !           344: /* Contains two expressions to compute, one followed by the other.
        !           345:    the first value is ignored.  The second one's value is used.  */
        !           346: DEFTREECODE (COMPOUND_EXPR, "compound_expr", "e", 2)
        !           347: 
        !           348: /* Assignment expression.  Operand 0 is the what to set; 1, the new value.  */
        !           349: DEFTREECODE (MODIFY_EXPR, "modify_expr", "e", 2)
        !           350: 
        !           351: /* Initialization expression.  Operand 0 is the variable to initialize;
        !           352:    Operand 1 is the initializer.  */
        !           353: DEFTREECODE (INIT_EXPR, "init_expr", "e", 2)
        !           354: 
        !           355: /* For TARGET_EXPR, operand 0 is the target of an initialization,
        !           356:    operand 1 is the initializer for the target,
        !           357:    and operand 2 is the cleanup for this node, if any.  */
        !           358: DEFTREECODE (TARGET_EXPR, "target_expr", "e", 3)
        !           359: 
        !           360: /* Conditional expression ( ... ? ... : ...  in C).
        !           361:    Operand 0 is the condition.
        !           362:    Operand 1 is the then-value.
        !           363:    Operand 2 is the else-value.  */
        !           364: DEFTREECODE (COND_EXPR, "cond_expr", "e", 3)
        !           365: 
        !           366: /* Declare local variables, including making RTL and allocating space.
        !           367:    Operand 0 is a chain of VAR_DECL nodes for the variables.
        !           368:    Operand 1 is the body, the expression to be computed using 
        !           369:    the variables.  The value of operand 1 becomes that of the BIND_EXPR.
        !           370:    Operand 2 is the BLOCK that corresponds to these bindings
        !           371:    for debugging purposes.  If this BIND_EXPR is actually expanded,
        !           372:    that sets the TREE_USED flag in the BLOCK.
        !           373: 
        !           374:    The BIND_EXPR is not responsible for informing parsers
        !           375:    about these variables.  If the body is coming from the input file,
        !           376:    then the code that creates the BIND_EXPR is also responsible for 
        !           377:    informing the parser of the variables.
        !           378: 
        !           379:    If the BIND_EXPR is ever expanded, its TREE_USED flag is set.
        !           380:    This tells the code for debugging symbol tables not to ignore the BIND_EXPR.
        !           381:    If the BIND_EXPR should be output for debugging but will not be expanded, 
        !           382:    set the TREE_USED flag by hand.
        !           383: 
        !           384:    In order for the BIND_EXPR to be known at all, the code that creates it
        !           385:    must also install it as a subblock in the tree of BLOCK
        !           386:    nodes for the function.  */
        !           387: DEFTREECODE (BIND_EXPR, "bind_expr", "e", 3)
        !           388: 
        !           389: /* Function call.  Operand 0 is the function.
        !           390:    Operand 1 is the argument list, a list of expressions
        !           391:    made out of a chain of TREE_LIST nodes.
        !           392:    There is no operand 2.  That slot is used for the
        !           393:    CALL_EXPR_RTL macro (see preexpand_calls).  */
        !           394: DEFTREECODE (CALL_EXPR, "call_expr", "e", 3)
        !           395: 
        !           396: /* Call a method.  Operand 0 is the method, whose type is a METHOD_TYPE.
        !           397:    Operand 1 is the expression for "self".
        !           398:    Operand 2 is the list of explicit arguments.  */
        !           399: DEFTREECODE (METHOD_CALL_EXPR, "method_call_expr", "e", 4)
        !           400: 
        !           401: /* Specify a value to compute along with its corresponding cleanup.
        !           402:    Operand 0 argument is an expression whose value needs a cleanup.
        !           403:    Operand 1 is an RTL_EXPR which will eventually represent that value.
        !           404:    Operand 2 is the cleanup expression for the object.
        !           405:      The RTL_EXPR is used in this expression, which is how the expression
        !           406:      manages to act on the proper value.
        !           407:    The cleanup is executed when the value is no longer needed,
        !           408:    which is not at precisely the same time that this value is computed.  */
        !           409: DEFTREECODE (WITH_CLEANUP_EXPR, "with_cleanup_expr", "e", 3)
        !           410: 
        !           411: /* Simple arithmetic.  Operands must have the same machine mode
        !           412:    and the value shares that mode.  */
        !           413: DEFTREECODE (PLUS_EXPR, "plus_expr", "2", 2)
        !           414: DEFTREECODE (MINUS_EXPR, "minus_expr", "2", 2)
        !           415: DEFTREECODE (MULT_EXPR, "mult_expr", "2", 2)
        !           416: 
        !           417: /* Division for integer result that rounds the quotient toward zero.  */
        !           418: /* Operands must have the same machine mode.
        !           419:    In principle they may be real, but that is not currently supported.
        !           420:    The result is always fixed point, and it has the same type as the
        !           421:    operands if they are fixed point.   */
        !           422: DEFTREECODE (TRUNC_DIV_EXPR, "trunc_div_expr", "2", 2)
        !           423: 
        !           424: /* Division for integer result that rounds the quotient toward infinity.  */
        !           425: DEFTREECODE (CEIL_DIV_EXPR, "ceil_div_expr", "2", 2)
        !           426: 
        !           427: /* Division for integer result that rounds toward minus infinity.  */
        !           428: DEFTREECODE (FLOOR_DIV_EXPR, "floor_div_expr", "2", 2)
        !           429: 
        !           430: /* Division for integer result that rounds toward nearest integer.  */
        !           431: DEFTREECODE (ROUND_DIV_EXPR, "round_div_expr", "2", 2)
        !           432: 
        !           433: /* Four kinds of remainder that go with the four kinds of division.  */
        !           434: DEFTREECODE (TRUNC_MOD_EXPR, "trunc_mod_expr", "2", 2)
        !           435: DEFTREECODE (CEIL_MOD_EXPR, "ceil_mod_expr", "2", 2)
        !           436: DEFTREECODE (FLOOR_MOD_EXPR, "floor_mod_expr", "2", 2)
        !           437: DEFTREECODE (ROUND_MOD_EXPR, "round_mod_expr", "2", 2)
        !           438: 
        !           439: /* Division for real result.  The two operands must have the same type.
        !           440:    In principle they could be integers, but currently only real
        !           441:    operands are supported.  The result must have the same type
        !           442:    as the operands.  */
        !           443: DEFTREECODE (RDIV_EXPR, "rdiv_expr", "2", 2)
        !           444: 
        !           445: /* Division which is not supposed to need rounding.
        !           446:    Used for pointer subtraction in C.  */
        !           447: DEFTREECODE (EXACT_DIV_EXPR, "exact_div_expr", "2", 2)
        !           448: 
        !           449: /* Conversion of real to fixed point: four ways to round,
        !           450:    like the four ways to divide.
        !           451:    CONVERT_EXPR can also be used to convert a real to an integer,
        !           452:    and that is what is used in languages that do not have ways of
        !           453:    specifying which of these is wanted.  Maybe these are not needed.  */
        !           454: DEFTREECODE (FIX_TRUNC_EXPR, "fix_trunc_expr", "1", 1)
        !           455: DEFTREECODE (FIX_CEIL_EXPR, "fix_ceil_expr", "1", 1)
        !           456: DEFTREECODE (FIX_FLOOR_EXPR, "fix_floor_expr", "1", 1)
        !           457: DEFTREECODE (FIX_ROUND_EXPR, "fix_round_expr", "1", 1)
        !           458: 
        !           459: /* Conversion of an integer to a real.  */
        !           460: DEFTREECODE (FLOAT_EXPR, "float_expr", "1", 1)
        !           461: 
        !           462: /* Exponentiation.  Operands may have any types;
        !           463:    constraints on value type are not known yet.  */
        !           464: DEFTREECODE (EXPON_EXPR, "expon_expr", "2", 2)
        !           465: 
        !           466: /* Unary negation.  Value has same type as operand.  */
        !           467: DEFTREECODE (NEGATE_EXPR, "negate_expr", "1", 1)
        !           468: 
        !           469: DEFTREECODE (MIN_EXPR, "min_expr", "2", 2)
        !           470: DEFTREECODE (MAX_EXPR, "max_expr", "2", 2)
        !           471: DEFTREECODE (ABS_EXPR, "abs_expr", "1", 1)
        !           472: DEFTREECODE (FFS_EXPR, "ffs_expr", "1", 1)
        !           473: 
        !           474: /* Shift operations for shift and rotate.
        !           475:    Shift is supposed to mean logical shift if done on an
        !           476:    unsigned type, arithmetic shift on a signed type.
        !           477:    The second operand is the number of bits to
        !           478:    shift by, and must always have mode SImode.
        !           479:    The result has the same mode as the first operand.  */
        !           480: DEFTREECODE (LSHIFT_EXPR, "alshift_expr", "2", 2)
        !           481: DEFTREECODE (RSHIFT_EXPR, "arshift_expr", "2", 2)
        !           482: DEFTREECODE (LROTATE_EXPR, "lrotate_expr", "2", 2)
        !           483: DEFTREECODE (RROTATE_EXPR, "rrotate_expr", "2", 2)
        !           484: 
        !           485: /* Bitwise operations.  Operands have same mode as result.  */
        !           486: DEFTREECODE (BIT_IOR_EXPR, "bit_ior_expr", "2", 2)
        !           487: DEFTREECODE (BIT_XOR_EXPR, "bit_xor_expr", "2", 2)
        !           488: DEFTREECODE (BIT_AND_EXPR, "bit_and_expr", "2", 2)
        !           489: DEFTREECODE (BIT_ANDTC_EXPR, "bit_andtc_expr", "2", 2)
        !           490: DEFTREECODE (BIT_NOT_EXPR, "bit_not_expr", "1", 1)
        !           491: 
        !           492: /* Combination of boolean values or of integers considered only
        !           493:    as zero or nonzero.  ANDIF and ORIF allow the second operand
        !           494:    not to be computed if the value of the expression is determined
        !           495:    from the first operand.  AND and OR always compute the second
        !           496:    operand whether its value is needed or not (for side effects).  */
        !           497: DEFTREECODE (TRUTH_ANDIF_EXPR, "truth_andif_expr", "e", 2)
        !           498: DEFTREECODE (TRUTH_ORIF_EXPR, "truth_orif_expr", "e", 2)
        !           499: DEFTREECODE (TRUTH_AND_EXPR, "truth_and_expr", "2", 2)
        !           500: DEFTREECODE (TRUTH_OR_EXPR, "truth_or_expr", "2", 2)
        !           501: DEFTREECODE (TRUTH_NOT_EXPR, "truth_not_expr", "e", 1)
        !           502: 
        !           503: /* Relational operators.
        !           504:    `EQ_EXPR' and `NE_EXPR' are allowed for any types.
        !           505:    The others are allowed only for integer (or pointer or enumeral)
        !           506:    or real types.
        !           507:    In all cases the operands will have the same type,
        !           508:    and the value is always the type used by the language for booleans.  */
        !           509: DEFTREECODE (LT_EXPR, "lt_expr", "<", 2)
        !           510: DEFTREECODE (LE_EXPR, "le_expr", "<", 2)
        !           511: DEFTREECODE (GT_EXPR, "gt_expr", "<", 2)
        !           512: DEFTREECODE (GE_EXPR, "ge_expr", "<", 2)
        !           513: DEFTREECODE (EQ_EXPR, "eq_expr", "<", 2)
        !           514: DEFTREECODE (NE_EXPR, "ne_expr", "<", 2)
        !           515: 
        !           516: /* Operations for Pascal sets.  Not used now.  */
        !           517: DEFTREECODE (IN_EXPR, "in_expr", "2", 2)
        !           518: DEFTREECODE (SET_LE_EXPR, "set_le_expr", "<", 2)
        !           519: DEFTREECODE (CARD_EXPR, "card_expr", "1", 1)
        !           520: DEFTREECODE (RANGE_EXPR, "range_expr", "2", 2)
        !           521: 
        !           522: /* Represents a conversion of type of a value.
        !           523:    All conversions, including implicit ones, must be
        !           524:    represented by CONVERT_EXPR nodes.  */
        !           525: DEFTREECODE (CONVERT_EXPR, "convert_expr", "1", 1)
        !           526: 
        !           527: /* Represents a conversion expected to require no code to be generated.  */
        !           528: DEFTREECODE (NOP_EXPR, "nop_expr", "1", 1)
        !           529: 
        !           530: /* Value is same as argument, but guaranteed not an lvalue.  */
        !           531: DEFTREECODE (NON_LVALUE_EXPR, "non_lvalue_expr", "1", 1)
        !           532: 
        !           533: /* Represents something we computed once and will use multiple times.
        !           534:    First operand is that expression.  Second is the function decl
        !           535:    in which the SAVE_EXPR was created.  The third operand is the RTL,
        !           536:    nonzero only after the expression has been computed.  */
        !           537: DEFTREECODE (SAVE_EXPR, "save_expr", "e", 3)
        !           538: 
        !           539: /* Represents something whose RTL has already been expanded
        !           540:    as a sequence which should be emitted when this expression is expanded.
        !           541:    The first operand is the RTL to emit.  It is the first of a chain of insns.
        !           542:    The second is the RTL expression for the result.  */
        !           543: DEFTREECODE (RTL_EXPR, "rtl_expr", "e", 2)
        !           544: 
        !           545: /* & in C.  Value is the address at which the operand's value resides.
        !           546:    Operand may have any mode.  Result mode is Pmode.  */
        !           547: DEFTREECODE (ADDR_EXPR, "addr_expr", "e", 1)
        !           548: 
        !           549: /* Non-lvalue reference or pointer to an object.  */
        !           550: DEFTREECODE (REFERENCE_EXPR, "reference_expr", "e", 1)
        !           551: 
        !           552: /* A wrapper in C++.  Operand 0 is the type that the wrapper
        !           553:    belongs to (if non-virtual).  Operand 1 is the function
        !           554:    being wrapped.  An anti-wrapper means do not wrap the function
        !           555:    (if it would be wrapped by default).  */
        !           556: DEFTREECODE (WRAPPER_EXPR, "wrapper_expr", "e", 2)
        !           557: DEFTREECODE (ANTI_WRAPPER_EXPR, "anti_wrapper_expr", "e", 2)
        !           558: 
        !           559: /* Operand is a function constant; result is a function variable value
        !           560:    of typeEPmode.  Used only for languages that need static chains.  */
        !           561: DEFTREECODE (ENTRY_VALUE_EXPR, "entry_value_expr", "e", 1)
        !           562: 
        !           563: /* Given two real or integer operands of the same type,
        !           564:    returns a complex value of the corresponding complex type.  */
        !           565: DEFTREECODE (COMPLEX_EXPR, "complex_expr", "2", 2)
        !           566: 
        !           567: /* Complex conjugate of operand.  Used only on complex types.
        !           568:    The value has the same type as the operand.  */
        !           569: DEFTREECODE (CONJ_EXPR, "conj_expr", "1", 1)
        !           570: 
        !           571: /* Used only on an operand of complex type, these return
        !           572:    a value of the corresponding component type.  */
        !           573: DEFTREECODE (REALPART_EXPR, "realpart_expr", "1", 1)
        !           574: DEFTREECODE (IMAGPART_EXPR, "imagpart_expr", "1", 1)
        !           575: 
        !           576: /* Nodes for ++ and -- in C.
        !           577:    The second arg is how much to increment or decrement by.
        !           578:    For a pointer, it would be the size of the object pointed to.  */
        !           579: DEFTREECODE (PREDECREMENT_EXPR, "predecrement_expr", "e", 2)
        !           580: DEFTREECODE (PREINCREMENT_EXPR, "preincrement_expr", "e", 2)
        !           581: DEFTREECODE (POSTDECREMENT_EXPR, "postdecrement_expr", "e", 2)
        !           582: DEFTREECODE (POSTINCREMENT_EXPR, "postincrement_expr", "e", 2)
        !           583: 
        !           584: /* These types of expressions have no useful value,
        !           585:    and always have side effects.  */
        !           586: 
        !           587: /* A label definition, encapsulated as a statement.
        !           588:    Operand 0 is the LABEL_DECL node for the label that appears here.
        !           589:    The type should be void and the value should be ignored.  */
        !           590: DEFTREECODE (LABEL_EXPR, "label_expr", "s", 1)
        !           591: 
        !           592: /* GOTO.  Operand 0 is a LABEL_DECL node.
        !           593:    The type should be void and the value should be ignored.  */
        !           594: DEFTREECODE (GOTO_EXPR, "goto_expr", "s", 1)
        !           595: 
        !           596: /* RETURN.  Evaluates operand 0, then returns from the current function.
        !           597:    Presumably that operand is an assignment that stores into the
        !           598:    RESULT_DECL that hold the value to be returned.
        !           599:    The operand may be null.
        !           600:    The type should be void and the value should be ignored.  */
        !           601: DEFTREECODE (RETURN_EXPR, "return_expr", "s", 1)
        !           602: 
        !           603: /* Exit the inner most loop conditionally.  Operand 0 is the condition.
        !           604:    The type should be void and the value should be ignored.  */
        !           605: DEFTREECODE (EXIT_EXPR, "exit_expr", "s", 1)
        !           606: 
        !           607: /* A loop.  Operand 0 is the body of the loop.
        !           608:    It must contain an EXIT_EXPR or is an infinite loop.
        !           609:    The type should be void and the value should be ignored.  */
        !           610: DEFTREECODE (LOOP_EXPR, "loop_expr", "s", 1)
        !           611: 
        !           612: /*
        !           613: Local variables:
        !           614: mode:c
        !           615: version-control: t
        !           616: End:
        !           617: */

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.