9.8 Expressions
The internal representation for expressions is for the most part quite straightforward. However, there are a few facts that one must bear in mind. In particular, the expression “tree” is actually a directed acyclic graph. (For example there may be many references to the integer constant zero throughout the source program; many of these will be represented by the same expression node.) You should not rely on certain kinds of node being shared, nor should you rely on certain kinds of nodes being unshared.
The following macros can be used with all expression nodes:
TREE_TYPE
 Returns the type of the expression. This value may not be precisely the same type that would be given the expression in the original program.
In what follows, some nodes that one might expect to always have type
bool
are documented to have either integral or boolean type. At
some point in the future, the C front end may also make use of this same
intermediate representation, and at this point these nodes will
certainly have integral type. The previous sentence is not meant to
imply that the C++ front end does not or will not give these nodes
integral type.
Below, we list the various kinds of expression nodes. Except where
noted otherwise, the operands to an expression are accessed using the
TREE_OPERAND
macro. For example, to access the first operand to
a binary plus expression expr
, use:
TREE_OPERAND (expr, 0)
As this example indicates, the operands are zeroindexed.
All the expressions starting with OMP_
represent directives and
clauses used by the OpenMP API http://www.openmp.org/.
The table below begins with constants, moves on to unary expressions, then proceeds to binary expressions, and concludes with various other kinds of expressions:
INTEGER_CST
 These nodes represent integer constants. Note that the type of these
constants is obtained with
TREE_TYPE
; they are not always of typeint
. In particular,char
constants are represented withINTEGER_CST
nodes. The value of the integer constante
is given by((TREE_INT_CST_HIGH (e) << HOST_BITS_PER_WIDE_INT) + TREE_INST_CST_LOW (e))
HOST_BITS_PER_WIDE_INT is at least thirtytwo on all platforms. Both
TREE_INT_CST_HIGH
andTREE_INT_CST_LOW
return aHOST_WIDE_INT
. The value of anINTEGER_CST
is interpreted as a signed or unsigned quantity depending on the type of the constant. In general, the expression given above will overflow, so it should not be used to calculate the value of the constant.The variable
integer_zero_node
is an integer constant with value zero. Similarly,integer_one_node
is an integer constant with value one. Thesize_zero_node
andsize_one_node
variables are analogous, but have typesize_t
rather thanint
.The function
tree_int_cst_lt
is a predicate which holds if its first argument is less than its second. Both constants are assumed to have the same signedness (i.e., either both should be signed or both should be unsigned.) The full width of the constant is used when doing the comparison; the usual rules about promotions and conversions are ignored. Similarly,tree_int_cst_equal
holds if the two constants are equal. Thetree_int_cst_sgn
function returns the sign of a constant. The value is1
,0
, or1
according on whether the constant is greater than, equal to, or less than zero. Again, the signedness of the constant's type is taken into account; an unsigned constant is never less than zero, no matter what its bitpattern. REAL_CST

FIXME: Talk about how to obtain representations of this constant, do
comparisons, and so forth.
FIXED_CST

These nodes represent fixedpoint constants. The type of these constants
is obtained with
TREE_TYPE
.TREE_FIXED_CST_PTR
points to to struct fixed_value;TREE_FIXED_CST
returns the structure itself. Struct fixed_value containsdata
with the size of two HOST_BITS_PER_WIDE_INT andmode
as the associated fixedpoint machine mode fordata
. COMPLEX_CST
 These nodes are used to represent complex number constants, that is a
__complex__
whose parts are constant nodes. TheTREE_REALPART
andTREE_IMAGPART
return the real and the imaginary parts respectively. VECTOR_CST
 These nodes are used to represent vector constants, whose parts are
constant nodes. Each individual constant node is either an integer or a
double constant node. The first operand is a
TREE_LIST
of the constant nodes and is accessed throughTREE_VECTOR_CST_ELTS
. STRING_CST
 These nodes represent stringconstants. The
TREE_STRING_LENGTH
returns the length of the string, as anint
. TheTREE_STRING_POINTER
is achar*
containing the string itself. The string may not beNUL
terminated, and it may contain embeddedNUL
characters. Therefore, theTREE_STRING_LENGTH
includes the trailingNUL
if it is present.For wide string constants, the
TREE_STRING_LENGTH
is the number of bytes in the string, and theTREE_STRING_POINTER
points to an array of the bytes of the string, as represented on the target system (that is, as integers in the target endianness). Wide and nonwide string constants are distinguished only by theTREE_TYPE
of theSTRING_CST
.FIXME: The formats of string constants are not welldefined when the target system bytes are not the same width as host system bytes.
PTRMEM_CST
 These nodes are used to represent pointertomember constants. The
