Subversion Repositories openrisc

@c Copyright (c) 2008, 2009, 2010 Free Software Foundation, Inc.

@c Free Software Foundation, Inc.

@c This is part of the GCC manual.

@c For copying conditions, see the file gcc.texi.

@node GIMPLE

@chapter GIMPLE

@cindex GIMPLE

GIMPLE is a three-address representation derived from GENERIC by

breaking down GENERIC expressions into tuples of no more than 3

operands (with some exceptions like function calls).  GIMPLE was

heavily influenced by the SIMPLE IL used by the McCAT compiler

project at McGill University, though we have made some different

choices.  For one thing, SIMPLE doesn't support @code{goto}.

Temporaries are introduced to hold intermediate values needed to

compute complex expressions. Additionally, all the control

structures used in GENERIC are lowered into conditional jumps,

lexical scopes are removed and exception regions are converted

into an on the side exception region tree.

The compiler pass which converts GENERIC into GIMPLE is referred to as

the @samp{gimplifier}.  The gimplifier works recursively, generating

GIMPLE tuples out of the original GENERIC expressions.

One of the early implementation strategies used for the GIMPLE

representation was to use the same internal data structures used

by front ends to represent parse trees. This simplified

implementation because we could leverage existing functionality

and interfaces. However, GIMPLE is a much more restrictive

representation than abstract syntax trees (AST), therefore it

does not require the full structural complexity provided by the

main tree data structure.

The GENERIC representation of a function is stored in the

@code{DECL_SAVED_TREE} field of the associated @code{FUNCTION_DECL}

tree node.  It is converted to GIMPLE by a call to

@code{gimplify_function_tree}.

If a front end wants to include language-specific tree codes in the tree

representation which it provides to the back end, it must provide a

definition of @code{LANG_HOOKS_GIMPLIFY_EXPR} which knows how to

convert the front end trees to GIMPLE@.  Usually such a hook will involve

much of the same code for expanding front end trees to RTL@.  This function

can return fully lowered GIMPLE, or it can return GENERIC trees and let the

main gimplifier lower them the rest of the way; this is often simpler.

GIMPLE that is not fully lowered is known as ``High GIMPLE'' and

consists of the IL before the pass @code{pass_lower_cf}.  High GIMPLE

contains some container statements like lexical scopes

(represented by @code{GIMPLE_BIND}) and nested expressions (e.g.,

@code{GIMPLE_TRY}), while ``Low GIMPLE'' exposes all of the

implicit jumps for control and exception expressions directly in

the IL and EH region trees.

The C and C++ front ends currently convert directly from front end

trees to GIMPLE, and hand that off to the back end rather than first

converting to GENERIC@.  Their gimplifier hooks know about all the

@code{_STMT} nodes and how to convert them to GENERIC forms.  There

was some work done on a genericization pass which would run first, but

the existence of @code{STMT_EXPR} meant that in order to convert all

of the C statements into GENERIC equivalents would involve walking the

entire tree anyway, so it was simpler to lower all the way.  This

might change in the future if someone writes an optimization pass

which would work better with higher-level trees, but currently the

optimizers all expect GIMPLE@.

You can request to dump a C-like representation of the GIMPLE form

with the flag @option{-fdump-tree-gimple}.

@menu

* Tuple representation::

* GIMPLE instruction set::

* GIMPLE Exception Handling::

* Temporaries::

* Operands::

* Manipulating GIMPLE statements::

* Tuple specific accessors::

* GIMPLE sequences::

* Sequence iterators::

* Adding a new GIMPLE statement code::

* Statement and operand traversals::

@end menu

@node Tuple representation

@section Tuple representation

@cindex tuples

GIMPLE instructions are tuples of variable size divided in two

groups: a header describing the instruction and its locations,

and a variable length body with all the operands. Tuples are

organized into a hierarchy with 3 main classes of tuples.

@subsection @code{gimple_statement_base} (gsbase)

@cindex gimple_statement_base

This is the root of the hierarchy, it holds basic information

needed by most GIMPLE statements. There are some fields that

may not be relevant to every GIMPLE statement, but those were

moved into the base structure to take advantage of holes left by

other fields (thus making the structure more compact).  The

structure takes 4 words (32 bytes) on 64 bit hosts:

@multitable {@code{references_memory_p}} {Size (bits)}

@item Field                             @tab Size (bits)

@item @code{code}                       @tab 8

@item @code{subcode}                    @tab 16

@item @code{no_warning}                 @tab 1

@item @code{visited}                    @tab 1

@item @code{nontemporal_move}           @tab 1

@item @code{plf}                        @tab 2

@item @code{modified}                   @tab 1

@item @code{has_volatile_ops}           @tab 1

