Lines Matching refs:is
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
26 4th element is the number of argument slots to allocate. This
28 different structures, and the size is determined by the tree_union
38 /* Any erroneous construct is parsed into a node of this type.
39 This type of node is accepted without complaint in all contexts
47 There is only one IDENTIFIER_NODE ever made for any particular name.
70 this block is an instance of, or else is NULL to indicate that this
71 block is not an instance of anything else. When non-NULL, the value
75 BLOCK_ABSTRACT is nonzero if the block represents an abstract
76 instance of a block (i.e. one which is nested within an abstract
78 TREE_ASM_WRITTEN is nonzero if the block was actually referenced
82 /* Each data type is represented by a tree node whose code is one of
85 containing a tree that is an expression for the size in bits.
89 The TYPE_NEXT_VARIANT field is used to chain together types
93 The TYPE_NONCOPIED_PARTS field is a list specifying which parts
95 The TREE_VALUE of each is a FIELD_DECL that should not be
96 copied. The TREE_PURPOSE is an initial value for that field when
97 an object of this type is initialized via an INIT_EXPR. It may
98 be NULL if no special value is required. Even the things in this
99 list are copied if the right-hand side of an assignment is known
102 complete object is done by fixed_type_p.
104 for this type (for GDB symbol table output). It is either a
113 point to a FUNCTION_TYPE node (for types whose scope is limited to the
118 particular, since any type which is of some type category (e.g.
121 The TREE_CHAIN field is used as a forward-references to names for
125 /* The ordering of the following codes is optimized for the checking
130 /* An offset is a pointer relative to an object.
131 The TREE_TYPE field is the type of the object at the offset.
133 that the offset is relative to. */
139 however, the TYPE_VALUES is a list in which each element's TREE_PURPOSE
140 is a name and the TREE_VALUE is the value (an INTEGER_CST node). */
141 /* A forward reference `enum foo' when no enum named foo is defined yet
142 has zero (a null pointer) in its TYPE_SIZE. The tag name is in
143 the TYPE_NAME field. If the type is later defined, the normal
160 Otherwise, the TREE_TYPE is zero. */
167 /* The ordering of the following codes is optimized for the checking
176 /* A reference is like a pointer except that it is coerced
185 /* The ordering of the following codes is optimized for the checking
189 /* Complex number types. The TREE_TYPE field is the data type
193 /* Vector types. The TREE_TYPE field is the data type of the vector
194 elements. The TYPE_PRECISION field is the number of subparts of
198 /* The ordering of the following codes is optimized for the checking
207 The field TYPE_POINTER_TO (TREE_TYPE (array_type)) is always nonzero
232 field whose DECL_QUALIFIER expression is true is deemed to occupy
236 /* The ordering of the following codes is optimized for the checking
246 this list is made of TREE_LIST nodes.
248 have code FUNCTION_TYPE also, but then TREE_TYPE is zero or void type. */
251 /* METHOD_TYPE is the type of a function which takes an extra first
252 argument for "self", which is not present in the declared argument list.
253 The TREE_TYPE is the return type of the method. The TYPE_METHOD_BASETYPE
254 is the type of "self". TYPE_ARG_TYPES is the real argument list, which
258 /* This is a language-specific kind of type.
259 Its meaning is defined by the language front end.
273 TREE_CONSTANT_OVERFLOW already set, it is known to be unique.
297 FIELD_DECLs, this is the RECORD_TYPE, UNION_TYPE, or
298 QUAL_UNION_TYPE node that the field is a member of. For VAR_DECL,
304 ..._DECL node of which this decl is an (inlined or template expanded)
308 contents are the type whose name is being declared.
315 offset; it is to be multiplied by DECL_VOFFSET_UNIT (an integer).
322 in C, it is a flag, nonzero if the label's definition has been seen.
325 DECL_ARG_TYPE is the type in which the argument is actually
331 The DECL_RTL field is 0 for a function that returns no value.
333 The TREE_TYPE field is the type in which the result is actually
334 returned. This is usually the same as the return type of the
337 DECL_FUNCTION_CODE is a code number that is nonzero for
338 built-in functions. Its value is an enum built_in_function
339 that says which built-in function it is.
345 DECL_ABSTRACT is nonzero if the decl represents an abstract instance
346 of a decl (i.e. one which is nested within an abstract instance of a
351 /* The ordering of the following codes is optimized for the checking
372 /* A translation unit. This is not technically a declaration, since it
379 /* Value is structure or union component.
380 Operand 0 is the structure or union (an expression).
381 Operand 1 is the field (a node of type FIELD_DECL).
382 Operand 2, if present, is the value of DECL_FIELD_OFFSET, measured
387 except the position is given explicitly rather than via a FIELD_DECL.
388 Operand 0 is the structure or union expression;
389 operand 1 is a tree giving the number of bits being referenced;
390 operand 2 is a tree giving the position of the first referenced bit.
395 /* The ordering of the following codes is optimized for the checking
403 in P is not aligned on TYPE_ALIGN boundary, then &(*P) != P). */
408 Operand 0 is the referenced address (a pointer);
409 Operand 1 is an INTEGER_CST which represents the alignment of the address,
410 or 0 if the alignment is unknown. */
414 Operand 0 is the array; operand 1 is a (single) array index.
415 Operand 2, if present, is a copy of TYPE_MIN_VALUE of the index.
416 Operand 3, if present, is the element size, measured in units of
420 /* Likewise, except that the result is a range ("slice") of the array. The
421 starting index of the resulting array is taken from operand 1 and the size
422 of the range is taken from the type of the expression. */
425 /* Used to represent lookup of runtime type dependent data. Often this is
428 OBJ_TYPE_REF_OBJECT: Is the object on whose behalf the lookup is
444 In C, this is used only for structure and array initializers.
445 The operand is a sequence of component values made out of a VEC of
449 The field INDEX of each constructor_elt is the corresponding index.
450 If the index is a RANGE_EXPR, it is a short-hand for many nodes,
456 The field INDEX of each node is a FIELD_DECL. */
465 the first value is ignored. The second one's value is used. The
469 /* Assignment expression. Operand 0 is the what to set; 1, the new value. */
472 /* Initialization expression. Operand 0 is the variable to initialize;
473 Operand 1 is the initializer. This differs from MODIFY_EXPR in that any
474 reference to the referent of operand 0 within operand 1 is undefined. */
477 /* For TARGET_EXPR, operand 0 is the target of an initialization,
478 operand 1 is the initializer for the target, which may be void
480 operand 2 is the cleanup for this node, if any.
481 operand 3 is the saved initializer after this node has been
482 expanded once; this is so we can re-expand the tree later. */
486 Operand 0 is the condition.
487 Operand 1 is the then-value.
488 Operand 2 is the else-value.
495 /* Vector conditional expression. It is like COND_EXPR, but with
508 BIND_EXPR_VARS is a chain of VAR_DECL nodes for the variables.
509 BIND_EXPR_BODY is the body, the expression to be computed using
511 BIND_EXPR_BLOCK is the BLOCK that corresponds to these bindings
512 for debugging purposes. If this BIND_EXPR is actually expanded,
515 The BIND_EXPR is not responsible for informing parsers
516 about these variables. If the body is coming from the input file,
517 then the code that creates the BIND_EXPR is also responsible for
520 If the BIND_EXPR is ever expanded, its TREE_USED flag is set.
530 /* Function call. Operand 0 is the function.
531 Operand 1 is the argument list, a list of expressions
533 Operand 2 is the static chain argument, or NULL. */
537 Operand 0 is the cleanup expression.
538 The cleanup is executed by the first enclosing CLEANUP_POINT_EXPR,
540 is always evaluated when cleanups are run. */
544 Operand 0 is an expression that may have cleanups. If it does, those
545 cleanups are executed after the expression is expanded.
547 Note that if the expression is a reference to storage, it is forced out
548 of memory before the cleanups are run. This is necessary to handle
550 expression 't.i', if 't' is a struct with an integer member 'i' and a
552 whether the cleanup is run before or after 't.i' is evaluated. When
553 expand_expr is run on 't.i', it returns a MEM. This is not good enough;
561 some field in an object of the type contains a value that is used in
568 examples of such types. This mechanism is also used to create "fat
569 pointers" for unconstrained array types in Ada; the fat pointer is a
570 structure one of whose fields is a pointer to the actual array type
571 and the other field is a pointer to a template, which is a structure
580 Such a "self-references" is done using a PLACEHOLDER_EXPR. This is
582 Its type is that of the object and selects which object to use from
586 For example, if your type FOO is a RECORD_TYPE with a field BAR,
589 whose TREE_TYPE is FOO. Then construct your COMPONENT_REF with
591 type). Later, when the size is needed in the program, the back-end
594 calculation is done.
599 found. The latter expression is the object itself in the simple case of
609 The type of this expression is used to find the record to replace it. */
638 /* Division which is not supposed to need rounding.
645 and that is what is used in languages that do not have ways of
646 specifying which of these is wanted. Maybe these are not needed. */
659 operands are zeros, or if either operand is NaN, then it is unspecified
660 which of the two operands is returned as the result. */
673 The second operand is the number of bits to
675 Note that the result is undefined if the second operand is larger
689 value of the expression is determined from the first operand. AND,
690 OR, and XOR always compute the second operand whether its value is
709 and the value is always the type used by the language for booleans. */
728 /* This is the reverse of uneq_expr. */
741 /* Value is same as argument, but guaranteed not an lvalue. */
746 the idiom *(type2 *)&X in C. The only operand is the value to be
747 viewed as being of another type. It is undefined if the type of the
757 First operand is that expression. After it is evaluated once, it
761 /* & in C. Value is the address at which the operand's value resides.
762 Operand may have any mode. Result mode is Pmode. */
765 /* Operand0 is a function constant; result is part N of a function
782 The second arg is how much to increment or decrement by.
792 /* Evaluate operand 1. If and only if an exception is thrown during
795 This differs from TRY_FINALLY_EXPR in that operand 2 is not evaluated
800 The second operand is a cleanup expression which is evaluated
807 /* Used to represent a local declaration. The operand is DECL_EXPR_DECL. */
811 Operand 0 is the LABEL_DECL node for the label that appears here.
815 /* GOTO. Operand 0 is a LABEL_DECL node or an expression.
820 Presumably that operand is an assignment that stores into the
826 /* Exit the inner most loop conditionally. Operand 0 is the condition.
830 /* A loop. Operand 0 is the body of the loop.
831 It must contain an EXIT_EXPR or is an infinite loop.
837 TREE_TYPE is the original type of the condition, before any
841 Operand 0 is the expression used to perform the branch,
842 Operand 1 is the body of the switch, which probably contains
845 Operand 2 is either NULL_TREE or a TREE_VEC of the CASE_LABEL_EXPRs
850 CASE_HIGH, respectively. If CASE_LOW is NULL_TREE, the label is a
851 'default' label. If CASE_HIGH is NULL_TREE, the label is a normal case
852 label. CASE_LABEL is the corresponding LABEL_DECL. */
855 /* RESX. Resume execution after an exception. Operand 0 is a
856 number indicating the exception region that is being left. */
866 time a variable is assigned a new value. The SSA builder uses SSA_NAME
870 /* SSA PHI operator. PHI_RESULT is the new SSA_NAME node created by
871 the PHI node. PHI_ARG_LENGTH is the number of arguments.
875 is coming through. */
878 /* Used to represent a typed exception handler. CATCH_TYPES is the type (or
879 list of types) handled, and CATCH_BODY is the code for the handler. */
882 /* Used to represent an exception specification. EH_FILTER_TYPES is a list
883 of allowed types, and EH_FILTER_FAILURE is an expression to evaluate on
888 /* Node used for describing a property that is known at compile
892 /* Node used for describing a property that is not known at compile
917 1- X is a copy of Y.
918 2- EXPR is a GIMPLE conditional expression (as defined by
919 is_gimple_condexpr) and is known to be true.
921 The type of the expression is the same as Y. */
928 /* Records the size for an expression of variable size type. This is
931 Operand 0 is the real expression.
932 Operand 1 is the size of the type in the expression. */
940 If OFF == 0, then the returned vector is OP1.
948 OFFSET (integer constant). Corresponding address is
952 The type of STEP, INDEX and OFFSET is sizetype. The type of BASE is
953 sizetype or a pointer type (if SYMBOL is NULL).
955 The sixth argument is the reference to the original memory access, which
956 is preserved for the purposes of the RTL alias analysis. The seventh
957 argument is a tag representing results of the tree level alias analysis. */
961 /* The ordering of the codes between OMP_PARALLEL and OMP_CRITICAL is
989 VAR must be a signed integer variable, which is implicitly thread
1031 Operand 0: The address at which the atomic operation is to be performed.
1034 at the address is used in the expression, it should appear as if
1045 Operand 0 is a vector; the first element in the vector has the result.
1046 Operand 1 is a vector. */
1053 The third argument and the result are of type t2, such that t2 is at least
1054 twice the size of t1. DOT_PROD_EXPR(arg1,arg2,arg3) is equivalent to:
1063 The first argument is of type t1.
1064 The second argument is of type t2, such that t2 is at least twice
1065 the size of t1. The type of the entire expression is also t2.
1066 WIDEN_SUM_EXPR is equivalent to first widening (promoting)
1073 The result is of type t2, such that t2 is at least twice
1074 the size of t1. WIDEN_MULT_EXPR is equivalent to first widening (promoting)
1079 Operand 0 is a vector to be shifted.
1080 Operand 1 is an integer shift amount in bits. */