PTRMEM_CST_CLASS
is the class type (either aRECORD_TYPE
orUNION_TYPE
within which the pointer points), and thePTRMEM_CST_MEMBER
is the declaration for the pointed to object. Note that theDECL_CONTEXT
for thePTRMEM_CST_MEMBER
is in general different from thePTRMEM_CST_CLASS
. For example, given:struct B { int i; }; struct D : public B {}; int D::*dp = &D::i;
The
PTRMEM_CST_CLASS
for&D::i
isD
, even though theDECL_CONTEXT
for thePTRMEM_CST_MEMBER
isB
, sinceB::i
is a member ofB
, notD
. VAR_DECL

These nodes represent variables, including static data members. For
more information, see Declarations.
NEGATE_EXPR
 These nodes represent unary negation of the single operand, for both
integer and floatingpoint types. The type of negation can be
determined by looking at the type of the expression.
The behavior of this operation on signed arithmetic overflow is controlled by the
flag_wrapv
andflag_trapv
variables. ABS_EXPR
 These nodes represent the absolute value of the single operand, for
both integer and floatingpoint types. This is typically used to
implement the
abs
,labs
andllabs
builtins for integer types, and thefabs
,fabsf
andfabsl
builtins for floating point types. The type of abs operation can be determined by looking at the type of the expression.This node is not used for complex types. To represent the modulus or complex abs of a complex value, use the
BUILT_IN_CABS
,BUILT_IN_CABSF
orBUILT_IN_CABSL
builtins, as used to implement the C99cabs
,cabsf
andcabsl
builtin functions. BIT_NOT_EXPR
 These nodes represent bitwise complement, and will always have integral
type. The only operand is the value to be complemented.
TRUTH_NOT_EXPR
 These nodes represent logical negation, and will always have integral
(or boolean) type. The operand is the value being negated. The type
of the operand and that of the result are always of
BOOLEAN_TYPE
orINTEGER_TYPE
. PREDECREMENT_EXPR
PREINCREMENT_EXPR
POSTDECREMENT_EXPR
POSTINCREMENT_EXPR
 These nodes represent increment and decrement expressions. The value of
the single operand is computed, and the operand incremented or
decremented. In the case of
PREDECREMENT_EXPR
andPREINCREMENT_EXPR
, the value of the expression is the value resulting after the increment or decrement; in the case ofPOSTDECREMENT_EXPR
andPOSTINCREMENT_EXPR
is the value before the increment or decrement occurs. The type of the operand, like that of the result, will be either integral, boolean, or floatingpoint. ADDR_EXPR
 These nodes are used to represent the address of an object. (These
expressions will always have pointer or reference type.) The operand may
be another expression, or it may be a declaration.
As an extension, GCC allows users to take the address of a label. In this case, the operand of the
ADDR_EXPR
will be aLABEL_DECL
. The type of such an expression isvoid*
.If the object addressed is not an lvalue, a temporary is created, and the address of the temporary is used.
INDIRECT_REF
 These nodes are used to represent the object pointed to by a pointer.
The operand is the pointer being dereferenced; it will always have
pointer or reference type.
FIX_TRUNC_EXPR
 These nodes represent conversion of a floatingpoint value to an
integer. The single operand will have a floatingpoint type, while
the complete expression will have an integral (or boolean) type. The
operand is rounded towards zero.
FLOAT_EXPR
 These nodes represent conversion of an integral (or boolean) value to a
floatingpoint value. The single operand will have integral type, while
the complete expression will have a floatingpoint type.
FIXME: How is the operand supposed to be rounded? Is this dependent on mieee?
COMPLEX_EXPR
 These nodes are used to represent complex numbers constructed from two
expressions of the same (integer or real) type. The first operand is the
real part and the second operand is the imaginary part.
CONJ_EXPR
 These nodes represent the conjugate of their operand.
REALPART_EXPR
IMAGPART_EXPR
 These nodes represent respectively the real and the imaginary parts
of complex numbers (their sole argument).
NON_LVALUE_EXPR
 These nodes indicate that their one and only operand is not an lvalue.
A back end can treat these identically to the single operand.
NOP_EXPR
 These nodes are used to represent conversions that do not require any
codegeneration. For example, conversion of a
char*
to anint*
does not require any code be generated; such a conversion is represented by aNOP_EXPR
. The single operand is the expression to be converted. The conversion from a pointer to a reference is also represented with aNOP_EXPR
. CONVERT_EXPR
 These nodes are similar to