@item @code{references_memory_p}        @tab 1

@item @code{uid}                        @tab 32

@item @code{location}                   @tab 32

@item @code{num_ops}                    @tab 32

@item @code{bb}                         @tab 64

@item @code{block}                      @tab 63

@item Total size                        @tab 32 bytes

@end multitable

@itemize @bullet

@item @code{code}

Main identifier for a GIMPLE instruction.

@item @code{subcode}

Used to distinguish different variants of the same basic

instruction or provide flags applicable to a given code. The

@code{subcode} flags field has different uses depending on the code of

the instruction, but mostly it distinguishes instructions of the

same family. The most prominent use of this field is in

assignments, where subcode indicates the operation done on the

RHS of the assignment. For example, a = b + c is encoded as

@code{GIMPLE_ASSIGN <PLUS_EXPR, a, b, c>}.

@item @code{no_warning}

Bitflag to indicate whether a warning has already been issued on

this statement.

@item @code{visited}

General purpose ``visited'' marker. Set and cleared by each pass

when needed.

@item @code{nontemporal_move}

Bitflag used in assignments that represent non-temporal moves.

Although this bitflag is only used in assignments, it was moved

into the base to take advantage of the bit holes left by the

previous fields.

@item @code{plf}

Pass Local Flags. This 2-bit mask can be used as general purpose

markers by any pass. Passes are responsible for clearing and

setting these two flags accordingly.

@item @code{modified}

Bitflag to indicate whether the statement has been modified.

Used mainly by the operand scanner to determine when to re-scan a

statement for operands.

@item @code{has_volatile_ops}

Bitflag to indicate whether this statement contains operands that

have been marked volatile.

@item @code{references_memory_p}

Bitflag to indicate whether this statement contains memory

references (i.e., its operands are either global variables, or

pointer dereferences or anything that must reside in memory).

@item @code{uid}

This is an unsigned integer used by passes that want to assign

IDs to every statement. These IDs must be assigned and used by

each pass.

@item @code{location}

This is a @code{location_t} identifier to specify source code

location for this statement. It is inherited from the front

end.

@item @code{num_ops}

Number of operands that this statement has. This specifies the

size of the operand vector embedded in the tuple. Only used in

some tuples, but it is declared in the base tuple to take

advantage of the 32-bit hole left by the previous fields.

@item @code{bb}

Basic block holding the instruction.

@item @code{block}

Lexical block holding this statement.  Also used for debug

information generation.

@end itemize

@subsection @code{gimple_statement_with_ops}

@cindex gimple_statement_with_ops

This tuple is actually split in two:

@code{gimple_statement_with_ops_base} and

@code{gimple_statement_with_ops}. This is needed to accommodate the

way the operand vector is allocated. The operand vector is

defined to be an array of 1 element. So, to allocate a dynamic

number of operands, the memory allocator (@code{gimple_alloc}) simply

allocates enough memory to hold the structure itself plus @code{N

- 1} operands which run ``off the end'' of the structure. For

example, to allocate space for a tuple with 3 operands,

@code{gimple_alloc} reserves @code{sizeof (struct

gimple_statement_with_ops) + 2 * sizeof (tree)} bytes.

On the other hand, several fields in this tuple need to be shared

with the @code{gimple_statement_with_memory_ops} tuple. So, these

common fields are placed in @code{gimple_statement_with_ops_base} which

is then inherited from the other two tuples.

@multitable {@code{def_ops}}    {48 + 8 * @code{num_ops} bytes}

@item   @code{gsbase}           @tab 256

@item   @code{def_ops}          @tab 64

@item   @code{use_ops}          @tab 64

@item   @code{op}               @tab @code{num_ops} * 64

@item   Total size              @tab 48 + 8 * @code{num_ops} bytes

@end multitable

@itemize @bullet

@item @code{gsbase}

Inherited from @code{struct gimple_statement_base}.

@item @code{def_ops}

Array of pointers into the operand array indicating all the slots that

contain a variable written-to by the statement. This array is

also used for immediate use chaining. Note that it would be

possible to not rely on this array, but the changes required to

implement this are pretty invasive.

@item @code{use_ops}

Similar to @code{def_ops} but for variables read by the statement.

@item @code{op}

Array of trees with @code{num_ops} slots.

@end itemize

@subsection @code{gimple_statement_with_memory_ops}

This tuple is essentially identical to @code{gimple_statement_with_ops},

except that it contains 4 additional fields to hold vectors

related memory stores and loads.  Similar to the previous case,

the structure is split in two to accommodate for the operand

vector (@code{gimple_statement_with_memory_ops_base} and

@code{gimple_statement_with_memory_ops}).

