GCC Middle and Back End API Reference
gimple.c File Reference


void gimple_set_stored_syms (gimple, bitmap, bitmap_obstack *)
void gimple_set_loaded_syms (gimple, bitmap, bitmap_obstack *)
static void gimple_set_code ()
static size_t gimple_size ()
gimple gimple_alloc_stat ()
static void gimple_set_subcode ()
static gimple gimple_build_with_ops_stat (enum gimple_code code, unsigned subcode, unsigned num_ops MEM_STAT_DECL)
gimple gimple_build_return ()
void gimple_call_reset_alias_info ()
static gimple gimple_build_call_1 ()
gimple gimple_build_call_vec ()
gimple gimple_build_call ()
gimple gimple_build_call_valist ()
static gimple gimple_build_call_internal_1 ()
gimple gimple_build_call_internal ()
gimple gimple_build_call_internal_vec ()
gimple gimple_build_call_from_tree ()
unsigned gimple_call_get_nobnd_arg_index ()
void extract_ops_from_tree_1 (tree expr, enum tree_code *subcode_p, tree *op1_p, tree *op2_p, tree *op3_p)
gimple gimple_build_assign_stat ()
gimple gimple_build_assign_with_ops (enum tree_code subcode, tree lhs, tree op1, tree op2, tree op3 MEM_STAT_DECL)
gimple gimple_build_assign_with_ops (enum tree_code subcode, tree lhs, tree op1, tree op2 MEM_STAT_DECL)
gimple gimplify_assign ()
gimple gimple_build_cond (enum tree_code pred_code, tree lhs, tree rhs, tree t_label, tree f_label)
void gimple_cond_get_ops_from_tree (tree cond, enum tree_code *code_p, tree *lhs_p, tree *rhs_p)
gimple gimple_build_cond_from_tree ()
void gimple_cond_set_condition_from_tree ()
gimple gimple_build_label ()
gimple gimple_build_goto ()
gimple gimple_build_nop ()
gimple gimple_build_bind ()
static gimple gimple_build_asm_1 (const char *string, unsigned ninputs, unsigned noutputs, unsigned nclobbers, unsigned nlabels)
gimple gimple_build_asm_vec (const char *string, vec< tree, va_gc > *inputs, vec< tree, va_gc > *outputs, vec< tree, va_gc > *clobbers, vec< tree, va_gc > *labels)
gimple gimple_build_catch ()
gimple gimple_build_eh_filter ()
gimple gimple_build_eh_must_not_throw ()
gimple gimple_build_eh_else ()
gimple_statement_trygimple_build_try (gimple_seq eval, gimple_seq cleanup, enum gimple_try_flags kind)
gimple gimple_build_wce ()
gimple gimple_build_resx ()
gimple gimple_build_switch_nlabels ()
gimple gimple_build_switch ()
gimple gimple_build_eh_dispatch ()
gimple gimple_build_debug_bind_stat ()
gimple gimple_build_debug_source_bind_stat (tree var, tree value, gimple stmt MEM_STAT_DECL)
gimple gimple_build_omp_critical ()
gimple gimple_build_omp_for (gimple_seq body, int kind, tree clauses, size_t collapse, gimple_seq pre_body)
gimple gimple_build_omp_parallel (gimple_seq body, tree clauses, tree child_fn, tree data_arg)
gimple gimple_build_omp_task (gimple_seq body, tree clauses, tree child_fn, tree data_arg, tree copy_fn, tree arg_size, tree arg_align)
gimple gimple_build_omp_section ()
gimple gimple_build_omp_master ()
gimple gimple_build_omp_taskgroup ()
gimple gimple_build_omp_continue ()
gimple gimple_build_omp_ordered ()
gimple gimple_build_omp_return ()
gimple gimple_build_omp_sections ()
gimple gimple_build_omp_sections_switch ()
gimple gimple_build_omp_single ()
gimple gimple_build_omp_target ()
gimple gimple_build_omp_teams ()
gimple gimple_build_omp_atomic_load ()
gimple gimple_build_omp_atomic_store ()
gimple gimple_build_transaction ()
gimple gimple_build_predict ()
void gimple_check_failed (const_gimple gs, const char *file, int line, const char *function, enum gimple_code code, enum tree_code subcode)
void gimple_seq_add_stmt ()
void gimple_seq_add_seq ()
static bool empty_stmt_p ()
bool empty_body_p ()
gimple_seq gimple_seq_copy ()
gimple walk_gimple_seq_mod (gimple_seq *pseq, walk_stmt_fn callback_stmt, walk_tree_fn callback_op, struct walk_stmt_info *wi)
gimple walk_gimple_seq (gimple_seq seq, walk_stmt_fn callback_stmt, walk_tree_fn callback_op, struct walk_stmt_info *wi)
static tree walk_gimple_asm (gimple stmt, walk_tree_fn callback_op, struct walk_stmt_info *wi)
tree walk_gimple_op (gimple stmt, walk_tree_fn callback_op, struct walk_stmt_info *wi)
tree walk_gimple_stmt (gimple_stmt_iterator *gsi, walk_stmt_fn callback_stmt, walk_tree_fn callback_op, struct walk_stmt_info *wi)
void gimple_set_body ()
gimple_seq gimple_body ()
bool gimple_has_body_p ()
bool gimple_call_same_target_p ()
int gimple_call_flags ()
static tree gimple_call_fnspec ()
int gimple_call_arg_flags ()
int gimple_call_return_flags ()
bool gimple_assign_copy_p ()
bool gimple_assign_ssa_name_copy_p ()
bool gimple_assign_unary_nop_p ()
void gimple_set_bb ()
void gimple_assign_set_rhs_from_tree ()
void gimple_assign_set_rhs_with_ops_1 (gimple_stmt_iterator *gsi, enum tree_code code, tree op1, tree op2, tree op3)
tree gimple_get_lhs ()
void gimple_set_lhs ()
gimple gimple_copy ()
bool gimple_has_side_effects ()
bool gimple_could_trap_p_1 ()
bool gimple_could_trap_p ()
bool gimple_assign_rhs_could_trap_p ()
void dump_gimple_statistics ()
unsigned get_gimple_rhs_num_ops ()
bool is_gimple_lvalue ()
bool is_gimple_condexpr ()
bool is_gimple_addressable ()
bool is_gimple_constant ()
bool is_gimple_address ()
bool is_gimple_invariant_address ()
bool is_gimple_ip_invariant_address ()
bool is_gimple_min_invariant ()
bool is_gimple_ip_invariant ()
bool is_gimple_variable ()
bool is_gimple_id ()
bool virtual_operand_p ()
bool is_gimple_reg ()
bool is_gimple_val ()
bool is_gimple_asm_val ()
bool is_gimple_min_lval ()
bool is_gimple_call_addr ()
bool is_gimple_mem_ref_addr ()
tree get_base_address ()
void recalculate_side_effects ()
tree canonicalize_cond_expr_cond ()
gimple gimple_call_copy_skip_args ()
bool gimple_compare_field_offset ()
static tree gimple_signed_or_unsigned_type ()
tree gimple_unsigned_type ()
tree gimple_signed_type ()
alias_set_type gimple_get_alias_set ()
static tree get_base_loadstore ()
bool walk_stmt_load_store_addr_ops (gimple stmt, void *data, bool(*visit_load)(gimple, tree, void *), bool(*visit_store)(gimple, tree, void *), bool(*visit_addr)(gimple, tree, void *))
bool walk_stmt_load_store_ops (gimple stmt, void *data, bool(*visit_load)(gimple, tree, void *), bool(*visit_store)(gimple, tree, void *))
static bool gimple_ior_addresses_taken_1 (gimple stmt, tree addr, void *data)
bool gimple_ior_addresses_taken ()
const char * gimple_decl_printable_name ()
bool is_gimple_builtin_call ()
static bool validate_call ()
bool gimple_call_builtin_p ()
bool gimple_asm_clobbers_memory_p ()
bool useless_type_conversion_p ()
bool types_compatible_p ()
void dump_decl_set ()
bool gimple_can_coalesce_p ()
bool nonfreeing_call_p ()
tree copy_var_decl ()