NOP_EXPR
s, but are used in those situations where code may need to be generated. For example, if anint*
is converted to anint
code may need to be generated on some platforms. These nodes are never used for C++specific conversions, like conversions between pointers to different classes in an inheritance hierarchy. Any adjustments that need to be made in such cases are always indicated explicitly. Similarly, a userdefined conversion is never represented by aCONVERT_EXPR
; instead, the function calls are made explicit. FIXED_CONVERT_EXPR
 These nodes are used to represent conversions that involve fixedpoint
values. For example, from a fixedpoint value to another fixedpoint value,
from an integer to a fixedpoint value, from a fixedpoint value to an
integer, from a floatingpoint value to a fixedpoint value, or from
a fixedpoint value to a floatingpoint value.
THROW_EXPR
 These nodes represent
throw
expressions. The single operand is an expression for the code that should be executed to throw the exception. However, there is one implicit action not represented in that expression; namely the call to__throw
. This function takes no arguments. Ifsetjmp
/longjmp
exceptions are used, the function__sjthrow
is called instead. The normal GCC back end uses the functionemit_throw
to generate this code; you can examine this function to see what needs to be done. LSHIFT_EXPR
RSHIFT_EXPR
 These nodes represent left and right shifts, respectively. The first
operand is the value to shift; it will always be of integral type. The
second operand is an expression for the number of bits by which to
shift. Right shift should be treated as arithmetic, i.e., the
highorder bits should be zerofilled when the expression has unsigned
type and filled with the sign bit when the expression has signed type.
Note that the result is undefined if the second operand is larger
than or equal to the first operand's type size.
BIT_IOR_EXPR
BIT_XOR_EXPR
BIT_AND_EXPR
 These nodes represent bitwise inclusive or, bitwise exclusive or, and
bitwise and, respectively. Both operands will always have integral
type.
TRUTH_ANDIF_EXPR
TRUTH_ORIF_EXPR
 These nodes represent logical “and” and logical “or”, respectively.
These operators are not strict; i.e., the second operand is evaluated
only if the value of the expression is not determined by evaluation of
the first operand. The type of the operands and that of the result are
always of
BOOLEAN_TYPE
orINTEGER_TYPE
. TRUTH_AND_EXPR
TRUTH_OR_EXPR
TRUTH_XOR_EXPR
 These nodes represent logical and, logical or, and logical exclusive or.
They are strict; both arguments are always evaluated. There are no
corresponding operators in C or C++, but the front end will sometimes
generate these expressions anyhow, if it can tell that strictness does
not matter. The type of the operands and that of the result are
always of
BOOLEAN_TYPE
orINTEGER_TYPE
. POINTER_PLUS_EXPR
 This node represents pointer arithmetic. The first operand is always a pointer/reference type. The second operand is always an unsigned integer type compatible with sizetype. This is the only binary arithmetic operand that can operate on pointer types.
PLUS_EXPR
MINUS_EXPR
MULT_EXPR
 These nodes represent various binary arithmetic operations.
Respectively, these operations are addition, subtraction (of the second
operand from the first) and multiplication. Their operands may have
either integral or floating type, but there will never be case in which
one operand is of floating type and the other is of integral type.
The behavior of these operations on signed arithmetic overflow is controlled by the
flag_wrapv
andflag_trapv
variables. RDIV_EXPR
 This node represents a floating point division operation.
TRUNC_DIV_EXPR
FLOOR_DIV_EXPR
CEIL_DIV_EXPR
ROUND_DIV_EXPR
 These nodes represent integer division operations that return an integer
result.
TRUNC_DIV_EXPR
rounds towards zero,FLOOR_DIV_EXPR
rounds towards negative infinity,CEIL_DIV_EXPR
rounds towards positive infinity andROUND_DIV_EXPR
rounds to the closest integer. Integer division in C and C++ is truncating, i.e.TRUNC_DIV_EXPR
.The behavior of these operations on signed arithmetic overflow, when dividing the minimum signed integer by minus one, is controlled by the
flag_wrapv
andflag_trapv
variables. TRUNC_MOD_EXPR
FLOOR_MOD_EXPR
CEIL_MOD_EXPR
ROUND_MOD_EXPR
 These nodes represent the integer remainder or modulus operation.
The integer modulus of two operands
a
andb
is defined asa  (a/b)*b
where the division calculated using the corresponding division operator. Hence forTRUNC_MOD_EXPR
this definition assumes division using truncation towards zero, i.e.TRUNC_DIV_EXPR
. Integer remainder in C and C++ uses truncating division, i.e.TRUNC_MOD_EXPR
. EXACT_DIV_EXPR
 The