@multitable {@code{vdef_ops}}   {80 + 8 * @code{num_ops} bytes}

@item Field                     @tab Size (bits)

@item @code{gsbase}             @tab 256

@item @code{def_ops}            @tab 64

@item @code{use_ops}            @tab 64

@item @code{vdef_ops}           @tab 64

@item @code{vuse_ops}           @tab 64

@item @code{stores}             @tab 64

@item @code{loads}              @tab 64

@item @code{op}                 @tab @code{num_ops} * 64

@item Total size                @tab 80 + 8 * @code{num_ops} bytes

@end multitable

@itemize @bullet

@item @code{vdef_ops}

Similar to @code{def_ops} but for @code{VDEF} operators. There is

one entry per memory symbol written by this statement. This is

used to maintain the memory SSA use-def and def-def chains.

@item @code{vuse_ops}

Similar to @code{use_ops} but for @code{VUSE} operators. There is

one entry per memory symbol loaded by this statement. This is

used to maintain the memory SSA use-def chains.

@item @code{stores}

Bitset with all the UIDs for the symbols written-to by the

statement.  This is different than @code{vdef_ops} in that all the

affected symbols are mentioned in this set.  If memory

partitioning is enabled, the @code{vdef_ops} vector will refer to memory

partitions. Furthermore, no SSA information is stored in this

set.

@item @code{loads}

Similar to @code{stores}, but for memory loads. (Note that there

is some amount of redundancy here, it should be possible to

reduce memory utilization further by removing these sets).

@end itemize

All the other tuples are defined in terms of these three basic

ones. Each tuple will add some fields. The main gimple type

is defined to be the union of all these structures (@code{GTY} markers

elided for clarity):

@smallexample

union gimple_statement_d

@{

  struct gimple_statement_base gsbase;

  struct gimple_statement_with_ops gsops;

  struct gimple_statement_with_memory_ops gsmem;

  struct gimple_statement_omp omp;

  struct gimple_statement_bind gimple_bind;

  struct gimple_statement_catch gimple_catch;

  struct gimple_statement_eh_filter gimple_eh_filter;

  struct gimple_statement_phi gimple_phi;

  struct gimple_statement_resx gimple_resx;

  struct gimple_statement_try gimple_try;

  struct gimple_statement_wce gimple_wce;

  struct gimple_statement_asm gimple_asm;

  struct gimple_statement_omp_critical gimple_omp_critical;

  struct gimple_statement_omp_for gimple_omp_for;

  struct gimple_statement_omp_parallel gimple_omp_parallel;

  struct gimple_statement_omp_task gimple_omp_task;

  struct gimple_statement_omp_sections gimple_omp_sections;

  struct gimple_statement_omp_single gimple_omp_single;

  struct gimple_statement_omp_continue gimple_omp_continue;

  struct gimple_statement_omp_atomic_load gimple_omp_atomic_load;

  struct gimple_statement_omp_atomic_store gimple_omp_atomic_store;

@};

@end smallexample

@node GIMPLE instruction set

@section GIMPLE instruction set

@cindex GIMPLE instruction set

The following table briefly describes the GIMPLE instruction set.

@multitable {@code{GIMPLE_OMP_SECTIONS_SWITCH}} {High GIMPLE} {Low GIMPLE}

@item Instruction                       @tab High GIMPLE        @tab Low GIMPLE

@item @code{GIMPLE_ASM}                 @tab x                  @tab x

@item @code{GIMPLE_ASSIGN}              @tab x                  @tab x

@item @code{GIMPLE_BIND}                @tab x                  @tab

@item @code{GIMPLE_CALL}                @tab x                  @tab x

@item @code{GIMPLE_CATCH}               @tab x                  @tab

@item @code{GIMPLE_COND}                @tab x                  @tab x

@item @code{GIMPLE_DEBUG}               @tab x                  @tab x

@item @code{GIMPLE_EH_FILTER}           @tab x                  @tab

@item @code{GIMPLE_GOTO}                @tab x                  @tab x

@item @code{GIMPLE_LABEL}               @tab x                  @tab x

@item @code{GIMPLE_NOP}                 @tab x                  @tab x

@item @code{GIMPLE_OMP_ATOMIC_LOAD}     @tab x                  @tab x

@item @code{GIMPLE_OMP_ATOMIC_STORE}    @tab x                  @tab x

@item @code{GIMPLE_OMP_CONTINUE}        @tab x                  @tab x

@item @code{GIMPLE_OMP_CRITICAL}        @tab x                  @tab x

@item @code{GIMPLE_OMP_FOR}             @tab x                  @tab x

@item @code{GIMPLE_OMP_MASTER}          @tab x                  @tab x

@item @code{GIMPLE_OMP_ORDERED}         @tab x                  @tab x