EXPORTED_CONST size_t gimple_ops_offset_ []
static const size_t gsstruct_code_size []
const char *const gimple_code_name []
gss_for_code_ []
int gimple_alloc_counts [(int) gimple_alloc_kind_all]
int gimple_alloc_sizes [(int) gimple_alloc_kind_all]
static const char *const gimple_alloc_kind_names []
const unsigned char gimple_rhs_class_table []

Function Documentation

tree canonicalize_cond_expr_cond ( )
   Canonicalize a tree T for use in a COND_EXPR as conditional.  Returns
   a canonicalized tree that is valid for a COND_EXPR or NULL_TREE, if
   we failed to create one.  
     Strip conversions around boolean operations.  
     For !x use x == 0.  
     For cmp ? 1 : 0 use cmp.  
     For x ^ y use x != y.  

Referenced by ifcombine_ifandif().

tree copy_var_decl ( )
   Create a new VAR_DECL and copy information from VAR to it.  
void dump_decl_set ( )
   Dump bitmap SET (assumed to contain VAR_DECLs) to FILE.  

Referenced by prepare_block_for_update().

void dump_gimple_statistics ( void  )
   Print debugging information for gimple stmts generated.  

References handled_component_p(), and is_gimple_val().

bool empty_body_p ( )
   Return true if BODY contains nothing but empty statements.  

Referenced by gimple_build_transaction().

static bool empty_stmt_p ( )
   Helper function of empty_body_p.  Return true if STMT is an empty

Referenced by gimple_build_predict().