EXACT_DIV_EXPR
code is used to represent integer divisions where the numerator is known to be an exact multiple of the denominator. This allows the backend to choose between the faster ofTRUNC_DIV_EXPR
,CEIL_DIV_EXPR
andFLOOR_DIV_EXPR
for the current target. ARRAY_REF
 These nodes represent array accesses. The first operand is the array;
the second is the index. To calculate the address of the memory
accessed, you must scale the index by the size of the type of the array
elements. The type of these expressions must be the type of a component of
the array. The third and fourth operands are used after gimplification
to represent the lower bound and component size but should not be used
directly; call
array_ref_low_bound
andarray_ref_element_size
instead. ARRAY_RANGE_REF
 These nodes represent access to a range (or “slice”) of an array. The
operands are the same as that for
ARRAY_REF
and have the same meanings. The type of these expressions must be an array whose component type is the same as that of the first operand. The range of that array type determines the amount of data these expressions access. TARGET_MEM_REF
 These nodes represent memory accesses whose address directly map to
an addressing mode of the target architecture. The first argument
is
TMR_SYMBOL
and must be aVAR_DECL
of an object with a fixed address. The second argument isTMR_BASE
and the third one isTMR_INDEX
. The fourth argument isTMR_STEP
and must be anINTEGER_CST
. The fifth argument isTMR_OFFSET
and must be anINTEGER_CST
. Any of the arguments may be NULL if the appropriate component does not appear in the address. Address of theTARGET_MEM_REF
is determined in the following way.&TMR_SYMBOL + TMR_BASE + TMR_INDEX * TMR_STEP + TMR_OFFSET
The sixth argument is the reference to the original memory access, which is preserved for the purposes of the RTL alias analysis. The seventh argument is a tag representing the results of tree level alias analysis.
LT_EXPR
LE_EXPR
GT_EXPR
GE_EXPR
EQ_EXPR
NE_EXPR
 These nodes represent the less than, less than or equal to, greater
than, greater than or equal to, equal, and not equal comparison
operators. The first and second operand with either be both of integral
type or both of floating type. The result type of these expressions
will always be of integral or boolean type. These operations return
the result type's zero value for false, and the result type's one value
for true.
For floating point comparisons, if we honor IEEE NaNs and either operand is NaN, then
NE_EXPR
always returns true and the remaining operators always return false. On some targets, comparisons against an IEEE NaN, other than equality and inequality, may generate a floating point exception. ORDERED_EXPR
UNORDERED_EXPR
 These nodes represent nontrapping ordered and unordered comparison
operators. These operations take two floating point operands and
determine whether they are ordered or unordered relative to each other.
If either operand is an IEEE NaN, their comparison is defined to be
unordered, otherwise the comparison is defined to be ordered. The
result type of these expressions will always be of integral or boolean
type. These operations return the result type's zero value for false,
and the result type's one value for true.
UNLT_EXPR
UNLE_EXPR
UNGT_EXPR
UNGE_EXPR
UNEQ_EXPR
LTGT_EXPR
 These nodes represent the unordered comparison operators.
These operations take two floating point operands and determine whether
the operands are unordered or are less than, less than or equal to,
greater than, greater than or equal to, or equal respectively. For
example,
UNLT_EXPR
returns true if either operand is an IEEE NaN or the first operand is less than the second. With the possible exception ofLTGT_EXPR
, all of these operations are guaranteed not to generate a floating point exception. The result type of these expressions will always be of integral or boolean type. These operations return the result type's zero value for false, and the result type's one value for true. MODIFY_EXPR
 These nodes represent assignment. The lefthand side is the first
operand; the righthand side is the second operand. The lefthand side
will be a
VAR_DECL
,INDIRECT_REF
,COMPONENT_REF
, or other lvalue.These nodes are used to represent not only assignment with = but also compound assignments (like +=), by reduction to = assignment. In other words, the representation for i += 3 looks just like that for i = i + 3.
INIT_EXPR
 These nodes are just like
MODIFY_EXPR
, but are used only when a variable is initialized, rather than assigned to subsequently. This means that we can assume that the target of the initialization is not used in computing its own value; any reference to the lhs in computing the rhs is undefined. COMPONENT_REF
 These nodes represent nonstatic data member accesses. The first