@item @code{GIMPLE_OMP_PARALLEL}        @tab x                  @tab x

@item @code{GIMPLE_OMP_RETURN}          @tab x                  @tab x

@item @code{GIMPLE_OMP_SECTION}         @tab x                  @tab x

@item @code{GIMPLE_OMP_SECTIONS}        @tab x                  @tab x

@item @code{GIMPLE_OMP_SECTIONS_SWITCH} @tab x                  @tab x

@item @code{GIMPLE_OMP_SINGLE}          @tab x                  @tab x

@item @code{GIMPLE_PHI}                 @tab                    @tab x

@item @code{GIMPLE_RESX}                @tab                    @tab x

@item @code{GIMPLE_RETURN}              @tab x                  @tab x

@item @code{GIMPLE_SWITCH}              @tab x                  @tab x

@item @code{GIMPLE_TRY}                 @tab x                  @tab

@end multitable

@node GIMPLE Exception Handling

@section Exception Handling

@cindex GIMPLE Exception Handling

Other exception handling constructs are represented using

@code{GIMPLE_TRY_CATCH}.  @code{GIMPLE_TRY_CATCH} has two operands.  The

first operand is a sequence of statements to execute.  If executing

these statements does not throw an exception, then the second operand

is ignored.  Otherwise, if an exception is thrown, then the second

operand of the @code{GIMPLE_TRY_CATCH} is checked.  The second

operand may have the following forms:

@enumerate

@item A sequence of statements to execute.  When an exception occurs,

these statements are executed, and then the exception is rethrown.

@item A sequence of @code{GIMPLE_CATCH} statements.  Each

@code{GIMPLE_CATCH} has a list of applicable exception types and

handler code.  If the thrown exception matches one of the caught

types, the associated handler code is executed.  If the handler

code falls off the bottom, execution continues after the original

@code{GIMPLE_TRY_CATCH}.

@item A @code{GIMPLE_EH_FILTER} statement.  This has a list of

permitted exception types, and code to handle a match failure.  If the

thrown exception does not match one of the allowed types, the

associated match failure code is executed.  If the thrown exception

does match, it continues unwinding the stack looking for the next

handler.

@end enumerate

Currently throwing an exception is not directly represented in

GIMPLE, since it is implemented by calling a function.  At some

point in the future we will want to add some way to express that

the call will throw an exception of a known type.

Just before running the optimizers, the compiler lowers the

high-level EH constructs above into a set of @samp{goto}s, magic

labels, and EH regions.  Continuing to unwind at the end of a

cleanup is represented with a @code{GIMPLE_RESX}.

@node Temporaries

@section Temporaries

@cindex Temporaries

When gimplification encounters a subexpression that is too

complex, it creates a new temporary variable to hold the value of

the subexpression, and adds a new statement to initialize it

before the current statement. These special temporaries are known

as @samp{expression temporaries}, and are allocated using

@code{get_formal_tmp_var}.  The compiler tries to always evaluate

identical expressions into the same temporary, to simplify

elimination of redundant calculations.

We can only use expression temporaries when we know that it will

not be reevaluated before its value is used, and that it will not

be otherwise modified@footnote{These restrictions are derived

from those in Morgan 4.8.}. Other temporaries can be allocated

using @code{get_initialized_tmp_var} or @code{create_tmp_var}.

Currently, an expression like @code{a = b + 5} is not reduced any

further.  We tried converting it to something like

@smallexample

T1 = b + 5;

a = T1;

@end smallexample

but this bloated the representation for minimal benefit.  However, a

variable which must live in memory cannot appear in an expression; its

value is explicitly loaded into a temporary first.  Similarly, storing

the value of an expression to a memory variable goes through a

temporary.

@node Operands

@section Operands

@cindex Operands

In general, expressions in GIMPLE consist of an operation and the

appropriate number of simple operands; these operands must either be a

GIMPLE rvalue (@code{is_gimple_val}), i.e.@: a constant or a register

variable.  More complex operands are factored out into temporaries, so

that

@smallexample

a = b + c + d

@end smallexample

becomes

@smallexample

T1 = b + c;

a = T1 + d;

@end smallexample

The same rule holds for arguments to a @code{GIMPLE_CALL}.

The target of an assignment is usually a variable, but can also be a

@code{MEM_REF} or a compound lvalue as described below.

@menu

* Compound Expressions::

* Compound Lvalues::

* Conditional Expressions::

* Logical Operators::

@end menu

@node Compound Expressions

@subsection Compound Expressions

@cindex Compound Expressions

The left-hand side of a C comma expression is simply moved into a separate

statement.

@node Compound Lvalues

@subsection Compound Lvalues

@cindex Compound Lvalues

