Return to tree.def CVS log

Up to [Apple XNU] / GNUtools / cc

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

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