operand is the object (rather than a pointer to it); the second operand
is the
FIELD_DECL
for the data member. The third operand represents the byte offset of the field, but should not be used directly; callcomponent_ref_field_offset
instead. COMPOUND_EXPR
 These nodes represent commaexpressions. The first operand is an
expression whose value is computed and thrown away prior to the
evaluation of the second operand. The value of the entire expression is
the value of the second operand.
COND_EXPR
 These nodes represent
?:
expressions. The first operand is of boolean or integral type. If it evaluates to a nonzero value, the second operand should be evaluated, and returned as the value of the expression. Otherwise, the third operand is evaluated, and returned as the value of the expression.The second operand must have the same type as the entire expression, unless it unconditionally throws an exception or calls a noreturn function, in which case it should have void type. The same constraints apply to the third operand. This allows array bounds checks to be represented conveniently as
(i >= 0 && i < 10) ? i : abort()
.As a GNU extension, the C language frontends allow the second operand of the
?:
operator may be omitted in the source. For example,x ? : 3
is equivalent tox ? x : 3
, assuming thatx
is an expression without sideeffects. In the tree representation, however, the second operand is always present, possibly protected bySAVE_EXPR
if the first argument does cause sideeffects. CALL_EXPR
 These nodes are used to represent calls to functions, including
nonstatic member functions.
CALL_EXPR
s are implemented as expression nodes with a variable number of operands. Rather than usingTREE_OPERAND
to extract them, it is preferable to use the specialized accessor macros and functions that operate specifically onCALL_EXPR
nodes.CALL_EXPR_FN
returns a pointer to the function to call; it is always an expression whose type is aPOINTER_TYPE
.The number of arguments to the call is returned by
call_expr_nargs
, while the arguments themselves can be accessed with theCALL_EXPR_ARG
macro. The arguments are zeroindexed and numbered lefttoright. You can iterate over the arguments usingFOR_EACH_CALL_EXPR_ARG
, as in:tree call, arg; call_expr_arg_iterator iter; FOR_EACH_CALL_EXPR_ARG (arg, iter, call) /* arg is bound to successive arguments of call. */ ...;
For nonstatic member functions, there will be an operand corresponding to the
this
pointer. There will always be expressions corresponding to all of the arguments, even if the function is declared with default arguments and some arguments are not explicitly provided at the call sites.CALL_EXPR
s also have aCALL_EXPR_STATIC_CHAIN
operand that is used to implement nested functions. This operand is otherwise null. STMT_EXPR
 These nodes are used to represent GCC's statementexpression extension.
The statementexpression extension allows code like this:
int f() { return ({ int j; j = 3; j + 7; }); }
In other words, an sequence of statements may occur where a single expression would normally appear. The
STMT_EXPR
node represents such an expression. TheSTMT_EXPR_STMT
gives the statement contained in the expression. The value of the expression is the value of the last substatement in the body. More precisely, the value is the value computed by the last statement nested insideBIND_EXPR
,TRY_FINALLY_EXPR
, orTRY_CATCH_EXPR
. For example, in:({ 3; })
the value is
3
while in:({ if (x) { 3; } })
there is no value. If the
STMT_EXPR
does not yield a value, it's type will bevoid
. BIND_EXPR
 These nodes represent local blocks. The first operand is a list of
variables, connected via their
TREE_CHAIN
field. These will never require cleanups. The scope of these variables is just the body of theBIND_EXPR
. The body of theBIND_EXPR
is the second operand. LOOP_EXPR
 These nodes represent “infinite” loops. The
LOOP_EXPR_BODY
represents the body of the loop. It should be executed forever, unless anEXIT_EXPR
is encountered. EXIT_EXPR
 These nodes represent conditional exits from the nearest enclosing
LOOP_EXPR
. The single operand is the condition; if it is nonzero, then the loop should be exited. AnEXIT_EXPR
will only appear within aLOOP_EXPR
. CLEANUP_POINT_EXPR
 These nodes represent fullexpressions. The single operand is an
expression to evaluate. Any destructor calls engendered by the creation
of temporaries during the evaluation of that expression should be
performed immediately after the expression is evaluated.
CONSTRUCTOR
 These nodes represent the braceenclosed initializers for a structure or