Currently compound lvalues involving array and structure field references

are not broken down; an expression like @code{a.b[2] = 42} is not reduced

any further (though complex array subscripts are).  This restriction is a

workaround for limitations in later optimizers; if we were to convert this

to

@smallexample

T1 = &a.b;

T1[2] = 42;

@end smallexample

alias analysis would not remember that the reference to @code{T1[2]} came

by way of @code{a.b}, so it would think that the assignment could alias

another member of @code{a}; this broke @code{struct-alias-1.c}.  Future

optimizer improvements may make this limitation unnecessary.

@node Conditional Expressions

@subsection Conditional Expressions

@cindex Conditional Expressions

A C @code{?:} expression is converted into an @code{if} statement with

each branch assigning to the same temporary.  So,

@smallexample

a = b ? c : d;

@end smallexample

becomes

@smallexample

if (b == 1)

  T1 = c;

else

  T1 = d;

a = T1;

@end smallexample

The GIMPLE level if-conversion pass re-introduces @code{?:}

expression, if appropriate. It is used to vectorize loops with

conditions using vector conditional operations.

Note that in GIMPLE, @code{if} statements are represented using

@code{GIMPLE_COND}, as described below.

@node Logical Operators

@subsection Logical Operators

@cindex Logical Operators

Except when they appear in the condition operand of a

@code{GIMPLE_COND}, logical `and' and `or' operators are simplified

as follows: @code{a = b && c} becomes

@smallexample

T1 = (bool)b;

if (T1 == true)

  T1 = (bool)c;

a = T1;

@end smallexample

Note that @code{T1} in this example cannot be an expression temporary,

because it has two different assignments.

@subsection Manipulating operands

All gimple operands are of type @code{tree}.  But only certain

types of trees are allowed to be used as operand tuples.  Basic

validation is controlled by the function

@code{get_gimple_rhs_class}, which given a tree code, returns an

@code{enum} with the following values of type @code{enum

gimple_rhs_class}

@itemize @bullet

@item @code{GIMPLE_INVALID_RHS}

The tree cannot be used as a GIMPLE operand.

@item @code{GIMPLE_TERNARY_RHS}

The tree is a valid GIMPLE ternary operation.

@item @code{GIMPLE_BINARY_RHS}

The tree is a valid GIMPLE binary operation.

@item @code{GIMPLE_UNARY_RHS}

The tree is a valid GIMPLE unary operation.

@item @code{GIMPLE_SINGLE_RHS}

The tree is a single object, that cannot be split into simpler

operands (for instance, @code{SSA_NAME}, @code{VAR_DECL}, @code{COMPONENT_REF}, etc).

This operand class also acts as an escape hatch for tree nodes

that may be flattened out into the operand vector, but would need

more than two slots on the RHS.  For instance, a @code{COND_EXPR}

expression of the form @code{(a op b) ? x : y} could be flattened

out on the operand vector using 4 slots, but it would also

require additional processing to distinguish @code{c = a op b}

from @code{c = a op b ? x : y}.  Something similar occurs with

@code{ASSERT_EXPR}.   In time, these special case tree

expressions should be flattened into the operand vector.

@end itemize

For tree nodes in the categories @code{GIMPLE_TERNARY_RHS},

@code{GIMPLE_BINARY_RHS} and @code{GIMPLE_UNARY_RHS}, they cannot be

stored inside tuples directly.  They first need to be flattened and

separated into individual components.  For instance, given the GENERIC

expression

@smallexample

a = b + c

@end smallexample

its tree representation is:

@smallexample

MODIFY_EXPR <VAR_DECL  <a>, PLUS_EXPR <VAR_DECL <b>, VAR_DECL <c>>>

@end smallexample

In this case, the GIMPLE form for this statement is logically

identical to its GENERIC form but in GIMPLE, the @code{PLUS_EXPR}

on the RHS of the assignment is not represented as a tree,

instead the two operands are taken out of the @code{PLUS_EXPR} sub-tree

and flattened into the GIMPLE tuple as follows:

@smallexample

GIMPLE_ASSIGN <PLUS_EXPR, VAR_DECL <a>, VAR_DECL <b>, VAR_DECL <c>>

@end smallexample

@subsection Operand vector allocation

The operand vector is stored at the bottom of the three tuple

structures that accept operands. This means, that depending on

the code of a given statement, its operand vector will be at

different offsets from the base of the structure.  To access

tuple operands use the following accessors

@deftypefn {GIMPLE function} unsigned gimple_num_ops (gimple g)

Returns the number of operands in statement G.

@end deftypefn

@deftypefn {GIMPLE function} tree gimple_op (gimple g, unsigned i)

Returns operand @code{I} from statement @code{G}.