void extract_ops_from_tree_1 ( tree  expr,
enum tree_code subcode_p,
tree op1_p,
tree op2_p,
tree op3_p 
   Extract the operands and code for expression EXPR into *SUBCODE_P,
   *OP1_P, *OP2_P and *OP3_P respectively.  

Referenced by gimple_call_return_flags().

tree get_base_address ( )
   Given a memory reference expression T, return its base address.
   The base address of a memory reference expression is the main
   object being referenced.  For instance, the base address for
   'array[i].fld[j]' is 'array'.  You can think of this as stripping
   away the offset part from a memory address.

   This function calls handled_component_p to strip away all the inner
   parts of the memory reference until it reaches the base object.  
     ???  Either the alias oracle or all callers need to properly deal
     with WITH_SIZE_EXPRs before we can look through those.  

Referenced by add_stack_var_conflict(), build_access_from_expr(), execute_sm_if_changed_flag_set(), expand_builtin_prefetch(), get_address_description(), gimple_redirect_edge_and_branch(), gimple_stmt_nonnegative_warnv_p(), initialize_argument_information(), ipa_analyze_virtual_call_uses(), make_constraint_from(), maybe_optimize_var(), refs_independent_p(), tree_nrv(), unmodified_parm(), unmodified_parm_or_parm_agg_item(), and warn_uninitialized_vars().

static tree get_base_loadstore ( )
   From a tree operand OP return the base of a load or store operation
   or NULL_TREE if OP is not a load or a store.  
unsigned get_gimple_rhs_num_ops ( )
   Return the number of operands needed on the RHS of a GIMPLE
   assignment for an expression with tree code CODE.  

Referenced by gimple_assign_copy_p().

gimple gimple_alloc_stat ( )
   Allocate memory for a GIMPLE statement with code CODE and NUM_OPS
     Do not call gimple_set_modified here as it has other side
     effects and this tuple is still not completely built.  

References gimple_alloc_counts, and gimple_alloc_sizes.

Referenced by gimple_set_subcode().

bool gimple_asm_clobbers_memory_p ( )
   Return true if STMT clobbers memory.  STMT is required to be a

References prototype_p(), and useless_type_conversion_p().

Referenced by check_stmt().

bool gimple_assign_copy_p ( )
   Return true if GS is a copy assignment.  

References get_gimple_rhs_num_ops(), gimple_assign_lhs(), and gsi_stmt().

Referenced by live_track_init(), and tree_nrv().

bool gimple_assign_rhs_could_trap_p ( )
   Return true if RHS of a GIMPLE_ASSIGN S can trap.  
void gimple_assign_set_rhs_from_tree ( )
   Modify the RHS of the assignment pointed-to by GSI using the
   operands in the expression tree EXPR.

   NOTE: The statement pointed-to by GSI may be reallocated if it
   did not have enough operand slots.

   This function is useful to convert an existing tree expression into
   the flat representation used for the RHS of a GIMPLE assignment.
   It will reallocate memory as needed to expand or shrink the number
   of operand slots needed to represent EXPR.

   NOTE: If you find yourself building a tree and then calling this
   function, you are most certainly doing it the slow way.  It is much
   better to build a new assignment or to use the function
   gimple_assign_set_rhs_with_ops, which does not require an
   expression tree to be built.  

Referenced by combine_cond_exprs(), forward_propagate_addr_expr(), may_propagate_copy_into_asm(), may_reassociate_p(), simplify_conversion_from_bitmask(), and test_for_singularity().

void gimple_assign_set_rhs_with_ops_1 ( gimple_stmt_iterator gsi,
enum tree_code  code,
tree  op1,
tree  op2,
tree  op3 
   Set the RHS of assignment statement pointed-to by GSI to CODE with
   operands OP1, OP2 and OP3.

   NOTE: The statement pointed-to by GSI may be reallocated if it
   did not have enough operand slots.  
     If the new CODE needs more operands, allocate a new statement.  
         The LHS needs to be reset as this also changes the SSA name
         on the LHS.  

Referenced by gimple_call_return_flags().

bool gimple_assign_ssa_name_copy_p ( )
   Return true if GS is a SSA_NAME copy assignment.  

Referenced by create_outofssa_var_map(), get_prop_dest_stmt(), and recognize_single_bit_test().

bool gimple_assign_unary_nop_p ( )
   Return true if GS is an assignment with a unary RHS, but the
   operator has no effect on the assigned value.  The logic is adapted
   from STRIP_NOPS.  This predicate is intended to be used in tuplifying
   instances in which STRIP_NOPS was previously applied to the RHS of
   an assignment.

   NOTE: In the use cases that led to the creation of this function
   and of gimple_assign_single_p, it is typical to test for either
   condition and to proceed in the same manner.  In each case, the
   assigned value is represented by the single RHS operand of the
   assignment.  I suspect there may be cases where gimple_assign_copy_p,
   gimple_assign_single_p, or equivalent logic is used where a similar
   treatment of unary NOPs is appropriate.  

References gimple_assign_lhs(), and gimple_call_lhs().

Referenced by check_for_plus_in_loops_1().

gimple_seq gimple_body ( )
   Return the body of GIMPLE statements for function FN.  After the
   CFG pass, the function body doesn't exist anymore because it has
   been split up into basic blocks.  In this case, it returns

References gimple_call_flags().

Referenced by finalize_nesting_tree_1(), move_sese_region_to_fn(), and remap_vla_decls().

static gimple gimple_build_asm_1 ( const char *  string,
unsigned  ninputs,
unsigned  noutputs,
unsigned  nclobbers,
unsigned  nlabels 
   Helper function to set the simple fields of a asm stmt.

   STRING is a pointer to a string that is the asm blocks assembly code.
   NINPUT is the number of register inputs.
   NOUTPUT is the number of register outputs.
   NCLOBBERS is the number of clobbered registers.
     ASMs with labels cannot have outputs.  This should have been
     enforced by the front end.  

References gimple_asm_set_clobber_op(), gimple_asm_set_input_op(), gimple_asm_set_label_op(), gimple_asm_set_output_op(), and vec_safe_length().

gimple gimple_build_asm_vec ( const char *  string,
vec< tree, va_gc > *  inputs,
vec< tree, va_gc > *  outputs,
vec< tree, va_gc > *  clobbers,
vec< tree, va_gc > *  labels 
   Build a GIMPLE_ASM statement.

   STRING is the assembly code.
   NINPUT is the number of register inputs.
   NOUTPUT is the number of register outputs.
   NCLOBBERS is the number of clobbered registers.
   INPUTS is a vector of the input register parameters.
   OUTPUTS is a vector of the output register parameters.
   CLOBBERS is a vector of the clobbered register parameters.
   LABELS is a vector of destination labels.  

References gimple_eh_filter_set_failure(), and gimple_eh_filter_set_types().

gimple gimple_build_assign_stat ( )
   Build a GIMPLE_ASSIGN statement.

   LHS of the assignment.
   RHS of the assignment which can be unary or binary.  
gimple gimple_build_assign_with_ops ( enum tree_code  subcode,
tree  lhs,
tree  op1,
tree  op2,
tree op3  MEM_STAT_DECL 
   Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operands
   OP1 and OP2.  If OP2 is NULL then SUBCODE must be of class
     Need 1 operand for LHS and 1 or 2 for the RHS (depending on the

Referenced by attempt_builtin_powi(), check_bool_pattern(), create_iv(), expand_transaction(), gimple_expand_builtin_powi(), instrument_builtin_call(), is_phi_for_stmt(), rewrite_to_defined_overflow(), simplify_bitwise_binary_boolean(), swap_ops_for_binary_stmt(), vect_init_vector_1(), vect_permute_store_chain(), and vect_recog_pow_pattern().

gimple gimple_build_assign_with_ops ( enum tree_code  subcode,
tree  lhs,
tree  op1,
tree op2  MEM_STAT_DECL 
gimple gimple_build_bind ( )
   Build a GIMPLE_BIND statement.
   VARS are the variables in BODY.
   BLOCK is the containing block.  

Referenced by lower_omp_sections(), and maybe_add_implicit_barrier_cancel().

static gimple gimple_build_call_1 ( )
   Helper for gimple_build_call, gimple_build_call_valist,
   gimple_build_call_vec and gimple_build_call_from_tree.  Build the basic
   components of a GIMPLE_CALL statement to function FN with NARGS

References gimple_call_set_arg().

Referenced by gimple_build_call(), and gimple_build_call_vec().

gimple gimple_build_call_from_tree ( )
   Build a GIMPLE_CALL statement from CALL_EXPR T.  Note that T is
   assumed to be in GIMPLE form already.  Minimal checking is done of
   this fact.  
     Carry all the CALL_EXPR flags to the new GIMPLE_CALL.  
gimple gimple_build_call_internal ( )
   Build a GIMPLE_CALL statement to internal function FN.  NARGS is
   the number of arguments.  The ... are the arguments.  

References gimple_build_call_internal_1(), and gimple_call_set_arg().

static gimple gimple_build_call_internal_1 ( )
   Helper for gimple_build_call_internal and gimple_build_call_internal_vec.
   Build the basic components of a GIMPLE_CALL statement to internal
   function FN with NARGS arguments.  

Referenced by gimple_build_call_internal().

gimple gimple_build_call_internal_vec ( )
   Build a GIMPLE_CALL statement to internal function FN with the arguments
   specified in vector ARGS.  
gimple gimple_build_call_valist ( )
   Build a GIMPLE_CALL statement to function FN.  NARGS is the number of
   arguments.  AP contains the arguments.  

References GF_CALL_INTERNAL, gimple_call_reset_alias_info(), gimple_call_set_internal_fn(), and gimple_statement_base::subcode.

gimple gimple_build_call_vec ( )
   Build a GIMPLE_CALL statement to function FN with the arguments
   specified in vector ARGS.  

References gimple_build_call_1(), gimple_call_set_arg(), and is_gimple_call_addr().

Referenced by finish_update_gimple_call().

gimple gimple_build_catch ( )
   Build a GIMPLE_CATCH statement.

  TYPES are the catch types.
  HANDLER is the exception handler.  

References gimple_eh_else_set_e_body(), and gimple_eh_else_set_n_body().

gimple gimple_build_cond ( enum tree_code  pred_code,
tree  lhs,
tree  rhs,
tree  t_label,
tree  f_label 
   Build a GIMPLE_COND statement.

   PRED is the condition used to compare LHS and the RHS.
   T_LABEL is the label to jump to if the condition is true.
   F_LABEL is the label to jump to otherwise.  

Referenced by expand_transaction(), gimple_cond_get_ops_from_tree(), instrument_derefs(), and restore_vars_to_original_value().

gimple gimple_build_cond_from_tree ( )
   Build a GIMPLE_COND statement from the conditional expression tree
   COND.  T_LABEL and F_LABEL are as in gimple_build_cond.  

References gimple_goto_set_dest().

Referenced by update_dominators_in_loop().

gimple gimple_build_debug_bind_stat ( )
   Build a new GIMPLE_DEBUG_BIND statement.

   VAR is bound to VALUE; block and location are taken from STMT.  

References gimple_statement_omp_for::collapse, ggc_internal_cleared_vec_alloc_stat(), gimple_omp_for_set_clauses(), gimple_omp_for_set_kind(), gimple_omp_set_body(), and gimple_statement_omp_for::iter.

gimple gimple_build_debug_source_bind_stat ( tree  var,
tree  value,
gimple stmt  MEM_STAT_DECL 
   Build a new GIMPLE_DEBUG_SOURCE_BIND statement.

   VAR is bound to VALUE; block and location are taken from STMT.  
gimple gimple_build_eh_dispatch ( )
   Build a GIMPLE_EH_DISPATCH statement.  

References gimple_omp_critical_set_name(), and gimple_omp_set_body().

gimple gimple_build_eh_else ( )
   Build a GIMPLE_EH_ELSE statement.  

References gimple_statement_eh_ctrl::region.

gimple gimple_build_eh_filter ( )
   Build a GIMPLE_EH_FILTER statement.

   TYPES are the filter's types.
   FAILURE is the filter's failure action.  

References gimple_set_subcode(), GIMPLE_TRY_CATCH, GIMPLE_TRY_FINALLY, gimple_try_set_cleanup(), and gimple_try_set_eval().

gimple gimple_build_eh_must_not_throw ( )
   Build a GIMPLE_EH_MUST_NOT_THROW statement.  

References gimple_wce_set_cleanup().

gimple gimple_build_goto ( )
   Build a GIMPLE_GOTO statement to label DEST.  

References strlen().

Referenced by factor_computed_gotos(), gimplify_vla_decl(), honor_protect_cleanup_actions(), and lower_gimple_return().

gimple gimple_build_nop ( void  )
   Build a GIMPLE_NOP statement.  

Referenced by fold_gimple_cond().

gimple gimple_build_omp_atomic_load ( )
   Build a GIMPLE_OMP_ATOMIC_LOAD statement.  

Referenced by create_phi_for_local_result().

gimple gimple_build_omp_atomic_store ( )
   Build a GIMPLE_OMP_ATOMIC_STORE statement.

   VAL is the value we are storing.  
gimple gimple_build_omp_continue ( )
   Build a GIMPLE_OMP_CONTINUE statement.

   CONTROL_DEF is the definition of the control variable.
   CONTROL_USE is the use of the control variable.  

References gimple_omp_set_body(), and gimple_omp_single_set_clauses().

gimple gimple_build_omp_critical ( )
   Build a GIMPLE_OMP_CRITICAL statement.

   BODY is the sequence of statements for which only one thread can execute.
   NAME is optional identifier for this critical block.  
gimple gimple_build_omp_for ( gimple_seq  body,
int  kind,
tree  clauses,
size_t  collapse,
gimple_seq  pre_body 
   Build a GIMPLE_OMP_FOR statement.

   BODY is sequence of statements inside the for loop.
   KIND is the `for' variant.
   CLAUSES, are any of the OMP loop construct's clauses: private, firstprivate,
   lastprivate, reductions, ordered, schedule, and nowait.
   COLLAPSE is the collapse count.
   PRE_BODY is the sequence of statements that are loop invariant.  
gimple gimple_build_omp_master ( )
   Build a GIMPLE_OMP_MASTER statement.

   BODY is the sequence of statements to be executed by just the master.  
gimple gimple_build_omp_ordered ( )
   Build a GIMPLE_OMP_ORDERED statement.

   BODY is the sequence of statements inside a loop that will executed in
gimple gimple_build_omp_parallel ( gimple_seq  body,
tree  clauses,
tree  child_fn,
tree  data_arg 
   Build a GIMPLE_OMP_PARALLEL statement.

   BODY is sequence of statements which are executed in parallel.
   CLAUSES, are the OMP parallel construct's clauses.
   CHILD_FN is the function created for the parallel threads to execute.
   DATA_ARG are the shared data argument(s).  

References gimple_omp_set_body().

gimple gimple_build_omp_return ( )
   Build a GIMPLE_OMP_RETURN statement.
   WAIT_P is true if this is a non-waiting return.  

Referenced by lower_omp_sections(), and maybe_add_implicit_barrier_cancel().

gimple gimple_build_omp_section ( )
   Build a GIMPLE_OMP_SECTION statement for a sections statement.

   BODY is the sequence of statements in the section.  

References gimple_omp_set_body().

gimple gimple_build_omp_sections ( )
   Build a GIMPLE_OMP_SECTIONS statement.

   BODY is a sequence of section statements.
   CLAUSES are any of the OMP sections contsruct's clauses: private,
   firstprivate, lastprivate, reduction, and nowait.  
gimple gimple_build_omp_sections_switch ( void  )

References gimple_omp_atomic_store_set_val().

gimple gimple_build_omp_single ( )
   Build a GIMPLE_OMP_SINGLE statement.

   BODY is the sequence of statements that will be executed once.
   CLAUSES are any of the OMP single construct's clauses: private, firstprivate,
   copyprivate, nowait.  

References gimple_transaction_set_body(), and gimple_transaction_set_label().

gimple gimple_build_omp_target ( )
   Build a GIMPLE_OMP_TARGET statement.

   BODY is the sequence of statements that will be executed.
   CLAUSES are any of the OMP target construct's clauses.  
gimple gimple_build_omp_task ( gimple_seq  body,
tree  clauses,
tree  child_fn,
tree  data_arg,
tree  copy_fn,
tree  arg_size,
tree  arg_align 
   Build a GIMPLE_OMP_TASK statement.

   BODY is sequence of statements which are executed by the explicit task.
   CLAUSES, are the OMP parallel construct's clauses.
   CHILD_FN is the function created for the parallel threads to execute.
   DATA_ARG are the shared data argument(s).
   COPY_FN is the optional function for firstprivate initialization.
   ARG_SIZE and ARG_ALIGN are size and alignment of the data block.  
gimple gimple_build_omp_taskgroup ( )
   Build a GIMPLE_OMP_TASKGROUP statement.

   BODY is the sequence of statements to be executed by the taskgroup
gimple gimple_build_omp_teams ( )
   Build a GIMPLE_OMP_TEAMS statement.

   BODY is the sequence of statements that will be executed.
   CLAUSES are any of the OMP teams construct's clauses.  
gimple gimple_build_predict ( )
   Build a GIMPLE_PREDICT statement.  PREDICT is one of the predictors from
   predict.def, OUTCOME is NOT_TAKEN or TAKEN.  
     Ensure all the predictors fit into the lower bits of the subcode.  

References empty_stmt_p(), gimple_seq_empty_p(), gsi_end_p(), gsi_next(), gsi_stmt(), and is_gimple_debug().

Referenced by estimate_num_insns_fn().

gimple gimple_build_resx ( )
   Build a GIMPLE_RESX statement.  

References gimple_statement_eh_ctrl::region.

gimple gimple_build_return ( )
   Build a GIMPLE_RETURN statement returning RETVAL.  

Referenced by split_function().

gimple gimple_build_switch ( )
   Build a GIMPLE_SWITCH statement.

   INDEX is the switch's index.
   DEFAULT_LABEL is the default label
   ARGS is a vector of labels excluding the default.  
     Copy the labels from the vector to the switch statement.  
gimple gimple_build_switch_nlabels ( )
   The helper for constructing a gimple switch statement.
   INDEX is the switch's index.
   NLABELS is the number of labels in the switch excluding the default.
   DEFAULT_LABEL is the default label for the switch statement.  
     nlabels + 1 default label + 1 index.  
gimple gimple_build_transaction ( )
   Build a GIMPLE_TRANSACTION statement.  

References empty_body_p(), and gimple_bind_body().

gimple_statement_try* gimple_build_try ( gimple_seq  eval,
gimple_seq  cleanup,
enum gimple_try_flags  kind 
   Build a GIMPLE_TRY statement.

   EVAL is the expression to evaluate.
   CLEANUP is the cleanup expression.
   KIND is either GIMPLE_TRY_CATCH or GIMPLE_TRY_FINALLY depending on
   whether this is a try/catch or a try/finally respectively.  

References gimple_switch_set_default_label(), and gimple_switch_set_index().

Referenced by gimplify_expr().

gimple gimple_build_wce ( )
   Construct a GIMPLE_WITH_CLEANUP_EXPR statement.

   CLEANUP is the cleanup expression.  
static gimple gimple_build_with_ops_stat ( enum gimple_code  code,
unsigned  subcode,
unsigned num_ops  MEM_STAT_DECL 
int gimple_call_arg_flags ( )
   Detects argument flags for argument number ARG on call STMT.  

References gimple_statement_base::bb, function::cfg, cfun, gimple_label_label(), control_flow_graph::last_label_uid, vec_safe_grow_cleared(), and vec_safe_length().

bool gimple_call_builtin_p ( )
   Return true when STMT is builtins call to CLASS.  
   Return true when STMT is builtins call to CODE of CLASS.  

Referenced by get_mem_ref_of_assignment(), and phi_result_unknown_predicate().

gimple gimple_call_copy_skip_args ( )
   Build a GIMPLE_CALL identical to STMT but skipping the arguments in
   the positions marked by the set ARGS_TO_SKIP.  
int gimple_call_flags ( )
static tree gimple_call_fnspec ( )
   Return the "fn spec" string for call STMT.  

References gimple_assign_lhs(), gimple_assign_rhs1(), gimple_assign_rhs_code(), and is_gimple_assign().

unsigned gimple_call_get_nobnd_arg_index ( )
   Return index of INDEX's non bound argument of the call.  
void gimple_call_reset_alias_info ( )
   Reset alias information on call S.  

References gimple_call_set_fntype(), and gimple_set_op().

Referenced by gimple_build_call_valist().

int gimple_call_return_flags ( )
   Detects return flags for the call STMT.  

References extract_ops_from_tree_1(), and gimple_assign_set_rhs_with_ops_1().

bool gimple_call_same_target_p ( )
   Return true if calls C1 and C2 are known to go to the same function.  

Referenced by same_succ_def::equal().

bool gimple_can_coalesce_p ( )
   Given SSA_NAMEs NAME1 and NAME2, return true if they are candidates for
   coalescing together, false otherwise.

   This must stay consistent with var_map_base_init in tree-ssa-live.c.  
     First check the SSA_NAME's associated DECL.  We only want to
     coalesce if they have the same DECL or both have no associated DECL.  
     Now check the types.  If the types are the same, then we should
     try to coalesce V1 and V2.  
     If the types are not the same, check for a canonical type match.  This
     (for example) allows coalescing when the types are fundamentally the
     same, but just have different names. 

     Note pointer types with different address spaces may have the same
     canonical type.  Those are rejected for coalescing by the
     types_compatible_p check.  

Referenced by create_outofssa_var_map(), and uncprop_into_successor_phis().

void gimple_check_failed ( const_gimple  gs,
const char *  file,
int  line,
const char *  function,
enum gimple_code  code,
enum tree_code  subcode 
   Complain of a gimple type mismatch and die.  

References gimple_copy(), gimple_seq_add_stmt(), gsi_end_p(), gsi_next(), and gsi_stmt().

bool gimple_compare_field_offset ( )
   Return true if the field decls F1 and F2 are at the same offset.

   This is intended to be used on GIMPLE types only.  
                  Once gimplification is done, self-referential offsets are
                  instantiated as operand #2 of the COMPONENT_REF built for
                  each access and reset.  Therefore, they are not relevant
                  anymore and fields are interchangeable provided that they
                  represent the same access.  
     Fortran and C do not always agree on what DECL_OFFSET_ALIGN
     should be, so handle differing ones specially by decomposing
     the offset into a byte and bit offset manually.  
void gimple_cond_get_ops_from_tree ( tree  cond,
enum tree_code code_p,
tree lhs_p,
tree rhs_p 
   Extract operands for a GIMPLE_COND statement out of COND_EXPR tree COND.  
     Canonicalize conditionals of the form 'if (!VAL)'.  
     Canonicalize conditionals of the form 'if (VAL)'  

References gimple_build_cond(), and gimple_cond_get_ops_from_tree().

Referenced by gimple_cond_get_ops_from_tree().

void gimple_cond_set_condition_from_tree ( )
   Set code, lhs, and rhs of a GIMPLE_COND from a suitable
   boolean expression tree COND.  

Referenced by ifcombine_ifandif(), and tree_unswitch_single_loop().

gimple gimple_copy ( )
   Return a deep copy of statement STMT.  All the operands from STMT
   are reallocated and copied using unshare_expr.  The DEF, USE, VDEF
   and VUSE operand arrays are set to empty in the new copy.  The new
   copy isn't part of any sequence.  
     Shallow copy all the fields from STMT.  
     If STMT has sub-statements, deep-copy them as well.  
     Make copy of operands.  
     Clear out SSA operand vectors on COPY.  
         SSA operands need to be updated.  

Referenced by gimple_check_failed(), and gimple_redirect_edge_and_branch().

bool gimple_could_trap_p ( )
   Return true if statement S can trap.  
bool gimple_could_trap_p_1 ( )
   Helper for gimple_could_trap_p and gimple_assign_rhs_could_trap_p.
   Return true if S can trap.  When INCLUDE_MEM is true, check whether
   the memory operations could trap.  When INCLUDE_STORES is true and
   S is a GIMPLE_ASSIGN, the LHS of the assignment is also checked.  
         Assume that calls to weak functions may trap.  
const char* gimple_decl_printable_name ( )
   Return a printable name for symbol DECL.  
alias_set_type gimple_get_alias_set ( )
   Return the typed-based alias set for T, which may be an expression
   or a type.  Return -1 if we don't do anything special.  
     Permit type-punning when accessing a union, provided the access
     is directly through the union.  For example, this code does not
     permit taking the address of a union member and then storing
     through it.  Even the type-punning allowed here is a GCC
     extension, albeit a common and useful one; the C standard says
     that such accesses have implementation-defined behavior.  
     That's all the expressions we handle specially.  
     For convenience, follow the C standard when dealing with
     character types.  Any object may be accessed via an lvalue that
     has character type.  
     Allow aliasing between signed and unsigned variants of the same
     type.  We treat the signed variant as canonical.  
         t1 == t can happen for boolean nodes which are always unsigned.  
tree gimple_get_lhs ( )
   Return the LHS of a statement that performs an assignment,
   either a GIMPLE_ASSIGN or a GIMPLE_CALL.  Returns NULL_TREE
   for a call to a function that returns no value, or for a
   statement other than an assignment or a call.  

Referenced by check_array_ref(), dse_optimize_stmt(), execute_sm_if_changed_flag_set(), extract_component(), gimple_redirect_edge_and_branch(), gsi_split_seq_before(), inhibit_phi_insertion(), make_blocks(), maybe_optimize_var(), ref_may_be_aliased(), tree_nrv(), and vect_build_slp_tree_1().

bool gimple_has_body_p ( )
   Return true when FNDECL has Gimple body either in unlowered
   or CFG form.  

Referenced by cgraph_edge_cannot_lead_to_return(), cgraph_materialize_clone(), comp_type_attributes(), and gcc::pass_manager::pass_manager().

bool gimple_has_side_effects ( )
   Return true if statement S has side-effects.  We consider a
   statement to have side effects if:

   - It is a GIMPLE_CALL not marked with ECF_PURE or ECF_CONST.
   - Any of its operands are marked TREE_THIS_VOLATILE or TREE_SIDE_EFFECTS.  
     We don't have to scan the arguments to check for
     volatile arguments, though, at present, we still
     do a scan to check for TREE_SIDE_EFFECTS.  
         An infinite loop is considered a side effect.  


Referenced by do_partial_partial_insertion(), find_case_label_for_value(), mark_stmt_if_obviously_necessary(), and tree_bb_level_predictions().

bool gimple_ior_addresses_taken ( )
   Set the bit for the uid of all decls that have their address taken
   in STMT in the ADDRESSES_TAKEN bitmap.  Returns true if there
   were any in this stmt.  
static bool gimple_ior_addresses_taken_1 ( gimple  stmt,
tree  addr,
void *  data 
   Helper for gimple_ior_addresses_taken_1.  
void gimple_seq_add_seq ( )
   Append sequence SRC to the end of sequence *DST_P.  If *DST_P is
   NULL, a new sequence is allocated.  

References walk_stmt_info::callback_result, gsi_next(), gsi_stmt(), walk_stmt_info::removed_stmt, and walk_gimple_stmt().

Referenced by finalize_nesting_tree_1(), gimplify_expr(), honor_protect_cleanup_actions(), and vect_create_cond_for_alias_checks().

void gimple_seq_add_stmt ( )
   Link gimple statement GS to the end of the sequence *SEQ_P.  If
   *SEQ_P is NULL, a new sequence is allocated.  

References gsi_end_p().

Referenced by do_return_redirection(), gimple_check_failed(), gsi_move_after(), honor_protect_cleanup_actions(), and remap_vla_decls().

gimple_seq gimple_seq_copy ( )
   Perform a deep copy of sequence SRC and return the result.  

Referenced by find_goto_replacement(), and replace_goto_queue_cond_clause().

void gimple_set_bb ( )
   Set BB to be the basic block holding G.  
     If the statement is a label, add the label to block-to-labels map
     so that we can speed up edge creation for GIMPLE_GOTOs.  

References gimple_assign_set_lhs(), and gimple_call_set_lhs().

Referenced by gsi_split_seq_before(), and update_bb_for_stmts().

void gimple_set_body ( )
   Set sequence SEQ to be the GIMPLE body for function FN.  
         If FNDECL still does not have a function structure associated
         with it, then it does not make sense for it to receive a
         GIMPLE body.  
static void gimple_set_code ( )
   Gimple tuple constructors.
   Note: Any constructor taking a ``gimple_seq'' as a parameter, can
   be passed a NULL to start with an empty sequence.  
   Set the code for statement G to CODE.  

References gss_for_code(), and gsstruct_code_size.

void gimple_set_lhs ( )
   Set the LHS of a statement that performs an assignment,
   either a GIMPLE_ASSIGN or a GIMPLE_CALL.  

Referenced by make_blocks().

void gimple_set_loaded_syms ( gimple  ,
bitmap  ,
void gimple_set_stored_syms ( gimple  ,
bitmap  ,
   Private API manipulation functions shared only with some
   other files.  
static void gimple_set_subcode ( )
   Set SUBCODE to be the code of the expression computed by statement G.  
     We only have 16 bits for the RHS code.  Assert that we are not
     overflowing it.  

References gimple_alloc_stat().

Referenced by gimple_build_eh_filter().

static tree gimple_signed_or_unsigned_type ( )
   Return a type the same as TYPE except unsigned or
   signed according to UNSIGNEDP.  
     For ENUMERAL_TYPEs in C++, must check the mode of the types, not
     the precision; they have precision set to match their range, but
     may use a wider mode to match an ABI.  If we change modes, we may
     wind up with bad conversions.  For INTEGER_TYPEs in C, must check
     the precision as well, so as to yield correct results for
     bit-field types.  C++ does not have these separate bit-field
     types, and producing a signed or unsigned variant of an
     ENUMERAL_TYPE may cause other problems as well.  
tree gimple_signed_type ( )
   Return a signed type the same as TYPE in other respects.  
static size_t gimple_size ( )
   Return the number of bytes needed to hold a GIMPLE statement with
   code CODE.  
tree gimple_unsigned_type ( )
   Return an unsigned type the same as TYPE in other respects.  
gimple gimplify_assign ( )
   Build a new GIMPLE_ASSIGN tuple and append it to the end of *SEQ_P.

   DST/SRC are the destination and source respectively.  You can pass
   ungimplified trees in DST or SRC, in which case they will be
   converted to a gimple operand if necessary.

   This function returns the newly created GIMPLE_ASSIGN tuple.  

References extract_ops_from_tree(), is_gimple_min_invariant(), and tcc_comparison.

Referenced by assign_parms(), and lower_reduction_clauses().

bool is_gimple_address ( )
   Return true if T is a gimple address.  
bool is_gimple_addressable ( )
    Return true if T is something whose address can be taken.  
bool is_gimple_asm_val ( )
   Similarly, but accept hard registers as inputs to asm statements.  

References gimple_call_num_args().

bool is_gimple_builtin_call ( )
   Return TRUE iff stmt is a call to a built-in function.  
bool is_gimple_call_addr ( )
   Return true if T is a valid function operand of a CALL_EXPR.  

Referenced by gimple_build_call(), and gimple_build_call_vec().

bool is_gimple_constant ( )
   Return true if T is a valid gimple constant.  

References is_gimple_variable().

Referenced by find_matching_predicate_in_rest_chains(), instrument_derefs(), is_gimple_condexpr(), and is_gimple_lvalue().

bool is_gimple_id ( )
    Return true if T is a GIMPLE identifier (something with an address).  
             Allow string constants, since they are addressable.  
bool is_gimple_invariant_address ( )
   Return true if T is a gimple invariant address.  

Referenced by is_gimple_lvalue().

bool is_gimple_ip_invariant ( )
   Return true if T is a GIMPLE interprocedural invariant.  It's a restricted
   form of gimple minimal invariant.  

References decl_address_invariant_p(), and is_gimple_reg().

Referenced by ipa_load_from_parm_agg(), and ipa_prop_write_all_agg_replacement().

bool is_gimple_ip_invariant_address ( )
   Return true if T is a gimple invariant address at IPA level
   (so addresses of variables on stack are not allowed).  

Referenced by is_gimple_condexpr().

bool is_gimple_lvalue ( )
   For the definitive definition of GIMPLE, see doc/tree-ssa.texi.  
   Validation of GIMPLE expressions.  
    Return true if T is a valid LHS for a GIMPLE assignment expression.  
             These are complex lvalues, but don't have addresses, so they
             go here.  

References is_gimple_constant(), and is_gimple_invariant_address().

bool is_gimple_mem_ref_addr ( )
   Return true if T is a valid address operand of a MEM_REF.  

Referenced by create_mem_ref(), expand_builtin_prefetch(), and last_stmt().

bool is_gimple_min_lval ( )
   Return true if T is a GIMPLE minimal lvalue.  
bool is_gimple_reg ( )
   Return true if T is a non-aggregate register variable.  
     A volatile decl is not acceptable because we can't reuse it as
     needed.  We need to copy it into a temp first.  
     We define "registers" as things that can be renamed as needed,
     which with our infrastructure does not apply to memory.  
     Hard register variables are an interesting case.  For those that
     are call-clobbered, we don't know where all the calls are, since
     we don't (want to) take into account which operations will turn
     into libcalls at the rtl level.  For those that are call-saved,
     we don't currently model the fact that calls may in fact change
     global hard registers, nor do we examine ASM_CLOBBERS at the tree
     level, and so miss variable changes that might imply.  All around,
     it seems safest to not do too much optimization with these at the
     tree level at all.  We'll have to rely on the rtl optimizers to
     clean this up, as there we've got all the appropriate bits exposed.  
     Complex and vector values must have been put into SSA-like form.
     That is, no assignments to the individual components.  

Referenced by adjust_return_value(), build1_stat(), generic_expr_could_trap_p(), initialize_parameter_reductions(), is_gimple_ip_invariant(), non_rewritable_mem_ref_base(), num_imm_uses(), op_iter_init_phidef(), op_iter_next_def(), remap_vla_decls(), rewrite_dom_walker::rewrite_dom_walker(), rewrite_reductions_out_of_ssa(), update_complex_components_on_edge(), vect_get_vec_defs_for_stmt_copy(), and walk_gimple_asm().

bool is_gimple_val ( )
   Return true if T is a GIMPLE rvalue, i.e. an identifier or a constant.  
     Make loads from volatiles and memory vars explicit.  

Referenced by dump_gimple_statistics(), find_loop_location(), gimple_call_flags(), is_gimple_min_invariant(), and ssa_prop_fini().

bool is_gimple_variable ( )
   Return true if T is a variable.  

References handled_component_p().

Referenced by is_gimple_constant().

bool nonfreeing_call_p ( )
   Return true when CALL is a call stmt that definitely doesn't
   free any memory or makes it unavailable otherwise.  
           Just in case these become ECF_LEAF in the future.  
void recalculate_side_effects ( )
             All of these have side-effects, no matter what their
             operands are.  
         Fall through.  
         No side-effects.  

References HOST_WIDE_INT.

bool types_compatible_p ( )
   Return true if a conversion from either type of TYPE1 and TYPE2
   to the other is not required.  Otherwise return false.  

Referenced by gimplify_omp_task(), propagate_with_phi(), and vect_init_vector_1().

bool useless_type_conversion_p ( )
   Return true if the conversion from INNER_TYPE to OUTER_TYPE is a
   useless type conversion, otherwise return false.

   This function implicitly defines the middle-end type system.  With
   the notion of 'a < b' meaning that useless_type_conversion_p (a, b)
   holds and 'a > b' meaning that useless_type_conversion_p (b, a) holds,
   the following invariants shall be fulfilled:

     1) useless_type_conversion_p is transitive.
        If a < b and b < c then a < c.

     2) useless_type_conversion_p is not symmetric.
        From a < b does not follow a > b.

     3) Types define the available set of operations applicable to values.
        A type conversion is useless if the operations for the target type
        is a subset of the operations for the source type.  For example
        casts to void* are useless, casts from void* are not (void* can't
        be dereferenced or offsetted, but copied, hence its set of operations
        is a strict subset of that of all other data pointer types).  Casts
        to const T* are useless (can't be written to), casts from const T*
        to T* are not.  
     Do the following before stripping toplevel qualifiers.  
         Do not lose casts between pointers to different address spaces.  
     From now on qualifiers on value types do not matter.  
     If we know the canonical types, compare them.  
     Changes in machine mode are never useless conversions unless we
     deal with aggregate types in which case we defer to later checks.  
     If both the inner and outer types are integral types, then the
     conversion is not necessary if they have the same mode and
     signedness and precision, and both or neither are boolean.  
         Preserve changes in signedness or precision.  
         Preserve conversions to/from BOOLEAN_TYPE if types are not
         of precision one.  
         We don't need to preserve changes in the types minimum or
         maximum value in general as these do not generate code
         unless the types precisions are different.  
     Scalar floating point types with the same mode are compatible.  
     Fixed point types with the same mode are compatible.  
     We need to take special care recursing to pointed-to types.  
         Do not lose casts to function pointer types.  
         We do not care for const qualification of the pointed-to types
         as const qualification has no semantic value to the middle-end.  
         Otherwise pointers/references are equivalent.  
     Recurse for complex types.  
     Recurse for vector types with the same number of subparts.  
         Preserve string attributes.  
         Conversions from array types with unknown extent to
         array types with known extent are not useless.  
         Nor are conversions from array types with non-constant size to
         array types with constant size or to different size.  
         Check conversions between arrays with partially known extents.
         If the array min/max values are constant they have to match.
         Otherwise allow conversions to unknown and variable extents.
         In particular this declares conversions that may change the
         mode to BLKmode as useless.  
             After gimplification a variable min/max value carries no
             additional information compared to a NULL value.  All that
             matters has been lowered to be part of the IL.  
             Conversions NULL / variable <- cst are useless, but not
             the other way around.  
         Recurse on the element check.  
         If the return types are not compatible bail out.  
         Method types should belong to a compatible base class.  
         A conversion to an unprototyped argument list is ok.  
         If the unqualified argument types are compatible the conversion
         is useless.  
         If there is a mismatch in the number of arguments the functions
         are not compatible.  
         Defer to the target if necessary.  
     For aggregates we rely on TYPE_CANONICAL exclusively and require
     explicit conversions for types involving to be structurally
     compared types.  

Referenced by build_access_from_expr_1(), copy_debug_stmts(), create_mem_ref(), expand_omp_sections(), generate_subtree_copies(), gimple_asm_clobbers_memory_p(), gimple_get_virt_method_for_binfo(), gimplify_init_ctor_eval(), gimplify_modify_expr_complex_part(), gimplify_switch_expr(), instrument_builtin_call(), ipa_load_from_parm_agg(), ipa_modify_call_arguments(), replace_ref(), sra_modify_expr(), and tree_nrv().

static bool validate_call ( )
   Return true when STMTs arguments match those of FNDECL.  
         Variadic args follow.  
static tree walk_gimple_asm ( gimple  stmt,
walk_tree_fn  callback_op,
struct walk_stmt_info wi 
tree walk_gimple_op ( gimple  stmt,
walk_tree_fn  callback_op,
struct walk_stmt_info wi 
   Helper function of WALK_GIMPLE_STMT.  Walk every tree operand in

   CALLBACK_OP is called on each operand of STMT via walk_tree.
   Additional parameters to walk_tree must be stored in WI.  For each operand
   OP, walk_tree is called as:

        walk_tree (&OP, CALLBACK_OP, WI, WI->PSET)

   If CALLBACK_OP returns non-NULL for an operand, the remaining
   operands are not scanned.

   The return value is that returned by the last call to walk_tree, or
   NULL_TREE if no CALLBACK_OP is specified.  
         Walk the RHS operands.  If the LHS is of a non-renamable type or
         is a register variable, we may use a COMPONENT_REF on the RHS.  
         Walk the LHS.  If the RHS is appropriate for a memory, we
         may use a COMPONENT_REF on the LHS.  
             If the RHS is of a non-renamable type or is a register variable,
             we may use a COMPONENT_REF on the LHS.  
         Tuples that do not have operands.  

Referenced by count_uses_and_derefs(), and note_simd_array_uses().

gimple walk_gimple_seq ( gimple_seq  seq,
walk_stmt_fn  callback_stmt,
walk_tree_fn  callback_op,
struct walk_stmt_info wi 
   Like walk_gimple_seq_mod, but ensure that the head of SEQ isn't
   changed by the callbacks.  

References walk_stmt_info::pset.

gimple walk_gimple_seq_mod ( gimple_seq pseq,
walk_stmt_fn  callback_stmt,
walk_tree_fn  callback_op,
struct walk_stmt_info wi 
   Walk all the statements in the sequence *PSEQ calling walk_gimple_stmt
   on each one.  WI is as in walk_gimple_stmt.

   If walk_gimple_stmt returns non-NULL, the walk is stopped, and the
   value is stored in WI->CALLBACK_RESULT.  Also, the statement that
   produced the value is returned if this statement has not been
   removed by a callback (wi->removed_stmt).  If the statement has
   been removed, NULL is returned.

   Otherwise, all the statements are walked and NULL returned.  
             If CALLBACK_STMT or CALLBACK_OP return a value, WI must exist
             to hold it.  

References walk_stmt_info::is_lhs, and walk_stmt_info::val_only.

tree walk_gimple_stmt ( gimple_stmt_iterator gsi,
walk_stmt_fn  callback_stmt,
walk_tree_fn  callback_op,
struct walk_stmt_info wi 
   Walk the current statement in GSI (optionally using traversal state
   stored in WI).  If WI is NULL, no state is kept during traversal.
   The callback CALLBACK_STMT is called.  If CALLBACK_STMT indicates
   that it has handled all the operands of the statement, its return
   value is returned.  Otherwise, the return value from CALLBACK_STMT
   is discarded and its operands are scanned.

   If CALLBACK_STMT is NULL or it didn't handle the operands,
   CALLBACK_OP is called on each operand of the statement via
   walk_gimple_op.  If walk_gimple_op returns non-NULL for any
   operand, the remaining operands are not scanned.  In this case, the
   return value from CALLBACK_OP is returned.

   In any other case, NULL_TREE is returned.  
     Invoke the statement callback.  Return if the callback handled
     all of STMT operands by itself.  
         If CALLBACK_STMT did not handle operands, it should not have
         a value to return.  
         Re-read stmt in case the callback changed it.  
     If CALLBACK_OP is defined, invoke it on every operand of STMT.  
     If STMT can have statements inside (e.g. GIMPLE_BIND), walk them.  
         FALL THROUGH.  

Referenced by gimple_seq_add_seq().

bool walk_stmt_load_store_addr_ops ( gimple  stmt,
void *  data,
bool(*)(gimple, tree, void *)  visit_load,
bool(*)(gimple, tree, void *)  visit_store,
bool(*)(gimple, tree, void *)  visit_addr 
   For the statement STMT call the callbacks VISIT_LOAD, VISIT_STORE and
   VISIT_ADDR if non-NULL on loads, store and address-taken operands
   passing the STMT, the base of the operand and DATA to it.  The base
   will be either a decl, an indirect reference (including TARGET_MEM_REF)
   or the argument of an address expression.
   Returns the results of these callbacks or'ed.  
             COND_EXPR and VCOND_EXPR rhs1 argument is a comparison
             tree with two operands.  

References gimple_phi_arg_def(), and gimple_phi_num_args().

Referenced by mark_store().

bool walk_stmt_load_store_ops ( gimple  stmt,
void *  data,
bool(*)(gimple, tree, void *)  visit_load,
bool(*)(gimple, tree, void *)  visit_store 
   Like walk_stmt_load_store_addr_ops but with NULL visit_addr.  IPA-CP
   should make a faster clone for this case.  

Variable Documentation

int gimple_alloc_counts[(int) gimple_alloc_kind_all]
   Gimple stats.  

Referenced by gimple_alloc_stat().

const char* const gimple_alloc_kind_names[]
Initial value:
"phi nodes",
"everything else"
   Keep in sync with gimple.h:enum gimple_alloc_kind.  
int gimple_alloc_sizes[(int) gimple_alloc_kind_all]

Referenced by gimple_alloc_stat().

const char* const gimple_code_name[]
Initial value:
#include "gimple.def"

Referenced by dump_gimple_fmt().

EXPORTED_CONST size_t gimple_ops_offset_[]
Initial value:
#include "gsstruct.def"
   Offset in bytes to the location of the operand vector.
   Zero if there is no operand vector for this tuple structure.  
const unsigned char gimple_rhs_class_table[]
Initial value:
#include "all-tree.def"
EXPORTED_CONST enum gimple_statement_structure_enum gss_for_code_[]
Initial value:
#include "gimple.def"
   Map GIMPLE codes to GSS codes.  
const size_t gsstruct_code_size[]
Initial value:
#include "gsstruct.def"

Referenced by gimple_set_code().