array. The first operand is reserved for use by the back end. The
second operand is a
TREE_LIST
. If theTREE_TYPE
of theCONSTRUCTOR
is aRECORD_TYPE
orUNION_TYPE
, then theTREE_PURPOSE
of each node in theTREE_LIST
will be aFIELD_DECL
and theTREE_VALUE
of each node will be the expression used to initialize that field.If the
TREE_TYPE
of theCONSTRUCTOR
is anARRAY_TYPE
, then theTREE_PURPOSE
of each element in theTREE_LIST
will be anINTEGER_CST
or aRANGE_EXPR
of twoINTEGER_CST
s. A singleINTEGER_CST
indicates which element of the array (indexed from zero) is being assigned to. ARANGE_EXPR
indicates an inclusive range of elements to initialize. In both cases theTREE_VALUE
is the corresponding initializer. It is reevaluated for each element of aRANGE_EXPR
. If theTREE_PURPOSE
isNULL_TREE
, then the initializer is for the next available array element.In the front end, you should not depend on the fields appearing in any particular order. However, in the middle end, fields must appear in declaration order. You should not assume that all fields will be represented. Unrepresented fields will be set to zero.
COMPOUND_LITERAL_EXPR
 These nodes represent ISO C99 compound literals. The
COMPOUND_LITERAL_EXPR_DECL_STMT
is aDECL_STMT
containing an anonymousVAR_DECL
for the unnamed object represented by the compound literal; theDECL_INITIAL
of thatVAR_DECL
is aCONSTRUCTOR
representing the braceenclosed list of initializers in the compound literal. That anonymousVAR_DECL
can also be accessed directly by theCOMPOUND_LITERAL_EXPR_DECL
macro. SAVE_EXPR

A
SAVE_EXPR
represents an expression (possibly involving sideeffects) that is used more than once. The sideeffects should occur only the first time the expression is evaluated. Subsequent uses should just reuse the computed value. The first operand to theSAVE_EXPR
is the expression to evaluate. The sideeffects should be executed where theSAVE_EXPR
is first encountered in a depthfirst preorder traversal of the expression tree. TARGET_EXPR
 A
TARGET_EXPR
represents a temporary object. The first operand is aVAR_DECL
for the temporary variable. The second operand is the initializer for the temporary. The initializer is evaluated and, if nonvoid, copied (bitwise) into the temporary. If the initializer is void, that means that it will perform the initialization itself.Often, a
TARGET_EXPR
occurs on the righthand side of an assignment, or as the second operand to a commaexpression which is itself the righthand side of an assignment, etc. In this case, we say that theTARGET_EXPR
is “normal”; otherwise, we say it is “orphaned”. For a normalTARGET_EXPR
the temporary variable should be treated as an alias for the lefthand side of the assignment, rather than as a new temporary variable.The third operand to the
TARGET_EXPR
, if present, is a cleanupexpression (i.e., destructor call) for the temporary. If this expression is orphaned, then this expression must be executed when the statement containing this expression is complete. These cleanups must always be executed in the order opposite to that in which they were encountered. Note that if a temporary is created on one branch of a conditional operator (i.e., in the second or third operand to aCOND_EXPR
), the cleanup must be run only if that branch is actually executed.See
STMT_IS_FULL_EXPR_P
for more information about running these cleanups. AGGR_INIT_EXPR
 An
AGGR_INIT_EXPR
represents the initialization as the return value of a function call, or as the result of a constructor. AnAGGR_INIT_EXPR
will only appear as a fullexpression, or as the second operand of aTARGET_EXPR
.AGGR_INIT_EXPR
s have a representation similar to that ofCALL_EXPR
s. You can use theAGGR_INIT_EXPR_FN
andAGGR_INIT_EXPR_ARG
macros to access the function to call and the arguments to pass.If
AGGR_INIT_VIA_CTOR_P
holds of theAGGR_INIT_EXPR
, then the initialization is via a constructor call. The address of theAGGR_INIT_EXPR_SLOT
operand, which is always aVAR_DECL
, is taken, and this value replaces the first argument in the argument list.In either case, the expression is void.
VA_ARG_EXPR
 This node is used to implement support for the C/C++ variable argumentlist
mechanism. It represents expressions like
va_arg (ap, type)
. ItsTREE_TYPE
yields the tree representation fortype
and its sole argument yields the representation forap
. CHANGE_DYNAMIC_TYPE_EXPR
 Indicates the special aliasing required by C++ placement new. It has
two operands: a type and a location. It means that the dynamic type
of the location is changing to be the specified type. The alias
analysis code takes this into account when doing type based alias
analysis.
OMP_PARALLEL