@end deftypefn

@deftypefn {GIMPLE function} {tree *} gimple_ops (gimple g)

Returns a pointer into the operand vector for statement @code{G}.  This

is computed using an internal table called @code{gimple_ops_offset_}[].

This table is indexed by the gimple code of @code{G}.

When the compiler is built, this table is filled-in using the

sizes of the structures used by each statement code defined in

gimple.def.  Since the operand vector is at the bottom of the

structure, for a gimple code @code{C} the offset is computed as sizeof

(struct-of @code{C}) - sizeof (tree).

This mechanism adds one memory indirection to every access when

using @code{gimple_op}(), if this becomes a bottleneck, a pass can

choose to memoize the result from @code{gimple_ops}() and use that to

access the operands.

@end deftypefn

@subsection Operand validation

When adding a new operand to a gimple statement, the operand will

be validated according to what each tuple accepts in its operand

vector.  These predicates are called by the

@code{gimple_@var{name}_set_...()}.  Each tuple will use one of the

following predicates (Note, this list is not exhaustive):

@deftypefn {GIMPLE function} bool is_gimple_val (tree t)

Returns true if t is a "GIMPLE value", which are all the

non-addressable stack variables (variables for which

@code{is_gimple_reg} returns true) and constants (expressions for which

@code{is_gimple_min_invariant} returns true).

@end deftypefn

@deftypefn {GIMPLE function} bool is_gimple_addressable (tree t)

Returns true if t is a symbol or memory reference whose address

can be taken.

@end deftypefn

@deftypefn {GIMPLE function} bool is_gimple_asm_val (tree t)

Similar to @code{is_gimple_val} but it also accepts hard registers.

@end deftypefn

@deftypefn {GIMPLE function} bool is_gimple_call_addr (tree t)

Return true if t is a valid expression to use as the function

called by a @code{GIMPLE_CALL}.

@end deftypefn

@deftypefn {GIMPLE function} bool is_gimple_mem_ref_addr (tree t)

Return true if t is a valid expression to use as first operand

of a @code{MEM_REF} expression.

@end deftypefn

@deftypefn {GIMPLE function} bool is_gimple_constant (tree t)

Return true if t is a valid gimple constant.

@end deftypefn

@deftypefn {GIMPLE function} bool is_gimple_min_invariant (tree t)

Return true if t is a valid minimal invariant.  This is different

from constants, in that the specific value of t may not be known

at compile time, but it is known that it doesn't change (e.g.,

the address of a function local variable).

@end deftypefn

@deftypefn {GIMPLE function} bool is_gimple_ip_invariant (tree t)

Return true if t is an interprocedural invariant.  This means that t

is a valid invariant in all functions (e.g. it can be an address of a

global variable but not of a local one).

@end deftypefn

@deftypefn {GIMPLE function} bool is_gimple_ip_invariant_address (tree t)

Return true if t is an @code{ADDR_EXPR} that does not change once the

program is running (and which is valid in all functions).

@end deftypefn

@subsection Statement validation

@deftypefn {GIMPLE function} bool is_gimple_assign (gimple g)

Return true if the code of g is @code{GIMPLE_ASSIGN}.

@end deftypefn

@deftypefn {GIMPLE function} bool is_gimple_call (gimple g)

Return true if the code of g is @code{GIMPLE_CALL}.

@end deftypefn

@deftypefn {GIMPLE function} bool is_gimple_debug (gimple g)

Return true if the code of g is @code{GIMPLE_DEBUG}.

@end deftypefn

@deftypefn {GIMPLE function} bool gimple_assign_cast_p (gimple g)

Return true if g is a @code{GIMPLE_ASSIGN} that performs a type cast

operation.

@end deftypefn

@deftypefn {GIMPLE function} bool gimple_debug_bind_p (gimple g)

Return true if g is a @code{GIMPLE_DEBUG} that binds the value of an

expression to a variable.

@end deftypefn

@node Manipulating GIMPLE statements

@section Manipulating GIMPLE statements

@cindex Manipulating GIMPLE statements

This section documents all the functions available to handle each

of the GIMPLE instructions.

@subsection Common accessors

The following are common accessors for gimple statements.

@deftypefn {GIMPLE function} {enum gimple_code} gimple_code (gimple g)

Return the code for statement @code{G}.

@end deftypefn

@deftypefn {GIMPLE function} basic_block gimple_bb (gimple g)

Return the basic block to which statement @code{G} belongs to.

@end deftypefn

@deftypefn {GIMPLE function} tree gimple_block (gimple g)

Return the lexical scope block holding statement @code{G}.

@end deftypefn

@deftypefn {GIMPLE function} tree gimple_expr_type (gimple stmt)

