@@ -64,9 +64,8 @@ typedef const struct hwivec_def *const_hwivec;
union tree_node;
typedef union tree_node *tree;
typedef const union tree_node *const_tree;
-typedef struct gimple_statement_base *gimple;
-typedef const struct gimple_statement_base *const_gimple;
-typedef gimple gimple_seq;
+class gimple;
+typedef gimple *gimple_seq;
struct gimple_stmt_iterator;
union section;
typedef union section section;
@@ -92,8 +92,8 @@ 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
+@subsection @code{gimple} (gsbase)
+@cindex gimple
This is the root of the hierarchy, it holds basic information
needed by most GIMPLE statements. There are some fields that
@@ -192,12 +192,12 @@ Lexical block holding this statement. Also used for debug
information generation.
@end itemize
-@subsection @code{gimple_statement_with_ops}
-@cindex gimple_statement_with_ops
+@subsection @code{gimple_with_ops}
+@cindex gimple_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
+@code{gimple_with_ops_base} and
+@code{gimple_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
@@ -205,11 +205,11 @@ 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.
+gimple_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
+with the @code{gimple_with_memory_ops} tuple. So, these
+common fields are placed in @code{gimple_with_ops_base} which
is then inherited from the other two tuples.
@@ -223,7 +223,7 @@ is then inherited from the other two tuples.
@itemize @bullet
@item @code{gsbase}
-Inherited from @code{struct gimple_statement_base}.
+Inherited from @code{struct gimple}.
@item @code{def_ops}
Array of pointers into the operand array indicating all the slots that
@@ -239,14 +239,14 @@ Similar to @code{def_ops} but for variables read by the statement.
Array of trees with @code{num_ops} slots.
@end itemize
-@subsection @code{gimple_statement_with_memory_ops}
+@subsection @code{gimple_with_memory_ops}
-This tuple is essentially identical to @code{gimple_statement_with_ops},
+This tuple is essentially identical to @code{gimple_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}).
+vector (@code{gimple_with_memory_ops_base} and
+@code{gimple_with_memory_ops}).
@multitable {@code{vdef_ops}} {80 + 8 * @code{num_ops} bytes}
@@ -300,17 +300,17 @@ kinds, along with their relationships to @code{GSS_} values (layouts) and
@code{GIMPLE_} values (codes):
@smallexample
- gimple_statement_base
+ gimple
| layout: GSS_BASE
| used for 4 codes: GIMPLE_ERROR_MARK
| GIMPLE_NOP
| GIMPLE_OMP_SECTIONS_SWITCH
| GIMPLE_PREDICT
|
- + gimple_statement_with_ops_base
+ + gimple_with_ops_base
| | (no GSS layout)
| |
- | + gimple_statement_with_ops
+ | + gimple_with_ops
| | layout: GSS_WITH_OPS
| | Used for 5 codes: GIMPLE_COND
| | GIMPLE_DEBUG
@@ -318,104 +318,104 @@ kinds, along with their relationships to @code{GSS_} values (layouts) and
| | GIMPLE_LABEL
| | GIMPLE_SWITCH
| |
- | + gimple_statement_with_memory_ops_base
+ | + gimple_with_memory_ops_base
| | layout: GSS_WITH_MEM_OPS_BASE
| |
- | + gimple_statement_with_memory_ops
+ | + gimple_with_memory_ops
| | layout: GSS_WITH_MEM_OPS.
| | used for codes GIMPLE_ASSIGN and GIMPLE_RETURN.
| |
- | + gimple_statement_call
+ | + gcall
| | layout: GSS_CALL, code: GIMPLE_CALL
| |
- | + gimple_statement_asm
+ | + gasm
| | layout: GSS_ASM, code: GIMPLE_ASM
| |
- | + gimple_statement_transaction
+ | + gtransaction
| layout: GSS_TRANSACTION, code: GIMPLE_TRANSACTION
|
- + gimple_statement_omp
+ + gomp
| | layout: GSS_OMP. Used for code GIMPLE_OMP_SECTION
| |
- | + gimple_statement_omp_critical
+ | + gomp_critical
| | layout: GSS_OMP_CRITICAL, code: GIMPLE_OMP_CRITICAL
| |
- | + gimple_statement_omp_for
+ | + gomp_for
| | layout: GSS_OMP_FOR, code: GIMPLE_OMP_FOR
| |
- | + gimple_statement_omp_parallel_layout
+ | + gomp_parallel_layout
| | | layout: GSS_OMP_PARALLEL_LAYOUT
| | |
- | | + gimple_statement_omp_taskreg
+ | | + gomp_taskreg
| | | |
- | | | + gimple_statement_omp_parallel
+ | | | + gomp_parallel
| | | | code: GIMPLE_OMP_PARALLEL
| | | |
- | | | + gimple_statement_omp_task
+ | | | + gomp_task
| | | code: GIMPLE_OMP_TASK
| | |
- | | + gimple_statement_omp_target
+ | | + gomp_target
| | code: GIMPLE_OMP_TARGET
| |
- | + gimple_statement_omp_sections
+ | + gomp_sections
| | layout: GSS_OMP_SECTIONS, code: GIMPLE_OMP_SECTIONS
| |
- | + gimple_statement_omp_single_layout
+ | + gomp_single_layout
| | layout: GSS_OMP_SINGLE_LAYOUT
| |
- | + gimple_statement_omp_single
+ | + gomp_single
| | code: GIMPLE_OMP_SINGLE
| |
- | + gimple_statement_omp_teams
+ | + gomp_teams
| code: GIMPLE_OMP_TEAMS
|
- + gimple_statement_bind
+ + gbind
| layout: GSS_BIND, code: GIMPLE_BIND
|
- + gimple_statement_catch
+ + gcatch
| layout: GSS_CATCH, code: GIMPLE_CATCH
|
- + gimple_statement_eh_filter
+ + geh_filter
| layout: GSS_EH_FILTER, code: GIMPLE_EH_FILTER
|
- + gimple_statement_eh_else
+ + geh_else
| layout: GSS_EH_ELSE, code: GIMPLE_EH_ELSE
|
- + gimple_statement_eh_mnt
+ + geh_mnt
| layout: GSS_EH_MNT, code: GIMPLE_EH_MUST_NOT_THROW
|
- + gimple_statement_phi
+ + gphi
| layout: GSS_PHI, code: GIMPLE_PHI
|
- + gimple_statement_eh_ctrl
+ + geh_ctrl
| | layout: GSS_EH_CTRL
| |
- | + gimple_statement_resx
+ | + gresx
| | code: GIMPLE_RESX
| |
- | + gimple_statement_eh_dispatch
+ | + geh_dispatch
| code: GIMPLE_EH_DISPATCH
|
- + gimple_statement_try
+ + gtry
| layout: GSS_TRY, code: GIMPLE_TRY
|
- + gimple_statement_wce
+ + gwce
| layout: GSS_WCE, code: GIMPLE_WITH_CLEANUP_EXPR
|
- + gimple_statement_omp_continue
+ + gomp_continue
| layout: GSS_OMP_CONTINUE, code: GIMPLE_OMP_CONTINUE
|
- + gimple_statement_omp_atomic_load
+ + gomp_atomic_load
| layout: GSS_OMP_ATOMIC_LOAD, code: GIMPLE_OMP_ATOMIC_LOAD
|
- + gimple_statement_omp_atomic_store_layout
+ + gomp_atomic_store_layout
| layout: GSS_OMP_ATOMIC_STORE_LAYOUT,
| code: GIMPLE_OMP_ATOMIC_STORE
|
- + gimple_statement_omp_atomic_store
+ + gomp_atomic_store
| code: GIMPLE_OMP_ATOMIC_STORE
|
- + gimple_statement_omp_return
+ + gomp_return
code: GIMPLE_OMP_RETURN
@end smallexample
@@ -706,15 +706,15 @@ 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)
+@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)
+@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)
+@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}.
@@ -790,15 +790,15 @@ program is running (and which is valid in all functions).
@subsection Statement validation
-@deftypefn {GIMPLE function} bool is_gimple_assign (gimple g)
+@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)
+@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)
+@deftypefn {GIMPLE function} bool is_gimple_debug (gimple *g)
Return true if the code of g is @code{GIMPLE_DEBUG}.
@end deftypefn
@@ -807,12 +807,12 @@ 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)
+@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
-@deftypefn {GIMPLE function} bool is_gimple_omp (gimple g)
+@deftypefn {GIMPLE function} bool is_gimple_omp (gimple *g)
Return true if g is any of the OpenMP codes.
@end deftypefn
@@ -826,19 +826,19 @@ 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)
+@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)
+@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)
+@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)
+@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
@@ -846,7 +846,8 @@ something meaningful for @code{GIMPLE_ASSIGN}, @code{GIMPLE_COND} and
@code{void_type_node}.
@end deftypefn
-@deftypefn {GIMPLE function} {enum tree_code} gimple_expr_code (gimple stmt)
+@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}.
@@ -855,139 +856,153 @@ 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)
+@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)
+@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)
+@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)
+@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)
+@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)
+@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)
+@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)
+@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)
+@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)
+@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)
+@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)
+@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)
+@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)
+@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)
+@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)
+@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)
+@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)
+@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)
+@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)
+@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)
+@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)
+@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)
+@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)
+@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)
+@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)
+@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)
+@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)
+@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)
+@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)
+@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)
+@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)
+@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)
+@deftypefn {GIMPLE function} gimple *gimple_copy (gimple *stmt)
Return a deep copy of statement @code{STMT}.
@end deftypefn
@@ -1031,7 +1046,8 @@ Return a deep copy of statement @code{STMT}.
@subsection @code{GIMPLE_ASM}
@cindex @code{GIMPLE_ASM}
-@deftypefn {GIMPLE function} gimple gimple_build_asm (const char *string, ninputs, noutputs, nclobbers, ...)
+@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
@@ -1040,58 +1056,64 @@ 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) *)
+@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.
@end deftypefn
-@deftypefn {GIMPLE function} unsigned gimple_asm_ninputs (gimple g)
+@deftypefn {GIMPLE function} unsigned gimple_asm_ninputs (gimple *g)
Return the number of input operands for @code{GIMPLE_ASM} @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} unsigned gimple_asm_noutputs (gimple g)
+@deftypefn {GIMPLE function} unsigned gimple_asm_noutputs (gimple *g)
Return the number of output operands for @code{GIMPLE_ASM} @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} unsigned gimple_asm_nclobbers (gimple g)
+@deftypefn {GIMPLE function} unsigned gimple_asm_nclobbers (gimple *g)
Return the number of clobber operands for @code{GIMPLE_ASM} @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} tree gimple_asm_input_op (gimple g, unsigned index)
+@deftypefn {GIMPLE function} tree gimple_asm_input_op (gimple *g, @
+unsigned index)
Return input operand @code{INDEX} of @code{GIMPLE_ASM} @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_asm_set_input_op (gimple g, unsigned index, tree in_op)
+@deftypefn {GIMPLE function} void gimple_asm_set_input_op (gimple *g, @
+unsigned index, tree in_op)
Set @code{IN_OP} to be input operand @code{INDEX} in @code{GIMPLE_ASM} @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} tree gimple_asm_output_op (gimple g, unsigned index)
+@deftypefn {GIMPLE function} tree gimple_asm_output_op (gimple *g, @
+unsigned index)
Return output operand @code{INDEX} of @code{GIMPLE_ASM} @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_asm_set_output_op (gimple g, @
+@deftypefn {GIMPLE function} void gimple_asm_set_output_op (gimple *g, @
unsigned index, tree out_op)
Set @code{OUT_OP} to be output operand @code{INDEX} in @code{GIMPLE_ASM} @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} tree gimple_asm_clobber_op (gimple g, unsigned index)
+@deftypefn {GIMPLE function} tree gimple_asm_clobber_op (gimple *g, @
+unsigned index)
Return clobber operand @code{INDEX} of @code{GIMPLE_ASM} @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_asm_set_clobber_op (gimple g, unsigned index, tree clobber_op)
+@deftypefn {GIMPLE function} void gimple_asm_set_clobber_op (gimple *g, @
+unsigned index, tree clobber_op)
Set @code{CLOBBER_OP} to be clobber operand @code{INDEX} in @code{GIMPLE_ASM} @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} {const char *} gimple_asm_string (gimple g)
+@deftypefn {GIMPLE function} {const char *} gimple_asm_string (gimple *g)
Return the string representing the assembly instruction in
@code{GIMPLE_ASM} @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} bool gimple_asm_volatile_p (gimple g)
+@deftypefn {GIMPLE function} bool gimple_asm_volatile_p (gimple *g)
Return true if @code{G} is an asm statement marked volatile.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_asm_set_volatile (gimple g)
+@deftypefn {GIMPLE function} void gimple_asm_set_volatile (gimple *g)
Mark asm statement @code{G} as volatile.
@end deftypefn
@@ -1099,7 +1121,8 @@ Mark asm statement @code{G} as volatile.
@subsection @code{GIMPLE_ASSIGN}
@cindex @code{GIMPLE_ASSIGN}
-@deftypefn {GIMPLE function} gimple gimple_build_assign (tree lhs, tree rhs)
+@deftypefn {GIMPLE function} gimple *gimple_build_assign (tree lhs, @
+tree rhs)
Build a @code{GIMPLE_ASSIGN} statement. The left-hand side is an lvalue
passed in lhs. The right-hand side can be either a unary or
binary tree expression. The expression tree rhs will be
@@ -1113,7 +1136,8 @@ operands in separate trees, it is better to use
@end deftypefn
-@deftypefn {GIMPLE function} gimple gimplify_assign (tree dst, tree src, gimple_seq *seq_p)
+@deftypefn {GIMPLE function} gimple *gimplify_assign (tree dst, tree src, @
+gimple_seq *seq_p)
Build a new @code{GIMPLE_ASSIGN} tuple and append it to the end of
@code{*SEQ_P}.
@end deftypefn
@@ -1124,7 +1148,7 @@ case they will be converted to a gimple operand if necessary.
This function returns the newly created @code{GIMPLE_ASSIGN} tuple.
-@deftypefn {GIMPLE function} gimple gimple_build_assign_with_ops @
+@deftypefn {GIMPLE function} gimple *gimple_build_assign_with_ops @
(enum tree_code subcode, tree lhs, tree op1, tree op2)
This function is similar to @code{gimple_build_assign}, but is used to
build a @code{GIMPLE_ASSIGN} statement when the operands of the
@@ -1137,73 +1161,79 @@ are the operands. If op2 is null, subcode must be a @code{tree_code}
for a unary expression.
@end deftypefn
-@deftypefn {GIMPLE function} {enum tree_code} gimple_assign_rhs_code (gimple g)
+@deftypefn {GIMPLE function} {enum tree_code} gimple_assign_rhs_code (@
+gimple *g)
Return the code of the expression computed on the @code{RHS} of
assignment statement @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} {enum gimple_rhs_class} gimple_assign_rhs_class (gimple g)
+@deftypefn {GIMPLE function} {enum gimple_rhs_class} gimple_assign_rhs_class (@
+gimple *g)
Return the gimple rhs class of the code for the expression
computed on the rhs of assignment statement @code{G}. This will never
return @code{GIMPLE_INVALID_RHS}.
@end deftypefn
-@deftypefn {GIMPLE function} tree gimple_assign_lhs (gimple g)
+@deftypefn {GIMPLE function} tree gimple_assign_lhs (gimple *g)
Return the @code{LHS} of assignment statement @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} {tree *} gimple_assign_lhs_ptr (gimple g)
+@deftypefn {GIMPLE function} {tree *} gimple_assign_lhs_ptr (gimple *g)
Return a pointer to the @code{LHS} of assignment statement @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} tree gimple_assign_rhs1 (gimple g)
+@deftypefn {GIMPLE function} tree gimple_assign_rhs1 (gimple *g)
Return the first operand on the @code{RHS} of assignment statement @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} {tree *} gimple_assign_rhs1_ptr (gimple g)
+@deftypefn {GIMPLE function} {tree *} gimple_assign_rhs1_ptr (gimple *g)
Return the address of the first operand on the @code{RHS} of assignment
statement @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} tree gimple_assign_rhs2 (gimple g)
+@deftypefn {GIMPLE function} tree gimple_assign_rhs2 (gimple *g)
Return the second operand on the @code{RHS} of assignment statement @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} {tree *} gimple_assign_rhs2_ptr (gimple g)
+@deftypefn {GIMPLE function} {tree *} gimple_assign_rhs2_ptr (gimple *g)
Return the address of the second operand on the @code{RHS} of assignment
statement @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} tree gimple_assign_rhs3 (gimple g)
+@deftypefn {GIMPLE function} tree gimple_assign_rhs3 (gimple *g)
Return the third operand on the @code{RHS} of assignment statement @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} {tree *} gimple_assign_rhs3_ptr (gimple g)
+@deftypefn {GIMPLE function} {tree *} gimple_assign_rhs3_ptr (gimple *g)
Return the address of the third operand on the @code{RHS} of assignment
statement @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_assign_set_lhs (gimple g, tree lhs)
+@deftypefn {GIMPLE function} void gimple_assign_set_lhs (gimple *g, @
+tree lhs)
Set @code{LHS} to be the @code{LHS} operand of assignment statement @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_assign_set_rhs1 (gimple g, tree rhs)
+@deftypefn {GIMPLE function} void gimple_assign_set_rhs1 (gimple *g, @
+tree rhs)
Set @code{RHS} to be the first operand on the @code{RHS} of assignment
statement @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_assign_set_rhs2 (gimple g, tree rhs)
+@deftypefn {GIMPLE function} void gimple_assign_set_rhs2 (gimple *g, @
+tree rhs)
Set @code{RHS} to be the second operand on the @code{RHS} of assignment
statement @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_assign_set_rhs3 (gimple g, tree rhs)
+@deftypefn {GIMPLE function} void gimple_assign_set_rhs3 (gimple *g, @
+tree rhs)
Set @code{RHS} to be the third operand on the @code{RHS} of assignment
statement @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} bool gimple_assign_cast_p (const_gimple s)
+@deftypefn {GIMPLE function} bool gimple_assign_cast_p (const_gimple *s)
Return true if @code{S} is a type-cast assignment.
@end deftypefn
@@ -1212,49 +1242,56 @@ Return true if @code{S} is a type-cast assignment.
@subsection @code{GIMPLE_BIND}
@cindex @code{GIMPLE_BIND}
-@deftypefn {GIMPLE function} gimple gimple_build_bind (tree vars, gimple_seq body)
+@deftypefn {GIMPLE function} gimple *gimple_build_bind (tree vars, @
+gimple_seq body)
Build a @code{GIMPLE_BIND} statement with a list of variables in @code{VARS}
and a body of statements in sequence @code{BODY}.
@end deftypefn
-@deftypefn {GIMPLE function} tree gimple_bind_vars (gimple g)
+@deftypefn {GIMPLE function} tree gimple_bind_vars (gimple *g)
Return the variables declared in the @code{GIMPLE_BIND} statement @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_bind_set_vars (gimple g, tree vars)
+@deftypefn {GIMPLE function} void gimple_bind_set_vars (gimple *g, @
+tree vars)
Set @code{VARS} to be the set of variables declared in the @code{GIMPLE_BIND}
statement @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_bind_append_vars (gimple g, tree vars)
+@deftypefn {GIMPLE function} void gimple_bind_append_vars (gimple *g, @
+tree vars)
Append @code{VARS} to the set of variables declared in the @code{GIMPLE_BIND}
statement @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} gimple_seq gimple_bind_body (gimple g)
+@deftypefn {GIMPLE function} gimple_seq gimple_bind_body (gimple *g)
Return the GIMPLE sequence contained in the @code{GIMPLE_BIND} statement
@code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_bind_set_body (gimple g, gimple_seq seq)
+@deftypefn {GIMPLE function} void gimple_bind_set_body (gimple *g, @
+gimple_seq seq)
Set @code{SEQ} to be sequence contained in the @code{GIMPLE_BIND} statement @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_bind_add_stmt (gimple gs, gimple stmt)
+@deftypefn {GIMPLE function} void gimple_bind_add_stmt (gimple *gs, @
+gimple *stmt)
Append a statement to the end of a @code{GIMPLE_BIND}'s body.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_bind_add_seq (gimple gs, gimple_seq seq)
+@deftypefn {GIMPLE function} void gimple_bind_add_seq (gimple *gs, @
+gimple_seq seq)
Append a sequence of statements to the end of a @code{GIMPLE_BIND}'s
body.
@end deftypefn
-@deftypefn {GIMPLE function} tree gimple_bind_block (gimple g)
+@deftypefn {GIMPLE function} tree gimple_bind_block (gimple *g)
Return the @code{TREE_BLOCK} node associated with @code{GIMPLE_BIND} statement
@code{G}. This is analogous to the @code{BIND_EXPR_BLOCK} field in trees.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_bind_set_block (gimple g, tree block)
+@deftypefn {GIMPLE function} void gimple_bind_set_block (gimple *g, @
+tree block)
Set @code{BLOCK} to be the @code{TREE_BLOCK} node associated with @code{GIMPLE_BIND}
statement @code{G}.
@end deftypefn
@@ -1264,7 +1301,8 @@ statement @code{G}.
@subsection @code{GIMPLE_CALL}
@cindex @code{GIMPLE_CALL}
-@deftypefn {GIMPLE function} gimple gimple_build_call (tree fn, unsigned nargs, ...)
+@deftypefn {GIMPLE function} gimple *gimple_build_call (tree fn, @
+unsigned nargs, ...)
Build a @code{GIMPLE_CALL} statement to function @code{FN}. The argument @code{FN}
must be either a @code{FUNCTION_DECL} or a gimple call address as
determined by @code{is_gimple_call_addr}. @code{NARGS} are the number of
@@ -1274,7 +1312,8 @@ operand is validated with @code{is_gimple_operand}).
@end deftypefn
-@deftypefn {GIMPLE function} gimple gimple_build_call_from_tree (tree call_expr)
+@deftypefn {GIMPLE function} gimple *gimple_build_call_from_tree (@
+tree call_expr)
Build a @code{GIMPLE_CALL} from a @code{CALL_EXPR} node. The arguments and the
function are taken from the expression directly. This routine
assumes that @code{call_expr} is already in GIMPLE form. That is, its
@@ -1283,98 +1322,105 @@ simplification. All the call flags in @code{call_expr} are copied over
to the new @code{GIMPLE_CALL}.
@end deftypefn
-@deftypefn {GIMPLE function} gimple gimple_build_call_vec (tree fn, @code{VEC}(tree, heap) *args)
+@deftypefn {GIMPLE function} gimple *gimple_build_call_vec (tree fn, @
+@code{VEC}(tree, heap) *args)
Identical to @code{gimple_build_call} but the arguments are stored in a
@code{VEC}().
@end deftypefn
-@deftypefn {GIMPLE function} tree gimple_call_lhs (gimple g)
+@deftypefn {GIMPLE function} tree gimple_call_lhs (gimple *g)
Return the @code{LHS} of call statement @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} {tree *} gimple_call_lhs_ptr (gimple g)
+@deftypefn {GIMPLE function} {tree *} gimple_call_lhs_ptr (gimple *g)
Return a pointer to the @code{LHS} of call statement @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_call_set_lhs (gimple g, tree lhs)
+@deftypefn {GIMPLE function} void gimple_call_set_lhs (gimple *g, tree lhs)
Set @code{LHS} to be the @code{LHS} operand of call statement @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} tree gimple_call_fn (gimple g)
+@deftypefn {GIMPLE function} tree gimple_call_fn (gimple *g)
Return the tree node representing the function called by call
statement @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_call_set_fn (gimple g, tree fn)
+@deftypefn {GIMPLE function} void gimple_call_set_fn (gimple *g, tree fn)
Set @code{FN} to be the function called by call statement @code{G}. This has
to be a gimple value specifying the address of the called
function.
@end deftypefn
-@deftypefn {GIMPLE function} tree gimple_call_fndecl (gimple g)
+@deftypefn {GIMPLE *function} tree gimple_call_fndecl (gimple *g)
If a given @code{GIMPLE_CALL}'s callee is a @code{FUNCTION_DECL}, return it.
Otherwise return @code{NULL}. This function is analogous to
@code{get_callee_fndecl} in @code{GENERIC}.
@end deftypefn
-@deftypefn {GIMPLE function} tree gimple_call_set_fndecl (gimple g, tree fndecl)
+@deftypefn {GIMPLE function} tree gimple_call_set_fndecl (gimple *g, @
+tree fndecl)
Set the called function to @code{FNDECL}.
@end deftypefn
-@deftypefn {GIMPLE function} tree gimple_call_return_type (gimple g)
+@deftypefn {GIMPLE function} tree gimple_call_return_type (gimple *g)
Return the type returned by call statement @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} tree gimple_call_chain (gimple g)
+@deftypefn {GIMPLE function} tree gimple_call_chain (gimple *g)
Return the static chain for call statement @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_call_set_chain (gimple g, tree chain)
+@deftypefn {GIMPLE function} void gimple_call_set_chain (gimple *g, @
+tree chain)
Set @code{CHAIN} to be the static chain for call statement @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} unsigned gimple_call_num_args (gimple g)
+@deftypefn {GIMPLE function} unsigned gimple_call_num_args (gimple *g)
Return the number of arguments used by call statement @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} tree gimple_call_arg (gimple g, unsigned index)
+@deftypefn {GIMPLE function} tree gimple_call_arg (gimple *g, @
+unsigned index)
Return the argument at position @code{INDEX} for call statement @code{G}. The
first argument is 0.
@end deftypefn
-@deftypefn {GIMPLE function} {tree *} gimple_call_arg_ptr (gimple g, unsigned index)
+@deftypefn {GIMPLE function} {tree *} gimple_call_arg_ptr (gimple *g, @
+unsigned index)
Return a pointer to the argument at position @code{INDEX} for call
statement @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_call_set_arg (gimple g, unsigned index, tree arg)
+@deftypefn {GIMPLE function} void gimple_call_set_arg (gimple *g, @
+unsigned index, tree arg)
Set @code{ARG} to be the argument at position @code{INDEX} for call statement
@code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_call_set_tail (gimple s)
+@deftypefn {GIMPLE function} void gimple_call_set_tail (gimple *s)
Mark call statement @code{S} as being a tail call (i.e., a call just
before the exit of a function). These calls are candidate for
tail call optimization.
@end deftypefn
-@deftypefn {GIMPLE function} bool gimple_call_tail_p (gimple s)
+@deftypefn {GIMPLE function} bool gimple_call_tail_p (gimple *s)
Return true if @code{GIMPLE_CALL} @code{S} is marked as a tail call.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_call_mark_uninlinable (gimple s)
+@deftypefn {GIMPLE function} void gimple_call_mark_uninlinable (gimple *s)
Mark @code{GIMPLE_CALL} @code{S} as being uninlinable.
@end deftypefn
-@deftypefn {GIMPLE function} bool gimple_call_cannot_inline_p (gimple s)
+@deftypefn {GIMPLE function} bool gimple_call_cannot_inline_p (gimple *s)
Return true if @code{GIMPLE_CALL} @code{S} cannot be inlined.
@end deftypefn
-@deftypefn {GIMPLE function} bool gimple_call_noreturn_p (gimple s)
+@deftypefn {GIMPLE function} bool gimple_call_noreturn_p (gimple *s)
Return true if @code{S} is a noreturn call.
@end deftypefn
-@deftypefn {GIMPLE function} gimple gimple_call_copy_skip_args (gimple stmt, bitmap args_to_skip)
+@deftypefn {GIMPLE function} gimple *gimple_call_copy_skip_args (@
+gimple *stmt, bitmap args_to_skip)
Build a @code{GIMPLE_CALL} identical to @code{STMT} but skipping the arguments
in the positions marked by the set @code{ARGS_TO_SKIP}.
@end deftypefn
@@ -1384,31 +1430,34 @@ in the positions marked by the set @code{ARGS_TO_SKIP}.
@subsection @code{GIMPLE_CATCH}
@cindex @code{GIMPLE_CATCH}
-@deftypefn {GIMPLE function} gimple gimple_build_catch (tree types, gimple_seq handler)
+@deftypefn {GIMPLE function} gimple *gimple_build_catch (tree types, @
+gimple_seq handler)
Build a @code{GIMPLE_CATCH} statement. @code{TYPES} are the tree types this
catch handles. @code{HANDLER} is a sequence of statements with the code
for the handler.
@end deftypefn
-@deftypefn {GIMPLE function} tree gimple_catch_types (gimple g)
+@deftypefn {GIMPLE function} tree gimple_catch_types (gimple *g)
Return the types handled by @code{GIMPLE_CATCH} statement @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} {tree *} gimple_catch_types_ptr (gimple g)
+@deftypefn {GIMPLE function} {tree *} gimple_catch_types_ptr (gimple *g)
Return a pointer to the types handled by @code{GIMPLE_CATCH} statement
@code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} gimple_seq gimple_catch_handler (gimple g)
+@deftypefn {GIMPLE function} gimple_seq gimple_catch_handler (gimple *g)
Return the GIMPLE sequence representing the body of the handler
of @code{GIMPLE_CATCH} statement @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_catch_set_types (gimple g, tree t)
+@deftypefn {GIMPLE function} void gimple_catch_set_types (gimple *g, @
+tree t)
Set @code{T} to be the set of types handled by @code{GIMPLE_CATCH} @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_catch_set_handler (gimple g, gimple_seq handler)
+@deftypefn {GIMPLE function} void gimple_catch_set_handler (gimple *g, @
+gimple_seq handler)
Set @code{HANDLER} to be the body of @code{GIMPLE_CATCH} @code{G}.
@end deftypefn
@@ -1417,7 +1466,8 @@ Set @code{HANDLER} to be the body of @code{GIMPLE_CATCH} @code{G}.
@subsection @code{GIMPLE_COND}
@cindex @code{GIMPLE_COND}
-@deftypefn {GIMPLE function} gimple gimple_build_cond (enum tree_code pred_code, tree lhs, tree rhs, tree t_label, tree f_label)
+@deftypefn {GIMPLE function} gimple *gimple_build_cond (@
+enum tree_code pred_code, tree lhs, tree rhs, tree t_label, tree f_label)
Build a @code{GIMPLE_COND} statement. @code{A} @code{GIMPLE_COND} statement compares
@code{LHS} and @code{RHS} and if the condition in @code{PRED_CODE} is true, jump to
the label in @code{t_label}, otherwise jump to the label in @code{f_label}.
@@ -1426,66 +1476,70 @@ the label in @code{t_label}, otherwise jump to the label in @code{f_label}.
@end deftypefn
-@deftypefn {GIMPLE function} gimple gimple_build_cond_from_tree (tree cond, tree t_label, tree f_label)
+@deftypefn {GIMPLE function} gimple *gimple_build_cond_from_tree (@
+tree cond, tree t_label, tree f_label)
Build a @code{GIMPLE_COND} statement from the conditional expression
tree @code{COND}. @code{T_LABEL} and @code{F_LABEL} are as in @code{gimple_build_cond}.
@end deftypefn
-@deftypefn {GIMPLE function} {enum tree_code} gimple_cond_code (gimple g)
+@deftypefn {GIMPLE function} {enum tree_code} gimple_cond_code (gimple *g)
Return the code of the predicate computed by conditional
statement @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_cond_set_code (gimple g, enum tree_code code)
+@deftypefn {GIMPLE function} void gimple_cond_set_code (gimple *g, @
+enum tree_code code)
Set @code{CODE} to be the predicate code for the conditional statement
@code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} tree gimple_cond_lhs (gimple g)
+@deftypefn {GIMPLE function} tree gimple_cond_lhs (gimple *g)
Return the @code{LHS} of the predicate computed by conditional statement
@code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_cond_set_lhs (gimple g, tree lhs)
+@deftypefn {GIMPLE function} void gimple_cond_set_lhs (gimple *g, tree lhs)
Set @code{LHS} to be the @code{LHS} operand of the predicate computed by
conditional statement @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} tree gimple_cond_rhs (gimple g)
+@deftypefn {GIMPLE function} tree gimple_cond_rhs (gimple *g)
Return the @code{RHS} operand of the predicate computed by conditional
@code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_cond_set_rhs (gimple g, tree rhs)
+@deftypefn {GIMPLE function} void gimple_cond_set_rhs (gimple *g, tree rhs)
Set @code{RHS} to be the @code{RHS} operand of the predicate computed by
conditional statement @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} tree gimple_cond_true_label (gimple g)
+@deftypefn {GIMPLE function} tree gimple_cond_true_label (gimple *g)
Return the label used by conditional statement @code{G} when its
predicate evaluates to true.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_cond_set_true_label (gimple g, tree label)
+@deftypefn {GIMPLE function} void gimple_cond_set_true_label (gimple *g, @
+tree label)
Set @code{LABEL} to be the label used by conditional statement @code{G} when
its predicate evaluates to true.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_cond_set_false_label (gimple g, tree label)
+@deftypefn {GIMPLE function} void gimple_cond_set_false_label (gimple *g, @
+tree label)
Set @code{LABEL} to be the label used by conditional statement @code{G} when
its predicate evaluates to false.
@end deftypefn
-@deftypefn {GIMPLE function} tree gimple_cond_false_label (gimple g)
+@deftypefn {GIMPLE function} tree gimple_cond_false_label (gimple *g)
Return the label used by conditional statement @code{G} when its
predicate evaluates to false.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_cond_make_false (gimple g)
+@deftypefn {GIMPLE function} void gimple_cond_make_false (gimple *g)
Set the conditional @code{COND_STMT} to be of the form 'if (1 == 0)'.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_cond_make_true (gimple g)
+@deftypefn {GIMPLE function} void gimple_cond_make_true (gimple *g)
Set the conditional @code{COND_STMT} to be of the form 'if (1 == 1)'.
@end deftypefn
@@ -1494,7 +1548,8 @@ Set the conditional @code{COND_STMT} to be of the form 'if (1 == 1)'.
@cindex @code{GIMPLE_DEBUG}
@cindex @code{GIMPLE_DEBUG_BIND}
-@deftypefn {GIMPLE function} gimple gimple_build_debug_bind (tree var, tree value, gimple stmt)
+@deftypefn {GIMPLE function} gimple *gimple_build_debug_bind (tree var, @
+tree value, gimple *stmt)
Build a @code{GIMPLE_DEBUG} statement with @code{GIMPLE_DEBUG_BIND} of
@code{subcode}. The effect of this statement is to tell debug
information generation machinery that the value of user variable
@@ -1533,35 +1588,41 @@ Block and location information for the newly-created stmt are
taken from @code{stmt}, if given.
@end deftypefn
-@deftypefn {GIMPLE function} tree gimple_debug_bind_get_var (gimple stmt)
+@deftypefn {GIMPLE function} tree gimple_debug_bind_get_var (gimple *stmt)
Return the user variable @var{var} that is bound at @code{stmt}.
@end deftypefn
-@deftypefn {GIMPLE function} tree gimple_debug_bind_get_value (gimple stmt)
+@deftypefn {GIMPLE function} tree gimple_debug_bind_get_value (@
+gimple *stmt)
Return the value expression that is bound to a user variable at
@code{stmt}.
@end deftypefn
-@deftypefn {GIMPLE function} {tree *} gimple_debug_bind_get_value_ptr (gimple stmt)
+@deftypefn {GIMPLE function} {tree *} gimple_debug_bind_get_value_ptr (@
+gimple *stmt)
Return a pointer to the value expression that is bound to a user
variable at @code{stmt}.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_debug_bind_set_var (gimple stmt, tree var)
+@deftypefn {GIMPLE function} void gimple_debug_bind_set_var (@
+gimple *stmt, tree var)
Modify the user variable bound at @code{stmt} to @var{var}.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_debug_bind_set_value (gimple stmt, tree var)
+@deftypefn {GIMPLE function} void gimple_debug_bind_set_value (@
+gimple *stmt, tree var)
Modify the value bound to the user variable bound at @code{stmt} to
@var{value}.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_debug_bind_reset_value (gimple stmt)
+@deftypefn {GIMPLE function} void gimple_debug_bind_reset_value (@
+gimple *stmt)
Modify the value bound to the user variable bound at @code{stmt} so
that the variable becomes unbound.
@end deftypefn
-@deftypefn {GIMPLE function} bool gimple_debug_bind_has_value_p (gimple stmt)
+@deftypefn {GIMPLE function} bool gimple_debug_bind_has_value_p (@
+gimple *stmt)
Return @code{TRUE} if @code{stmt} binds a user variable to a value,
and @code{FALSE} if it unbinds the variable.
@end deftypefn
@@ -1570,39 +1631,46 @@ and @code{FALSE} if it unbinds the variable.
@subsection @code{GIMPLE_EH_FILTER}
@cindex @code{GIMPLE_EH_FILTER}
-@deftypefn {GIMPLE function} gimple gimple_build_eh_filter (tree types, gimple_seq failure)
+@deftypefn {GIMPLE function} gimple *gimple_build_eh_filter (@
+tree types, gimple_seq failure)
Build a @code{GIMPLE_EH_FILTER} statement. @code{TYPES} are the filter's
types. @code{FAILURE} is a sequence with the filter's failure action.
@end deftypefn
-@deftypefn {GIMPLE function} tree gimple_eh_filter_types (gimple g)
+@deftypefn {GIMPLE function} tree gimple_eh_filter_types (gimple *g)
Return the types handled by @code{GIMPLE_EH_FILTER} statement @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} {tree *} gimple_eh_filter_types_ptr (gimple g)
+@deftypefn {GIMPLE function} {tree *} gimple_eh_filter_types_ptr (@
+gimple *g)
Return a pointer to the types handled by @code{GIMPLE_EH_FILTER}
statement @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} gimple_seq gimple_eh_filter_failure (gimple g)
+@deftypefn {GIMPLE function} gimple_seq gimple_eh_filter_failure (@
+gimple *g)
Return the sequence of statement to execute when @code{GIMPLE_EH_FILTER}
statement fails.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_eh_filter_set_types (gimple g, tree types)
+@deftypefn {GIMPLE function} void gimple_eh_filter_set_types (gimple *g, @
+tree types)
Set @code{TYPES} to be the set of types handled by @code{GIMPLE_EH_FILTER} @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_eh_filter_set_failure (gimple g, gimple_seq failure)
+@deftypefn {GIMPLE function} void gimple_eh_filter_set_failure (@
+gimple *g, gimple_seq failure)
Set @code{FAILURE} to be the sequence of statements to execute on
failure for @code{GIMPLE_EH_FILTER} @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} bool gimple_eh_filter_must_not_throw (gimple g)
+@deftypefn {GIMPLE function} bool gimple_eh_filter_must_not_throw (@
+gimple *g)
Return the @code{EH_FILTER_MUST_NOT_THROW} flag.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_eh_filter_set_must_not_throw (gimple g, bool mntp)
+@deftypefn {GIMPLE function} void gimple_eh_filter_set_must_not_throw (@
+gimple *g, bool mntp)
Set the @code{EH_FILTER_MUST_NOT_THROW} flag.
@end deftypefn
@@ -1611,30 +1679,32 @@ Set the @code{EH_FILTER_MUST_NOT_THROW} flag.
@subsection @code{GIMPLE_LABEL}
@cindex @code{GIMPLE_LABEL}
-@deftypefn {GIMPLE function} gimple gimple_build_label (tree label)
+@deftypefn {GIMPLE function} gimple *gimple_build_label (tree label)
Build a @code{GIMPLE_LABEL} statement with corresponding to the tree
label, @code{LABEL}.
@end deftypefn
-@deftypefn {GIMPLE function} tree gimple_label_label (gimple g)
+@deftypefn {GIMPLE function} tree gimple_label_label (gimple *g)
Return the @code{LABEL_DECL} node used by @code{GIMPLE_LABEL} statement @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_label_set_label (gimple g, tree label)
+@deftypefn {GIMPLE function} void gimple_label_set_label (gimple *g, @
+tree label)
Set @code{LABEL} to be the @code{LABEL_DECL} node used by @code{GIMPLE_LABEL}
statement @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} gimple gimple_build_goto (tree dest)
+@deftypefn {GIMPLE function} gimple *gimple_build_goto (tree dest)
Build a @code{GIMPLE_GOTO} statement to label @code{DEST}.
@end deftypefn
-@deftypefn {GIMPLE function} tree gimple_goto_dest (gimple g)
+@deftypefn {GIMPLE function} tree gimple_goto_dest (gimple *g)
Return the destination of the unconditional jump @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_goto_set_dest (gimple g, tree dest)
+@deftypefn {GIMPLE function} void gimple_goto_set_dest (gimple *g, @
+tree dest)
Set @code{DEST} to be the destination of the unconditional jump @code{G}.
@end deftypefn
@@ -1643,11 +1713,11 @@ Set @code{DEST} to be the destination of the unconditional jump @code{G}.
@subsection @code{GIMPLE_NOP}
@cindex @code{GIMPLE_NOP}
-@deftypefn {GIMPLE function} gimple gimple_build_nop (void)
+@deftypefn {GIMPLE function} gimple *gimple_build_nop (void)
Build a @code{GIMPLE_NOP} statement.
@end deftypefn
-@deftypefn {GIMPLE function} bool gimple_nop_p (gimple g)
+@deftypefn {GIMPLE function} bool gimple_nop_p (gimple *g)
Returns @code{TRUE} if statement @code{G} is a @code{GIMPLE_NOP}.
@end deftypefn
@@ -1655,25 +1725,28 @@ Returns @code{TRUE} if statement @code{G} is a @code{GIMPLE_NOP}.
@subsection @code{GIMPLE_OMP_ATOMIC_LOAD}
@cindex @code{GIMPLE_OMP_ATOMIC_LOAD}
-@deftypefn {GIMPLE function} gimple gimple_build_omp_atomic_load (tree lhs, tree rhs)
+@deftypefn {GIMPLE function} gimple *gimple_build_omp_atomic_load (@
+tree lhs, tree rhs)
Build a @code{GIMPLE_OMP_ATOMIC_LOAD} statement. @code{LHS} is the left-hand
side of the assignment. @code{RHS} is the right-hand side of the
assignment.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_omp_atomic_load_set_lhs (gimple g, tree lhs)
+@deftypefn {GIMPLE function} void gimple_omp_atomic_load_set_lhs (@
+gimple *g, tree lhs)
Set the @code{LHS} of an atomic load.
@end deftypefn
-@deftypefn {GIMPLE function} tree gimple_omp_atomic_load_lhs (gimple g)
+@deftypefn {GIMPLE function} tree gimple_omp_atomic_load_lhs (gimple *g)
Get the @code{LHS} of an atomic load.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_omp_atomic_load_set_rhs (gimple g, tree rhs)
+@deftypefn {GIMPLE function} void gimple_omp_atomic_load_set_rhs (@
+gimple *g, tree rhs)
Set the @code{RHS} of an atomic set.
@end deftypefn
-@deftypefn {GIMPLE function} tree gimple_omp_atomic_load_rhs (gimple g)
+@deftypefn {GIMPLE function} tree gimple_omp_atomic_load_rhs (gimple *g)
Get the @code{RHS} of an atomic set.
@end deftypefn
@@ -1682,16 +1755,18 @@ Get the @code{RHS} of an atomic set.
@subsection @code{GIMPLE_OMP_ATOMIC_STORE}
@cindex @code{GIMPLE_OMP_ATOMIC_STORE}
-@deftypefn {GIMPLE function} gimple gimple_build_omp_atomic_store (tree val)
+@deftypefn {GIMPLE function} gimple *gimple_build_omp_atomic_store (@
+tree val)
Build a @code{GIMPLE_OMP_ATOMIC_STORE} statement. @code{VAL} is the value to be
stored.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_omp_atomic_store_set_val (gimple g, tree val)
+@deftypefn {GIMPLE function} void gimple_omp_atomic_store_set_val (@
+gimple *g, tree val)
Set the value being stored in an atomic store.
@end deftypefn
-@deftypefn {GIMPLE function} tree gimple_omp_atomic_store_val (gimple g)
+@deftypefn {GIMPLE function} tree gimple_omp_atomic_store_val (gimple *g)
Return the value being stored in an atomic store.
@end deftypefn
@@ -1699,36 +1774,43 @@ Return the value being stored in an atomic store.
@subsection @code{GIMPLE_OMP_CONTINUE}
@cindex @code{GIMPLE_OMP_CONTINUE}
-@deftypefn {GIMPLE function} gimple gimple_build_omp_continue (tree control_def, tree control_use)
+@deftypefn {GIMPLE function} gimple *gimple_build_omp_continue (@
+tree control_def, tree control_use)
Build a @code{GIMPLE_OMP_CONTINUE} statement. @code{CONTROL_DEF} is the
definition of the control variable. @code{CONTROL_USE} is the use of
the control variable.
@end deftypefn
-@deftypefn {GIMPLE function} tree gimple_omp_continue_control_def (gimple s)
+@deftypefn {GIMPLE function} tree gimple_omp_continue_control_def (@
+gimple *s)
Return the definition of the control variable on a
@code{GIMPLE_OMP_CONTINUE} in @code{S}.
@end deftypefn
-@deftypefn {GIMPLE function} tree gimple_omp_continue_control_def_ptr (gimple s)
+@deftypefn {GIMPLE function} tree gimple_omp_continue_control_def_ptr (@
+gimple *s)
Same as above, but return the pointer.
@end deftypefn
-@deftypefn {GIMPLE function} tree gimple_omp_continue_set_control_def (gimple s)
+@deftypefn {GIMPLE function} tree gimple_omp_continue_set_control_def (@
+gimple *s)
Set the control variable definition for a @code{GIMPLE_OMP_CONTINUE}
statement in @code{S}.
@end deftypefn
-@deftypefn {GIMPLE function} tree gimple_omp_continue_control_use (gimple s)
+@deftypefn {GIMPLE function} tree gimple_omp_continue_control_use (@
+gimple *s)
Return the use of the control variable on a @code{GIMPLE_OMP_CONTINUE}
in @code{S}.
@end deftypefn
-@deftypefn {GIMPLE function} tree gimple_omp_continue_control_use_ptr (gimple s)
+@deftypefn {GIMPLE function} tree gimple_omp_continue_control_use_ptr (@
+gimple *s)
Same as above, but return the pointer.
@end deftypefn
-@deftypefn {GIMPLE function} tree gimple_omp_continue_set_control_use (gimple s)
+@deftypefn {GIMPLE function} tree gimple_omp_continue_set_control_use (@
+gimple *s)
Set the control variable use for a @code{GIMPLE_OMP_CONTINUE} statement
in @code{S}.
@end deftypefn
@@ -1738,22 +1820,25 @@ in @code{S}.
@subsection @code{GIMPLE_OMP_CRITICAL}
@cindex @code{GIMPLE_OMP_CRITICAL}
-@deftypefn {GIMPLE function} gimple gimple_build_omp_critical (gimple_seq body, tree name)
+@deftypefn {GIMPLE function} gimple *gimple_build_omp_critical (@
+gimple_seq body, tree name)
Build a @code{GIMPLE_OMP_CRITICAL} statement. @code{BODY} is the sequence of
statements for which only one thread can execute. @code{NAME} is an
optional identifier for this critical block.
@end deftypefn
-@deftypefn {GIMPLE function} tree gimple_omp_critical_name (gimple g)
+@deftypefn {GIMPLE function} tree gimple_omp_critical_name (gimple *g)
Return the name associated with @code{OMP_CRITICAL} statement @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} {tree *} gimple_omp_critical_name_ptr (gimple g)
+@deftypefn {GIMPLE function} {tree *} gimple_omp_critical_name_ptr (@
+gimple *g)
Return a pointer to the name associated with @code{OMP} critical
statement @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_omp_critical_set_name (gimple g, tree name)
+@deftypefn {GIMPLE function} void gimple_omp_critical_set_name (@
+gimple *g, tree name)
Set @code{NAME} to be the name associated with @code{OMP} critical statement @code{G}.
@end deftypefn
@@ -1761,7 +1846,8 @@ Set @code{NAME} to be the name associated with @code{OMP} critical statement @co
@subsection @code{GIMPLE_OMP_FOR}
@cindex @code{GIMPLE_OMP_FOR}
-@deftypefn {GIMPLE function} gimple gimple_build_omp_for (gimple_seq body, @
+@deftypefn {GIMPLE function} gimple *gimple_build_omp_for (@
+gimple_seq body, @
tree clauses, tree index, tree initial, tree final, tree incr, @
gimple_seq pre_body, enum tree_code omp_for_cond)
Build a @code{GIMPLE_OMP_FOR} statement. @code{BODY} is sequence of statements
@@ -1774,81 +1860,91 @@ final value of @code{INDEX}. OMP_FOR_COND is the predicate used to
compare @code{INDEX} and @code{FINAL}. @code{INCR} is the increment expression.
@end deftypefn
-@deftypefn {GIMPLE function} tree gimple_omp_for_clauses (gimple g)
+@deftypefn {GIMPLE function} tree gimple_omp_for_clauses (gimple *g)
Return the clauses associated with @code{OMP_FOR} @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} {tree *} gimple_omp_for_clauses_ptr (gimple g)
+@deftypefn {GIMPLE function} {tree *} gimple_omp_for_clauses_ptr (@
+gimple *g)
Return a pointer to the @code{OMP_FOR} @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_omp_for_set_clauses (gimple g, tree clauses)
+@deftypefn {GIMPLE function} void gimple_omp_for_set_clauses (@
+gimple *g, tree clauses)
Set @code{CLAUSES} to be the list of clauses associated with @code{OMP_FOR} @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} tree gimple_omp_for_index (gimple g)
+@deftypefn {GIMPLE function} tree gimple_omp_for_index (gimple *g)
Return the index variable for @code{OMP_FOR} @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} {tree *} gimple_omp_for_index_ptr (gimple g)
+@deftypefn {GIMPLE function} {tree *} gimple_omp_for_index_ptr (gimple *g)
Return a pointer to the index variable for @code{OMP_FOR} @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_omp_for_set_index (gimple g, tree index)
+@deftypefn {GIMPLE function} void gimple_omp_for_set_index (@
+gimple *g, tree index)
Set @code{INDEX} to be the index variable for @code{OMP_FOR} @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} tree gimple_omp_for_initial (gimple g)
+@deftypefn {GIMPLE function} tree gimple_omp_for_initial (gimple *g)
Return the initial value for @code{OMP_FOR} @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} {tree *} gimple_omp_for_initial_ptr (gimple g)
+@deftypefn {GIMPLE function} {tree *} gimple_omp_for_initial_ptr (@
+gimple *g)
Return a pointer to the initial value for @code{OMP_FOR} @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_omp_for_set_initial (gimple g, tree initial)
+@deftypefn {GIMPLE function} void gimple_omp_for_set_initial (gimple *g, @
+tree initial)
Set @code{INITIAL} to be the initial value for @code{OMP_FOR} @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} tree gimple_omp_for_final (gimple g)
+@deftypefn {GIMPLE function} tree gimple_omp_for_final (gimple *g)
Return the final value for @code{OMP_FOR} @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} {tree *} gimple_omp_for_final_ptr (gimple g)
+@deftypefn {GIMPLE function} {tree *} gimple_omp_for_final_ptr (gimple *g)
turn a pointer to the final value for @code{OMP_FOR} @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_omp_for_set_final (gimple g, tree final)
+@deftypefn {GIMPLE function} void gimple_omp_for_set_final (gimple *g, @
+tree final)
Set @code{FINAL} to be the final value for @code{OMP_FOR} @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} tree gimple_omp_for_incr (gimple g)
+@deftypefn {GIMPLE function} tree gimple_omp_for_incr (gimple *g)
Return the increment value for @code{OMP_FOR} @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} {tree *} gimple_omp_for_incr_ptr (gimple g)
+@deftypefn {GIMPLE function} {tree *} gimple_omp_for_incr_ptr (gimple *g)
Return a pointer to the increment value for @code{OMP_FOR} @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_omp_for_set_incr (gimple g, tree incr)
+@deftypefn {GIMPLE function} void gimple_omp_for_set_incr (gimple *g, @
+tree incr)
Set @code{INCR} to be the increment value for @code{OMP_FOR} @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} gimple_seq gimple_omp_for_pre_body (gimple g)
+@deftypefn {GIMPLE function} gimple_seq gimple_omp_for_pre_body (gimple *g)
Return the sequence of statements to execute before the @code{OMP_FOR}
statement @code{G} starts.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_omp_for_set_pre_body (gimple g, gimple_seq pre_body)
+@deftypefn {GIMPLE function} void gimple_omp_for_set_pre_body (gimple *g, @
+gimple_seq pre_body)
Set @code{PRE_BODY} to be the sequence of statements to execute before
the @code{OMP_FOR} statement @code{G} starts.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_omp_for_set_cond (gimple g, enum tree_code cond)
+@deftypefn {GIMPLE function} void gimple_omp_for_set_cond (gimple *g, @
+enum tree_code cond)
Set @code{COND} to be the condition code for @code{OMP_FOR} @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} {enum tree_code} gimple_omp_for_cond (gimple g)
+@deftypefn {GIMPLE function} {enum tree_code} gimple_omp_for_cond (@
+gimple *g)
Return the condition code associated with @code{OMP_FOR} @code{G}.
@end deftypefn
@@ -1857,7 +1953,8 @@ Return the condition code associated with @code{OMP_FOR} @code{G}.
@subsection @code{GIMPLE_OMP_MASTER}
@cindex @code{GIMPLE_OMP_MASTER}
-@deftypefn {GIMPLE function} gimple gimple_build_omp_master (gimple_seq body)
+@deftypefn {GIMPLE function} gimple *gimple_build_omp_master (@
+gimple_seq body)
Build a @code{GIMPLE_OMP_MASTER} statement. @code{BODY} is the sequence of
statements to be executed by just the master.
@end deftypefn
@@ -1867,7 +1964,8 @@ statements to be executed by just the master.
@subsection @code{GIMPLE_OMP_ORDERED}
@cindex @code{GIMPLE_OMP_ORDERED}
-@deftypefn {GIMPLE function} gimple gimple_build_omp_ordered (gimple_seq body)
+@deftypefn {GIMPLE function} gimple *gimple_build_omp_ordered (@
+gimple_seq body)
Build a @code{GIMPLE_OMP_ORDERED} statement.
@end deftypefn
@@ -1879,8 +1977,8 @@ executed in sequence.
@subsection @code{GIMPLE_OMP_PARALLEL}
@cindex @code{GIMPLE_OMP_PARALLEL}
-@deftypefn {GIMPLE function} gimple gimple_build_omp_parallel (gimple_seq @
-body, tree clauses, tree child_fn, tree data_arg)
+@deftypefn {GIMPLE function} gimple *gimple_build_omp_parallel (@
+gimple_seq body, tree clauses, tree child_fn, tree data_arg)
Build a @code{GIMPLE_OMP_PARALLEL} statement.
@end deftypefn
@@ -1889,61 +1987,70 @@ Build a @code{GIMPLE_OMP_PARALLEL} statement.
the function created for the parallel threads to execute.
@code{DATA_ARG} are the shared data argument(s).
-@deftypefn {GIMPLE function} bool gimple_omp_parallel_combined_p (gimple g)
+@deftypefn {GIMPLE function} bool gimple_omp_parallel_combined_p (@
+gimple *g)
Return true if @code{OMP} parallel statement @code{G} has the
@code{GF_OMP_PARALLEL_COMBINED} flag set.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_omp_parallel_set_combined_p (gimple g)
+@deftypefn {GIMPLE function} void gimple_omp_parallel_set_combined_p (@
+gimple *g)
Set the @code{GF_OMP_PARALLEL_COMBINED} field in @code{OMP} parallel statement
@code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} gimple_seq gimple_omp_body (gimple g)
+@deftypefn {GIMPLE function} gimple_seq gimple_omp_body (gimple *g)
Return the body for the @code{OMP} statement @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_omp_set_body (gimple g, gimple_seq body)
+@deftypefn {GIMPLE function} void gimple_omp_set_body (gimple *g, @
+gimple_seq body)
Set @code{BODY} to be the body for the @code{OMP} statement @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} tree gimple_omp_parallel_clauses (gimple g)
+@deftypefn {GIMPLE function} tree gimple_omp_parallel_clauses (gimple *g)
Return the clauses associated with @code{OMP_PARALLEL} @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} {tree *} gimple_omp_parallel_clauses_ptr (gimple g)
+@deftypefn {GIMPLE function} {tree *} gimple_omp_parallel_clauses_ptr (@
+gimple *g)
Return a pointer to the clauses associated with @code{OMP_PARALLEL} @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_omp_parallel_set_clauses (gimple g, tree clauses)
+@deftypefn {GIMPLE function} void gimple_omp_parallel_set_clauses (@
+gimple *g, tree clauses)
Set @code{CLAUSES} to be the list of clauses associated with
@code{OMP_PARALLEL} @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} tree gimple_omp_parallel_child_fn (gimple g)
+@deftypefn {GIMPLE function} tree gimple_omp_parallel_child_fn (gimple *g)
Return the child function used to hold the body of @code{OMP_PARALLEL}
@code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} {tree *} gimple_omp_parallel_child_fn_ptr (gimple g)
+@deftypefn {GIMPLE function} {tree *} gimple_omp_parallel_child_fn_ptr (@
+gimple *g)
Return a pointer to the child function used to hold the body of
@code{OMP_PARALLEL} @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_omp_parallel_set_child_fn (gimple g, tree child_fn)
+@deftypefn {GIMPLE function} void gimple_omp_parallel_set_child_fn (@
+gimple *g, tree child_fn)
Set @code{CHILD_FN} to be the child function for @code{OMP_PARALLEL} @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} tree gimple_omp_parallel_data_arg (gimple g)
+@deftypefn {GIMPLE function} tree gimple_omp_parallel_data_arg (gimple *g)
Return the artificial argument used to send variables and values
from the parent to the children threads in @code{OMP_PARALLEL} @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} {tree *} gimple_omp_parallel_data_arg_ptr (gimple g)
+@deftypefn {GIMPLE function} {tree *} gimple_omp_parallel_data_arg_ptr (@
+gimple *g)
Return a pointer to the data argument for @code{OMP_PARALLEL} @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_omp_parallel_set_data_arg (gimple g, tree data_arg)
+@deftypefn {GIMPLE function} void gimple_omp_parallel_set_data_arg (@
+gimple *g, tree data_arg)
Set @code{DATA_ARG} to be the data argument for @code{OMP_PARALLEL} @code{G}.
@end deftypefn
@@ -1952,17 +2059,17 @@ Set @code{DATA_ARG} to be the data argument for @code{OMP_PARALLEL} @code{G}.
@subsection @code{GIMPLE_OMP_RETURN}
@cindex @code{GIMPLE_OMP_RETURN}
-@deftypefn {GIMPLE function} gimple gimple_build_omp_return (bool wait_p)
+@deftypefn {GIMPLE function} gimple *gimple_build_omp_return (bool wait_p)
Build a @code{GIMPLE_OMP_RETURN} statement. @code{WAIT_P} is true if this is a
non-waiting return.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_omp_return_set_nowait (gimple s)
+@deftypefn {GIMPLE function} void gimple_omp_return_set_nowait (gimple *s)
Set the nowait flag on @code{GIMPLE_OMP_RETURN} statement @code{S}.
@end deftypefn
-@deftypefn {GIMPLE function} bool gimple_omp_return_nowait_p (gimple g)
+@deftypefn {GIMPLE function} bool gimple_omp_return_nowait_p (gimple *g)
Return true if @code{OMP} return statement @code{G} has the
@code{GF_OMP_RETURN_NOWAIT} flag set.
@end deftypefn
@@ -1971,18 +2078,19 @@ Return true if @code{OMP} return statement @code{G} has the
@subsection @code{GIMPLE_OMP_SECTION}
@cindex @code{GIMPLE_OMP_SECTION}
-@deftypefn {GIMPLE function} gimple gimple_build_omp_section (gimple_seq body)
+@deftypefn {GIMPLE function} gimple *gimple_build_omp_section (@
+gimple_seq body)
Build a @code{GIMPLE_OMP_SECTION} statement for a sections statement.
@end deftypefn
@code{BODY} is the sequence of statements in the section.
-@deftypefn {GIMPLE function} bool gimple_omp_section_last_p (gimple g)
+@deftypefn {GIMPLE function} bool gimple_omp_section_last_p (gimple *g)
Return true if @code{OMP} section statement @code{G} has the
@code{GF_OMP_SECTION_LAST} flag set.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_omp_section_set_last (gimple g)
+@deftypefn {GIMPLE function} void gimple_omp_section_set_last (gimple *g)
Set the @code{GF_OMP_SECTION_LAST} flag on @code{G}.
@end deftypefn
@@ -1990,7 +2098,8 @@ Set the @code{GF_OMP_SECTION_LAST} flag on @code{G}.
@subsection @code{GIMPLE_OMP_SECTIONS}
@cindex @code{GIMPLE_OMP_SECTIONS}
-@deftypefn {GIMPLE function} gimple gimple_build_omp_sections (gimple_seq body, tree clauses)
+@deftypefn {GIMPLE function} gimple *gimple_build_omp_sections (@
+gimple_seq body, tree clauses)
Build a @code{GIMPLE_OMP_SECTIONS} statement. @code{BODY} is a sequence of
section statements. @code{CLAUSES} are any of the @code{OMP} sections
construct's clauses: private, firstprivate, lastprivate,
@@ -1998,34 +2107,39 @@ reduction, and nowait.
@end deftypefn
-@deftypefn {GIMPLE function} gimple gimple_build_omp_sections_switch (void)
+@deftypefn {GIMPLE function} gimple *gimple_build_omp_sections_switch (@
+void)
Build a @code{GIMPLE_OMP_SECTIONS_SWITCH} statement.
@end deftypefn
-@deftypefn {GIMPLE function} tree gimple_omp_sections_control (gimple g)
+@deftypefn {GIMPLE function} tree gimple_omp_sections_control (gimple *g)
Return the control variable associated with the
@code{GIMPLE_OMP_SECTIONS} in @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} {tree *} gimple_omp_sections_control_ptr (gimple g)
+@deftypefn {GIMPLE function} {tree *} gimple_omp_sections_control_ptr (@
+gimple *g)
Return a pointer to the clauses associated with the
@code{GIMPLE_OMP_SECTIONS} in @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_omp_sections_set_control (gimple g, tree control)
+@deftypefn {GIMPLE function} void gimple_omp_sections_set_control (@
+gimple *g, tree control)
Set @code{CONTROL} to be the set of clauses associated with the
@code{GIMPLE_OMP_SECTIONS} in @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} tree gimple_omp_sections_clauses (gimple g)
+@deftypefn {GIMPLE function} tree gimple_omp_sections_clauses (gimple *g)
Return the clauses associated with @code{OMP_SECTIONS} @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} {tree *} gimple_omp_sections_clauses_ptr (gimple g)
+@deftypefn {GIMPLE function} {tree *} gimple_omp_sections_clauses_ptr (@
+gimple *g)
Return a pointer to the clauses associated with @code{OMP_SECTIONS} @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_omp_sections_set_clauses (gimple g, tree clauses)
+@deftypefn {GIMPLE function} void gimple_omp_sections_set_clauses (@
+gimple *g, tree clauses)
Set @code{CLAUSES} to be the set of clauses associated with @code{OMP_SECTIONS}
@code{G}.
@end deftypefn
@@ -2035,22 +2149,25 @@ Set @code{CLAUSES} to be the set of clauses associated with @code{OMP_SECTIONS}
@subsection @code{GIMPLE_OMP_SINGLE}
@cindex @code{GIMPLE_OMP_SINGLE}
-@deftypefn {GIMPLE function} gimple gimple_build_omp_single (gimple_seq body, tree clauses)
+@deftypefn {GIMPLE function} gimple *gimple_build_omp_single (@
+gimple_seq body, tree clauses)
Build a @code{GIMPLE_OMP_SINGLE} statement. @code{BODY} is the sequence of
statements that will be executed once. @code{CLAUSES} are any of the
@code{OMP} single construct's clauses: private, firstprivate,
copyprivate, nowait.
@end deftypefn
-@deftypefn {GIMPLE function} tree gimple_omp_single_clauses (gimple g)
+@deftypefn {GIMPLE function} tree gimple_omp_single_clauses (gimple *g)
Return the clauses associated with @code{OMP_SINGLE} @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} {tree *} gimple_omp_single_clauses_ptr (gimple g)
+@deftypefn {GIMPLE function} {tree *} gimple_omp_single_clauses_ptr (@
+gimple *g)
Return a pointer to the clauses associated with @code{OMP_SINGLE} @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_omp_single_set_clauses (gimple g, tree clauses)
+@deftypefn {GIMPLE function} void gimple_omp_single_set_clauses (@
+gimple *g, tree clauses)
Set @code{CLAUSES} to be the clauses associated with @code{OMP_SINGLE} @code{G}.
@end deftypefn
@@ -2059,34 +2176,37 @@ Set @code{CLAUSES} to be the clauses associated with @code{OMP_SINGLE} @code{G}.
@subsection @code{GIMPLE_PHI}
@cindex @code{GIMPLE_PHI}
-@deftypefn {GIMPLE function} unsigned gimple_phi_capacity (gimple g)
+@deftypefn {GIMPLE function} unsigned gimple_phi_capacity (gimple *g)
Return the maximum number of arguments supported by @code{GIMPLE_PHI} @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} unsigned gimple_phi_num_args (gimple g)
+@deftypefn {GIMPLE function} unsigned gimple_phi_num_args (gimple *g)
Return the number of arguments in @code{GIMPLE_PHI} @code{G}. This must always
be exactly the number of incoming edges for the basic block
holding @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} tree gimple_phi_result (gimple g)
+@deftypefn {GIMPLE function} tree gimple_phi_result (gimple *g)
Return the @code{SSA} name created by @code{GIMPLE_PHI} @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} {tree *} gimple_phi_result_ptr (gimple g)
+@deftypefn {GIMPLE function} {tree *} gimple_phi_result_ptr (gimple *g)
Return a pointer to the @code{SSA} name created by @code{GIMPLE_PHI} @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_phi_set_result (gimple g, tree result)
+@deftypefn {GIMPLE function} void gimple_phi_set_result (gimple *g, @
+tree result)
Set @code{RESULT} to be the @code{SSA} name created by @code{GIMPLE_PHI} @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} {struct phi_arg_d *} gimple_phi_arg (gimple g, index)
+@deftypefn {GIMPLE function} {struct phi_arg_d *} gimple_phi_arg (@
+gimple *g, index)
Return the @code{PHI} argument corresponding to incoming edge @code{INDEX} for
@code{GIMPLE_PHI} @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_phi_set_arg (gimple g, index, struct phi_arg_d * phiarg)
+@deftypefn {GIMPLE function} void gimple_phi_set_arg (gimple *g, @
+index, struct phi_arg_d * phiarg)
Set @code{PHIARG} to be the argument corresponding to incoming edge
@code{INDEX} for @code{GIMPLE_PHI} @code{G}.
@end deftypefn
@@ -2095,18 +2215,19 @@ Set @code{PHIARG} to be the argument corresponding to incoming edge
@subsection @code{GIMPLE_RESX}
@cindex @code{GIMPLE_RESX}
-@deftypefn {GIMPLE function} gimple gimple_build_resx (int region)
+@deftypefn {GIMPLE function} gimple *gimple_build_resx (int region)
Build a @code{GIMPLE_RESX} statement which is a statement. This
statement is a placeholder for _Unwind_Resume before we know if a
function call or a branch is needed. @code{REGION} is the exception
region from which control is flowing.
@end deftypefn
-@deftypefn {GIMPLE function} int gimple_resx_region (gimple g)
+@deftypefn {GIMPLE function} int gimple_resx_region (gimple *g)
Return the region number for @code{GIMPLE_RESX} @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_resx_set_region (gimple g, int region)
+@deftypefn {GIMPLE function} void gimple_resx_set_region (gimple *g, @
+int region)
Set @code{REGION} to be the region number for @code{GIMPLE_RESX} @code{G}.
@end deftypefn
@@ -2114,15 +2235,16 @@ Set @code{REGION} to be the region number for @code{GIMPLE_RESX} @code{G}.
@subsection @code{GIMPLE_RETURN}
@cindex @code{GIMPLE_RETURN}
-@deftypefn {GIMPLE function} gimple gimple_build_return (tree retval)
+@deftypefn {GIMPLE function} gimple *gimple_build_return (tree retval)
Build a @code{GIMPLE_RETURN} statement whose return value is retval.
@end deftypefn
-@deftypefn {GIMPLE function} tree gimple_return_retval (gimple g)
+@deftypefn {GIMPLE function} tree gimple_return_retval (gimple *g)
Return the return value for @code{GIMPLE_RETURN} @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_return_set_retval (gimple g, tree retval)
+@deftypefn {GIMPLE function} void gimple_return_set_retval (gimple *g, @
+tree retval)
Set @code{RETVAL} to be the return value for @code{GIMPLE_RETURN} @code{G}.
@end deftypefn
@@ -2130,50 +2252,52 @@ Set @code{RETVAL} to be the return value for @code{GIMPLE_RETURN} @code{G}.
@subsection @code{GIMPLE_SWITCH}
@cindex @code{GIMPLE_SWITCH}
-@deftypefn {GIMPLE function} gimple gimple_build_switch (tree index, tree @
-default_label, @code{VEC}(tree,heap) *args)
+@deftypefn {GIMPLE function} gimple *gimple_build_switch (tree index, @
+tree default_label, @code{VEC}(tree,heap) *args)
Build a @code{GIMPLE_SWITCH} statement. @code{INDEX} is the index variable
to switch on, and @code{DEFAULT_LABEL} represents the default label.
@code{ARGS} is a vector of @code{CASE_LABEL_EXPR} trees that contain the
non-default case labels. Each label is a tree of code @code{CASE_LABEL_EXPR}.
@end deftypefn
-@deftypefn {GIMPLE function} unsigned gimple_switch_num_labels (gimple g)
+@deftypefn {GIMPLE function} unsigned gimple_switch_num_labels (gimple *g)
Return the number of labels associated with the switch statement
@code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_switch_set_num_labels (gimple g, @
-unsigned nlabels)
+@deftypefn {GIMPLE function} void gimple_switch_set_num_labels (@
+gimple *g, unsigned nlabels)
Set @code{NLABELS} to be the number of labels for the switch statement
@code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} tree gimple_switch_index (gimple g)
+@deftypefn {GIMPLE function} tree gimple_switch_index (gimple *g)
Return the index variable used by the switch statement @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_switch_set_index (gimple g, tree index)
+@deftypefn {GIMPLE function} void gimple_switch_set_index (gimple *g, @
+tree index)
Set @code{INDEX} to be the index variable for switch statement @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} tree gimple_switch_label (gimple g, unsigned index)
+@deftypefn {GIMPLE function} tree gimple_switch_label (gimple *g, @
+unsigned index)
Return the label numbered @code{INDEX}. The default label is 0, followed
by any labels in a switch statement.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_switch_set_label (gimple g, unsigned @
-index, tree label)
+@deftypefn {GIMPLE function} void gimple_switch_set_label (gimple *g, @
+unsigned index, tree label)
Set the label number @code{INDEX} to @code{LABEL}. 0 is always the default
label.
@end deftypefn
-@deftypefn {GIMPLE function} tree gimple_switch_default_label (gimple g)
+@deftypefn {GIMPLE function} tree gimple_switch_default_label (gimple *g)
Return the default label for a switch statement.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_switch_set_default_label (gimple g, @
-tree label)
+@deftypefn {GIMPLE function} void gimple_switch_set_default_label (@
+gimple *g, tree label)
Set the default label for a switch statement.
@end deftypefn
@@ -2182,7 +2306,7 @@ Set the default label for a switch statement.
@subsection @code{GIMPLE_TRY}
@cindex @code{GIMPLE_TRY}
-@deftypefn {GIMPLE function} gimple gimple_build_try (gimple_seq eval, @
+@deftypefn {GIMPLE function} gimple *gimple_build_try (gimple_seq eval, @
gimple_seq cleanup, unsigned int kind)
Build a @code{GIMPLE_TRY} statement. @code{EVAL} is a sequence with the
expression to evaluate. @code{CLEANUP} is a sequence of statements to
@@ -2192,36 +2316,39 @@ or @code{GIMPLE_TRY_FINALLY} if this statement denotes a try/finally
construct.
@end deftypefn
-@deftypefn {GIMPLE function} {enum gimple_try_flags} gimple_try_kind (gimple g)
+@deftypefn {GIMPLE function} {enum gimple_try_flags} gimple_try_kind (@
+gimple *g)
Return the kind of try block represented by @code{GIMPLE_TRY} @code{G}. This is
either @code{GIMPLE_TRY_CATCH} or @code{GIMPLE_TRY_FINALLY}.
@end deftypefn
-@deftypefn {GIMPLE function} bool gimple_try_catch_is_cleanup (gimple g)
+@deftypefn {GIMPLE function} bool gimple_try_catch_is_cleanup (gimple *g)
Return the @code{GIMPLE_TRY_CATCH_IS_CLEANUP} flag.
@end deftypefn
-@deftypefn {GIMPLE function} gimple_seq gimple_try_eval (gimple g)
+@deftypefn {GIMPLE function} gimple_seq gimple_try_eval (gimple *g)
Return the sequence of statements used as the body for @code{GIMPLE_TRY}
@code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} gimple_seq gimple_try_cleanup (gimple g)
+@deftypefn {GIMPLE function} gimple_seq gimple_try_cleanup (gimple *g)
Return the sequence of statements used as the cleanup body for
@code{GIMPLE_TRY} @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_try_set_catch_is_cleanup (gimple g, @
-bool catch_is_cleanup)
+@deftypefn {GIMPLE function} void gimple_try_set_catch_is_cleanup (@
+gimple *g, bool catch_is_cleanup)
Set the @code{GIMPLE_TRY_CATCH_IS_CLEANUP} flag.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_try_set_eval (gimple g, gimple_seq eval)
+@deftypefn {GIMPLE function} void gimple_try_set_eval (gimple *g, @
+gimple_seq eval)
Set @code{EVAL} to be the sequence of statements to use as the body for
@code{GIMPLE_TRY} @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_try_set_cleanup (gimple g, gimple_seq cleanup)
+@deftypefn {GIMPLE function} void gimple_try_set_cleanup (gimple *g, @
+gimple_seq cleanup)
Set @code{CLEANUP} to be the sequence of statements to use as the
cleanup body for @code{GIMPLE_TRY} @code{G}.
@end deftypefn
@@ -2230,24 +2357,26 @@ cleanup body for @code{GIMPLE_TRY} @code{G}.
@subsection @code{GIMPLE_WITH_CLEANUP_EXPR}
@cindex @code{GIMPLE_WITH_CLEANUP_EXPR}
-@deftypefn {GIMPLE function} gimple gimple_build_wce (gimple_seq cleanup)
+@deftypefn {GIMPLE function} gimple *gimple_build_wce (gimple_seq cleanup)
Build a @code{GIMPLE_WITH_CLEANUP_EXPR} statement. @code{CLEANUP} is the
clean-up expression.
@end deftypefn
-@deftypefn {GIMPLE function} gimple_seq gimple_wce_cleanup (gimple g)
+@deftypefn {GIMPLE function} gimple_seq gimple_wce_cleanup (gimple *g)
Return the cleanup sequence for cleanup statement @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_wce_set_cleanup (gimple g, gimple_seq cleanup)
+@deftypefn {GIMPLE function} void gimple_wce_set_cleanup (gimple *g, @
+gimple_seq cleanup)
Set @code{CLEANUP} to be the cleanup sequence for @code{G}.
@end deftypefn
-@deftypefn {GIMPLE function} bool gimple_wce_cleanup_eh_only (gimple g)
+@deftypefn {GIMPLE function} bool gimple_wce_cleanup_eh_only (gimple *g)
Return the @code{CLEANUP_EH_ONLY} flag for a @code{WCE} tuple.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_wce_set_cleanup_eh_only (gimple g, bool eh_only_p)
+@deftypefn {GIMPLE function} void gimple_wce_set_cleanup_eh_only (@
+gimple *g, bool eh_only_p)
Set the @code{CLEANUP_EH_ONLY} flag for a @code{WCE} tuple.
@end deftypefn
@@ -2274,7 +2403,8 @@ in the section entitled Sequence Iterators.
Below is a list of functions to manipulate and query sequences.
-@deftypefn {GIMPLE function} void gimple_seq_add_stmt (gimple_seq *seq, gimple g)
+@deftypefn {GIMPLE function} void gimple_seq_add_stmt (gimple_seq *seq, @
+gimple *g)
Link a gimple statement to the end of the sequence *@code{SEQ} if @code{G} is
not @code{NULL}. If *@code{SEQ} is @code{NULL}, allocate a sequence before linking.
@end deftypefn
@@ -2294,19 +2424,21 @@ Reverse the order of the statements in the sequence @code{SEQ}. Return
@code{SEQ}.
@end deftypefn
-@deftypefn {GIMPLE function} gimple gimple_seq_first (gimple_seq s)
+@deftypefn {GIMPLE function} gimple *gimple_seq_first (gimple_seq s)
Return the first statement in sequence @code{S}.
@end deftypefn
-@deftypefn {GIMPLE function} gimple gimple_seq_last (gimple_seq s)
+@deftypefn {GIMPLE function} gimple *gimple_seq_last (gimple_seq s)
Return the last statement in sequence @code{S}.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_seq_set_last (gimple_seq s, gimple last)
+@deftypefn {GIMPLE function} void gimple_seq_set_last (gimple_seq s, @
+gimple *last)
Set the last statement in sequence @code{S} to the statement in @code{LAST}.
@end deftypefn
-@deftypefn {GIMPLE function} void gimple_seq_set_first (gimple_seq s, gimple first)
+@deftypefn {GIMPLE function} void gimple_seq_set_first (gimple_seq s, @
+gimple *first)
Set the first statement in sequence @code{S} to the statement in @code{FIRST}.
@end deftypefn
@@ -2352,7 +2484,7 @@ gimple_stmt_iterator gsi;
for (gsi = gsi_start (seq); !gsi_end_p (gsi); gsi_next (&gsi))
@{
- gimple g = gsi_stmt (gsi);
+ gimple *g = gsi_stmt (gsi);
/* Do something with gimple statement @code{G}. */
@}
@end smallexample
@@ -2424,7 +2556,7 @@ Advance the iterator to the next gimple statement.
Advance the iterator to the previous gimple statement.
@end deftypefn
-@deftypefn {GIMPLE function} gimple gsi_stmt (gimple_stmt_iterator i)
+@deftypefn {GIMPLE function} gimple *gsi_stmt (gimple_stmt_iterator i)
Return the current stmt.
@end deftypefn
@@ -2433,7 +2565,8 @@ Return a block statement iterator that points to the first
non-label statement in block @code{BB}.
@end deftypefn
-@deftypefn {GIMPLE function} {gimple *} gsi_stmt_ptr (gimple_stmt_iterator *i)
+@deftypefn {GIMPLE function} {gimple **} gsi_stmt_ptr (@
+gimple_stmt_iterator *i)
Return a pointer to the current stmt.
@end deftypefn
@@ -2460,7 +2593,8 @@ by iterator @code{I}. @code{MODE} indicates what to do with the iterator
after insertion (see @code{enum gsi_iterator_update} above).
@end deftypefn
-@deftypefn {GIMPLE function} void gsi_link_before (gimple_stmt_iterator *i, gimple g, enum gsi_iterator_update mode)
+@deftypefn {GIMPLE function} void gsi_link_before (gimple_stmt_iterator *i, @
+gimple *g, enum gsi_iterator_update mode)
Links statement @code{G} before the statement pointed-to by iterator @code{I}.
Updates iterator @code{I} according to @code{MODE}.
@end deftypefn
@@ -2472,7 +2606,7 @@ Links sequence @code{SEQ} after the statement pointed-to by iterator @code{I}.
@end deftypefn
@deftypefn {GIMPLE function} void gsi_link_after (gimple_stmt_iterator *i, @
-gimple g, enum gsi_iterator_update mode)
+gimple *g, enum gsi_iterator_update mode)
Links statement @code{G} after the statement pointed-to by iterator @code{I}.
@code{MODE} is as in @code{gsi_insert_after}.
@end deftypefn
@@ -2488,14 +2622,14 @@ Return this new sequence.
@end deftypefn
@deftypefn {GIMPLE function} void gsi_replace (gimple_stmt_iterator *i, @
-gimple stmt, bool update_eh_info)
+gimple *stmt, bool update_eh_info)
Replace the statement pointed-to by @code{I} to @code{STMT}. If @code{UPDATE_EH_INFO}
is true, the exception handling information of the original
statement is moved to the new statement.
@end deftypefn
@deftypefn {GIMPLE function} void gsi_insert_before (gimple_stmt_iterator *i, @
-gimple stmt, enum gsi_iterator_update mode)
+gimple *stmt, enum gsi_iterator_update mode)
Insert statement @code{STMT} before the statement pointed-to by iterator
@code{I}, update @code{STMT}'s basic block and scan it for new operands. @code{MODE}
specifies how to update iterator @code{I} after insertion (see enum
@@ -2508,7 +2642,7 @@ Like @code{gsi_insert_before}, but for all the statements in @code{SEQ}.
@end deftypefn
@deftypefn {GIMPLE function} void gsi_insert_after (gimple_stmt_iterator *i, @
-gimple stmt, enum gsi_iterator_update mode)
+gimple *stmt, enum gsi_iterator_update mode)
Insert statement @code{STMT} after the statement pointed-to by iterator
@code{I}, update @code{STMT}'s basic block and scan it for new operands. @code{MODE}
specifies how to update iterator @code{I} after insertion (see enum
@@ -2520,7 +2654,8 @@ gimple_seq seq, enum gsi_iterator_update mode)
Like @code{gsi_insert_after}, but for all the statements in @code{SEQ}.
@end deftypefn
-@deftypefn {GIMPLE function} gimple_stmt_iterator gsi_for_stmt (gimple stmt)
+@deftypefn {GIMPLE function} gimple_stmt_iterator gsi_for_stmt (@
+gimple *stmt)
Finds iterator for @code{STMT}.
@end deftypefn
@@ -2541,7 +2676,7 @@ basic_block bb)
Move the statement at @code{FROM} to the end of basic block @code{BB}.
@end deftypefn
-@deftypefn {GIMPLE function} void gsi_insert_on_edge (edge e, gimple stmt)
+@deftypefn {GIMPLE function} void gsi_insert_on_edge (edge e, gimple *stmt)
Add @code{STMT} to the pending list of edge @code{E}. No actual insertion is
made until a call to @code{gsi_commit_edge_inserts}() is made.
@end deftypefn
@@ -2552,7 +2687,8 @@ Add the sequence of statements in @code{SEQ} to the pending list of edge
@code{gsi_commit_edge_inserts}() is made.
@end deftypefn
-@deftypefn {GIMPLE function} basic_block gsi_insert_on_edge_immediate (edge e, gimple stmt)
+@deftypefn {GIMPLE function} basic_block gsi_insert_on_edge_immediate (@
+edge e, gimple *stmt)
Similar to @code{gsi_insert_on_edge}+@code{gsi_commit_edge_inserts}. If a new
block has to be created, it is returned.
@end deftypefn
@@ -2626,7 +2762,7 @@ The return value is that returned by the last call to
@end deftypefn
-@deftypefn {GIMPLE function} tree walk_gimple_op (gimple stmt, @
+@deftypefn {GIMPLE function} tree walk_gimple_op (gimple *stmt, @
walk_tree_fn callback_op, struct walk_stmt_info *wi)
Use this function to walk the operands of statement @code{STMT}. Every
operand is walked via @code{walk_tree} with optional state information
@@ -454,7 +454,7 @@ def build_pretty_printer():
'tree', TreePrinter)
pp.add_printer_for_types(['cgraph_node *'],
'cgraph_node', CGraphNodePrinter)
- pp.add_printer_for_types(['gimple', 'gimple_statement_base *'],
+ pp.add_printer_for_types(['gimple *'],
'gimple',
GimplePrinter)
pp.add_printer_for_types(['basic_block', 'basic_block_def *'],
@@ -270,10 +270,10 @@ ggc_alloc_cleared_tree_node_stat (size_t s MEM_STAT_DECL)
return (union tree_node *) ggc_internal_cleared_alloc_stat (s PASS_MEM_STAT);
}
-static inline struct gimple_statement_base *
-ggc_alloc_cleared_gimple_statement_stat (size_t s MEM_STAT_DECL)
+static inline gimple
+ggc_alloc_cleared_gimple_stat (size_t s MEM_STAT_DECL)
{
- return (struct gimple_statement_base *)
+ return (gimple)
ggc_internal_cleared_alloc_stat (s PASS_MEM_STAT);
}
@@ -94,13 +94,13 @@ print_gimple_stmt (FILE *file, gimple g, int spc, int flags)
}
DEBUG_FUNCTION void
-debug (gimple_statement_base &ref)
+debug (gimple &ref)
{
print_gimple_stmt (stderr, &ref, 0, 0);
}
DEBUG_FUNCTION void
-debug (gimple_statement_base *ptr)
+debug (gimple *ptr)
{
if (ptr)
debug (*ptr);
@@ -29,8 +29,8 @@ extern void debug_gimple_stmt (gimple);
extern void debug_gimple_seq (gimple_seq);
extern void print_gimple_seq (FILE *, gimple_seq, int, int);
extern void print_gimple_stmt (FILE *, gimple, int, int);
-extern void debug (gimple_statement_base &ref);
-extern void debug (gimple_statement_base *ptr);
+extern void debug (gimple &ref);
+extern void debug (gimple *ptr);
extern void print_gimple_expr (FILE *, gimple, int, int);
extern void pp_gimple_stmt_1 (pretty_printer *, gimple, int, int);
extern void gimple_dump_bb (FILE *, basic_block, int, int);
@@ -108,8 +108,8 @@ static inline use_operand_p
gimple_vuse_op (const_gimple g)
{
struct use_optype_d *ops;
- const gimple_statement_with_memory_ops *mem_ops_stmt =
- dyn_cast <const gimple_statement_with_memory_ops *> (g);
+ const gimple_with_memory_ops *mem_ops_stmt =
+ dyn_cast <const gimple_with_memory_ops *> (g);
if (!mem_ops_stmt)
return NULL_USE_OPERAND_P;
ops = mem_ops_stmt->use_ops;
@@ -124,8 +124,8 @@ gimple_vuse_op (const_gimple g)
static inline def_operand_p
gimple_vdef_op (gimple g)
{
- gimple_statement_with_memory_ops *mem_ops_stmt =
- dyn_cast <gimple_statement_with_memory_ops *> (g);
+ gimple_with_memory_ops *mem_ops_stmt =
+ dyn_cast <gimple_with_memory_ops *> (g);
if (!mem_ops_stmt)
return NULL_DEF_OPERAND_P;
if (mem_ops_stmt->vdef)
@@ -137,7 +137,7 @@ input_gimple_stmt (struct lto_input_block *ib, struct data_in *data_in,
case GIMPLE_ASM:
{
/* FIXME lto. Move most of this into a new gimple_asm_set_string(). */
- gimple_statement_asm *asm_stmt = as_a <gimple_statement_asm *> (stmt);
+ gasm *asm_stmt = as_a <gasm *> (stmt);
tree str;
asm_stmt->ni = streamer_read_uhwi (ib);
asm_stmt->no = streamer_read_uhwi (ib);
@@ -132,7 +132,7 @@ gimple_alloc_stat (enum gimple_code code, unsigned num_ops MEM_STAT_DECL)
gimple_alloc_sizes[(int) kind] += size;
}
- stmt = ggc_alloc_cleared_gimple_statement_stat (size PASS_MEM_STAT);
+ stmt = ggc_alloc_cleared_gimple_stat (size PASS_MEM_STAT);
gimple_set_code (stmt, code);
gimple_set_num_ops (stmt, num_ops);
@@ -537,14 +537,14 @@ static inline gimple
gimple_build_asm_1 (const char *string, unsigned ninputs, unsigned noutputs,
unsigned nclobbers, unsigned nlabels)
{
- gimple_statement_asm *p;
+ gasm *p;
int size = strlen (string);
/* ASMs with labels cannot have outputs. This should have been
enforced by the front end. */
gcc_assert (nlabels == 0 || noutputs == 0);
- p = as_a <gimple_statement_asm *> (
+ p = as_a <gasm *> (
gimple_build_with_ops (GIMPLE_ASM, ERROR_MARK,
ninputs + noutputs + nclobbers + nlabels));
@@ -664,14 +664,14 @@ gimple_build_eh_else (gimple_seq n_body, gimple_seq e_body)
KIND is either GIMPLE_TRY_CATCH or GIMPLE_TRY_FINALLY depending on
whether this is a try/catch or a try/finally respectively. */
-gimple_statement_try *
+gtry *
gimple_build_try (gimple_seq eval, gimple_seq cleanup,
enum gimple_try_flags kind)
{
- gimple_statement_try *p;
+ gtry *p;
gcc_assert (kind == GIMPLE_TRY_CATCH || kind == GIMPLE_TRY_FINALLY);
- p = as_a <gimple_statement_try *> (gimple_alloc (GIMPLE_TRY, 0));
+ p = as_a <gtry *> (gimple_alloc (GIMPLE_TRY, 0));
gimple_set_subcode (p, kind);
if (eval)
gimple_try_set_eval (p, eval);
@@ -701,8 +701,8 @@ gimple_build_wce (gimple_seq cleanup)
gimple
gimple_build_resx (int region)
{
- gimple_statement_resx *p =
- as_a <gimple_statement_resx *> (
+ gresx *p =
+ as_a <gresx *> (
gimple_build_with_ops (GIMPLE_RESX, ERROR_MARK, 0));
p->region = region;
return p;
@@ -751,8 +751,8 @@ gimple_build_switch (tree index, tree default_label, vec<tree> args)
gimple
gimple_build_eh_dispatch (int region)
{
- gimple_statement_eh_dispatch *p =
- as_a <gimple_statement_eh_dispatch *> (
+ geh_dispatch *p =
+ as_a <geh_dispatch *> (
gimple_build_with_ops (GIMPLE_EH_DISPATCH, ERROR_MARK, 0));
p->region = region;
return p;
@@ -828,8 +828,7 @@ gimple
gimple_build_omp_for (gimple_seq body, int kind, tree clauses, size_t collapse,
gimple_seq pre_body)
{
- gimple_statement_omp_for *p =
- as_a <gimple_statement_omp_for *> (gimple_alloc (GIMPLE_OMP_FOR, 0));
+ gomp_for *p = as_a <gomp_for *> (gimple_alloc (GIMPLE_OMP_FOR, 0));
if (body)
gimple_omp_set_body (p, body);
gimple_omp_for_set_clauses (p, clauses);
@@ -1663,8 +1662,7 @@ gimple_copy (gimple stmt)
t = unshare_expr (gimple_omp_for_clauses (stmt));
gimple_omp_for_set_clauses (copy, t);
{
- gimple_statement_omp_for *omp_for_copy =
- as_a <gimple_statement_omp_for *> (copy);
+ gomp_for *omp_for_copy = as_a <gomp_for *> (copy);
omp_for_copy->iter =
static_cast <struct gimple_omp_for_iter *> (
ggc_internal_vec_alloc_stat (sizeof (struct gimple_omp_for_iter),
@@ -70,7 +70,7 @@ enum gimple_rhs_class
};
/* Specific flags for individual GIMPLE statements. These flags are
- always stored in gimple_statement_base.subcode and they may only be
+ always stored in gimple.subcode and they may only be
defined for statement codes that do not use subcodes.
Values for the masks can overlap as long as the overlapping values
@@ -136,7 +136,7 @@ enum plf_mask {
struct GTY((desc ("gimple_statement_structure (&%h)"), tag ("GSS_BASE"),
chain_next ("%h.next"), variable_size))
- gimple_statement_base
+ gimple
{
/* [ WORD 1 ]
Main identifying code for a tuple. */
@@ -206,7 +206,7 @@ struct GTY((desc ("gimple_statement_structure (&%h)"), tag ("GSS_BASE"),
/* This gimple subclass has no tag value. */
struct GTY(())
- gimple_statement_with_ops_base : public gimple_statement_base
+ gimple_with_ops_base : public gimple
{
/* [ WORD 1-6 ] : base class */
@@ -222,7 +222,7 @@ struct GTY(())
/* Statements that take register operands. */
struct GTY((tag("GSS_WITH_OPS")))
- gimple_statement_with_ops : public gimple_statement_with_ops_base
+ gimple_with_ops : public gimple_with_ops_base
{
/* [ WORD 1-7 ] : base class */
@@ -237,7 +237,7 @@ struct GTY((tag("GSS_WITH_OPS")))
/* Base for statements that take both memory and register operands. */
struct GTY((tag("GSS_WITH_MEM_OPS_BASE")))
- gimple_statement_with_memory_ops_base : public gimple_statement_with_ops_base
+ gimple_with_memory_ops_base : public gimple_with_ops_base
{
/* [ WORD 1-7 ] : base class */
@@ -252,8 +252,8 @@ struct GTY((tag("GSS_WITH_MEM_OPS_BASE")))
/* Statements that take both memory and register operands. */
struct GTY((tag("GSS_WITH_MEM_OPS")))
- gimple_statement_with_memory_ops :
- public gimple_statement_with_memory_ops_base
+ gimple_with_memory_ops :
+ public gimple_with_memory_ops_base
{
/* [ WORD 1-9 ] : base class */
@@ -268,7 +268,7 @@ struct GTY((tag("GSS_WITH_MEM_OPS")))
/* Call statements that take both memory and register operands. */
struct GTY((tag("GSS_CALL")))
- gimple_statement_call : public gimple_statement_with_memory_ops_base
+ gcall : public gimple_with_memory_ops_base
{
/* [ WORD 1-9 ] : base class */
@@ -293,7 +293,7 @@ struct GTY((tag("GSS_CALL")))
/* OpenMP statements (#pragma omp). */
struct GTY((tag("GSS_OMP")))
- gimple_statement_omp : public gimple_statement_base
+ gomp : public gimple
{
/* [ WORD 1-6 ] : base class */
@@ -305,7 +305,7 @@ struct GTY((tag("GSS_OMP")))
/* GIMPLE_BIND */
struct GTY((tag("GSS_BIND")))
- gimple_statement_bind : public gimple_statement_base
+ gbind : public gimple
{
/* [ WORD 1-6 ] : base class */
@@ -314,7 +314,7 @@ struct GTY((tag("GSS_BIND")))
tree vars;
/* [ WORD 8 ]
- This is different than the BLOCK field in gimple_statement_base,
+ This is different than the BLOCK field in gimple,
which is analogous to TREE_BLOCK (i.e., the lexical block holding
this statement). This field is the equivalent of BIND_EXPR_BLOCK
in tree land (i.e., the lexical scope defined by this bind). See
@@ -329,7 +329,7 @@ struct GTY((tag("GSS_BIND")))
/* GIMPLE_CATCH */
struct GTY((tag("GSS_CATCH")))
- gimple_statement_catch : public gimple_statement_base
+ gcatch : public gimple
{
/* [ WORD 1-6 ] : base class */
@@ -344,7 +344,7 @@ struct GTY((tag("GSS_CATCH")))
/* GIMPLE_EH_FILTER */
struct GTY((tag("GSS_EH_FILTER")))
- gimple_statement_eh_filter : public gimple_statement_base
+ geh_filter : public gimple
{
/* [ WORD 1-6 ] : base class */
@@ -360,7 +360,7 @@ struct GTY((tag("GSS_EH_FILTER")))
/* GIMPLE_EH_ELSE */
struct GTY((tag("GSS_EH_ELSE")))
- gimple_statement_eh_else : public gimple_statement_base
+ geh_else : public gimple
{
/* [ WORD 1-6 ] : base class */
@@ -371,7 +371,7 @@ struct GTY((tag("GSS_EH_ELSE")))
/* GIMPLE_EH_MUST_NOT_THROW */
struct GTY((tag("GSS_EH_MNT")))
- gimple_statement_eh_mnt : public gimple_statement_base
+ geh_mnt : public gimple
{
/* [ WORD 1-6 ] : base class */
@@ -382,7 +382,7 @@ struct GTY((tag("GSS_EH_MNT")))
/* GIMPLE_PHI */
struct GTY((tag("GSS_PHI")))
- gimple_statement_phi : public gimple_statement_base
+ gphi : public gimple
{
/* [ WORD 1-6 ] : base class */
@@ -401,7 +401,7 @@ struct GTY((tag("GSS_PHI")))
/* GIMPLE_RESX, GIMPLE_EH_DISPATCH */
struct GTY((tag("GSS_EH_CTRL")))
- gimple_statement_eh_ctrl : public gimple_statement_base
+ geh_ctrl : public gimple
{
/* [ WORD 1-6 ] : base class */
@@ -411,14 +411,14 @@ struct GTY((tag("GSS_EH_CTRL")))
};
struct GTY((tag("GSS_EH_CTRL")))
- gimple_statement_resx : public gimple_statement_eh_ctrl
+ gresx : public geh_ctrl
{
/* No extra fields; adds invariant:
stmt->code == GIMPLE_RESX. */
};
struct GTY((tag("GSS_EH_CTRL")))
- gimple_statement_eh_dispatch : public gimple_statement_eh_ctrl
+ geh_dispatch : public geh_ctrl
{
/* No extra fields; adds invariant:
stmt->code == GIMPLE_EH_DISPATH. */
@@ -428,7 +428,7 @@ struct GTY((tag("GSS_EH_CTRL")))
/* GIMPLE_TRY */
struct GTY((tag("GSS_TRY")))
- gimple_statement_try : public gimple_statement_base
+ gtry : public gimple
{
/* [ WORD 1-6 ] : base class */
@@ -458,7 +458,7 @@ enum gimple_try_flags
/* GIMPLE_WITH_CLEANUP_EXPR */
struct GTY((tag("GSS_WCE")))
- gimple_statement_wce : public gimple_statement_base
+ gwce : public gimple
{
/* [ WORD 1-6 ] : base class */
@@ -476,7 +476,7 @@ struct GTY((tag("GSS_WCE")))
/* GIMPLE_ASM */
struct GTY((tag("GSS_ASM")))
- gimple_statement_asm : public gimple_statement_with_memory_ops_base
+ gasm : public gimple_with_memory_ops_base
{
/* [ WORD 1-9 ] : base class */
@@ -501,7 +501,7 @@ struct GTY((tag("GSS_ASM")))
/* GIMPLE_OMP_CRITICAL */
struct GTY((tag("GSS_OMP_CRITICAL")))
- gimple_statement_omp_critical : public gimple_statement_omp
+ gomp_critical : public gomp
{
/* [ WORD 1-7 ] : base class */
@@ -531,7 +531,7 @@ struct GTY(()) gimple_omp_for_iter {
/* GIMPLE_OMP_FOR */
struct GTY((tag("GSS_OMP_FOR")))
- gimple_statement_omp_for : public gimple_statement_omp
+ gomp_for : public gomp
{
/* [ WORD 1-7 ] : base class */
@@ -553,7 +553,7 @@ struct GTY((tag("GSS_OMP_FOR")))
/* GIMPLE_OMP_PARALLEL, GIMPLE_OMP_TARGET */
struct GTY((tag("GSS_OMP_PARALLEL_LAYOUT")))
- gimple_statement_omp_parallel_layout : public gimple_statement_omp
+ gomp_parallel_layout : public gomp
{
/* [ WORD 1-7 ] : base class */
@@ -572,7 +572,7 @@ struct GTY((tag("GSS_OMP_PARALLEL_LAYOUT")))
/* GIMPLE_OMP_PARALLEL or GIMPLE_TASK */
struct GTY((tag("GSS_OMP_PARALLEL_LAYOUT")))
- gimple_statement_omp_taskreg : public gimple_statement_omp_parallel_layout
+ gomp_taskreg : public gomp_parallel_layout
{
/* No extra fields; adds invariant:
stmt->code == GIMPLE_OMP_PARALLEL
@@ -582,14 +582,14 @@ struct GTY((tag("GSS_OMP_PARALLEL_LAYOUT")))
/* GIMPLE_OMP_PARALLEL */
struct GTY((tag("GSS_OMP_PARALLEL_LAYOUT")))
- gimple_statement_omp_parallel : public gimple_statement_omp_taskreg
+ gomp_parallel : public gomp_taskreg
{
/* No extra fields; adds invariant:
stmt->code == GIMPLE_OMP_PARALLEL. */
};
struct GTY((tag("GSS_OMP_PARALLEL_LAYOUT")))
- gimple_statement_omp_target : public gimple_statement_omp_parallel_layout
+ gomp_target : public gomp_parallel_layout
{
/* No extra fields; adds invariant:
stmt->code == GIMPLE_OMP_TARGET. */
@@ -598,7 +598,7 @@ struct GTY((tag("GSS_OMP_PARALLEL_LAYOUT")))
/* GIMPLE_OMP_TASK */
struct GTY((tag("GSS_OMP_TASK")))
- gimple_statement_omp_task : public gimple_statement_omp_taskreg
+ gomp_task : public gomp_taskreg
{
/* [ WORD 1-10 ] : base class */
@@ -614,13 +614,13 @@ struct GTY((tag("GSS_OMP_TASK")))
/* GIMPLE_OMP_SECTION */
-/* Uses struct gimple_statement_omp. */
+/* Uses struct gimple_omp. */
/* GIMPLE_OMP_SECTIONS */
struct GTY((tag("GSS_OMP_SECTIONS")))
- gimple_statement_omp_sections : public gimple_statement_omp
+ gomp_sections : public gomp
{
/* [ WORD 1-7 ] : base class */
@@ -635,11 +635,11 @@ struct GTY((tag("GSS_OMP_SECTIONS")))
/* GIMPLE_OMP_CONTINUE.
- Note: This does not inherit from gimple_statement_omp, because we
+ Note: This does not inherit from gomp, because we
do not need the body field. */
struct GTY((tag("GSS_OMP_CONTINUE")))
- gimple_statement_omp_continue : public gimple_statement_base
+ gomp_continue : public gimple
{
/* [ WORD 1-6 ] : base class */
@@ -653,7 +653,7 @@ struct GTY((tag("GSS_OMP_CONTINUE")))
/* GIMPLE_OMP_SINGLE, GIMPLE_OMP_TEAMS */
struct GTY((tag("GSS_OMP_SINGLE_LAYOUT")))
- gimple_statement_omp_single_layout : public gimple_statement_omp
+ gomp_single_layout : public gomp
{
/* [ WORD 1-7 ] : base class */
@@ -662,14 +662,14 @@ struct GTY((tag("GSS_OMP_SINGLE_LAYOUT")))
};
struct GTY((tag("GSS_OMP_SINGLE_LAYOUT")))
- gimple_statement_omp_single : public gimple_statement_omp_single_layout
+ gomp_single : public gomp_single_layout
{
/* No extra fields; adds invariant:
stmt->code == GIMPLE_OMP_SINGLE. */
};
struct GTY((tag("GSS_OMP_SINGLE_LAYOUT")))
- gimple_statement_omp_teams : public gimple_statement_omp_single_layout
+ gomp_teams : public gomp_single_layout
{
/* No extra fields; adds invariant:
stmt->code == GIMPLE_OMP_TEAMS. */
@@ -677,11 +677,11 @@ struct GTY((tag("GSS_OMP_SINGLE_LAYOUT")))
/* GIMPLE_OMP_ATOMIC_LOAD.
- Note: This is based on gimple_statement_base, not g_s_omp, because g_s_omp
+ Note: This is based on gimple, not gomp, because gomp
contains a sequence, which we don't need here. */
struct GTY((tag("GSS_OMP_ATOMIC_LOAD")))
- gimple_statement_omp_atomic_load : public gimple_statement_base
+ gomp_atomic_load : public gimple
{
/* [ WORD 1-6 ] : base class */
@@ -693,7 +693,7 @@ struct GTY((tag("GSS_OMP_ATOMIC_LOAD")))
See note on GIMPLE_OMP_ATOMIC_LOAD. */
struct GTY((tag("GSS_OMP_ATOMIC_STORE_LAYOUT")))
- gimple_statement_omp_atomic_store_layout : public gimple_statement_base
+ gomp_atomic_store_layout : public gimple
{
/* [ WORD 1-6 ] : base class */
@@ -702,16 +702,16 @@ struct GTY((tag("GSS_OMP_ATOMIC_STORE_LAYOUT")))
};
struct GTY((tag("GSS_OMP_ATOMIC_STORE_LAYOUT")))
- gimple_statement_omp_atomic_store :
- public gimple_statement_omp_atomic_store_layout
+ gomp_atomic_store :
+ public gomp_atomic_store_layout
{
/* No extra fields; adds invariant:
stmt->code == GIMPLE_OMP_ATOMIC_STORE. */
};
struct GTY((tag("GSS_OMP_ATOMIC_STORE_LAYOUT")))
- gimple_statement_omp_return :
- public gimple_statement_omp_atomic_store_layout
+ gomp_return :
+ public gomp_atomic_store_layout
{
/* No extra fields; adds invariant:
stmt->code == GIMPLE_OMP_RETURN. */
@@ -746,7 +746,7 @@ struct GTY((tag("GSS_OMP_ATOMIC_STORE_LAYOUT")))
#define GTMA_HAS_NO_INSTRUMENTATION (1u << 7)
struct GTY((tag("GSS_TRANSACTION")))
- gimple_statement_transaction : public gimple_statement_with_memory_ops_base
+ gtransaction : public gimple_with_memory_ops_base
{
/* [ WORD 1-9 ] : base class */
@@ -767,7 +767,7 @@ enum gimple_statement_structure_enum {
template <>
template <>
inline bool
-is_a_helper <gimple_statement_asm *>::test (gimple gs)
+is_a_helper <gasm *>::test (gimple gs)
{
return gs->code == GIMPLE_ASM;
}
@@ -775,7 +775,7 @@ is_a_helper <gimple_statement_asm *>::test (gimple gs)
template <>
template <>
inline bool
-is_a_helper <gimple_statement_bind *>::test (gimple gs)
+is_a_helper <gbind *>::test (gimple gs)
{
return gs->code == GIMPLE_BIND;
}
@@ -783,7 +783,7 @@ is_a_helper <gimple_statement_bind *>::test (gimple gs)
template <>
template <>
inline bool
-is_a_helper <gimple_statement_call *>::test (gimple gs)
+is_a_helper <gcall *>::test (gimple gs)
{
return gs->code == GIMPLE_CALL;
}
@@ -791,7 +791,7 @@ is_a_helper <gimple_statement_call *>::test (gimple gs)
template <>
template <>
inline bool
-is_a_helper <gimple_statement_catch *>::test (gimple gs)
+is_a_helper <gcatch *>::test (gimple gs)
{
return gs->code == GIMPLE_CATCH;
}
@@ -799,7 +799,7 @@ is_a_helper <gimple_statement_catch *>::test (gimple gs)
template <>
template <>
inline bool
-is_a_helper <gimple_statement_resx *>::test (gimple gs)
+is_a_helper <gresx *>::test (gimple gs)
{
return gs->code == GIMPLE_RESX;
}
@@ -807,7 +807,7 @@ is_a_helper <gimple_statement_resx *>::test (gimple gs)
template <>
template <>
inline bool
-is_a_helper <gimple_statement_eh_dispatch *>::test (gimple gs)
+is_a_helper <geh_dispatch *>::test (gimple gs)
{
return gs->code == GIMPLE_EH_DISPATCH;
}
@@ -815,7 +815,7 @@ is_a_helper <gimple_statement_eh_dispatch *>::test (gimple gs)
template <>
template <>
inline bool
-is_a_helper <gimple_statement_eh_else *>::test (gimple gs)
+is_a_helper <geh_else *>::test (gimple gs)
{
return gs->code == GIMPLE_EH_ELSE;
}
@@ -823,7 +823,7 @@ is_a_helper <gimple_statement_eh_else *>::test (gimple gs)
template <>
template <>
inline bool
-is_a_helper <gimple_statement_eh_filter *>::test (gimple gs)
+is_a_helper <geh_filter *>::test (gimple gs)
{
return gs->code == GIMPLE_EH_FILTER;
}
@@ -831,7 +831,7 @@ is_a_helper <gimple_statement_eh_filter *>::test (gimple gs)
template <>
template <>
inline bool
-is_a_helper <gimple_statement_eh_mnt *>::test (gimple gs)
+is_a_helper <geh_mnt *>::test (gimple gs)
{
return gs->code == GIMPLE_EH_MUST_NOT_THROW;
}
@@ -839,7 +839,7 @@ is_a_helper <gimple_statement_eh_mnt *>::test (gimple gs)
template <>
template <>
inline bool
-is_a_helper <gimple_statement_omp_atomic_load *>::test (gimple gs)
+is_a_helper <gomp_atomic_load *>::test (gimple gs)
{
return gs->code == GIMPLE_OMP_ATOMIC_LOAD;
}
@@ -847,7 +847,7 @@ is_a_helper <gimple_statement_omp_atomic_load *>::test (gimple gs)
template <>
template <>
inline bool
-is_a_helper <gimple_statement_omp_atomic_store *>::test (gimple gs)
+is_a_helper <gomp_atomic_store *>::test (gimple gs)
{
return gs->code == GIMPLE_OMP_ATOMIC_STORE;
}
@@ -855,7 +855,7 @@ is_a_helper <gimple_statement_omp_atomic_store *>::test (gimple gs)
template <>
template <>
inline bool
-is_a_helper <gimple_statement_omp_return *>::test (gimple gs)
+is_a_helper <gomp_return *>::test (gimple gs)
{
return gs->code == GIMPLE_OMP_RETURN;
}
@@ -863,7 +863,7 @@ is_a_helper <gimple_statement_omp_return *>::test (gimple gs)
template <>
template <>
inline bool
-is_a_helper <gimple_statement_omp_continue *>::test (gimple gs)
+is_a_helper <gomp_continue *>::test (gimple gs)
{
return gs->code == GIMPLE_OMP_CONTINUE;
}
@@ -871,7 +871,7 @@ is_a_helper <gimple_statement_omp_continue *>::test (gimple gs)
template <>
template <>
inline bool
-is_a_helper <gimple_statement_omp_critical *>::test (gimple gs)
+is_a_helper <gomp_critical *>::test (gimple gs)
{
return gs->code == GIMPLE_OMP_CRITICAL;
}
@@ -879,7 +879,7 @@ is_a_helper <gimple_statement_omp_critical *>::test (gimple gs)
template <>
template <>
inline bool
-is_a_helper <gimple_statement_omp_for *>::test (gimple gs)
+is_a_helper <gomp_for *>::test (gimple gs)
{
return gs->code == GIMPLE_OMP_FOR;
}
@@ -887,7 +887,7 @@ is_a_helper <gimple_statement_omp_for *>::test (gimple gs)
template <>
template <>
inline bool
-is_a_helper <gimple_statement_omp_taskreg *>::test (gimple gs)
+is_a_helper <gomp_taskreg *>::test (gimple gs)
{
return gs->code == GIMPLE_OMP_PARALLEL || gs->code == GIMPLE_OMP_TASK;
}
@@ -895,7 +895,7 @@ is_a_helper <gimple_statement_omp_taskreg *>::test (gimple gs)
template <>
template <>
inline bool
-is_a_helper <gimple_statement_omp_parallel *>::test (gimple gs)
+is_a_helper <gomp_parallel *>::test (gimple gs)
{
return gs->code == GIMPLE_OMP_PARALLEL;
}
@@ -903,7 +903,7 @@ is_a_helper <gimple_statement_omp_parallel *>::test (gimple gs)
template <>
template <>
inline bool
-is_a_helper <gimple_statement_omp_target *>::test (gimple gs)
+is_a_helper <gomp_target *>::test (gimple gs)
{
return gs->code == GIMPLE_OMP_TARGET;
}
@@ -911,7 +911,7 @@ is_a_helper <gimple_statement_omp_target *>::test (gimple gs)
template <>
template <>
inline bool
-is_a_helper <gimple_statement_omp_sections *>::test (gimple gs)
+is_a_helper <gomp_sections *>::test (gimple gs)
{
return gs->code == GIMPLE_OMP_SECTIONS;
}
@@ -919,7 +919,7 @@ is_a_helper <gimple_statement_omp_sections *>::test (gimple gs)
template <>
template <>
inline bool
-is_a_helper <gimple_statement_omp_single *>::test (gimple gs)
+is_a_helper <gomp_single *>::test (gimple gs)
{
return gs->code == GIMPLE_OMP_SINGLE;
}
@@ -927,7 +927,7 @@ is_a_helper <gimple_statement_omp_single *>::test (gimple gs)
template <>
template <>
inline bool
-is_a_helper <gimple_statement_omp_teams *>::test (gimple gs)
+is_a_helper <gomp_teams *>::test (gimple gs)
{
return gs->code == GIMPLE_OMP_TEAMS;
}
@@ -935,7 +935,7 @@ is_a_helper <gimple_statement_omp_teams *>::test (gimple gs)
template <>
template <>
inline bool
-is_a_helper <gimple_statement_omp_task *>::test (gimple gs)
+is_a_helper <gomp_task *>::test (gimple gs)
{
return gs->code == GIMPLE_OMP_TASK;
}
@@ -943,7 +943,7 @@ is_a_helper <gimple_statement_omp_task *>::test (gimple gs)
template <>
template <>
inline bool
-is_a_helper <gimple_statement_phi *>::test (gimple gs)
+is_a_helper <gphi *>::test (gimple gs)
{
return gs->code == GIMPLE_PHI;
}
@@ -951,7 +951,7 @@ is_a_helper <gimple_statement_phi *>::test (gimple gs)
template <>
template <>
inline bool
-is_a_helper <gimple_statement_transaction *>::test (gimple gs)
+is_a_helper <gtransaction *>::test (gimple gs)
{
return gs->code == GIMPLE_TRANSACTION;
}
@@ -959,7 +959,7 @@ is_a_helper <gimple_statement_transaction *>::test (gimple gs)
template <>
template <>
inline bool
-is_a_helper <gimple_statement_try *>::test (gimple gs)
+is_a_helper <gtry *>::test (gimple gs)
{
return gs->code == GIMPLE_TRY;
}
@@ -967,7 +967,7 @@ is_a_helper <gimple_statement_try *>::test (gimple gs)
template <>
template <>
inline bool
-is_a_helper <gimple_statement_wce *>::test (gimple gs)
+is_a_helper <gwce *>::test (gimple gs)
{
return gs->code == GIMPLE_WITH_CLEANUP_EXPR;
}
@@ -975,7 +975,7 @@ is_a_helper <gimple_statement_wce *>::test (gimple gs)
template <>
template <>
inline bool
-is_a_helper <const gimple_statement_asm *>::test (const_gimple gs)
+is_a_helper <const gasm *>::test (const_gimple gs)
{
return gs->code == GIMPLE_ASM;
}
@@ -983,7 +983,7 @@ is_a_helper <const gimple_statement_asm *>::test (const_gimple gs)
template <>
template <>
inline bool
-is_a_helper <const gimple_statement_bind *>::test (const_gimple gs)
+is_a_helper <const gbind *>::test (const_gimple gs)
{
return gs->code == GIMPLE_BIND;
}
@@ -991,7 +991,7 @@ is_a_helper <const gimple_statement_bind *>::test (const_gimple gs)
template <>
template <>
inline bool
-is_a_helper <const gimple_statement_call *>::test (const_gimple gs)
+is_a_helper <const gcall *>::test (const_gimple gs)
{
return gs->code == GIMPLE_CALL;
}
@@ -999,7 +999,7 @@ is_a_helper <const gimple_statement_call *>::test (const_gimple gs)
template <>
template <>
inline bool
-is_a_helper <const gimple_statement_catch *>::test (const_gimple gs)
+is_a_helper <const gcatch *>::test (const_gimple gs)
{
return gs->code == GIMPLE_CATCH;
}
@@ -1007,7 +1007,7 @@ is_a_helper <const gimple_statement_catch *>::test (const_gimple gs)
template <>
template <>
inline bool
-is_a_helper <const gimple_statement_resx *>::test (const_gimple gs)
+is_a_helper <const gresx *>::test (const_gimple gs)
{
return gs->code == GIMPLE_RESX;
}
@@ -1015,7 +1015,7 @@ is_a_helper <const gimple_statement_resx *>::test (const_gimple gs)
template <>
template <>
inline bool
-is_a_helper <const gimple_statement_eh_dispatch *>::test (const_gimple gs)
+is_a_helper <const geh_dispatch *>::test (const_gimple gs)
{
return gs->code == GIMPLE_EH_DISPATCH;
}
@@ -1023,7 +1023,7 @@ is_a_helper <const gimple_statement_eh_dispatch *>::test (const_gimple gs)
template <>
template <>
inline bool
-is_a_helper <const gimple_statement_eh_filter *>::test (const_gimple gs)
+is_a_helper <const geh_filter *>::test (const_gimple gs)
{
return gs->code == GIMPLE_EH_FILTER;
}
@@ -1031,7 +1031,7 @@ is_a_helper <const gimple_statement_eh_filter *>::test (const_gimple gs)
template <>
template <>
inline bool
-is_a_helper <const gimple_statement_omp_atomic_load *>::test (const_gimple gs)
+is_a_helper <const gomp_atomic_load *>::test (const_gimple gs)
{
return gs->code == GIMPLE_OMP_ATOMIC_LOAD;
}
@@ -1039,7 +1039,7 @@ is_a_helper <const gimple_statement_omp_atomic_load *>::test (const_gimple gs)
template <>
template <>
inline bool
-is_a_helper <const gimple_statement_omp_atomic_store *>::test (const_gimple gs)
+is_a_helper <const gomp_atomic_store *>::test (const_gimple gs)
{
return gs->code == GIMPLE_OMP_ATOMIC_STORE;
}
@@ -1047,7 +1047,7 @@ is_a_helper <const gimple_statement_omp_atomic_store *>::test (const_gimple gs)
template <>
template <>
inline bool
-is_a_helper <const gimple_statement_omp_return *>::test (const_gimple gs)
+is_a_helper <const gomp_return *>::test (const_gimple gs)
{
return gs->code == GIMPLE_OMP_RETURN;
}
@@ -1055,7 +1055,7 @@ is_a_helper <const gimple_statement_omp_return *>::test (const_gimple gs)
template <>
template <>
inline bool
-is_a_helper <const gimple_statement_omp_continue *>::test (const_gimple gs)
+is_a_helper <const gomp_continue *>::test (const_gimple gs)
{
return gs->code == GIMPLE_OMP_CONTINUE;
}
@@ -1063,7 +1063,7 @@ is_a_helper <const gimple_statement_omp_continue *>::test (const_gimple gs)
template <>
template <>
inline bool
-is_a_helper <const gimple_statement_omp_critical *>::test (const_gimple gs)
+is_a_helper <const gomp_critical *>::test (const_gimple gs)
{
return gs->code == GIMPLE_OMP_CRITICAL;
}
@@ -1071,7 +1071,7 @@ is_a_helper <const gimple_statement_omp_critical *>::test (const_gimple gs)
template <>
template <>
inline bool
-is_a_helper <const gimple_statement_omp_for *>::test (const_gimple gs)
+is_a_helper <const gomp_for *>::test (const_gimple gs)
{
return gs->code == GIMPLE_OMP_FOR;
}
@@ -1079,7 +1079,7 @@ is_a_helper <const gimple_statement_omp_for *>::test (const_gimple gs)
template <>
template <>
inline bool
-is_a_helper <const gimple_statement_omp_taskreg *>::test (const_gimple gs)
+is_a_helper <const gomp_taskreg *>::test (const_gimple gs)
{
return gs->code == GIMPLE_OMP_PARALLEL || gs->code == GIMPLE_OMP_TASK;
}
@@ -1087,7 +1087,7 @@ is_a_helper <const gimple_statement_omp_taskreg *>::test (const_gimple gs)
template <>
template <>
inline bool
-is_a_helper <const gimple_statement_omp_parallel *>::test (const_gimple gs)
+is_a_helper <const gomp_parallel *>::test (const_gimple gs)
{
return gs->code == GIMPLE_OMP_PARALLEL;
}
@@ -1095,7 +1095,7 @@ is_a_helper <const gimple_statement_omp_parallel *>::test (const_gimple gs)
template <>
template <>
inline bool
-is_a_helper <const gimple_statement_omp_target *>::test (const_gimple gs)
+is_a_helper <const gomp_target *>::test (const_gimple gs)
{
return gs->code == GIMPLE_OMP_TARGET;
}
@@ -1103,7 +1103,7 @@ is_a_helper <const gimple_statement_omp_target *>::test (const_gimple gs)
template <>
template <>
inline bool
-is_a_helper <const gimple_statement_omp_sections *>::test (const_gimple gs)
+is_a_helper <const gomp_sections *>::test (const_gimple gs)
{
return gs->code == GIMPLE_OMP_SECTIONS;
}
@@ -1111,7 +1111,7 @@ is_a_helper <const gimple_statement_omp_sections *>::test (const_gimple gs)
template <>
template <>
inline bool
-is_a_helper <const gimple_statement_omp_single *>::test (const_gimple gs)
+is_a_helper <const gomp_single *>::test (const_gimple gs)
{
return gs->code == GIMPLE_OMP_SINGLE;
}
@@ -1119,7 +1119,7 @@ is_a_helper <const gimple_statement_omp_single *>::test (const_gimple gs)
template <>
template <>
inline bool
-is_a_helper <const gimple_statement_omp_teams *>::test (const_gimple gs)
+is_a_helper <const gomp_teams *>::test (const_gimple gs)
{
return gs->code == GIMPLE_OMP_TEAMS;
}
@@ -1127,7 +1127,7 @@ is_a_helper <const gimple_statement_omp_teams *>::test (const_gimple gs)
template <>
template <>
inline bool
-is_a_helper <const gimple_statement_omp_task *>::test (const_gimple gs)
+is_a_helper <const gomp_task *>::test (const_gimple gs)
{
return gs->code == GIMPLE_OMP_TASK;
}
@@ -1135,7 +1135,7 @@ is_a_helper <const gimple_statement_omp_task *>::test (const_gimple gs)
template <>
template <>
inline bool
-is_a_helper <const gimple_statement_phi *>::test (const_gimple gs)
+is_a_helper <const gphi *>::test (const_gimple gs)
{
return gs->code == GIMPLE_PHI;
}
@@ -1143,7 +1143,7 @@ is_a_helper <const gimple_statement_phi *>::test (const_gimple gs)
template <>
template <>
inline bool
-is_a_helper <const gimple_statement_transaction *>::test (const_gimple gs)
+is_a_helper <const gtransaction *>::test (const_gimple gs)
{
return gs->code == GIMPLE_TRANSACTION;
}
@@ -1189,8 +1189,8 @@ gimple gimple_build_catch (tree, gimple_seq);
gimple gimple_build_eh_filter (tree, gimple_seq);
gimple gimple_build_eh_must_not_throw (tree);
gimple gimple_build_eh_else (gimple_seq, gimple_seq);
-gimple_statement_try *gimple_build_try (gimple_seq, gimple_seq,
- enum gimple_try_flags);
+gtry *gimple_build_try (gimple_seq, gimple_seq,
+ enum gimple_try_flags);
gimple gimple_build_wce (gimple_seq);
gimple gimple_build_resx (int);
gimple gimple_build_switch_nlabels (unsigned, tree, tree);
@@ -1647,7 +1647,7 @@ gimple_has_ops (const_gimple g)
template <>
template <>
inline bool
-is_a_helper <const gimple_statement_with_ops *>::test (const_gimple gs)
+is_a_helper <const gimple_with_ops *>::test (const_gimple gs)
{
return gimple_has_ops (gs);
}
@@ -1655,7 +1655,7 @@ is_a_helper <const gimple_statement_with_ops *>::test (const_gimple gs)
template <>
template <>
inline bool
-is_a_helper <gimple_statement_with_ops *>::test (gimple gs)
+is_a_helper <gimple_with_ops *>::test (gimple gs)
{
return gimple_has_ops (gs);
}
@@ -1671,7 +1671,7 @@ gimple_has_mem_ops (const_gimple g)
template <>
template <>
inline bool
-is_a_helper <const gimple_statement_with_memory_ops *>::test (const_gimple gs)
+is_a_helper <const gimple_with_memory_ops *>::test (const_gimple gs)
{
return gimple_has_mem_ops (gs);
}
@@ -1679,7 +1679,7 @@ is_a_helper <const gimple_statement_with_memory_ops *>::test (const_gimple gs)
template <>
template <>
inline bool
-is_a_helper <gimple_statement_with_memory_ops *>::test (gimple gs)
+is_a_helper <gimple_with_memory_ops *>::test (gimple gs)
{
return gimple_has_mem_ops (gs);
}
@@ -1689,8 +1689,7 @@ is_a_helper <gimple_statement_with_memory_ops *>::test (gimple gs)
static inline struct use_optype_d *
gimple_use_ops (const_gimple g)
{
- const gimple_statement_with_ops *ops_stmt =
- dyn_cast <const gimple_statement_with_ops *> (g);
+ const gimple_with_ops *ops_stmt = dyn_cast <const gimple_with_ops *> (g);
if (!ops_stmt)
return NULL;
return ops_stmt->use_ops;
@@ -1702,8 +1701,7 @@ gimple_use_ops (const_gimple g)
static inline void
gimple_set_use_ops (gimple g, struct use_optype_d *use)
{
- gimple_statement_with_ops *ops_stmt =
- as_a <gimple_statement_with_ops *> (g);
+ gimple_with_ops *ops_stmt = as_a <gimple_with_ops *> (g);
ops_stmt->use_ops = use;
}
@@ -1713,8 +1711,8 @@ gimple_set_use_ops (gimple g, struct use_optype_d *use)
static inline tree
gimple_vuse (const_gimple g)
{
- const gimple_statement_with_memory_ops *mem_ops_stmt =
- dyn_cast <const gimple_statement_with_memory_ops *> (g);
+ const gimple_with_memory_ops *mem_ops_stmt =
+ dyn_cast <const gimple_with_memory_ops *> (g);
if (!mem_ops_stmt)
return NULL_TREE;
return mem_ops_stmt->vuse;
@@ -1725,8 +1723,8 @@ gimple_vuse (const_gimple g)
static inline tree
gimple_vdef (const_gimple g)
{
- const gimple_statement_with_memory_ops *mem_ops_stmt =
- dyn_cast <const gimple_statement_with_memory_ops *> (g);
+ const gimple_with_memory_ops *mem_ops_stmt =
+ dyn_cast <const gimple_with_memory_ops *> (g);
if (!mem_ops_stmt)
return NULL_TREE;
return mem_ops_stmt->vdef;
@@ -1737,8 +1735,8 @@ gimple_vdef (const_gimple g)
static inline tree *
gimple_vuse_ptr (gimple g)
{
- gimple_statement_with_memory_ops *mem_ops_stmt =
- dyn_cast <gimple_statement_with_memory_ops *> (g);
+ gimple_with_memory_ops *mem_ops_stmt =
+ dyn_cast <gimple_with_memory_ops *> (g);
if (!mem_ops_stmt)
return NULL;
return &mem_ops_stmt->vuse;
@@ -1749,8 +1747,8 @@ gimple_vuse_ptr (gimple g)
static inline tree *
gimple_vdef_ptr (gimple g)
{
- gimple_statement_with_memory_ops *mem_ops_stmt =
- dyn_cast <gimple_statement_with_memory_ops *> (g);
+ gimple_with_memory_ops *mem_ops_stmt =
+ dyn_cast <gimple_with_memory_ops *> (g);
if (!mem_ops_stmt)
return NULL;
return &mem_ops_stmt->vdef;
@@ -1761,8 +1759,8 @@ gimple_vdef_ptr (gimple g)
static inline void
gimple_set_vuse (gimple g, tree vuse)
{
- gimple_statement_with_memory_ops *mem_ops_stmt =
- as_a <gimple_statement_with_memory_ops *> (g);
+ gimple_with_memory_ops *mem_ops_stmt =
+ as_a <gimple_with_memory_ops *> (g);
mem_ops_stmt->vuse = vuse;
}
@@ -1771,8 +1769,8 @@ gimple_set_vuse (gimple g, tree vuse)
static inline void
gimple_set_vdef (gimple g, tree vdef)
{
- gimple_statement_with_memory_ops *mem_ops_stmt =
- as_a <gimple_statement_with_memory_ops *> (g);
+ gimple_with_memory_ops *mem_ops_stmt =
+ as_a <gimple_with_memory_ops *> (g);
mem_ops_stmt->vdef = vdef;
}
@@ -1903,8 +1901,7 @@ gimple_omp_return_nowait_p (const_gimple g)
static inline void
gimple_omp_return_set_lhs (gimple g, tree lhs)
{
- gimple_statement_omp_return *omp_return_stmt =
- as_a <gimple_statement_omp_return *> (g);
+ gomp_return *omp_return_stmt = as_a <gomp_return *> (g);
omp_return_stmt->val = lhs;
}
@@ -1914,8 +1911,7 @@ gimple_omp_return_set_lhs (gimple g, tree lhs)
static inline tree
gimple_omp_return_lhs (const_gimple g)
{
- const gimple_statement_omp_return *omp_return_stmt =
- as_a <const gimple_statement_omp_return *> (g);
+ const gomp_return *omp_return_stmt = as_a <const gomp_return *> (g);
return omp_return_stmt->val;
}
@@ -1925,8 +1921,7 @@ gimple_omp_return_lhs (const_gimple g)
static inline tree *
gimple_omp_return_lhs_ptr (gimple g)
{
- gimple_statement_omp_return *omp_return_stmt =
- as_a <gimple_statement_omp_return *> (g);
+ gomp_return *omp_return_stmt = as_a <gomp_return *> (g);
return &omp_return_stmt->val;
}
@@ -2444,7 +2439,7 @@ static inline enum internal_fn
gimple_call_internal_fn (const_gimple gs)
{
gcc_gimple_checking_assert (gimple_call_internal_p (gs));
- return static_cast <const gimple_statement_call *> (gs)->u.internal_fn;
+ return static_cast <const gcall *> (gs)->u.internal_fn;
}
@@ -2453,8 +2448,8 @@ gimple_call_internal_fn (const_gimple gs)
static inline tree
gimple_call_fntype (const_gimple gs)
{
- const gimple_statement_call *call_stmt =
- as_a <const gimple_statement_call *> (gs);
+ const gcall *call_stmt =
+ as_a <const gcall *> (gs);
if (gimple_call_internal_p (gs))
return NULL_TREE;
return call_stmt->u.fntype;
@@ -2465,7 +2460,7 @@ gimple_call_fntype (const_gimple gs)
static inline void
gimple_call_set_fntype (gimple gs, tree fntype)
{
- gimple_statement_call *call_stmt = as_a <gimple_statement_call *> (gs);
+ gcall *call_stmt = as_a <gcall *> (gs);
gcc_gimple_checking_assert (!gimple_call_internal_p (gs));
call_stmt->u.fntype = fntype;
}
@@ -2519,7 +2514,7 @@ gimple_call_set_fndecl (gimple gs, tree decl)
static inline void
gimple_call_set_internal_fn (gimple gs, enum internal_fn fn)
{
- gimple_statement_call *call_stmt = as_a <gimple_statement_call *> (gs);
+ gcall *call_stmt = as_a <gcall *> (gs);
gcc_gimple_checking_assert (gimple_call_internal_p (gs));
call_stmt->u.internal_fn = fn;
}
@@ -2797,7 +2792,7 @@ gimple_call_copy_flags (gimple dest_call, gimple orig_call)
static inline struct pt_solution *
gimple_call_use_set (gimple call)
{
- gimple_statement_call *call_stmt = as_a <gimple_statement_call *> (call);
+ gcall *call_stmt = as_a <gcall *> (call);
return &call_stmt->call_used;
}
@@ -2808,7 +2803,7 @@ gimple_call_use_set (gimple call)
static inline struct pt_solution *
gimple_call_clobber_set (gimple call)
{
- gimple_statement_call *call_stmt = as_a <gimple_statement_call *> (call);
+ gcall *call_stmt = as_a <gcall *> (call);
return &call_stmt->call_clobbered;
}
@@ -3077,8 +3072,7 @@ gimple_goto_set_dest (gimple gs, tree dest)
static inline tree
gimple_bind_vars (const_gimple gs)
{
- const gimple_statement_bind *bind_stmt =
- as_a <const gimple_statement_bind *> (gs);
+ const gbind *bind_stmt = as_a <const gbind *> (gs);
return bind_stmt->vars;
}
@@ -3089,7 +3083,7 @@ gimple_bind_vars (const_gimple gs)
static inline void
gimple_bind_set_vars (gimple gs, tree vars)
{
- gimple_statement_bind *bind_stmt = as_a <gimple_statement_bind *> (gs);
+ gbind *bind_stmt = as_a <gbind *> (gs);
bind_stmt->vars = vars;
}
@@ -3100,7 +3094,7 @@ gimple_bind_set_vars (gimple gs, tree vars)
static inline void
gimple_bind_append_vars (gimple gs, tree vars)
{
- gimple_statement_bind *bind_stmt = as_a <gimple_statement_bind *> (gs);
+ gbind *bind_stmt = as_a <gbind *> (gs);
bind_stmt->vars = chainon (bind_stmt->vars, vars);
}
@@ -3108,7 +3102,7 @@ gimple_bind_append_vars (gimple gs, tree vars)
static inline gimple_seq *
gimple_bind_body_ptr (gimple gs)
{
- gimple_statement_bind *bind_stmt = as_a <gimple_statement_bind *> (gs);
+ gbind *bind_stmt = as_a <gbind *> (gs);
return &bind_stmt->body;
}
@@ -3127,7 +3121,7 @@ gimple_bind_body (gimple gs)
static inline void
gimple_bind_set_body (gimple gs, gimple_seq seq)
{
- gimple_statement_bind *bind_stmt = as_a <gimple_statement_bind *> (gs);
+ gbind *bind_stmt = as_a <gbind *> (gs);
bind_stmt->body = seq;
}
@@ -3137,7 +3131,7 @@ gimple_bind_set_body (gimple gs, gimple_seq seq)
static inline void
gimple_bind_add_stmt (gimple gs, gimple stmt)
{
- gimple_statement_bind *bind_stmt = as_a <gimple_statement_bind *> (gs);
+ gbind *bind_stmt = as_a <gbind *> (gs);
gimple_seq_add_stmt (&bind_stmt->body, stmt);
}
@@ -3147,7 +3141,7 @@ gimple_bind_add_stmt (gimple gs, gimple stmt)
static inline void
gimple_bind_add_seq (gimple gs, gimple_seq seq)
{
- gimple_statement_bind *bind_stmt = as_a <gimple_statement_bind *> (gs);
+ gbind *bind_stmt = as_a <gbind *> (gs);
gimple_seq_add_seq (&bind_stmt->body, seq);
}
@@ -3158,8 +3152,7 @@ gimple_bind_add_seq (gimple gs, gimple_seq seq)
static inline tree
gimple_bind_block (const_gimple gs)
{
- const gimple_statement_bind *bind_stmt =
- as_a <const gimple_statement_bind *> (gs);
+ const gbind *bind_stmt = as_a <const gbind *> (gs);
return bind_stmt->block;
}
@@ -3170,7 +3163,7 @@ gimple_bind_block (const_gimple gs)
static inline void
gimple_bind_set_block (gimple gs, tree block)
{
- gimple_statement_bind *bind_stmt = as_a <gimple_statement_bind *> (gs);
+ gbind *bind_stmt = as_a <gbind *> (gs);
gcc_gimple_checking_assert (block == NULL_TREE
|| TREE_CODE (block) == BLOCK);
bind_stmt->block = block;
@@ -3182,8 +3175,7 @@ gimple_bind_set_block (gimple gs, tree block)
static inline unsigned
gimple_asm_ninputs (const_gimple gs)
{
- const gimple_statement_asm *asm_stmt =
- as_a <const gimple_statement_asm *> (gs);
+ const gasm *asm_stmt = as_a <const gasm *> (gs);
return asm_stmt->ni;
}
@@ -3193,8 +3185,7 @@ gimple_asm_ninputs (const_gimple gs)
static inline unsigned
gimple_asm_noutputs (const_gimple gs)
{
- const gimple_statement_asm *asm_stmt =
- as_a <const gimple_statement_asm *> (gs);
+ const gasm *asm_stmt = as_a <const gasm *> (gs);
return asm_stmt->no;
}
@@ -3204,8 +3195,7 @@ gimple_asm_noutputs (const_gimple gs)
static inline unsigned
gimple_asm_nclobbers (const_gimple gs)
{
- const gimple_statement_asm *asm_stmt =
- as_a <const gimple_statement_asm *> (gs);
+ const gasm *asm_stmt = as_a <const gasm *> (gs);
return asm_stmt->nc;
}
@@ -3214,8 +3204,7 @@ gimple_asm_nclobbers (const_gimple gs)
static inline unsigned
gimple_asm_nlabels (const_gimple gs)
{
- const gimple_statement_asm *asm_stmt =
- as_a <const gimple_statement_asm *> (gs);
+ const gasm *asm_stmt = as_a <const gasm *> (gs);
return asm_stmt->nl;
}
@@ -3224,8 +3213,7 @@ gimple_asm_nlabels (const_gimple gs)
static inline tree
gimple_asm_input_op (const_gimple gs, unsigned index)
{
- const gimple_statement_asm *asm_stmt =
- as_a <const gimple_statement_asm *> (gs);
+ const gasm *asm_stmt = as_a <const gasm *> (gs);
gcc_gimple_checking_assert (index < asm_stmt->ni);
return gimple_op (gs, index + asm_stmt->no);
}
@@ -3235,8 +3223,7 @@ gimple_asm_input_op (const_gimple gs, unsigned index)
static inline tree *
gimple_asm_input_op_ptr (const_gimple gs, unsigned index)
{
- const gimple_statement_asm *asm_stmt =
- as_a <const gimple_statement_asm *> (gs);
+ const gasm *asm_stmt = as_a <const gasm *> (gs);
gcc_gimple_checking_assert (index < asm_stmt->ni);
return gimple_op_ptr (gs, index + asm_stmt->no);
}
@@ -3247,7 +3234,7 @@ gimple_asm_input_op_ptr (const_gimple gs, unsigned index)
static inline void
gimple_asm_set_input_op (gimple gs, unsigned index, tree in_op)
{
- gimple_statement_asm *asm_stmt = as_a <gimple_statement_asm *> (gs);
+ gasm *asm_stmt = as_a <gasm *> (gs);
gcc_gimple_checking_assert (index < asm_stmt->ni
&& TREE_CODE (in_op) == TREE_LIST);
gimple_set_op (gs, index + asm_stmt->no, in_op);
@@ -3259,8 +3246,7 @@ gimple_asm_set_input_op (gimple gs, unsigned index, tree in_op)
static inline tree
gimple_asm_output_op (const_gimple gs, unsigned index)
{
- const gimple_statement_asm *asm_stmt =
- as_a <const gimple_statement_asm *> (gs);
+ const gasm *asm_stmt = as_a <const gasm *> (gs);
gcc_gimple_checking_assert (index < asm_stmt->no);
return gimple_op (gs, index);
}
@@ -3270,8 +3256,7 @@ gimple_asm_output_op (const_gimple gs, unsigned index)
static inline tree *
gimple_asm_output_op_ptr (const_gimple gs, unsigned index)
{
- const gimple_statement_asm *asm_stmt =
- as_a <const gimple_statement_asm *> (gs);
+ const gasm *asm_stmt = as_a <const gasm *> (gs);
gcc_gimple_checking_assert (index < asm_stmt->no);
return gimple_op_ptr (gs, index);
}
@@ -3282,7 +3267,7 @@ gimple_asm_output_op_ptr (const_gimple gs, unsigned index)
static inline void
gimple_asm_set_output_op (gimple gs, unsigned index, tree out_op)
{
- gimple_statement_asm *asm_stmt = as_a <gimple_statement_asm *> (gs);
+ gasm *asm_stmt = as_a <gasm *> (gs);
gcc_gimple_checking_assert (index < asm_stmt->no
&& TREE_CODE (out_op) == TREE_LIST);
gimple_set_op (gs, index, out_op);
@@ -3294,8 +3279,7 @@ gimple_asm_set_output_op (gimple gs, unsigned index, tree out_op)
static inline tree
gimple_asm_clobber_op (const_gimple gs, unsigned index)
{
- const gimple_statement_asm *asm_stmt =
- as_a <const gimple_statement_asm *> (gs);
+ const gasm *asm_stmt = as_a <const gasm *> (gs);
gcc_gimple_checking_assert (index < asm_stmt->nc);
return gimple_op (gs, index + asm_stmt->ni + asm_stmt->no);
}
@@ -3306,7 +3290,7 @@ gimple_asm_clobber_op (const_gimple gs, unsigned index)
static inline void
gimple_asm_set_clobber_op (gimple gs, unsigned index, tree clobber_op)
{
- gimple_statement_asm *asm_stmt = as_a <gimple_statement_asm *> (gs);
+ gasm *asm_stmt = as_a <gasm *> (gs);
gcc_gimple_checking_assert (index < asm_stmt->nc
&& TREE_CODE (clobber_op) == TREE_LIST);
gimple_set_op (gs, index + asm_stmt->ni + asm_stmt->no, clobber_op);
@@ -3317,8 +3301,7 @@ gimple_asm_set_clobber_op (gimple gs, unsigned index, tree clobber_op)
static inline tree
gimple_asm_label_op (const_gimple gs, unsigned index)
{
- const gimple_statement_asm *asm_stmt =
- as_a <const gimple_statement_asm *> (gs);
+ const gasm *asm_stmt = as_a <const gasm *> (gs);
gcc_gimple_checking_assert (index < asm_stmt->nl);
return gimple_op (gs, index + asm_stmt->ni + asm_stmt->nc);
}
@@ -3328,7 +3311,7 @@ gimple_asm_label_op (const_gimple gs, unsigned index)
static inline void
gimple_asm_set_label_op (gimple gs, unsigned index, tree label_op)
{
- gimple_statement_asm *asm_stmt = as_a <gimple_statement_asm *> (gs);
+ gasm *asm_stmt = as_a <gasm *> (gs);
gcc_gimple_checking_assert (index < asm_stmt->nl
&& TREE_CODE (label_op) == TREE_LIST);
gimple_set_op (gs, index + asm_stmt->ni + asm_stmt->nc, label_op);
@@ -3340,8 +3323,7 @@ gimple_asm_set_label_op (gimple gs, unsigned index, tree label_op)
static inline const char *
gimple_asm_string (const_gimple gs)
{
- const gimple_statement_asm *asm_stmt =
- as_a <const gimple_statement_asm *> (gs);
+ const gasm *asm_stmt = as_a <const gasm *> (gs);
return asm_stmt->string;
}
@@ -3397,8 +3379,7 @@ gimple_asm_input_p (const_gimple gs)
static inline tree
gimple_catch_types (const_gimple gs)
{
- const gimple_statement_catch *catch_stmt =
- as_a <const gimple_statement_catch *> (gs);
+ const gcatch *catch_stmt = as_a <const gcatch *> (gs);
return catch_stmt->types;
}
@@ -3408,7 +3389,7 @@ gimple_catch_types (const_gimple gs)
static inline tree *
gimple_catch_types_ptr (gimple gs)
{
- gimple_statement_catch *catch_stmt = as_a <gimple_statement_catch *> (gs);
+ gcatch *catch_stmt = as_a <gcatch *> (gs);
return &catch_stmt->types;
}
@@ -3419,7 +3400,7 @@ gimple_catch_types_ptr (gimple gs)
static inline gimple_seq *
gimple_catch_handler_ptr (gimple gs)
{
- gimple_statement_catch *catch_stmt = as_a <gimple_statement_catch *> (gs);
+ gcatch *catch_stmt = as_a <gcatch *> (gs);
return &catch_stmt->handler;
}
@@ -3439,7 +3420,7 @@ gimple_catch_handler (gimple gs)
static inline void
gimple_catch_set_types (gimple gs, tree t)
{
- gimple_statement_catch *catch_stmt = as_a <gimple_statement_catch *> (gs);
+ gcatch *catch_stmt = as_a <gcatch *> (gs);
catch_stmt->types = t;
}
@@ -3449,7 +3430,7 @@ gimple_catch_set_types (gimple gs, tree t)
static inline void
gimple_catch_set_handler (gimple gs, gimple_seq handler)
{
- gimple_statement_catch *catch_stmt = as_a <gimple_statement_catch *> (gs);
+ gcatch *catch_stmt = as_a <gcatch *> (gs);
catch_stmt->handler = handler;
}
@@ -3459,8 +3440,7 @@ gimple_catch_set_handler (gimple gs, gimple_seq handler)
static inline tree
gimple_eh_filter_types (const_gimple gs)
{
- const gimple_statement_eh_filter *eh_filter_stmt =
- as_a <const gimple_statement_eh_filter *> (gs);
+ const geh_filter *eh_filter_stmt = as_a <const geh_filter *> (gs);
return eh_filter_stmt->types;
}
@@ -3471,8 +3451,7 @@ gimple_eh_filter_types (const_gimple gs)
static inline tree *
gimple_eh_filter_types_ptr (gimple gs)
{
- gimple_statement_eh_filter *eh_filter_stmt =
- as_a <gimple_statement_eh_filter *> (gs);
+ geh_filter *eh_filter_stmt = as_a <geh_filter *> (gs);
return &eh_filter_stmt->types;
}
@@ -3483,8 +3462,7 @@ gimple_eh_filter_types_ptr (gimple gs)
static inline gimple_seq *
gimple_eh_filter_failure_ptr (gimple gs)
{
- gimple_statement_eh_filter *eh_filter_stmt =
- as_a <gimple_statement_eh_filter *> (gs);
+ geh_filter *eh_filter_stmt = as_a <geh_filter *> (gs);
return &eh_filter_stmt->failure;
}
@@ -3504,8 +3482,7 @@ gimple_eh_filter_failure (gimple gs)
static inline void
gimple_eh_filter_set_types (gimple gs, tree types)
{
- gimple_statement_eh_filter *eh_filter_stmt =
- as_a <gimple_statement_eh_filter *> (gs);
+ geh_filter *eh_filter_stmt = as_a <geh_filter *> (gs);
eh_filter_stmt->types = types;
}
@@ -3516,8 +3493,7 @@ gimple_eh_filter_set_types (gimple gs, tree types)
static inline void
gimple_eh_filter_set_failure (gimple gs, gimple_seq failure)
{
- gimple_statement_eh_filter *eh_filter_stmt =
- as_a <gimple_statement_eh_filter *> (gs);
+ geh_filter *eh_filter_stmt = as_a <geh_filter *> (gs);
eh_filter_stmt->failure = failure;
}
@@ -3526,7 +3502,7 @@ gimple_eh_filter_set_failure (gimple gs, gimple_seq failure)
static inline tree
gimple_eh_must_not_throw_fndecl (gimple gs)
{
- gimple_statement_eh_mnt *eh_mnt_stmt = as_a <gimple_statement_eh_mnt *> (gs);
+ geh_mnt *eh_mnt_stmt = as_a <geh_mnt *> (gs);
return eh_mnt_stmt->fndecl;
}
@@ -3535,7 +3511,7 @@ gimple_eh_must_not_throw_fndecl (gimple gs)
static inline void
gimple_eh_must_not_throw_set_fndecl (gimple gs, tree decl)
{
- gimple_statement_eh_mnt *eh_mnt_stmt = as_a <gimple_statement_eh_mnt *> (gs);
+ geh_mnt *eh_mnt_stmt = as_a <geh_mnt *> (gs);
eh_mnt_stmt->fndecl = decl;
}
@@ -3544,8 +3520,7 @@ gimple_eh_must_not_throw_set_fndecl (gimple gs, tree decl)
static inline gimple_seq *
gimple_eh_else_n_body_ptr (gimple gs)
{
- gimple_statement_eh_else *eh_else_stmt =
- as_a <gimple_statement_eh_else *> (gs);
+ geh_else *eh_else_stmt = as_a <geh_else *> (gs);
return &eh_else_stmt->n_body;
}
@@ -3558,8 +3533,7 @@ gimple_eh_else_n_body (gimple gs)
static inline gimple_seq *
gimple_eh_else_e_body_ptr (gimple gs)
{
- gimple_statement_eh_else *eh_else_stmt =
- as_a <gimple_statement_eh_else *> (gs);
+ geh_else *eh_else_stmt = as_a <geh_else *> (gs);
return &eh_else_stmt->e_body;
}
@@ -3572,16 +3546,14 @@ gimple_eh_else_e_body (gimple gs)
static inline void
gimple_eh_else_set_n_body (gimple gs, gimple_seq seq)
{
- gimple_statement_eh_else *eh_else_stmt =
- as_a <gimple_statement_eh_else *> (gs);
+ geh_else *eh_else_stmt = as_a <geh_else *> (gs);
eh_else_stmt->n_body = seq;
}
static inline void
gimple_eh_else_set_e_body (gimple gs, gimple_seq seq)
{
- gimple_statement_eh_else *eh_else_stmt =
- as_a <gimple_statement_eh_else *> (gs);
+ geh_else *eh_else_stmt = as_a <geh_else *> (gs);
eh_else_stmt->e_body = seq;
}
@@ -3627,7 +3599,7 @@ gimple_try_catch_is_cleanup (const_gimple gs)
static inline gimple_seq *
gimple_try_eval_ptr (gimple gs)
{
- gimple_statement_try *try_stmt = as_a <gimple_statement_try *> (gs);
+ gtry *try_stmt = as_a <gtry *> (gs);
return &try_stmt->eval;
}
@@ -3647,7 +3619,7 @@ gimple_try_eval (gimple gs)
static inline gimple_seq *
gimple_try_cleanup_ptr (gimple gs)
{
- gimple_statement_try *try_stmt = as_a <gimple_statement_try *> (gs);
+ gtry *try_stmt = as_a <gtry *> (gs);
return &try_stmt->cleanup;
}
@@ -3681,7 +3653,7 @@ gimple_try_set_catch_is_cleanup (gimple g, bool catch_is_cleanup)
static inline void
gimple_try_set_eval (gimple gs, gimple_seq eval)
{
- gimple_statement_try *try_stmt = as_a <gimple_statement_try *> (gs);
+ gtry *try_stmt = as_a <gtry *> (gs);
try_stmt->eval = eval;
}
@@ -3692,7 +3664,7 @@ gimple_try_set_eval (gimple gs, gimple_seq eval)
static inline void
gimple_try_set_cleanup (gimple gs, gimple_seq cleanup)
{
- gimple_statement_try *try_stmt = as_a <gimple_statement_try *> (gs);
+ gtry *try_stmt = as_a <gtry *> (gs);
try_stmt->cleanup = cleanup;
}
@@ -3702,7 +3674,7 @@ gimple_try_set_cleanup (gimple gs, gimple_seq cleanup)
static inline gimple_seq *
gimple_wce_cleanup_ptr (gimple gs)
{
- gimple_statement_wce *wce_stmt = as_a <gimple_statement_wce *> (gs);
+ gwce *wce_stmt = as_a <gwce *> (gs);
return &wce_stmt->cleanup;
}
@@ -3721,7 +3693,7 @@ gimple_wce_cleanup (gimple gs)
static inline void
gimple_wce_set_cleanup (gimple gs, gimple_seq cleanup)
{
- gimple_statement_wce *wce_stmt = as_a <gimple_statement_wce *> (gs);
+ gwce *wce_stmt = as_a <gwce *> (gs);
wce_stmt->cleanup = cleanup;
}
@@ -3751,8 +3723,7 @@ gimple_wce_set_cleanup_eh_only (gimple gs, bool eh_only_p)
static inline unsigned
gimple_phi_capacity (const_gimple gs)
{
- const gimple_statement_phi *phi_stmt =
- as_a <const gimple_statement_phi *> (gs);
+ const gphi *phi_stmt = as_a <const gphi *> (gs);
return phi_stmt->capacity;
}
@@ -3764,8 +3735,7 @@ gimple_phi_capacity (const_gimple gs)
static inline unsigned
gimple_phi_num_args (const_gimple gs)
{
- const gimple_statement_phi *phi_stmt =
- as_a <const gimple_statement_phi *> (gs);
+ const gphi *phi_stmt = as_a <const gphi *> (gs);
return phi_stmt->nargs;
}
@@ -3775,8 +3745,7 @@ gimple_phi_num_args (const_gimple gs)
static inline tree
gimple_phi_result (const_gimple gs)
{
- const gimple_statement_phi *phi_stmt =
- as_a <const gimple_statement_phi *> (gs);
+ const gphi *phi_stmt = as_a <const gphi *> (gs);
return phi_stmt->result;
}
@@ -3785,7 +3754,7 @@ gimple_phi_result (const_gimple gs)
static inline tree *
gimple_phi_result_ptr (gimple gs)
{
- gimple_statement_phi *phi_stmt = as_a <gimple_statement_phi *> (gs);
+ gphi *phi_stmt = as_a <gphi *> (gs);
return &phi_stmt->result;
}
@@ -3794,7 +3763,7 @@ gimple_phi_result_ptr (gimple gs)
static inline void
gimple_phi_set_result (gimple gs, tree result)
{
- gimple_statement_phi *phi_stmt = as_a <gimple_statement_phi *> (gs);
+ gphi *phi_stmt = as_a <gphi *> (gs);
phi_stmt->result = result;
if (result && TREE_CODE (result) == SSA_NAME)
SSA_NAME_DEF_STMT (result) = gs;
@@ -3807,7 +3776,7 @@ gimple_phi_set_result (gimple gs, tree result)
static inline struct phi_arg_d *
gimple_phi_arg (gimple gs, unsigned index)
{
- gimple_statement_phi *phi_stmt = as_a <gimple_statement_phi *> (gs);
+ gphi *phi_stmt = as_a <gphi *> (gs);
gcc_gimple_checking_assert (index <= phi_stmt->capacity);
return &(phi_stmt->args[index]);
}
@@ -3818,7 +3787,7 @@ gimple_phi_arg (gimple gs, unsigned index)
static inline void
gimple_phi_set_arg (gimple gs, unsigned index, struct phi_arg_d * phiarg)
{
- gimple_statement_phi *phi_stmt = as_a <gimple_statement_phi *> (gs);
+ gphi *phi_stmt = as_a <gphi *> (gs);
gcc_gimple_checking_assert (index <= phi_stmt->nargs);
phi_stmt->args[index] = *phiarg;
}
@@ -3905,8 +3874,7 @@ gimple_phi_arg_has_location (gimple gs, size_t i)
static inline int
gimple_resx_region (const_gimple gs)
{
- const gimple_statement_resx *resx_stmt =
- as_a <const gimple_statement_resx *> (gs);
+ const gresx *resx_stmt = as_a <const gresx *> (gs);
return resx_stmt->region;
}
@@ -3915,7 +3883,7 @@ gimple_resx_region (const_gimple gs)
static inline void
gimple_resx_set_region (gimple gs, int region)
{
- gimple_statement_resx *resx_stmt = as_a <gimple_statement_resx *> (gs);
+ gresx *resx_stmt = as_a <gresx *> (gs);
resx_stmt->region = region;
}
@@ -3924,8 +3892,7 @@ gimple_resx_set_region (gimple gs, int region)
static inline int
gimple_eh_dispatch_region (const_gimple gs)
{
- const gimple_statement_eh_dispatch *eh_dispatch_stmt =
- as_a <const gimple_statement_eh_dispatch *> (gs);
+ const geh_dispatch *eh_dispatch_stmt = as_a <const geh_dispatch *> (gs);
return eh_dispatch_stmt->region;
}
@@ -3934,8 +3901,7 @@ gimple_eh_dispatch_region (const_gimple gs)
static inline void
gimple_eh_dispatch_set_region (gimple gs, int region)
{
- gimple_statement_eh_dispatch *eh_dispatch_stmt =
- as_a <gimple_statement_eh_dispatch *> (gs);
+ geh_dispatch *eh_dispatch_stmt = as_a <geh_dispatch *> (gs);
eh_dispatch_stmt->region = region;
}
@@ -4221,7 +4187,7 @@ get_lineno (const_gimple stmt)
static inline gimple_seq *
gimple_omp_body_ptr (gimple gs)
{
- return &static_cast <gimple_statement_omp *> (gs)->body;
+ return &static_cast <gomp *> (gs)->body;
}
/* Return the body for the OMP statement GS. */
@@ -4237,7 +4203,7 @@ gimple_omp_body (gimple gs)
static inline void
gimple_omp_set_body (gimple gs, gimple_seq body)
{
- static_cast <gimple_statement_omp *> (gs)->body = body;
+ static_cast <gomp *> (gs)->body = body;
}
@@ -4246,8 +4212,7 @@ gimple_omp_set_body (gimple gs, gimple_seq body)
static inline tree
gimple_omp_critical_name (const_gimple gs)
{
- const gimple_statement_omp_critical *omp_critical_stmt =
- as_a <const gimple_statement_omp_critical *> (gs);
+ const gomp_critical *omp_critical_stmt = as_a <const gomp_critical *> (gs);
return omp_critical_stmt->name;
}
@@ -4257,8 +4222,7 @@ gimple_omp_critical_name (const_gimple gs)
static inline tree *
gimple_omp_critical_name_ptr (gimple gs)
{
- gimple_statement_omp_critical *omp_critical_stmt =
- as_a <gimple_statement_omp_critical *> (gs);
+ gomp_critical *omp_critical_stmt = as_a <gomp_critical *> (gs);
return &omp_critical_stmt->name;
}
@@ -4268,8 +4232,7 @@ gimple_omp_critical_name_ptr (gimple gs)
static inline void
gimple_omp_critical_set_name (gimple gs, tree name)
{
- gimple_statement_omp_critical *omp_critical_stmt =
- as_a <gimple_statement_omp_critical *> (gs);
+ gomp_critical *omp_critical_stmt = as_a <gomp_critical *> (gs);
omp_critical_stmt->name = name;
}
@@ -4350,8 +4313,7 @@ gimple_omp_for_set_combined_into_p (gimple g, bool combined_p)
static inline tree
gimple_omp_for_clauses (const_gimple gs)
{
- const gimple_statement_omp_for *omp_for_stmt =
- as_a <const gimple_statement_omp_for *> (gs);
+ const gomp_for *omp_for_stmt = as_a <const gomp_for *> (gs);
return omp_for_stmt->clauses;
}
@@ -4361,8 +4323,7 @@ gimple_omp_for_clauses (const_gimple gs)
static inline tree *
gimple_omp_for_clauses_ptr (gimple gs)
{
- gimple_statement_omp_for *omp_for_stmt =
- as_a <gimple_statement_omp_for *> (gs);
+ gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
return &omp_for_stmt->clauses;
}
@@ -4372,8 +4333,7 @@ gimple_omp_for_clauses_ptr (gimple gs)
static inline void
gimple_omp_for_set_clauses (gimple gs, tree clauses)
{
- gimple_statement_omp_for *omp_for_stmt =
- as_a <gimple_statement_omp_for *> (gs);
+ gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
omp_for_stmt->clauses = clauses;
}
@@ -4383,8 +4343,7 @@ gimple_omp_for_set_clauses (gimple gs, tree clauses)
static inline size_t
gimple_omp_for_collapse (gimple gs)
{
- gimple_statement_omp_for *omp_for_stmt =
- as_a <gimple_statement_omp_for *> (gs);
+ gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
return omp_for_stmt->collapse;
}
@@ -4394,8 +4353,7 @@ gimple_omp_for_collapse (gimple gs)
static inline tree
gimple_omp_for_index (const_gimple gs, size_t i)
{
- const gimple_statement_omp_for *omp_for_stmt =
- as_a <const gimple_statement_omp_for *> (gs);
+ const gomp_for *omp_for_stmt = as_a <const gomp_for *> (gs);
gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
return omp_for_stmt->iter[i].index;
}
@@ -4406,8 +4364,7 @@ gimple_omp_for_index (const_gimple gs, size_t i)
static inline tree *
gimple_omp_for_index_ptr (gimple gs, size_t i)
{
- gimple_statement_omp_for *omp_for_stmt =
- as_a <gimple_statement_omp_for *> (gs);
+ gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
return &omp_for_stmt->iter[i].index;
}
@@ -4418,8 +4375,7 @@ gimple_omp_for_index_ptr (gimple gs, size_t i)
static inline void
gimple_omp_for_set_index (gimple gs, size_t i, tree index)
{
- gimple_statement_omp_for *omp_for_stmt =
- as_a <gimple_statement_omp_for *> (gs);
+ gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
omp_for_stmt->iter[i].index = index;
}
@@ -4430,8 +4386,7 @@ gimple_omp_for_set_index (gimple gs, size_t i, tree index)
static inline tree
gimple_omp_for_initial (const_gimple gs, size_t i)
{
- const gimple_statement_omp_for *omp_for_stmt =
- as_a <const gimple_statement_omp_for *> (gs);
+ const gomp_for *omp_for_stmt = as_a <const gomp_for *> (gs);
gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
return omp_for_stmt->iter[i].initial;
}
@@ -4442,8 +4397,7 @@ gimple_omp_for_initial (const_gimple gs, size_t i)
static inline tree *
gimple_omp_for_initial_ptr (gimple gs, size_t i)
{
- gimple_statement_omp_for *omp_for_stmt =
- as_a <gimple_statement_omp_for *> (gs);
+ gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
return &omp_for_stmt->iter[i].initial;
}
@@ -4454,8 +4408,7 @@ gimple_omp_for_initial_ptr (gimple gs, size_t i)
static inline void
gimple_omp_for_set_initial (gimple gs, size_t i, tree initial)
{
- gimple_statement_omp_for *omp_for_stmt =
- as_a <gimple_statement_omp_for *> (gs);
+ gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
omp_for_stmt->iter[i].initial = initial;
}
@@ -4466,8 +4419,7 @@ gimple_omp_for_set_initial (gimple gs, size_t i, tree initial)
static inline tree
gimple_omp_for_final (const_gimple gs, size_t i)
{
- const gimple_statement_omp_for *omp_for_stmt =
- as_a <const gimple_statement_omp_for *> (gs);
+ const gomp_for *omp_for_stmt = as_a <const gomp_for *> (gs);
gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
return omp_for_stmt->iter[i].final;
}
@@ -4478,8 +4430,7 @@ gimple_omp_for_final (const_gimple gs, size_t i)
static inline tree *
gimple_omp_for_final_ptr (gimple gs, size_t i)
{
- gimple_statement_omp_for *omp_for_stmt =
- as_a <gimple_statement_omp_for *> (gs);
+ gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
return &omp_for_stmt->iter[i].final;
}
@@ -4490,8 +4441,7 @@ gimple_omp_for_final_ptr (gimple gs, size_t i)
static inline void
gimple_omp_for_set_final (gimple gs, size_t i, tree final)
{
- gimple_statement_omp_for *omp_for_stmt =
- as_a <gimple_statement_omp_for *> (gs);
+ gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
omp_for_stmt->iter[i].final = final;
}
@@ -4502,8 +4452,7 @@ gimple_omp_for_set_final (gimple gs, size_t i, tree final)
static inline tree
gimple_omp_for_incr (const_gimple gs, size_t i)
{
- const gimple_statement_omp_for *omp_for_stmt =
- as_a <const gimple_statement_omp_for *> (gs);
+ const gomp_for *omp_for_stmt = as_a <const gomp_for *> (gs);
gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
return omp_for_stmt->iter[i].incr;
}
@@ -4514,8 +4463,7 @@ gimple_omp_for_incr (const_gimple gs, size_t i)
static inline tree *
gimple_omp_for_incr_ptr (gimple gs, size_t i)
{
- gimple_statement_omp_for *omp_for_stmt =
- as_a <gimple_statement_omp_for *> (gs);
+ gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
return &omp_for_stmt->iter[i].incr;
}
@@ -4526,8 +4474,7 @@ gimple_omp_for_incr_ptr (gimple gs, size_t i)
static inline void
gimple_omp_for_set_incr (gimple gs, size_t i, tree incr)
{
- gimple_statement_omp_for *omp_for_stmt =
- as_a <gimple_statement_omp_for *> (gs);
+ gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
omp_for_stmt->iter[i].incr = incr;
}
@@ -4539,8 +4486,7 @@ gimple_omp_for_set_incr (gimple gs, size_t i, tree incr)
static inline gimple_seq *
gimple_omp_for_pre_body_ptr (gimple gs)
{
- gimple_statement_omp_for *omp_for_stmt =
- as_a <gimple_statement_omp_for *> (gs);
+ gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
return &omp_for_stmt->pre_body;
}
@@ -4561,8 +4507,7 @@ gimple_omp_for_pre_body (gimple gs)
static inline void
gimple_omp_for_set_pre_body (gimple gs, gimple_seq pre_body)
{
- gimple_statement_omp_for *omp_for_stmt =
- as_a <gimple_statement_omp_for *> (gs);
+ gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
omp_for_stmt->pre_body = pre_body;
}
@@ -4572,8 +4517,8 @@ gimple_omp_for_set_pre_body (gimple gs, gimple_seq pre_body)
static inline tree
gimple_omp_parallel_clauses (const_gimple gs)
{
- const gimple_statement_omp_parallel *omp_parallel_stmt =
- as_a <const gimple_statement_omp_parallel *> (gs);
+ const gomp_parallel *omp_parallel_stmt =
+ as_a <const gomp_parallel *> (gs);
return omp_parallel_stmt->clauses;
}
@@ -4583,8 +4528,7 @@ gimple_omp_parallel_clauses (const_gimple gs)
static inline tree *
gimple_omp_parallel_clauses_ptr (gimple gs)
{
- gimple_statement_omp_parallel *omp_parallel_stmt =
- as_a <gimple_statement_omp_parallel *> (gs);
+ gomp_parallel *omp_parallel_stmt = as_a <gomp_parallel *> (gs);
return &omp_parallel_stmt->clauses;
}
@@ -4595,8 +4539,7 @@ gimple_omp_parallel_clauses_ptr (gimple gs)
static inline void
gimple_omp_parallel_set_clauses (gimple gs, tree clauses)
{
- gimple_statement_omp_parallel *omp_parallel_stmt =
- as_a <gimple_statement_omp_parallel *> (gs);
+ gomp_parallel *omp_parallel_stmt = as_a <gomp_parallel *> (gs);
omp_parallel_stmt->clauses = clauses;
}
@@ -4606,8 +4549,8 @@ gimple_omp_parallel_set_clauses (gimple gs, tree clauses)
static inline tree
gimple_omp_parallel_child_fn (const_gimple gs)
{
- const gimple_statement_omp_parallel *omp_parallel_stmt =
- as_a <const gimple_statement_omp_parallel *> (gs);
+ const gomp_parallel *omp_parallel_stmt =
+ as_a <const gomp_parallel *> (gs);
return omp_parallel_stmt->child_fn;
}
@@ -4617,8 +4560,7 @@ gimple_omp_parallel_child_fn (const_gimple gs)
static inline tree *
gimple_omp_parallel_child_fn_ptr (gimple gs)
{
- gimple_statement_omp_parallel *omp_parallel_stmt =
- as_a <gimple_statement_omp_parallel *> (gs);
+ gomp_parallel *omp_parallel_stmt = as_a <gomp_parallel *> (gs);
return &omp_parallel_stmt->child_fn;
}
@@ -4628,8 +4570,7 @@ gimple_omp_parallel_child_fn_ptr (gimple gs)
static inline void
gimple_omp_parallel_set_child_fn (gimple gs, tree child_fn)
{
- gimple_statement_omp_parallel *omp_parallel_stmt =
- as_a <gimple_statement_omp_parallel *> (gs);
+ gomp_parallel *omp_parallel_stmt =as_a <gomp_parallel *> (gs);
omp_parallel_stmt->child_fn = child_fn;
}
@@ -4640,8 +4581,8 @@ gimple_omp_parallel_set_child_fn (gimple gs, tree child_fn)
static inline tree
gimple_omp_parallel_data_arg (const_gimple gs)
{
- const gimple_statement_omp_parallel *omp_parallel_stmt =
- as_a <const gimple_statement_omp_parallel *> (gs);
+ const gomp_parallel *omp_parallel_stmt =
+ as_a <const gomp_parallel *> (gs);
return omp_parallel_stmt->data_arg;
}
@@ -4651,8 +4592,7 @@ gimple_omp_parallel_data_arg (const_gimple gs)
static inline tree *
gimple_omp_parallel_data_arg_ptr (gimple gs)
{
- gimple_statement_omp_parallel *omp_parallel_stmt =
- as_a <gimple_statement_omp_parallel *> (gs);
+ gomp_parallel *omp_parallel_stmt = as_a <gomp_parallel *> (gs);
return &omp_parallel_stmt->data_arg;
}
@@ -4662,8 +4602,7 @@ gimple_omp_parallel_data_arg_ptr (gimple gs)
static inline void
gimple_omp_parallel_set_data_arg (gimple gs, tree data_arg)
{
- gimple_statement_omp_parallel *omp_parallel_stmt =
- as_a <gimple_statement_omp_parallel *> (gs);
+ gomp_parallel *omp_parallel_stmt = as_a <gomp_parallel *> (gs);
omp_parallel_stmt->data_arg = data_arg;
}
@@ -4673,8 +4612,7 @@ gimple_omp_parallel_set_data_arg (gimple gs, tree data_arg)
static inline tree
gimple_omp_task_clauses (const_gimple gs)
{
- const gimple_statement_omp_task *omp_task_stmt =
- as_a <const gimple_statement_omp_task *> (gs);
+ const gomp_task *omp_task_stmt = as_a <const gomp_task *> (gs);
return omp_task_stmt->clauses;
}
@@ -4684,8 +4622,7 @@ gimple_omp_task_clauses (const_gimple gs)
static inline tree *
gimple_omp_task_clauses_ptr (gimple gs)
{
- gimple_statement_omp_task *omp_task_stmt =
- as_a <gimple_statement_omp_task *> (gs);
+ gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
return &omp_task_stmt->clauses;
}
@@ -4696,8 +4633,7 @@ gimple_omp_task_clauses_ptr (gimple gs)
static inline void
gimple_omp_task_set_clauses (gimple gs, tree clauses)
{
- gimple_statement_omp_task *omp_task_stmt =
- as_a <gimple_statement_omp_task *> (gs);
+ gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
omp_task_stmt->clauses = clauses;
}
@@ -4707,8 +4643,7 @@ gimple_omp_task_set_clauses (gimple gs, tree clauses)
static inline tree
gimple_omp_task_child_fn (const_gimple gs)
{
- const gimple_statement_omp_task *omp_task_stmt =
- as_a <const gimple_statement_omp_task *> (gs);
+ const gomp_task *omp_task_stmt = as_a <const gomp_task *> (gs);
return omp_task_stmt->child_fn;
}
@@ -4718,8 +4653,7 @@ gimple_omp_task_child_fn (const_gimple gs)
static inline tree *
gimple_omp_task_child_fn_ptr (gimple gs)
{
- gimple_statement_omp_task *omp_task_stmt =
- as_a <gimple_statement_omp_task *> (gs);
+ gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
return &omp_task_stmt->child_fn;
}
@@ -4729,8 +4663,7 @@ gimple_omp_task_child_fn_ptr (gimple gs)
static inline void
gimple_omp_task_set_child_fn (gimple gs, tree child_fn)
{
- gimple_statement_omp_task *omp_task_stmt =
- as_a <gimple_statement_omp_task *> (gs);
+ gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
omp_task_stmt->child_fn = child_fn;
}
@@ -4741,8 +4674,7 @@ gimple_omp_task_set_child_fn (gimple gs, tree child_fn)
static inline tree
gimple_omp_task_data_arg (const_gimple gs)
{
- const gimple_statement_omp_task *omp_task_stmt =
- as_a <const gimple_statement_omp_task *> (gs);
+ const gomp_task *omp_task_stmt = as_a <const gomp_task *> (gs);
return omp_task_stmt->data_arg;
}
@@ -4752,8 +4684,7 @@ gimple_omp_task_data_arg (const_gimple gs)
static inline tree *
gimple_omp_task_data_arg_ptr (gimple gs)
{
- gimple_statement_omp_task *omp_task_stmt =
- as_a <gimple_statement_omp_task *> (gs);
+ gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
return &omp_task_stmt->data_arg;
}
@@ -4763,8 +4694,7 @@ gimple_omp_task_data_arg_ptr (gimple gs)
static inline void
gimple_omp_task_set_data_arg (gimple gs, tree data_arg)
{
- gimple_statement_omp_task *omp_task_stmt =
- as_a <gimple_statement_omp_task *> (gs);
+ gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
omp_task_stmt->data_arg = data_arg;
}
@@ -4774,8 +4704,7 @@ gimple_omp_task_set_data_arg (gimple gs, tree data_arg)
static inline tree
gimple_omp_taskreg_clauses (const_gimple gs)
{
- const gimple_statement_omp_taskreg *omp_taskreg_stmt =
- as_a <const gimple_statement_omp_taskreg *> (gs);
+ const gomp_taskreg *omp_taskreg_stmt = as_a <const gomp_taskreg *> (gs);
return omp_taskreg_stmt->clauses;
}
@@ -4785,8 +4714,7 @@ gimple_omp_taskreg_clauses (const_gimple gs)
static inline tree *
gimple_omp_taskreg_clauses_ptr (gimple gs)
{
- gimple_statement_omp_taskreg *omp_taskreg_stmt =
- as_a <gimple_statement_omp_taskreg *> (gs);
+ gomp_taskreg *omp_taskreg_stmt = as_a <gomp_taskreg *> (gs);
return &omp_taskreg_stmt->clauses;
}
@@ -4797,8 +4725,7 @@ gimple_omp_taskreg_clauses_ptr (gimple gs)
static inline void
gimple_omp_taskreg_set_clauses (gimple gs, tree clauses)
{
- gimple_statement_omp_taskreg *omp_taskreg_stmt =
- as_a <gimple_statement_omp_taskreg *> (gs);
+ gomp_taskreg *omp_taskreg_stmt = as_a <gomp_taskreg *> (gs);
omp_taskreg_stmt->clauses = clauses;
}
@@ -4808,8 +4735,7 @@ gimple_omp_taskreg_set_clauses (gimple gs, tree clauses)
static inline tree
gimple_omp_taskreg_child_fn (const_gimple gs)
{
- const gimple_statement_omp_taskreg *omp_taskreg_stmt =
- as_a <const gimple_statement_omp_taskreg *> (gs);
+ const gomp_taskreg *omp_taskreg_stmt = as_a <const gomp_taskreg *> (gs);
return omp_taskreg_stmt->child_fn;
}
@@ -4819,8 +4745,7 @@ gimple_omp_taskreg_child_fn (const_gimple gs)
static inline tree *
gimple_omp_taskreg_child_fn_ptr (gimple gs)
{
- gimple_statement_omp_taskreg *omp_taskreg_stmt =
- as_a <gimple_statement_omp_taskreg *> (gs);
+ gomp_taskreg *omp_taskreg_stmt = as_a <gomp_taskreg *> (gs);
return &omp_taskreg_stmt->child_fn;
}
@@ -4830,8 +4755,7 @@ gimple_omp_taskreg_child_fn_ptr (gimple gs)
static inline void
gimple_omp_taskreg_set_child_fn (gimple gs, tree child_fn)
{
- gimple_statement_omp_taskreg *omp_taskreg_stmt =
- as_a <gimple_statement_omp_taskreg *> (gs);
+ gomp_taskreg *omp_taskreg_stmt = as_a <gomp_taskreg *> (gs);
omp_taskreg_stmt->child_fn = child_fn;
}
@@ -4842,8 +4766,7 @@ gimple_omp_taskreg_set_child_fn (gimple gs, tree child_fn)
static inline tree
gimple_omp_taskreg_data_arg (const_gimple gs)
{
- const gimple_statement_omp_taskreg *omp_taskreg_stmt =
- as_a <const gimple_statement_omp_taskreg *> (gs);
+ const gomp_taskreg *omp_taskreg_stmt = as_a <const gomp_taskreg *> (gs);
return omp_taskreg_stmt->data_arg;
}
@@ -4853,8 +4776,7 @@ gimple_omp_taskreg_data_arg (const_gimple gs)
static inline tree *
gimple_omp_taskreg_data_arg_ptr (gimple gs)
{
- gimple_statement_omp_taskreg *omp_taskreg_stmt =
- as_a <gimple_statement_omp_taskreg *> (gs);
+ gomp_taskreg *omp_taskreg_stmt = as_a <gomp_taskreg *> (gs);
return &omp_taskreg_stmt->data_arg;
}
@@ -4864,8 +4786,7 @@ gimple_omp_taskreg_data_arg_ptr (gimple gs)
static inline void
gimple_omp_taskreg_set_data_arg (gimple gs, tree data_arg)
{
- gimple_statement_omp_taskreg *omp_taskreg_stmt =
- as_a <gimple_statement_omp_taskreg *> (gs);
+ gomp_taskreg *omp_taskreg_stmt = as_a <gomp_taskreg *> (gs);
omp_taskreg_stmt->data_arg = data_arg;
}
@@ -4875,8 +4796,7 @@ gimple_omp_taskreg_set_data_arg (gimple gs, tree data_arg)
static inline tree
gimple_omp_task_copy_fn (const_gimple gs)
{
- const gimple_statement_omp_task *omp_task_stmt =
- as_a <const gimple_statement_omp_task *> (gs);
+ const gomp_task *omp_task_stmt = as_a <const gomp_task *> (gs);
return omp_task_stmt->copy_fn;
}
@@ -4886,8 +4806,7 @@ gimple_omp_task_copy_fn (const_gimple gs)
static inline tree *
gimple_omp_task_copy_fn_ptr (gimple gs)
{
- gimple_statement_omp_task *omp_task_stmt =
- as_a <gimple_statement_omp_task *> (gs);
+ gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
return &omp_task_stmt->copy_fn;
}
@@ -4897,8 +4816,7 @@ gimple_omp_task_copy_fn_ptr (gimple gs)
static inline void
gimple_omp_task_set_copy_fn (gimple gs, tree copy_fn)
{
- gimple_statement_omp_task *omp_task_stmt =
- as_a <gimple_statement_omp_task *> (gs);
+ gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
omp_task_stmt->copy_fn = copy_fn;
}
@@ -4908,8 +4826,7 @@ gimple_omp_task_set_copy_fn (gimple gs, tree copy_fn)
static inline tree
gimple_omp_task_arg_size (const_gimple gs)
{
- const gimple_statement_omp_task *omp_task_stmt =
- as_a <const gimple_statement_omp_task *> (gs);
+ const gomp_task *omp_task_stmt = as_a <const gomp_task *> (gs);
return omp_task_stmt->arg_size;
}
@@ -4919,8 +4836,7 @@ gimple_omp_task_arg_size (const_gimple gs)
static inline tree *
gimple_omp_task_arg_size_ptr (gimple gs)
{
- gimple_statement_omp_task *omp_task_stmt =
- as_a <gimple_statement_omp_task *> (gs);
+ gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
return &omp_task_stmt->arg_size;
}
@@ -4930,8 +4846,7 @@ gimple_omp_task_arg_size_ptr (gimple gs)
static inline void
gimple_omp_task_set_arg_size (gimple gs, tree arg_size)
{
- gimple_statement_omp_task *omp_task_stmt =
- as_a <gimple_statement_omp_task *> (gs);
+ gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
omp_task_stmt->arg_size = arg_size;
}
@@ -4941,8 +4856,7 @@ gimple_omp_task_set_arg_size (gimple gs, tree arg_size)
static inline tree
gimple_omp_task_arg_align (const_gimple gs)
{
- const gimple_statement_omp_task *omp_task_stmt =
- as_a <const gimple_statement_omp_task *> (gs);
+ const gomp_task *omp_task_stmt = as_a <const gomp_task *> (gs);
return omp_task_stmt->arg_align;
}
@@ -4952,8 +4866,7 @@ gimple_omp_task_arg_align (const_gimple gs)
static inline tree *
gimple_omp_task_arg_align_ptr (gimple gs)
{
- gimple_statement_omp_task *omp_task_stmt =
- as_a <gimple_statement_omp_task *> (gs);
+ gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
return &omp_task_stmt->arg_align;
}
@@ -4963,8 +4876,7 @@ gimple_omp_task_arg_align_ptr (gimple gs)
static inline void
gimple_omp_task_set_arg_align (gimple gs, tree arg_align)
{
- gimple_statement_omp_task *omp_task_stmt =
- as_a <gimple_statement_omp_task *> (gs);
+ gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
omp_task_stmt->arg_align = arg_align;
}
@@ -4974,8 +4886,7 @@ gimple_omp_task_set_arg_align (gimple gs, tree arg_align)
static inline tree
gimple_omp_single_clauses (const_gimple gs)
{
- const gimple_statement_omp_single *omp_single_stmt =
- as_a <const gimple_statement_omp_single *> (gs);
+ const gomp_single *omp_single_stmt = as_a <const gomp_single *> (gs);
return omp_single_stmt->clauses;
}
@@ -4985,8 +4896,7 @@ gimple_omp_single_clauses (const_gimple gs)
static inline tree *
gimple_omp_single_clauses_ptr (gimple gs)
{
- gimple_statement_omp_single *omp_single_stmt =
- as_a <gimple_statement_omp_single *> (gs);
+ gomp_single *omp_single_stmt = as_a <gomp_single *> (gs);
return &omp_single_stmt->clauses;
}
@@ -4996,8 +4906,7 @@ gimple_omp_single_clauses_ptr (gimple gs)
static inline void
gimple_omp_single_set_clauses (gimple gs, tree clauses)
{
- gimple_statement_omp_single *omp_single_stmt =
- as_a <gimple_statement_omp_single *> (gs);
+ gomp_single *omp_single_stmt = as_a <gomp_single *> (gs);
omp_single_stmt->clauses = clauses;
}
@@ -5007,8 +4916,7 @@ gimple_omp_single_set_clauses (gimple gs, tree clauses)
static inline tree
gimple_omp_target_clauses (const_gimple gs)
{
- const gimple_statement_omp_target *omp_target_stmt =
- as_a <const gimple_statement_omp_target *> (gs);
+ const gomp_target *omp_target_stmt = as_a <const gomp_target *> (gs);
return omp_target_stmt->clauses;
}
@@ -5018,8 +4926,7 @@ gimple_omp_target_clauses (const_gimple gs)
static inline tree *
gimple_omp_target_clauses_ptr (gimple gs)
{
- gimple_statement_omp_target *omp_target_stmt =
- as_a <gimple_statement_omp_target *> (gs);
+ gomp_target *omp_target_stmt = as_a <gomp_target *> (gs);
return &omp_target_stmt->clauses;
}
@@ -5029,8 +4936,7 @@ gimple_omp_target_clauses_ptr (gimple gs)
static inline void
gimple_omp_target_set_clauses (gimple gs, tree clauses)
{
- gimple_statement_omp_target *omp_target_stmt =
- as_a <gimple_statement_omp_target *> (gs);
+ gomp_target *omp_target_stmt = as_a <gomp_target *> (gs);
omp_target_stmt->clauses = clauses;
}
@@ -5061,8 +4967,7 @@ gimple_omp_target_set_kind (gimple g, int kind)
static inline tree
gimple_omp_target_child_fn (const_gimple gs)
{
- const gimple_statement_omp_target *omp_target_stmt =
- as_a <const gimple_statement_omp_target *> (gs);
+ const gomp_target *omp_target_stmt = as_a <const gomp_target *> (gs);
return omp_target_stmt->child_fn;
}
@@ -5072,8 +4977,7 @@ gimple_omp_target_child_fn (const_gimple gs)
static inline tree *
gimple_omp_target_child_fn_ptr (gimple gs)
{
- gimple_statement_omp_target *omp_target_stmt =
- as_a <gimple_statement_omp_target *> (gs);
+ gomp_target *omp_target_stmt = as_a <gomp_target *> (gs);
return &omp_target_stmt->child_fn;
}
@@ -5083,8 +4987,7 @@ gimple_omp_target_child_fn_ptr (gimple gs)
static inline void
gimple_omp_target_set_child_fn (gimple gs, tree child_fn)
{
- gimple_statement_omp_target *omp_target_stmt =
- as_a <gimple_statement_omp_target *> (gs);
+ gomp_target *omp_target_stmt = as_a <gomp_target *> (gs);
omp_target_stmt->child_fn = child_fn;
}
@@ -5095,8 +4998,7 @@ gimple_omp_target_set_child_fn (gimple gs, tree child_fn)
static inline tree
gimple_omp_target_data_arg (const_gimple gs)
{
- const gimple_statement_omp_target *omp_target_stmt =
- as_a <const gimple_statement_omp_target *> (gs);
+ const gomp_target *omp_target_stmt = as_a <const gomp_target *> (gs);
return omp_target_stmt->data_arg;
}
@@ -5106,8 +5008,7 @@ gimple_omp_target_data_arg (const_gimple gs)
static inline tree *
gimple_omp_target_data_arg_ptr (gimple gs)
{
- gimple_statement_omp_target *omp_target_stmt =
- as_a <gimple_statement_omp_target *> (gs);
+ gomp_target *omp_target_stmt = as_a <gomp_target *> (gs);
return &omp_target_stmt->data_arg;
}
@@ -5117,8 +5018,7 @@ gimple_omp_target_data_arg_ptr (gimple gs)
static inline void
gimple_omp_target_set_data_arg (gimple gs, tree data_arg)
{
- gimple_statement_omp_target *omp_target_stmt =
- as_a <gimple_statement_omp_target *> (gs);
+ gomp_target *omp_target_stmt = as_a <gomp_target *> (gs);
omp_target_stmt->data_arg = data_arg;
}
@@ -5128,8 +5028,7 @@ gimple_omp_target_set_data_arg (gimple gs, tree data_arg)
static inline tree
gimple_omp_teams_clauses (const_gimple gs)
{
- const gimple_statement_omp_teams *omp_teams_stmt =
- as_a <const gimple_statement_omp_teams *> (gs);
+ const gomp_teams *omp_teams_stmt = as_a <const gomp_teams *> (gs);
return omp_teams_stmt->clauses;
}
@@ -5139,8 +5038,7 @@ gimple_omp_teams_clauses (const_gimple gs)
static inline tree *
gimple_omp_teams_clauses_ptr (gimple gs)
{
- gimple_statement_omp_teams *omp_teams_stmt =
- as_a <gimple_statement_omp_teams *> (gs);
+ gomp_teams *omp_teams_stmt = as_a <gomp_teams *> (gs);
return &omp_teams_stmt->clauses;
}
@@ -5150,8 +5048,7 @@ gimple_omp_teams_clauses_ptr (gimple gs)
static inline void
gimple_omp_teams_set_clauses (gimple gs, tree clauses)
{
- gimple_statement_omp_teams *omp_teams_stmt =
- as_a <gimple_statement_omp_teams *> (gs);
+ gomp_teams *omp_teams_stmt = as_a <gomp_teams *> (gs);
omp_teams_stmt->clauses = clauses;
}
@@ -5161,8 +5058,8 @@ gimple_omp_teams_set_clauses (gimple gs, tree clauses)
static inline tree
gimple_omp_sections_clauses (const_gimple gs)
{
- const gimple_statement_omp_sections *omp_sections_stmt =
- as_a <const gimple_statement_omp_sections *> (gs);
+ const gomp_sections *omp_sections_stmt =
+ as_a <const gomp_sections *> (gs);
return omp_sections_stmt->clauses;
}
@@ -5172,8 +5069,7 @@ gimple_omp_sections_clauses (const_gimple gs)
static inline tree *
gimple_omp_sections_clauses_ptr (gimple gs)
{
- gimple_statement_omp_sections *omp_sections_stmt =
- as_a <gimple_statement_omp_sections *> (gs);
+ gomp_sections *omp_sections_stmt = as_a <gomp_sections *> (gs);
return &omp_sections_stmt->clauses;
}
@@ -5184,8 +5080,7 @@ gimple_omp_sections_clauses_ptr (gimple gs)
static inline void
gimple_omp_sections_set_clauses (gimple gs, tree clauses)
{
- gimple_statement_omp_sections *omp_sections_stmt =
- as_a <gimple_statement_omp_sections *> (gs);
+ gomp_sections *omp_sections_stmt = as_a <gomp_sections *> (gs);
omp_sections_stmt->clauses = clauses;
}
@@ -5196,8 +5091,8 @@ gimple_omp_sections_set_clauses (gimple gs, tree clauses)
static inline tree
gimple_omp_sections_control (const_gimple gs)
{
- const gimple_statement_omp_sections *omp_sections_stmt =
- as_a <const gimple_statement_omp_sections *> (gs);
+ const gomp_sections *omp_sections_stmt =
+ as_a <const gomp_sections *> (gs);
return omp_sections_stmt->control;
}
@@ -5208,8 +5103,7 @@ gimple_omp_sections_control (const_gimple gs)
static inline tree *
gimple_omp_sections_control_ptr (gimple gs)
{
- gimple_statement_omp_sections *omp_sections_stmt =
- as_a <gimple_statement_omp_sections *> (gs);
+ gomp_sections *omp_sections_stmt = as_a <gomp_sections *> (gs);
return &omp_sections_stmt->control;
}
@@ -5220,8 +5114,7 @@ gimple_omp_sections_control_ptr (gimple gs)
static inline void
gimple_omp_sections_set_control (gimple gs, tree control)
{
- gimple_statement_omp_sections *omp_sections_stmt =
- as_a <gimple_statement_omp_sections *> (gs);
+ gomp_sections *omp_sections_stmt = as_a <gomp_sections *> (gs);
omp_sections_stmt->control = control;
}
@@ -5231,8 +5124,7 @@ gimple_omp_sections_set_control (gimple gs, tree control)
static inline void
gimple_omp_for_set_cond (gimple gs, size_t i, enum tree_code cond)
{
- gimple_statement_omp_for *omp_for_stmt =
- as_a <gimple_statement_omp_for *> (gs);
+ gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
gcc_gimple_checking_assert (TREE_CODE_CLASS (cond) == tcc_comparison
&& i < omp_for_stmt->collapse);
omp_for_stmt->iter[i].cond = cond;
@@ -5244,8 +5136,7 @@ gimple_omp_for_set_cond (gimple gs, size_t i, enum tree_code cond)
static inline enum tree_code
gimple_omp_for_cond (const_gimple gs, size_t i)
{
- const gimple_statement_omp_for *omp_for_stmt =
- as_a <const gimple_statement_omp_for *> (gs);
+ const gomp_for *omp_for_stmt = as_a <const gomp_for *> (gs);
gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
return omp_for_stmt->iter[i].cond;
}
@@ -5256,8 +5147,7 @@ gimple_omp_for_cond (const_gimple gs, size_t i)
static inline void
gimple_omp_atomic_store_set_val (gimple g, tree val)
{
- gimple_statement_omp_atomic_store *omp_atomic_store_stmt =
- as_a <gimple_statement_omp_atomic_store *> (g);
+ gomp_atomic_store *omp_atomic_store_stmt = as_a <gomp_atomic_store *> (g);
omp_atomic_store_stmt->val = val;
}
@@ -5267,8 +5157,8 @@ gimple_omp_atomic_store_set_val (gimple g, tree val)
static inline tree
gimple_omp_atomic_store_val (const_gimple g)
{
- const gimple_statement_omp_atomic_store *omp_atomic_store_stmt =
- as_a <const gimple_statement_omp_atomic_store *> (g);
+ const gomp_atomic_store *omp_atomic_store_stmt =
+ as_a <const gomp_atomic_store *> (g);
return omp_atomic_store_stmt->val;
}
@@ -5278,8 +5168,7 @@ gimple_omp_atomic_store_val (const_gimple g)
static inline tree *
gimple_omp_atomic_store_val_ptr (gimple g)
{
- gimple_statement_omp_atomic_store *omp_atomic_store_stmt =
- as_a <gimple_statement_omp_atomic_store *> (g);
+ gomp_atomic_store *omp_atomic_store_stmt = as_a <gomp_atomic_store *> (g);
return &omp_atomic_store_stmt->val;
}
@@ -5289,8 +5178,7 @@ gimple_omp_atomic_store_val_ptr (gimple g)
static inline void
gimple_omp_atomic_load_set_lhs (gimple g, tree lhs)
{
- gimple_statement_omp_atomic_load *omp_atomic_load_stmt =
- as_a <gimple_statement_omp_atomic_load *> (g);
+ gomp_atomic_load *omp_atomic_load_stmt = as_a <gomp_atomic_load *> (g);
omp_atomic_load_stmt->lhs = lhs;
}
@@ -5300,8 +5188,8 @@ gimple_omp_atomic_load_set_lhs (gimple g, tree lhs)
static inline tree
gimple_omp_atomic_load_lhs (const_gimple g)
{
- const gimple_statement_omp_atomic_load *omp_atomic_load_stmt =
- as_a <const gimple_statement_omp_atomic_load *> (g);
+ const gomp_atomic_load *omp_atomic_load_stmt =
+ as_a <const gomp_atomic_load *> (g);
return omp_atomic_load_stmt->lhs;
}
@@ -5311,8 +5199,7 @@ gimple_omp_atomic_load_lhs (const_gimple g)
static inline tree *
gimple_omp_atomic_load_lhs_ptr (gimple g)
{
- gimple_statement_omp_atomic_load *omp_atomic_load_stmt =
- as_a <gimple_statement_omp_atomic_load *> (g);
+ gomp_atomic_load *omp_atomic_load_stmt = as_a <gomp_atomic_load *> (g);
return &omp_atomic_load_stmt->lhs;
}
@@ -5322,8 +5209,7 @@ gimple_omp_atomic_load_lhs_ptr (gimple g)
static inline void
gimple_omp_atomic_load_set_rhs (gimple g, tree rhs)
{
- gimple_statement_omp_atomic_load *omp_atomic_load_stmt =
- as_a <gimple_statement_omp_atomic_load *> (g);
+ gomp_atomic_load *omp_atomic_load_stmt = as_a <gomp_atomic_load *> (g);
omp_atomic_load_stmt->rhs = rhs;
}
@@ -5333,8 +5219,7 @@ gimple_omp_atomic_load_set_rhs (gimple g, tree rhs)
static inline tree
gimple_omp_atomic_load_rhs (const_gimple g)
{
- const gimple_statement_omp_atomic_load *omp_atomic_load_stmt =
- as_a <const gimple_statement_omp_atomic_load *> (g);
+ const gomp_atomic_load *omp_atomic_load_stmt = as_a <const gomp_atomic_load *> (g);
return omp_atomic_load_stmt->rhs;
}
@@ -5344,8 +5229,7 @@ gimple_omp_atomic_load_rhs (const_gimple g)
static inline tree *
gimple_omp_atomic_load_rhs_ptr (gimple g)
{
- gimple_statement_omp_atomic_load *omp_atomic_load_stmt =
- as_a <gimple_statement_omp_atomic_load *> (g);
+ gomp_atomic_load *omp_atomic_load_stmt = as_a <gomp_atomic_load *> (g);
return &omp_atomic_load_stmt->rhs;
}
@@ -5355,8 +5239,7 @@ gimple_omp_atomic_load_rhs_ptr (gimple g)
static inline tree
gimple_omp_continue_control_def (const_gimple g)
{
- const gimple_statement_omp_continue *omp_continue_stmt =
- as_a <const gimple_statement_omp_continue *> (g);
+ const gomp_continue *omp_continue_stmt = as_a <const gomp_continue *> (g);
return omp_continue_stmt->control_def;
}
@@ -5365,8 +5248,7 @@ gimple_omp_continue_control_def (const_gimple g)
static inline tree *
gimple_omp_continue_control_def_ptr (gimple g)
{
- gimple_statement_omp_continue *omp_continue_stmt =
- as_a <gimple_statement_omp_continue *> (g);
+ gomp_continue *omp_continue_stmt = as_a <gomp_continue *> (g);
return &omp_continue_stmt->control_def;
}
@@ -5375,8 +5257,7 @@ gimple_omp_continue_control_def_ptr (gimple g)
static inline void
gimple_omp_continue_set_control_def (gimple g, tree def)
{
- gimple_statement_omp_continue *omp_continue_stmt =
- as_a <gimple_statement_omp_continue *> (g);
+ gomp_continue *omp_continue_stmt = as_a <gomp_continue *> (g);
omp_continue_stmt->control_def = def;
}
@@ -5386,8 +5267,7 @@ gimple_omp_continue_set_control_def (gimple g, tree def)
static inline tree
gimple_omp_continue_control_use (const_gimple g)
{
- const gimple_statement_omp_continue *omp_continue_stmt =
- as_a <const gimple_statement_omp_continue *> (g);
+ const gomp_continue *omp_continue_stmt = as_a <const gomp_continue *> (g);
return omp_continue_stmt->control_use;
}
@@ -5397,8 +5277,7 @@ gimple_omp_continue_control_use (const_gimple g)
static inline tree *
gimple_omp_continue_control_use_ptr (gimple g)
{
- gimple_statement_omp_continue *omp_continue_stmt =
- as_a <gimple_statement_omp_continue *> (g);
+ gomp_continue *omp_continue_stmt = as_a <gomp_continue *> (g);
return &omp_continue_stmt->control_use;
}
@@ -5408,8 +5287,7 @@ gimple_omp_continue_control_use_ptr (gimple g)
static inline void
gimple_omp_continue_set_control_use (gimple g, tree use)
{
- gimple_statement_omp_continue *omp_continue_stmt =
- as_a <gimple_statement_omp_continue *> (g);
+ gomp_continue *omp_continue_stmt = as_a <gomp_continue *> (g);
omp_continue_stmt->control_use = use;
}
@@ -5418,8 +5296,7 @@ gimple_omp_continue_set_control_use (gimple g, tree use)
static inline gimple_seq *
gimple_transaction_body_ptr (gimple gs)
{
- gimple_statement_transaction *transaction_stmt =
- as_a <gimple_statement_transaction *> (gs);
+ gtransaction *transaction_stmt = as_a <gtransaction *> (gs);
return &transaction_stmt->body;
}
@@ -5436,16 +5313,14 @@ gimple_transaction_body (gimple gs)
static inline tree
gimple_transaction_label (const_gimple gs)
{
- const gimple_statement_transaction *transaction_stmt =
- as_a <const gimple_statement_transaction *> (gs);
+ const gtransaction *transaction_stmt = as_a <const gtransaction *> (gs);
return transaction_stmt->label;
}
static inline tree *
gimple_transaction_label_ptr (gimple gs)
{
- gimple_statement_transaction *transaction_stmt =
- as_a <gimple_statement_transaction *> (gs);
+ gtransaction *transaction_stmt = as_a <gtransaction *> (gs);
return &transaction_stmt->label;
}
@@ -5463,8 +5338,7 @@ gimple_transaction_subcode (const_gimple gs)
static inline void
gimple_transaction_set_body (gimple gs, gimple_seq body)
{
- gimple_statement_transaction *transaction_stmt =
- as_a <gimple_statement_transaction *> (gs);
+ gtransaction *transaction_stmt = as_a <gtransaction *> (gs);
transaction_stmt->body = body;
}
@@ -5473,8 +5347,7 @@ gimple_transaction_set_body (gimple gs, gimple_seq body)
static inline void
gimple_transaction_set_label (gimple gs, tree label)
{
- gimple_statement_transaction *transaction_stmt =
- as_a <gimple_statement_transaction *> (gs);
+ gtransaction *transaction_stmt = as_a <gtransaction *> (gs);
transaction_stmt->label = label;
}
@@ -5173,7 +5173,7 @@ gimplify_cleanup_point_expr (tree *expr_p, gimple_seq *pre_p)
}
else
{
- gimple_statement_try *gtry;
+ gtry *gtry;
gimple_seq seq;
enum gimple_try_flags kind;
@@ -25,29 +25,29 @@ along with GCC; see the file COPYING3. If not see
Each enum value should correspond with a single member of the union
gimple_statement_d. */
-DEFGSSTRUCT(GSS_BASE, gimple_statement_base, false)
-DEFGSSTRUCT(GSS_WITH_OPS, gimple_statement_with_ops, true)
-DEFGSSTRUCT(GSS_WITH_MEM_OPS_BASE, gimple_statement_with_memory_ops_base, false)
-DEFGSSTRUCT(GSS_WITH_MEM_OPS, gimple_statement_with_memory_ops, true)
-DEFGSSTRUCT(GSS_CALL, gimple_statement_call, true)
-DEFGSSTRUCT(GSS_ASM, gimple_statement_asm, true)
-DEFGSSTRUCT(GSS_BIND, gimple_statement_bind, false)
-DEFGSSTRUCT(GSS_PHI, gimple_statement_phi, false)
-DEFGSSTRUCT(GSS_TRY, gimple_statement_try, false)
-DEFGSSTRUCT(GSS_CATCH, gimple_statement_catch, false)
-DEFGSSTRUCT(GSS_EH_FILTER, gimple_statement_eh_filter, false)
-DEFGSSTRUCT(GSS_EH_MNT, gimple_statement_eh_mnt, false)
-DEFGSSTRUCT(GSS_EH_CTRL, gimple_statement_eh_ctrl, false)
-DEFGSSTRUCT(GSS_EH_ELSE, gimple_statement_eh_else, false)
-DEFGSSTRUCT(GSS_WCE, gimple_statement_wce, false)
-DEFGSSTRUCT(GSS_OMP, gimple_statement_omp, false)
-DEFGSSTRUCT(GSS_OMP_CRITICAL, gimple_statement_omp_critical, false)
-DEFGSSTRUCT(GSS_OMP_FOR, gimple_statement_omp_for, false)
-DEFGSSTRUCT(GSS_OMP_PARALLEL_LAYOUT, gimple_statement_omp_parallel_layout, false)
-DEFGSSTRUCT(GSS_OMP_TASK, gimple_statement_omp_task, false)
-DEFGSSTRUCT(GSS_OMP_SECTIONS, gimple_statement_omp_sections, false)
-DEFGSSTRUCT(GSS_OMP_SINGLE_LAYOUT, gimple_statement_omp_single_layout, false)
-DEFGSSTRUCT(GSS_OMP_CONTINUE, gimple_statement_omp_continue, false)
-DEFGSSTRUCT(GSS_OMP_ATOMIC_LOAD, gimple_statement_omp_atomic_load, false)
-DEFGSSTRUCT(GSS_OMP_ATOMIC_STORE_LAYOUT, gimple_statement_omp_atomic_store, false)
-DEFGSSTRUCT(GSS_TRANSACTION, gimple_statement_transaction, false)
+DEFGSSTRUCT(GSS_BASE, gimple, false)
+DEFGSSTRUCT(GSS_WITH_OPS, gimple_with_ops, true)
+DEFGSSTRUCT(GSS_WITH_MEM_OPS_BASE, gimple_with_memory_ops_base, false)
+DEFGSSTRUCT(GSS_WITH_MEM_OPS, gimple_with_memory_ops, true)
+DEFGSSTRUCT(GSS_CALL, gcall, true)
+DEFGSSTRUCT(GSS_ASM, gasm, true)
+DEFGSSTRUCT(GSS_BIND, gbind, false)
+DEFGSSTRUCT(GSS_PHI, gphi, false)
+DEFGSSTRUCT(GSS_TRY, gtry, false)
+DEFGSSTRUCT(GSS_CATCH, gcatch, false)
+DEFGSSTRUCT(GSS_EH_FILTER, geh_filter, false)
+DEFGSSTRUCT(GSS_EH_MNT, geh_mnt, false)
+DEFGSSTRUCT(GSS_EH_CTRL, geh_ctrl, false)
+DEFGSSTRUCT(GSS_EH_ELSE, geh_else, false)
+DEFGSSTRUCT(GSS_WCE, gwce, false)
+DEFGSSTRUCT(GSS_OMP, gomp, false)
+DEFGSSTRUCT(GSS_OMP_CRITICAL, gomp_critical, false)
+DEFGSSTRUCT(GSS_OMP_FOR, gomp_for, false)
+DEFGSSTRUCT(GSS_OMP_PARALLEL_LAYOUT, gomp_parallel_layout, false)
+DEFGSSTRUCT(GSS_OMP_TASK, gomp_task, false)
+DEFGSSTRUCT(GSS_OMP_SECTIONS, gomp_sections, false)
+DEFGSSTRUCT(GSS_OMP_SINGLE_LAYOUT, gomp_single_layout, false)
+DEFGSSTRUCT(GSS_OMP_CONTINUE, gomp_continue, false)
+DEFGSSTRUCT(GSS_OMP_ATOMIC_LOAD, gomp_atomic_load, false)
+DEFGSSTRUCT(GSS_OMP_ATOMIC_STORE_LAYOUT, gomp_atomic_store, false)
+DEFGSSTRUCT(GSS_TRANSACTION, gtransaction, false)
@@ -1023,7 +1023,7 @@ helper_const_non_const_cast (const char *p)
#define CONST_CAST_TREE(X) CONST_CAST (union tree_node *, (X))
#define CONST_CAST_RTX(X) CONST_CAST (struct rtx_def *, (X))
#define CONST_CAST_BB(X) CONST_CAST (struct basic_block_def *, (X))
-#define CONST_CAST_GIMPLE(X) CONST_CAST (struct gimple_statement_base *, (X))
+#define CONST_CAST_GIMPLE(X) CONST_CAST (gimple *, (X))
/* Activate certain diagnostics as warnings (not errors via the
-Werror flag). */
@@ -3500,7 +3500,7 @@ DEFHOOK_UNDOC
"Perform architecture specific checking of statements gimplified\
from @code{VA_ARG_EXPR}. @var{stmt} is the statement. Returns true if\
the statement doesn't need to be checked for @code{va_list} references.",
- bool, (struct stdarg_info *ai, const_gimple stmt), NULL)
+ bool, (struct stdarg_info *ai, const gimple *stmt), NULL)
/* This target hook allows the operating system to override the DECL
that represents the external variable that contains the stack
@@ -64,7 +64,7 @@ get_real_ref_rhs (tree expr)
if ((!vdecl || DECL_ARTIFICIAL (vdecl))
&& !gimple_nop_p (SSA_NAME_DEF_STMT (expr)))
{
- gimple def_stmt = SSA_NAME_DEF_STMT (expr);
+ gimple *def_stmt = SSA_NAME_DEF_STMT (expr);
/* We are only interested in an assignment with a single
rhs operand because if it is not, the original assignment
will not possibly be a self-assignment. */
@@ -169,7 +169,7 @@ get_non_ssa_expr (tree expr)
if ((!vdecl || DECL_ARTIFICIAL (vdecl))
&& !gimple_nop_p (SSA_NAME_DEF_STMT (expr)))
{
- gimple def_stmt = SSA_NAME_DEF_STMT (expr);
+ gimple *def_stmt = SSA_NAME_DEF_STMT (expr);
if (gimple_assign_single_p (def_stmt))
vdecl = gimple_assign_rhs1 (def_stmt);
}
@@ -187,7 +187,7 @@ get_non_ssa_expr (tree expr)
they are the same. If so, print a warning message about self-assignment. */
static void
-compare_and_warn (gimple stmt, tree lhs, tree rhs)
+compare_and_warn (gimple *stmt, tree lhs, tree rhs)
{
if (operand_equal_p (lhs, rhs, OEP_PURE_SAME))
{
@@ -211,7 +211,7 @@ compare_and_warn (gimple stmt, tree lhs, tree rhs)
/* Check and warn if STMT is a self-assign statement. */
static void
-warn_self_assign (gimple stmt)
+warn_self_assign (gimple *stmt)
{
tree rhs, lhs;
@@ -64,7 +64,7 @@ get_real_ref_rhs (tree expr)
if ((!vdecl || DECL_ARTIFICIAL (vdecl))
&& !gimple_nop_p (SSA_NAME_DEF_STMT (expr)))
{
- gimple def_stmt = SSA_NAME_DEF_STMT (expr);
+ gimple *def_stmt = SSA_NAME_DEF_STMT (expr);
/* We are only interested in an assignment with a single
rhs operand because if it is not, the original assignment
will not possibly be a self-assignment. */
@@ -169,7 +169,7 @@ get_non_ssa_expr (tree expr)
if ((!vdecl || DECL_ARTIFICIAL (vdecl))
&& !gimple_nop_p (SSA_NAME_DEF_STMT (expr)))
{
- gimple def_stmt = SSA_NAME_DEF_STMT (expr);
+ gimple *def_stmt = SSA_NAME_DEF_STMT (expr);
if (gimple_assign_single_p (def_stmt))
vdecl = gimple_assign_rhs1 (def_stmt);
}
@@ -187,7 +187,7 @@ get_non_ssa_expr (tree expr)
they are the same. If so, print a warning message about self-assignment. */
static void
-compare_and_warn (gimple stmt, tree lhs, tree rhs)
+compare_and_warn (gimple *stmt, tree lhs, tree rhs)
{
if (operand_equal_p (lhs, rhs, OEP_PURE_SAME))
{
@@ -211,7 +211,7 @@ compare_and_warn (gimple stmt, tree lhs, tree rhs)
/* Check and warn if STMT is a self-assign statement. */
static void
-warn_self_assign (gimple stmt)
+warn_self_assign (gimple *stmt)
{
tree rhs, lhs;
@@ -233,7 +233,7 @@ dump_dfa_stats (FILE *file)
fprintf (file, fmt_str_1, "VDEF operands", dfa_stats.num_vdefs,
SCALE (size), LABEL (size));
- size = dfa_stats.num_phis * sizeof (struct gimple_statement_phi);
+ size = dfa_stats.num_phis * sizeof (struct gphi);
total += size;
fprintf (file, fmt_str_1, "PHI nodes", dfa_stats.num_phis,
SCALE (size), LABEL (size));
@@ -97,13 +97,12 @@ phinodes_print_statistics (void)
happens to contain a PHI node with LEN arguments or more, return
that one. */
-static inline gimple_statement_phi *
+static inline gphi *
allocate_phi_node (size_t len)
{
- gimple_statement_phi *phi;
+ gphi *phi;
size_t bucket = NUM_BUCKETS - 2;
- size_t size = sizeof (struct gimple_statement_phi)
- + (len - 1) * sizeof (struct phi_arg_d);
+ size_t size = sizeof (struct gphi) + (len - 1) * sizeof (struct phi_arg_d);
if (free_phinode_count)
for (bucket = len - 2; bucket < NUM_BUCKETS - 2; bucket++)
@@ -115,7 +114,7 @@ allocate_phi_node (size_t len)
&& gimple_phi_capacity ((*free_phinodes[bucket])[0]) >= len)
{
free_phinode_count--;
- phi = as_a <gimple_statement_phi *> (free_phinodes[bucket]->pop ());
+ phi = as_a <gimple_phi *> (free_phinodes[bucket]->pop ());
if (free_phinodes[bucket]->is_empty ())
vec_free (free_phinodes[bucket]);
if (GATHER_STATISTICS)
@@ -123,7 +122,7 @@ allocate_phi_node (size_t len)
}
else
{
- phi = static_cast <gimple_statement_phi *> (
+ phi = static_cast <gimple_phi *> (
ggc_internal_alloc_stat (size MEM_STAT_INFO));
if (GATHER_STATISTICS)
{
@@ -158,8 +157,7 @@ ideal_phi_node_len (int len)
len = 2;
/* Compute the number of bytes of the original request. */
- size = sizeof (struct gimple_statement_phi)
- + (len - 1) * sizeof (struct phi_arg_d);
+ size = sizeof (struct gphi) + (len - 1) * sizeof (struct phi_arg_d);
/* Round it up to the next power of two. */
log2 = ceil_log2 (size);
@@ -176,7 +174,7 @@ ideal_phi_node_len (int len)
static gimple
make_phi_node (tree var, int len)
{
- gimple_statement_phi *phi;
+ gphi *phi;
int capacity, i;
capacity = ideal_phi_node_len (len);
@@ -186,7 +184,7 @@ make_phi_node (tree var, int len)
/* We need to clear the entire PHI node, including the argument
portion, because we represent a "missing PHI argument" by placing
NULL_TREE in PHI_ARG_DEF. */
- memset (phi, 0, (sizeof (struct gimple_statement_phi)
+ memset (phi, 0, (sizeof (struct gphi)
- sizeof (struct phi_arg_d)
+ sizeof (struct phi_arg_d) * len));
phi->code = GIMPLE_PHI;
@@ -241,18 +239,18 @@ release_phi_node (gimple phi)
/* Resize an existing PHI node. The only way is up. Return the
possibly relocated phi. */
-static gimple_statement_phi *
-resize_phi_node (gimple_statement_phi *phi, size_t len)
+static gphi *
+resize_phi_node (gphi *phi, size_t len)
{
size_t old_size, i;
- gimple_statement_phi *new_phi;
+ gphi *new_phi;
gcc_assert (len > gimple_phi_capacity (phi));
/* The garbage collector will not look at the PHI node beyond the
first PHI_NUM_ARGS elements. Therefore, all we have to copy is a
portion of the PHI node currently in use. */
- old_size = sizeof (struct gimple_statement_phi)
+ old_size = sizeof (struct gphi)
+ (gimple_phi_num_args (phi) - 1) * sizeof (struct phi_arg_d);
new_phi = allocate_phi_node (len);
@@ -296,12 +294,11 @@ reserve_phi_args_for_new_edge (basic_block bb)
for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
{
- gimple_statement_phi *stmt =
- as_a <gimple_statement_phi *> (gsi_stmt (gsi));
+ gphi *stmt = as_a <gphi *> (gsi_stmt (gsi));
if (len > gimple_phi_capacity (stmt))
{
- gimple_statement_phi *new_phi = resize_phi_node (stmt, cap);
+ gphi *new_phi = resize_phi_node (stmt, cap);
/* The result of the PHI is defined by this PHI node. */
SSA_NAME_DEF_STMT (gimple_phi_result (new_phi)) = new_phi;
@@ -397,7 +394,7 @@ add_phi_arg (gimple phi, tree def, edge e, source_location locus)
is consistent with how we remove an edge from the edge vector. */
static void
-remove_phi_arg_num (gimple_statement_phi *phi, int i)
+remove_phi_arg_num (gphi *phi, int i)
{
int num_elem = gimple_phi_num_args (phi);
@@ -436,7 +433,7 @@ remove_phi_args (edge e)
gimple_stmt_iterator gsi;
for (gsi = gsi_start_phis (e->dest); !gsi_end_p (gsi); gsi_next (&gsi))
- remove_phi_arg_num (as_a <gimple_statement_phi *> (gsi_stmt (gsi)),
+ remove_phi_arg_num (as_a <gphi *> (gsi_stmt (gsi)),
e->dest_idx);
}
@@ -1895,7 +1895,7 @@ evaluate_stmt (gimple stmt)
return val;
}
-typedef hash_table <pointer_hash <gimple_statement_base> > gimple_htab;
+typedef hash_table <pointer_hash <gimple> > gimple_htab;
/* Given a BUILT_IN_STACK_SAVE value SAVED_VAL, insert a clobber of VAR before
each matching BUILT_IN_STACK_RESTORE. Mark visited phis in VISITED. */