Represents
#pragma omp parallel [clause1 ... clauseN]
. It has four operands:Operand
OMP_PARALLEL_BODY
is valid while in GENERIC and High GIMPLE forms. It contains the body of code to be executed by all the threads. During GIMPLE lowering, this operand becomesNULL
and the body is emitted linearly afterOMP_PARALLEL
.Operand
OMP_PARALLEL_CLAUSES
is the list of clauses associated with the directive.Operand
OMP_PARALLEL_FN
is created bypass_lower_omp
, it contains theFUNCTION_DECL
for the function that will contain the body of the parallel region.Operand
OMP_PARALLEL_DATA_ARG
is also created bypass_lower_omp
. If there are shared variables to be communicated to the children threads, this operand will contain theVAR_DECL
that contains all the shared values and variables. OMP_FOR

Represents
#pragma omp for [clause1 ... clauseN]
. It has 5 operands:Operand
OMP_FOR_BODY
contains the loop body.Operand
OMP_FOR_CLAUSES
is the list of clauses associated with the directive.Operand
OMP_FOR_INIT
is the loop initialization code of the formVAR = N1
.Operand
OMP_FOR_COND
is the loop conditional expression of the formVAR {<,>,<=,>=} N2
.Operand
OMP_FOR_INCR
is the loop index increment of the formVAR {+=,=} INCR
.Operand
OMP_FOR_PRE_BODY
contains sideeffect code from operandsOMP_FOR_INIT
,OMP_FOR_COND
andOMP_FOR_INC
. These sideeffects are part of theOMP_FOR
block but must be evaluated before the start of loop body.The loop index variable
VAR
must be a signed integer variable, which is implicitly private to each thread. BoundsN1
andN2
and the increment expressionINCR
are required to be loop invariant integer expressions that are evaluated without any synchronization. The evaluation order, frequency of evaluation and sideeffects are unspecified by the standard. OMP_SECTIONS

Represents
#pragma omp sections [clause1 ... clauseN]
.Operand
OMP_SECTIONS_BODY
contains the sections body, which in turn contains a set ofOMP_SECTION
nodes for each of the concurrent sections delimited by#pragma omp section
.Operand
OMP_SECTIONS_CLAUSES
is the list of clauses associated with the directive. OMP_SECTION

Section delimiter for
OMP_SECTIONS
. OMP_SINGLE

Represents
#pragma omp single
.Operand
OMP_SINGLE_BODY
contains the body of code to be executed by a single thread.Operand
OMP_SINGLE_CLAUSES
is the list of clauses associated with the directive. OMP_MASTER

Represents
#pragma omp master
.Operand
OMP_MASTER_BODY
contains the body of code to be executed by the master thread. OMP_ORDERED

Represents
#pragma omp ordered
.Operand
OMP_ORDERED_BODY
contains the body of code to be executed in the sequential order dictated by the loop index variable. OMP_CRITICAL

Represents
#pragma omp critical [name]
.Operand
OMP_CRITICAL_BODY
is the critical section.Operand
OMP_CRITICAL_NAME
is an optional identifier to label the critical section. OMP_RETURN

This does not represent any OpenMP directive, it is an artificial
marker to indicate the end of the body of an OpenMP. It is used
by the flow graph (
treecfg.c
) and OpenMP region building code (omplow.c
). OMP_CONTINUE

Similarly, this instruction does not represent an OpenMP
directive, it is used by
OMP_FOR
andOMP_SECTIONS
to mark the place where the code needs to loop to the next iteration (in the case ofOMP_FOR
) or the next section (in the case ofOMP_SECTIONS
).In some cases,
OMP_CONTINUE
is placed right beforeOMP_RETURN
. But if there are cleanups that need to occur right after the looping body, it will be emitted betweenOMP_CONTINUE
andOMP_RETURN
. OMP_ATOMIC

Represents
#pragma omp atomic
.Operand 0 is the address at which the atomic operation is to be performed.
Operand 1 is the expression to evaluate. The gimplifier tries three alternative code generation strategies. Whenever possible, an atomic update builtin is used. If that fails, a compareandswap loop is attempted. If that also fails, a regular critical section around the expression is used.
OMP_CLAUSE

Represents clauses associated with one of the
OMP_
directives. Clauses are represented by separate subcodes defined in tree.h. Clauses codes can be one of:OMP_CLAUSE_PRIVATE
,OMP_CLAUSE_SHARED
,OMP_CLAUSE_FIRSTPRIVATE
,OMP_CLAUSE_LASTPRIVATE
,OMP_CLAUSE_COPYIN
,OMP_CLAUSE_COPYPRIVATE
,OMP_CLAUSE_IF
,OMP_CLAUSE_NUM_THREADS
,OMP_CLAUSE_SCHEDULE
,OMP_CLAUSE_NOWAIT
,OMP_CLAUSE_ORDERED
,OMP_CLAUSE_DEFAULT
, andOMP_CLAUSE_REDUCTION
. Each code represents the corresponding OpenMP clause.Clauses associated with the same directive are chained together via
OMP_CLAUSE_CHAIN
. Those clauses that accept a list of variables are restricted to exactly one, accessed withOMP_CLAUSE_VAR
. Therefore, multiple variables under the same clauseC
need to be represented as multipleC
clauses chained together. This facilitates adding new clauses during compilation. VEC_LSHIFT_EXPR
VEC_RSHIFT_EXPR
 These nodes represent whole vector left and right shifts, respectively.