Return the type of the main expression computed by @code{STMT}. Return

@code{void_type_node} if @code{STMT} computes nothing. This will only return

something meaningful for @code{GIMPLE_ASSIGN}, @code{GIMPLE_COND} and

@code{GIMPLE_CALL}.  For all other tuple codes, it will return

@code{void_type_node}.

@end deftypefn

@deftypefn {GIMPLE function} {enum tree_code} gimple_expr_code (gimple stmt)

Return the tree code for the expression computed by @code{STMT}.  This

is only meaningful for @code{GIMPLE_CALL}, @code{GIMPLE_ASSIGN} and

@code{GIMPLE_COND}.  If @code{STMT} is @code{GIMPLE_CALL}, it will return @code{CALL_EXPR}.

For @code{GIMPLE_COND}, it returns the code of the comparison predicate.

For @code{GIMPLE_ASSIGN} it returns the code of the operation performed

by the @code{RHS} of the assignment.

@end deftypefn

@deftypefn {GIMPLE function} void gimple_set_block (gimple g, tree block)

Set the lexical scope block of @code{G} to @code{BLOCK}.

@end deftypefn

@deftypefn {GIMPLE function} location_t gimple_locus (gimple g)

Return locus information for statement @code{G}.

@end deftypefn

@deftypefn {GIMPLE function} void gimple_set_locus (gimple g, location_t locus)

Set locus information for statement @code{G}.

@end deftypefn

@deftypefn {GIMPLE function} bool gimple_locus_empty_p (gimple g)

Return true if @code{G} does not have locus information.

@end deftypefn

@deftypefn {GIMPLE function} bool gimple_no_warning_p (gimple stmt)

Return true if no warnings should be emitted for statement @code{STMT}.

@end deftypefn

@deftypefn {GIMPLE function} void gimple_set_visited (gimple stmt, bool visited_p)

Set the visited status on statement @code{STMT} to @code{VISITED_P}.

@end deftypefn

@deftypefn {GIMPLE function} bool gimple_visited_p (gimple stmt)

Return the visited status on statement @code{STMT}.

@end deftypefn

@deftypefn {GIMPLE function} void gimple_set_plf (gimple stmt, enum plf_mask plf, bool val_p)

Set pass local flag @code{PLF} on statement @code{STMT} to @code{VAL_P}.

@end deftypefn

@deftypefn {GIMPLE function} {unsigned int} gimple_plf (gimple stmt, enum plf_mask plf)

Return the value of pass local flag @code{PLF} on statement @code{STMT}.

@end deftypefn

@deftypefn {GIMPLE function} bool gimple_has_ops (gimple g)

Return true if statement @code{G} has register or memory operands.

@end deftypefn

@deftypefn {GIMPLE function} bool gimple_has_mem_ops (gimple g)

Return true if statement @code{G} has memory operands.

@end deftypefn

@deftypefn {GIMPLE function} unsigned gimple_num_ops (gimple g)

Return the number of operands for statement @code{G}.

@end deftypefn

@deftypefn {GIMPLE function} {tree *} gimple_ops (gimple g)

Return the array of operands for statement @code{G}.

@end deftypefn

@deftypefn {GIMPLE function} tree gimple_op (gimple g, unsigned i)

Return operand @code{I} for statement @code{G}.

@end deftypefn

@deftypefn {GIMPLE function} {tree *} gimple_op_ptr (gimple g, unsigned i)

Return a pointer to operand @code{I} for statement @code{G}.

@end deftypefn

@deftypefn {GIMPLE function} void gimple_set_op (gimple g, unsigned i, tree op)

Set operand @code{I} of statement @code{G} to @code{OP}.

@end deftypefn

@deftypefn {GIMPLE function} bitmap gimple_addresses_taken (gimple stmt)

Return the set of symbols that have had their address taken by

@code{STMT}.

@end deftypefn

@deftypefn {GIMPLE function} {struct def_optype_d *} gimple_def_ops (gimple g)

Return the set of @code{DEF} operands for statement @code{G}.

@end deftypefn

@deftypefn {GIMPLE function} void gimple_set_def_ops (gimple g, struct def_optype_d *def)

Set @code{DEF} to be the set of @code{DEF} operands for statement @code{G}.

@end deftypefn

@deftypefn {GIMPLE function} {struct use_optype_d *} gimple_use_ops (gimple g)

Return the set of @code{USE} operands for statement @code{G}.

@end deftypefn

@deftypefn {GIMPLE function} void gimple_set_use_ops (gimple g, struct use_optype_d *use)

Set @code{USE} to be the set of @code{USE} operands for statement @code{G}.

@end deftypefn

@deftypefn {GIMPLE function} {struct voptype_d *} gimple_vuse_ops (gimple g)

