![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tree.def CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10dc / cmd / gcc|
Return to tree.def CVS log | Up to [Research Unix] / researchv10dc / cmd / gcc |
1.1 ! root 1: /* This file contains the definitions and documentation for the ! 2: machine modes used in the the GNU compiler. ! 3: Copyright (C) 1987 Free Software Foundation, Inc. ! 4: ! 5: This file is part of GNU CC. ! 6: ! 7: GNU CC is distributed in the hope that it will be useful, ! 8: but WITHOUT ANY WARRANTY. No author or distributor ! 9: accepts responsibility to anyone for the consequences of using it ! 10: or for whether it serves any particular purpose or works at all, ! 11: unless he says so in writing. Refer to the GNU CC General Public ! 12: License for full details. ! 13: ! 14: Everyone is granted permission to copy, modify and redistribute ! 15: GNU CC, but only under the conditions described in the ! 16: GNU CC General Public License. A copy of this license is ! 17: supposed to have been given to you along with GNU CC so you ! 18: can know your rights and responsibilities. It should be in a ! 19: file named COPYING. Among other things, the copyright notice ! 20: and this notice must be preserved on all copies. */ ! 21: ! 22: ! 23: /* The third argument can be: ! 24: "x" for an exceptional code (fits no category). ! 25: "s" for a statement code. ! 26: "t" for a type object code. ! 27: ! 28: "c" for codes for constants. ! 29: "d" for codes for declarations (also serving as variable refs). ! 30: "r" for codes for references to storage. ! 31: "e" for codes for other kinds of expressions. */ ! 32: ! 33: /* Any erroneous construct is parsed into a node of this type. ! 34: This type of node is accepted without complaint in all contexts ! 35: by later parsing activities, to avoid multiple error messages ! 36: for one error. ! 37: No fields in these nodes are used except the TREE_CODE. */ ! 38: DEFTREECODE (ERROR_MARK, "error_mark", "x", 0) ! 39: ! 40: /* Used to represent a name (such as, in the DECL_NAME of a decl node). ! 41: Internally it looks like a STRING_CST node. ! 42: There is only one IDENTIFIER_NODE ever made for any particular name. ! 43: Use `get_identifier' to get it (or create it, the first time). */ ! 44: DEFTREECODE (IDENTIFIER_NODE, "identifier_node", "x", 6) ! 45: ! 46: /* Has the TREE_VALUE and TREE_PURPOSE fields. */ ! 47: /* These nodes are made into lists by chaining through the ! 48: TREE_CHAIN field. The elements of the list live in the ! 49: TREE_VALUE fields, while TREE_PURPOSE fields are occasionally ! 50: used as well to get the effect of Lisp association lists. */ ! 51: DEFTREECODE (TREE_LIST, "tree_list", "x", 2) ! 52: ! 53: /* Each data type is represented by a tree node whose code is one of ! 54: the following: */ ! 55: /* Each node that represents a data type has a component TYPE_SIZE ! 56: containing a tree that is an expression for the size in some units. ! 57: The TYPE_SIZE_UNIT component is the number of bits in a unit. ! 58: The TYPE_MODE contains the machine mode for values of this type. ! 59: The TYPE_POINTER_TO field contains a type for a pointer to this type, ! 60: or zero if no such has been created yet. ! 61: The TYPE_NEXT_VARIANT field is used to chain together types ! 62: that are variants made by type modifiers such as "const" and "volatile". ! 63: The TYPE_MAIN_VARIANT field, in any member of such a chain, ! 64: points to the start of the chain. ! 65: The TYPE_NAME field contains info on the name used in the program ! 66: for this type (for GDB symbol table output). It is either a ! 67: TYPE_DECL node, for types that are typedefs, or an IDENTIFIER_NODE ! 68: in the case of structs, unions or enums that are known with a tag, ! 69: or zero for types that have no special name. */ ! 70: /* The TREE_CHAIN of a ..._TYPE node is normally used to put ! 71: every type onto permanent_type_chain or temporary_type_chain (see tree.c). ! 72: One exception is for ENUMERAL_TYPE, RECORD_TYPE and UNION_TYPE ! 73: nodes used as forward-references to names; see below. */ ! 74: ! 75: DEFTREECODE (VOID_TYPE, "void_type", "t", 0) /* The void type in C */ ! 76: ! 77: /* Integer types in all languages, including char in C. */ ! 78: /* Has components TYPE_MIN_VALUE, TYPE_MAX_VALUE (expressions, inclusive) ! 79: and TYPE_PRECISION (number of bits used by this type). ! 80: In the case of a subrange type in Pascal, the TREE_TYPE ! 81: of this will point at the supertype (another INTEGER_TYPE). ! 82: Otherwise, the TREE_TYPE is zero. */ ! 83: DEFTREECODE (INTEGER_TYPE, "integer_type", "t", 0) ! 84: ! 85: /* C's float and double. Different floating types are distinguished ! 86: by machine mode and by the TYPE_SIZE and the TYPE_PRECISION. */ ! 87: DEFTREECODE (REAL_TYPE, "real_type", "t", 0) ! 88: ! 89: /* Complex number types. The TREE_TYPE field is the data type ! 90: of the real and imaginary parts. */ ! 91: DEFTREECODE (COMPLEX_TYPE, "complex_type", "t", 0) ! 92: ! 93: /* C enums. The type node looks just like an INTEGER_TYPE node. ! 94: The symbols for the values of the enum type are defined by ! 95: CONST_DECL nodes, but the type does not point to them; ! 96: however, the TREE_VALUES is a list in which each elements' TREE_PURPOSE ! 97: is a name and the TREE_VALUE is the value (an INTEGER_CST node). */ ! 98: /* A forward reference `enum foo' when no enum named foo is defined yet ! 99: has zero (a null pointer) in its TYPE_SIZE. The tag name is in ! 100: the TYPE_NAME field. If the type is later defined, the normal ! 101: fields are filled in. ! 102: RECORD_TYPE and UNION_TYPE forward refs are treated similarly. */ ! 103: DEFTREECODE (ENUMERAL_TYPE, "enumeral_type", "t", 0) ! 104: ! 105: /* Pascal's boolean type (true or false are the only values); ! 106: no special fields needed. */ ! 107: DEFTREECODE (BOOLEAN_TYPE, "boolean_type", "t", 0) ! 108: ! 109: /* CHAR in Pascal; not used in C. ! 110: No special fields needed. */ ! 111: DEFTREECODE (CHAR_TYPE, "char_type", "t", 0) ! 112: ! 113: /* All pointer-to-x types have code POINTER_TYPE. ! 114: The TREE_TYPE points to the node for the type pointed to. */ ! 115: DEFTREECODE (POINTER_TYPE, "pointer_type", "t", 0) ! 116: ! 117: /* Used for Pascal; details not determined right now. */ ! 118: DEFTREECODE (FILE_TYPE, "file_type", "t", 0) ! 119: ! 120: /* Types of arrays. Special fields: ! 121: TREE_TYPE Type of an array element. ! 122: TYPE_DOMAIN Type to index by. ! 123: Its range of values specifies the array length. ! 124: TYPE_SEP Expression for units from one elt to the next. ! 125: TYPE_SEP_UNIT Number of bits in a unit for previous. ! 126: TYPE_POINTER_TO It is safe to assume, for an array type, ! 127: that TYPE_POINTER_TO (TREE_TYPE (array_type)) is always nonzero ! 128: and holds the type to coerce a value of that array type to in C. */ ! 129: /* Array types in C or Pascal */ ! 130: DEFTREECODE (ARRAY_TYPE, "array_type", "t", 0) ! 131: ! 132: /* Types of sets for Pascal. Special fields are the same as ! 133: in an array type. The target type is always a boolean type. */ ! 134: DEFTREECODE (SET_TYPE, "set_type", "t", 0) ! 135: ! 136: /* Not known whether Pascal really needs this ! 137: or what it should contain. */ ! 138: DEFTREECODE (STRING_TYPE, "string_type", "t", 0) ! 139: ! 140: /* Struct in C, or record in Pascal. */ ! 141: /* Special fields: ! 142: TYPE_FIELDS chain of FIELD_DECLs for the fields of the struct. ! 143: A few may need to be added for Pascal. */ ! 144: /* See the comment above, before ENUMERAL_TYPE, for how ! 145: forward references to struct tags are handled in C. */ ! 146: DEFTREECODE (RECORD_TYPE, "record_type", "t", 0) ! 147: ! 148: /* Union in C. Like a struct, except that the offsets of the fields ! 149: will all be zero. */ ! 150: /* See the comment above, before ENUMERAL_TYPE, for how ! 151: forward references to union tags are handled in C. */ ! 152: DEFTREECODE (UNION_TYPE, "union_type", "t", 0) /* C union type */ ! 153: ! 154: /* Type of functions. Special fields: ! 155: TREE_TYPE type of value returned. ! 156: TYPE_ARG_TYPES list of types of arguments expected. ! 157: this list is made of TREE_LIST nodes. ! 158: Types of "Procedures" in languages where they are different from functions ! 159: have code FUNCTION_TYPE also, but then TREE_TYPE is zero or void type. */ ! 160: DEFTREECODE (FUNCTION_TYPE, "function_type", "t", 0) ! 161: ! 162: /* All statement types have fields STMT_SOURCE_FILE and STMT_SOURCE_LINE. */ ! 163: /* Consecutive statements within a compound statement are chained together ! 164: through the TREE_CHAIN field. */ ! 165: ! 166: /* A label definition, encapsulated as a statement. ! 167: STMT_BODY is the LABEL_DECL node for the label that appears here. */ ! 168: DEFTREECODE (LABEL_STMT, "label_stmt", "s", 1) ! 169: ! 170: /* GOTO, in any language. STMT_BODY is a LABEL_DECL node. */ ! 171: DEFTREECODE (GOTO_STMT, "goto_stmt", "s", 1) ! 172: ! 173: /* RETURN, in any language. ! 174: Evaluates the expression STMT_BODY, then returns from the current function. ! 175: Presumably STMT_BODY is an assignment that stores into the ! 176: RESULT_DECL that hold the value to be returned. ! 177: STMT_BODY may be zero. */ ! 178: DEFTREECODE (RETURN_STMT, "return_stmt", "s", 1) ! 179: ! 180: /* Statement that evaluates an expression. STMT_BODY is the expression. */ ! 181: DEFTREECODE (EXPR_STMT, "expr_stmt", "s", 1) ! 182: ! 183: /* Pascal WITH statement. ! 184: Contains a chain of variables (..._DECL nodes) in the STMT_VARS ! 185: and a chain of statements (the STMT_BODY). ! 186: STMT_SUPERCONTEXT points to the containing declaration scope. */ ! 187: DEFTREECODE (WITH_STMT, "with_stmt", "s", 5) ! 188: ! 189: /* Declare variables whose scope is less than a function. ! 190: This is used for C brace-pairs that contain declarations. ! 191: Contains a chain of variables (..._DECL nodes) in the STMT_VARS ! 192: and a chain of statements (the STMT_BODY). ! 193: STMT_SUPERCONTEXT points to the containing declaration scope. ! 194: STMT_BIND_SIZE is an expression for the size of local storage here. ! 195: STMT_TYPE_TAGS is a list (chain of TREE_LIST nodes) ! 196: pairing struct, union and enum tag names with the types they mean, ! 197: for tags defined in this context. */ ! 198: DEFTREECODE (LET_STMT, "let_stmt", "s", 5) ! 199: ! 200: /* if-then-else statements in C and other languages. ! 201: STMT_COND is the condition (an expression). ! 202: STMT_THEN is the then-branch (a statement or chain of statements). ! 203: STMT_ELSE is the else-branch (a statement or chain of statements). */ ! 204: DEFTREECODE (IF_STMT, "if_stmt", "s", 3) ! 205: ! 206: /* if-else-exit; used in building parts of iterations. ! 207: STMT_BODY is the condition (an expression). ! 208: Exit if the iteration if the condition is FALSE. */ ! 209: DEFTREECODE (EXIT_STMT, "exit_stmt", "s", 1) ! 210: ! 211: /* STMT_CASE_INDEX is an expression for the value to dispatch on. ! 212: STMT_CASE_LIST is a list (a chain of TREE_LIST nodes) ! 213: of the branches of the dispatch. ! 214: Each such TREE_LIST node has the case it is for (a constant expression) ! 215: as the TREE_PURPOSE ! 216: and the label to go to (a LABEL_DECL) as the TREE_VALUE. ! 217: ! 218: Normally, the labels reside inside a COMPOUND_STMT ! 219: which contains ths CASE_STMT as its first statement. */ ! 220: DEFTREECODE (CASE_STMT, "case_stmt", "s", 3) ! 221: ! 222: /* STMT_BODY contains a chain of statements to be executed repeatedly. */ ! 223: DEFTREECODE (LOOP_STMT, "loop_stmt", "s", 1) ! 224: ! 225: /* Contains as its STMT_BODY a chain of substatements. */ ! 226: DEFTREECODE (COMPOUND_STMT, "compound_stmt", "s", 1) ! 227: ! 228: /* Contains as its STMT_BODY a string of assembly code. */ ! 229: DEFTREECODE (ASM_STMT, "asm_stmt", "s", 1) ! 230: ! 231: /* Expressions */ ! 232: ! 233: /* First, the constants. */ ! 234: ! 235: /* Contents are in TREE_INT_CST_LOW and TREE_INT_CST_HIGH fields, ! 236: 32 bits each, giving us a 64 bit constant capability. ! 237: Note: constants of type char in Pascal are INTEGER_CST, ! 238: and so are pointer constants such as nil in Pascal or NULL in C. ! 239: `(int *) 1' in C also results in an INTEGER_CST. */ ! 240: DEFTREECODE (INTEGER_CST, "integer_cst", "c", 2) ! 241: ! 242: /* Contents are in TREE_REAL_CST field. Also there is TREE_CST_RTL. */ ! 243: DEFTREECODE (REAL_CST, "real_cst", "c", 3) ! 244: ! 245: /* Contents are in TREE_REALPART and TREE_IMAGPART fields, ! 246: whose contents are other constant nodes. ! 247: Also there is TREE_CST_RTL. */ ! 248: DEFTREECODE (COMPLEX_CST, "complex_cst", "c", 3) ! 249: ! 250: /* Contents are TREE_STRING_LENGTH and TREE_STRING_POINTER fields. ! 251: Also there is TREE_CST_RTL. */ ! 252: DEFTREECODE (STRING_CST, "string_cst", "c", 3) ! 253: ! 254: /* Declarations. All references to names are represented as ..._DECL nodes. ! 255: The decls in one binding context are chained through the TREE_CHAIN field. ! 256: Each DECL has a DECL_NAME field which contains an IDENTIFIER_NODE. ! 257: (Some decls, most often labels, may have zero as the DECL_NAME). ! 258: DECL_CONTEXT points to the node representing the context in which ! 259: this declaration has its scope. For FIELD_DECLs, this is the ! 260: RECORD_TYPE or UNION_TYPE node that the field belongs to; ! 261: for other kinds of decl nodes, this is a LET_STMT node or the ROOT_NODE. ! 262: The TREE_TYPE field holds the data type of the object, when relevant. ! 263: LABEL_DECLs have no data type. For TYPE_DECL, the TREE_TYPE field ! 264: contents are the type whose name is being declared. ! 265: The DECL_ALIGN, DECL_SIZE, DECL_SIZE_UNIT ! 266: and DECL_MODE fields exist in decl nodes just as in type nodes. ! 267: They are unused in LABEL_DECL, TYPE_DECL and CONST_DECL nodes. ! 268: ! 269: DECL_OFFSET holds an integer number of bits offset for the location. ! 270: DECL_VOFFSET holds an expression for a variable offset; it is ! 271: to be multiplied by DECL_VOFFSET_UNIT (an integer). ! 272: These fields are relevant only in FIELD_DECLs and PARM_DECLs. ! 273: ! 274: DECL_INITIAL holds the value to initialize a variable to, ! 275: or the value of a constant. For a function, it holds the body ! 276: (a node of type LET_STMT representing the function's binding contour ! 277: and whose body contains the function's statements.) ! 278: ! 279: PARM_DECLs use a special field: ! 280: DECL_ARG_TYPE is the type in which the argument is actually ! 281: passed, which may be different from its type within the function. ! 282: ! 283: FUNCTION_DECLs use four special fields: ! 284: DECL_ARGUMENTS holds a chain of PARM_DECL nodes for the arguments. ! 285: DECL_RESULT holds a RESULT_DECL node for the value of a function, ! 286: or it is 0 for a function that returns no value. ! 287: (C functions returning void have zero here.) ! 288: DECL_FUNCTION_CODE is a code number that is nonzero for ! 289: built-in functions. Its value is an enum built_in_function ! 290: that says which built-in function it is. ! 291: DECL_BLOCK_SYMTAB_ADDRESS records (after the symtab data for the function's ! 292: body has been output) the address in the symtab file of the ! 293: `struct block' for the function's top-level binding context. ! 294: This must be stored in the symtab structure for the function name. ! 295: Also, TREE_UNSIGNED (function_decl) is nonzero if the ({...}) ! 296: construct is used in the function. ! 297: ! 298: DECL_SOURCE_FILE holds a filename string and DECL_SOURCE_LINE ! 299: holds a line number. */ ! 300: ! 301: DEFTREECODE (FUNCTION_DECL, "function_decl", "d", 0) ! 302: DEFTREECODE (LABEL_DECL, "label_decl", "d", 0) ! 303: DEFTREECODE (CONST_DECL, "const_decl", "d", 0) ! 304: DEFTREECODE (TYPE_DECL, "type_decl", "d", 0) ! 305: DEFTREECODE (VAR_DECL, "var_decl", "d", 0) ! 306: DEFTREECODE (PARM_DECL, "parm_decl", "d", 0) ! 307: DEFTREECODE (RESULT_DECL, "result_decl", "d", 0) ! 308: DEFTREECODE (FIELD_DECL, "field_decl", "d", 0) ! 309: ! 310: /* References to storage. */ ! 311: ! 312: /* Value is structure or union component. ! 313: Operand 0 is the structure or union (an expression); ! 314: operand 1 is the field (a node of type FIELD_DECL). */ ! 315: DEFTREECODE (COMPONENT_REF, "component_ref", "r", 2) ! 316: ! 317: /* C unary `*' or Pascal `^'. One operand, an expression for a pointer. */ ! 318: DEFTREECODE (INDIRECT_REF, "indirect_ref", "r", 1) ! 319: ! 320: /* Pascal `^` on a file. One operand, an expression for the file. */ ! 321: DEFTREECODE (BUFFER_REF, "buffer_ref", "r", 1) ! 322: ! 323: /* Array indexing in languages other than C. ! 324: Operand 0 is the array; operand 1 is a list of indices ! 325: stored as a chain of TREE_LIST nodes. */ ! 326: DEFTREECODE (ARRAY_REF, "array_ref", "r", 2) ! 327: ! 328: /* Constructor: return an aggregate value made from specified components. ! 329: In C, this is used only for structure and array initializers. ! 330: The first "operand" is really a pointer to the RTL, ! 331: for constant constructors only. ! 332: The second operand is a list of component values ! 333: made out of a chain of TREE_LIST nodes. */ ! 334: DEFTREECODE (CONSTRUCTOR, "constructor", "e", 2) ! 335: ! 336: /* The expression types are mostly straightforward, ! 337: with the fourth argument of DEFTREECODE saying ! 338: how many operands there are. ! 339: Unless otherwise specified, the operands are expressions. */ ! 340: ! 341: /* Contains two expressions to compute, one followed by the other. ! 342: the first value is ignored. The second one's value is used. */ ! 343: DEFTREECODE (COMPOUND_EXPR, "compound_expr", "e", 2) ! 344: ! 345: /* Assignment expression. Operand 0 is the what to set; 1, the new value. */ ! 346: DEFTREECODE (MODIFY_EXPR, "modify_expr", "e", 2) ! 347: ! 348: /* Conditional expression ( ... ? ... : ... in C). ! 349: Operand 0 is the condition. ! 350: Operand 1 is the then-value. ! 351: Operand 2 is the else-value. */ ! 352: DEFTREECODE (COND_EXPR, "cond_expr", "e", 3) ! 353: ! 354: /* Function call. Operand 0 is the function. ! 355: Operand 1 is the argument list, a list of expressions ! 356: made out of a chain of TREE_LIST nodes. ! 357: There is no operand 2. That slot is used for the ! 358: CALL_EXPR_RTL macro (see preexpand_calls). */ ! 359: DEFTREECODE (CALL_EXPR, "call_expr", "e", 3) ! 360: ! 361: /* Simple arithmetic. Operands must have the same machine mode ! 362: and the value shares that mode. */ ! 363: DEFTREECODE (PLUS_EXPR, "plus_expr", "e", 2) ! 364: DEFTREECODE (MINUS_EXPR, "minus_expr", "e", 2) ! 365: DEFTREECODE (MULT_EXPR, "mult_expr", "e", 2) ! 366: ! 367: /* Division for integer result that rounds the quotient toward zero. */ ! 368: /* Operands must have the same machine mode. ! 369: In principle they may be real, but that is not currently supported. ! 370: The result is always fixed point, and it has the same type as the ! 371: operands if they are fixed point. */ ! 372: DEFTREECODE (TRUNC_DIV_EXPR, "trunc_div_expr", "e", 2) ! 373: ! 374: /* Division for integer result that rounds the quotient toward infinity. */ ! 375: DEFTREECODE (CEIL_DIV_EXPR, "ceil_div_expr", "e", 2) ! 376: ! 377: /* Division for integer result that rounds toward minus infinity. */ ! 378: DEFTREECODE (FLOOR_DIV_EXPR, "floor_div_expr", "e", 2) ! 379: ! 380: /* Division for integer result that rounds toward nearest integer. */ ! 381: DEFTREECODE (ROUND_DIV_EXPR, "round_div_expr", "e", 2) ! 382: ! 383: /* Four kinds of remainder that go with the four kinds of division. */ ! 384: DEFTREECODE (TRUNC_MOD_EXPR, "trunc_mod_expr", "e", 2) ! 385: DEFTREECODE (CEIL_MOD_EXPR, "ceil_mod_expr", "e", 2) ! 386: DEFTREECODE (FLOOR_MOD_EXPR, "floor_mod_expr", "e", 2) ! 387: DEFTREECODE (ROUND_MOD_EXPR, "round_mod_expr", "e", 2) ! 388: ! 389: /* Division for real result. The two operands must have the same type. ! 390: In principle they could be integers, but currently only real ! 391: operands are supported. The result must have the same type ! 392: as the operands. */ ! 393: DEFTREECODE (RDIV_EXPR, "rdiv_expr", "e", 2) ! 394: ! 395: /* Conversion of real to fixed point: four ways to round, ! 396: like the four ways to divide. ! 397: CONVERT_EXPR can also be used to convert a real to an integer, ! 398: and that is what is used in languages that do not have ways of ! 399: specifying which of these is wanted. Maybe these are not needed. */ ! 400: DEFTREECODE (FIX_TRUNC_EXPR, "fix_trunc_expr", "e", 1) ! 401: DEFTREECODE (FIX_CEIL_EXPR, "fix_ceil_expr", "e", 1) ! 402: DEFTREECODE (FIX_FLOOR_EXPR, "fix_floor_expr", "e", 1) ! 403: DEFTREECODE (FIX_ROUND_EXPR, "fix_round_expr", "e", 1) ! 404: ! 405: /* Conversion of an integer to a real. */ ! 406: DEFTREECODE (FLOAT_EXPR, "float_expr", "e", 1) ! 407: ! 408: /* Exponentiation. Operands may have any types; ! 409: constraints on value type are not known yet. */ ! 410: DEFTREECODE (EXPON_EXPR, "expon_expr", "e", 2) ! 411: ! 412: /* Unary negation. Value has same type as operand. */ ! 413: DEFTREECODE (NEGATE_EXPR, "negate_expr", "e", 1) ! 414: ! 415: DEFTREECODE (MIN_EXPR, "min_expr", "e", 2) ! 416: DEFTREECODE (MAX_EXPR, "max_expr", "e", 2) ! 417: DEFTREECODE (ABS_EXPR, "abs_expr", "e", 1) ! 418: DEFTREECODE (FFS_EXPR, "ffs_expr", "e", 1) ! 419: ! 420: /* Shift operations for shift and rotate. ! 421: Shift is supposed to mean logical shift if done on an ! 422: unsigned type, arithmetic shift on a signed type. ! 423: The second operand is the number of bits to ! 424: shift by, and must always have mode SImode. ! 425: The result has the same mode as the first operand. */ ! 426: DEFTREECODE (LSHIFT_EXPR, "alshift_expr", "e", 2) ! 427: DEFTREECODE (RSHIFT_EXPR, "arshift_expr", "e", 2) ! 428: DEFTREECODE (LROTATE_EXPR, "lrotate_expr", "e", 2) ! 429: DEFTREECODE (RROTATE_EXPR, "rrotate_expr", "e", 2) ! 430: ! 431: /* Bitwise operations. Operands have same mode as result. */ ! 432: DEFTREECODE (BIT_IOR_EXPR, "bit_ior_expr", "e", 2) ! 433: DEFTREECODE (BIT_XOR_EXPR, "bit_xor_expr", "e", 2) ! 434: DEFTREECODE (BIT_AND_EXPR, "bit_and_expr", "e", 2) ! 435: DEFTREECODE (BIT_ANDTC_EXPR, "bit_andtc_expr", "e", 2) ! 436: DEFTREECODE (BIT_NOT_EXPR, "bit_not_expr", "e", 1) ! 437: ! 438: /* Combination of boolean values or of integers considered only ! 439: as zero or nonzero. ANDIF and ORIF allow the second operand ! 440: not to be computed if the value of the expression is determined ! 441: from the first operand. AND and OR always compute the second ! 442: operand whether its value is needed or not (for side effects). */ ! 443: DEFTREECODE (TRUTH_ANDIF_EXPR, "truth_andif_expr", "e", 2) ! 444: DEFTREECODE (TRUTH_ORIF_EXPR, "truth_orif_expr", "e", 2) ! 445: DEFTREECODE (TRUTH_AND_EXPR, "truth_and_expr", "e", 2) ! 446: DEFTREECODE (TRUTH_OR_EXPR, "truth_or_expr", "e", 2) ! 447: DEFTREECODE (TRUTH_NOT_EXPR, "truth_not_expr", "e", 1) ! 448: ! 449: /* Relational operators. ! 450: `EQ_EXPR' and `NE_EXPR' are allowed for any types. ! 451: The others are allowed only for integer (or pointer or enumeral) ! 452: or real types. ! 453: In all cases the operands will have the same type, ! 454: and the value is always the type used by the language for booleans. */ ! 455: DEFTREECODE (LT_EXPR, "lt_expr", "e", 2) ! 456: DEFTREECODE (LE_EXPR, "le_expr", "e", 2) ! 457: DEFTREECODE (GT_EXPR, "gt_expr", "e", 2) ! 458: DEFTREECODE (GE_EXPR, "ge_expr", "e", 2) ! 459: DEFTREECODE (EQ_EXPR, "eq_expr", "e", 2) ! 460: DEFTREECODE (NE_EXPR, "ne_expr", "e", 2) ! 461: ! 462: /* Operations for Pascal sets. Not used now. */ ! 463: DEFTREECODE (IN_EXPR, "in_expr", "e", 2) ! 464: DEFTREECODE (SET_LE_EXPR, "set_le_expr", "e", 2) ! 465: DEFTREECODE (CARD_EXPR, "card_expr", "e", 1) ! 466: DEFTREECODE (RANGE_EXPR, "range_expr", "e", 2) ! 467: ! 468: /* Represents a conversion of type of a value. ! 469: All conversions, including implicit ones, must be ! 470: represented by CONVERT_EXPR nodes. */ ! 471: DEFTREECODE (CONVERT_EXPR, "convert_expr", "e", 1) ! 472: ! 473: /* Represents a conversion expected to require no code to be generated. */ ! 474: DEFTREECODE (NOP_EXPR, "nop_expr", "e", 1) ! 475: ! 476: /* Represents something we computed once and will use multiple times. ! 477: First operand is that expression. Second is the RTL, ! 478: nonzero only after the expression has been computed. ! 479: TREE_UNSIGNED in a SAVE_EXPR is nonzero if that SAVE_EXPR ! 480: has been seen already in assign_vars_1. */ ! 481: DEFTREECODE (SAVE_EXPR, "save_expr", "e", 2) ! 482: ! 483: /* Represents something whose RTL has already been expanded ! 484: as a sequence which should be emitted when this expression is expanded. ! 485: The first operand is the-the RTL to emit (which is a SEQUENCE). ! 486: The second is the RTL expression for the result. */ ! 487: DEFTREECODE (RTL_EXPR, "rtl_expr", "e", 2) ! 488: ! 489: /* & in C. Value is the address at which the operand's value resides. ! 490: Operand may have any mode. Result mode is Pmode. */ ! 491: DEFTREECODE (ADDR_EXPR, "addr_expr", "e", 1) ! 492: ! 493: /* Operand is a function constant; result is a function variable value ! 494: of typeEPmode. Used only for languages that need static chains. */ ! 495: DEFTREECODE (ENTRY_VALUE_EXPR, "entry_value_expr", "e", 1) ! 496: ! 497: /* Given two real or integer operands of the same type, ! 498: returns a complex value of the corresponding complex type. */ ! 499: DEFTREECODE (COMPLEX_EXPR, "complex_expr", "e", 2) ! 500: ! 501: /* Complex conjugate of operand. Used only on complex types. ! 502: The value has the same type as the operand. */ ! 503: DEFTREECODE (CONJ_EXPR, "conj_expr", "e", 1) ! 504: ! 505: /* Used only on an operand of complex type, these return ! 506: a value of the corresponding component type. */ ! 507: DEFTREECODE (REALPART_EXPR, "realpart_expr", "e", 1) ! 508: DEFTREECODE (IMAGPART_EXPR, "imagpart_expr", "e", 1) ! 509: ! 510: /* Nodes for ++ and -- in C. ! 511: The second arg is how much to increment or decrement by. ! 512: For a pointer, it would be the size of the object pointed to. */ ! 513: DEFTREECODE (PREDECREMENT_EXPR, "predecrement_expr", "e", 2) ! 514: DEFTREECODE (PREINCREMENT_EXPR, "preincrement_expr", "e", 2) ! 515: DEFTREECODE (POSTDECREMENT_EXPR, "postdecrement_expr", "e", 2) ! 516: DEFTREECODE (POSTINCREMENT_EXPR, "postincrement_expr", "e", 2) ! 517: ! 518: /* ! 519: Local variables: ! 520: mode:c ! 521: version-control: t ! 522: End: ! 523: */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.