The first operand is the vector to shift; it will always be of vector type.
The second operand is an expression for the number of bits by which to
shift. Note that the result is undefined if the second operand is larger
than or equal to the first operand's type size.
VEC_WIDEN_MULT_HI_EXPR
VEC_WIDEN_MULT_LO_EXPR
 These nodes represent widening vector multiplication of the high and low
parts of the two input vectors, respectively. Their operands are vectors
that contain the same number of elements (
N
) of the same integral type. The result is a vector that contains half as many elements, of an integral type whose size is twice as wide. In the case ofVEC_WIDEN_MULT_HI_EXPR
the highN/2
elements of the two vector are multiplied to produce the vector ofN/2
products. In the case ofVEC_WIDEN_MULT_LO_EXPR
the lowN/2
elements of the two vector are multiplied to produce the vector ofN/2
products. VEC_UNPACK_HI_EXPR
VEC_UNPACK_LO_EXPR
 These nodes represent unpacking of the high and low parts of the input vector,
respectively. The single operand is a vector that contains
N
elements of the same integral or floating point type. The result is a vector that contains half as many elements, of an integral or floating point type whose size is twice as wide. In the case ofVEC_UNPACK_HI_EXPR
the highN/2
elements of the vector are extracted and widened (promoted). In the case ofVEC_UNPACK_LO_EXPR
the lowN/2
elements of the vector are extracted and widened (promoted). VEC_UNPACK_FLOAT_HI_EXPR
VEC_UNPACK_FLOAT_LO_EXPR
 These nodes represent unpacking of the high and low parts of the input vector,
where the values are converted from fixed point to floating point. The
single operand is a vector that contains
N
elements of the same integral type. The result is a vector that contains half as many elements of a floating point type whose size is twice as wide. In the case ofVEC_UNPACK_HI_EXPR
the highN/2
elements of the vector are extracted, converted and widened. In the case ofVEC_UNPACK_LO_EXPR
the lowN/2
elements of the vector are extracted, converted and widened. VEC_PACK_TRUNC_EXPR
 This node represents packing of truncated elements of the two input vectors
into the output vector. Input operands are vectors that contain the same
number of elements of the same integral or floating point type. The result
is a vector that contains twice as many elements of an integral or floating
point type whose size is half as wide. The elements of the two vectors are
demoted and merged (concatenated) to form the output vector.
VEC_PACK_SAT_EXPR
 This node represents packing of elements of the two input vectors into the
output vector using saturation. Input operands are vectors that contain
the same number of elements of the same integral type. The result is a
vector that contains twice as many elements of an integral type whose size
is half as wide. The elements of the two vectors are demoted and merged
(concatenated) to form the output vector.
VEC_PACK_FIX_TRUNC_EXPR
 This node represents packing of elements of the two input vectors into the
output vector, where the values are converted from floating point
to fixed point. Input operands are vectors that contain the same number
of elements of a floating point type. The result is a vector that contains
twice as many elements of an integral type whose size is half as wide. The
elements of the two vectors are merged (concatenated) to form the output
vector.
VEC_EXTRACT_EVEN_EXPR
VEC_EXTRACT_ODD_EXPR
 These nodes represent extracting of the even/odd elements of the two input
vectors, respectively. Their operands and result are vectors that contain the
same number of elements of the same type.
VEC_INTERLEAVE_HIGH_EXPR
VEC_INTERLEAVE_LOW_EXPR
 These nodes represent merging and interleaving of the high/low elements of the
two input vectors, respectively. The operands and the result are vectors that
contain the same number of elements (
N
) of the same type. In the case ofVEC_INTERLEAVE_HIGH_EXPR
, the highN/2
elements of the first input vector are interleaved with the highN/2
elements of the second input vector. In the case ofVEC_INTERLEAVE_LOW_EXPR
, the lowN/2
elements of the first input vector are interleaved with the lowN/2
elements of the second input vector.