Return the set of @code{VUSE} operands for statement @code{G}.

@end deftypefn

@deftypefn {GIMPLE function} void gimple_set_vuse_ops (gimple g, struct voptype_d *ops)

Set @code{OPS} to be the set of @code{VUSE} operands for statement @code{G}.

@end deftypefn

@deftypefn {GIMPLE function} {struct voptype_d *} gimple_vdef_ops (gimple g)

Return the set of @code{VDEF} operands for statement @code{G}.

@end deftypefn

@deftypefn {GIMPLE function} void gimple_set_vdef_ops (gimple g, struct voptype_d *ops)

Set @code{OPS} to be the set of @code{VDEF} operands for statement @code{G}.

@end deftypefn

@deftypefn {GIMPLE function} bitmap gimple_loaded_syms (gimple g)

Return the set of symbols loaded by statement @code{G}.  Each element of

the set is the @code{DECL_UID} of the corresponding symbol.

@end deftypefn

@deftypefn {GIMPLE function} bitmap gimple_stored_syms (gimple g)

Return the set of symbols stored by statement @code{G}.  Each element of

the set is the @code{DECL_UID} of the corresponding symbol.

@end deftypefn

@deftypefn {GIMPLE function} bool gimple_modified_p (gimple g)

Return true if statement @code{G} has operands and the modified field

has been set.

@end deftypefn

@deftypefn {GIMPLE function} bool gimple_has_volatile_ops (gimple stmt)

Return true if statement @code{STMT} contains volatile operands.

@end deftypefn

@deftypefn {GIMPLE function} void gimple_set_has_volatile_ops (gimple stmt, bool volatilep)

Return true if statement @code{STMT} contains volatile operands.

@end deftypefn

@deftypefn {GIMPLE function} void update_stmt (gimple s)

Mark statement @code{S} as modified, and update it.

@end deftypefn

@deftypefn {GIMPLE function} void update_stmt_if_modified (gimple s)

Update statement @code{S} if it has been marked modified.

@end deftypefn

@deftypefn {GIMPLE function} gimple gimple_copy (gimple stmt)

Return a deep copy of statement @code{STMT}.

@end deftypefn

@node Tuple specific accessors

@section Tuple specific accessors

@cindex Tuple specific accessors

@menu

* @code{GIMPLE_ASM}::

* @code{GIMPLE_ASSIGN}::

* @code{GIMPLE_BIND}::

* @code{GIMPLE_CALL}::

* @code{GIMPLE_CATCH}::

* @code{GIMPLE_COND}::

* @code{GIMPLE_DEBUG}::

* @code{GIMPLE_EH_FILTER}::

* @code{GIMPLE_LABEL}::

* @code{GIMPLE_NOP}::

* @code{GIMPLE_OMP_ATOMIC_LOAD}::

* @code{GIMPLE_OMP_ATOMIC_STORE}::

* @code{GIMPLE_OMP_CONTINUE}::

* @code{GIMPLE_OMP_CRITICAL}::

* @code{GIMPLE_OMP_FOR}::

* @code{GIMPLE_OMP_MASTER}::

* @code{GIMPLE_OMP_ORDERED}::

* @code{GIMPLE_OMP_PARALLEL}::

* @code{GIMPLE_OMP_RETURN}::

* @code{GIMPLE_OMP_SECTION}::

* @code{GIMPLE_OMP_SECTIONS}::

* @code{GIMPLE_OMP_SINGLE}::

* @code{GIMPLE_PHI}::

* @code{GIMPLE_RESX}::

* @code{GIMPLE_RETURN}::

* @code{GIMPLE_SWITCH}::

* @code{GIMPLE_TRY}::

* @code{GIMPLE_WITH_CLEANUP_EXPR}::

@end menu

@node @code{GIMPLE_ASM}

@subsection @code{GIMPLE_ASM}

@cindex @code{GIMPLE_ASM}

@deftypefn {GIMPLE function} gimple gimple_build_asm (const char *string, ninputs, noutputs, nclobbers, ...)

Build a @code{GIMPLE_ASM} statement.  This statement is used for

building in-line assembly constructs.  @code{STRING} is the assembly

code.  @code{NINPUT} is the number of register inputs.  @code{NOUTPUT} is the

number of register outputs.  @code{NCLOBBERS} is the number of clobbered

registers.  The rest of the arguments trees for each input,

output, and clobbered registers.

@end deftypefn

@deftypefn {GIMPLE function} gimple gimple_build_asm_vec (const char *, VEC(tree,gc) *, VEC(tree,gc) *, VEC(tree,gc) *)

Identical to gimple_build_asm, but the arguments are passed in

VECs.