GCC Middle and Back End API Reference
gimple.h File Reference
#include "tree-ssa-alias.h"
#include "gimple-expr.h"
#include "gimple.def"
#include "gsstruct.def"
Include dependency graph for gimple.h:

Go to the source code of this file.

Data Structures

struct  remove_pointer< T >
 
struct  remove_pointer< T * >
 
struct  gimple
 
struct  gimple_statement_with_ops_base
 
struct  gimple_statement_with_ops
 
struct  gimple_statement_with_memory_ops_base
 
struct  gimple_statement_with_memory_ops
 
struct  gcall
 
struct  gimple_statement_omp
 
struct  gbind
 
struct  gcatch
 
struct  geh_filter
 
struct  geh_else
 
struct  geh_mnt
 
struct  gphi
 
struct  gimple_statement_eh_ctrl
 
struct  gresx
 
struct  geh_dispatch
 
struct  gtry
 
struct  gimple_statement_wce
 
struct  gasm
 
struct  gomp_critical
 
struct  gimple_omp_for_iter
 
struct  gomp_for
 
struct  gimple_statement_omp_parallel_layout
 
struct  gimple_statement_omp_taskreg
 
struct  gomp_parallel
 
struct  gomp_target
 
struct  gomp_task
 
struct  gomp_sections
 
struct  gomp_continue
 
struct  gimple_statement_omp_single_layout
 
struct  gomp_single
 
struct  gomp_teams
 
struct  gomp_ordered
 
struct  gomp_scan
 
struct  gomp_atomic_load
 
struct  gimple_statement_omp_atomic_store_layout
 
struct  gomp_atomic_store
 
struct  gimple_statement_omp_return
 
struct  gimple_statement_assume
 
struct  gtransaction
 
struct  gcond
 
struct  gdebug
 
struct  ggoto
 
struct  glabel
 
struct  gswitch
 
struct  gassign
 
struct  greturn
 
struct  gimple_temp_hash_elt
 

Macros

#define DEFGSCODE(SYM, STRING, STRUCT)   SYM,
 
#define gcc_gimple_checking_assert(EXPR)   ((void)(0 && (EXPR)))
 
#define GIMPLE_CHECK(GS, CODE)   (void)0
 
#define GTMA_IS_OUTER   (1u << 0)
 
#define GTMA_IS_RELAXED   (1u << 1)
 
#define GTMA_DECLARATION_MASK   (GTMA_IS_OUTER | GTMA_IS_RELAXED)
 
#define GTMA_HAVE_ABORT   (1u << 2)
 
#define GTMA_HAVE_LOAD   (1u << 3)
 
#define GTMA_HAVE_STORE   (1u << 4)
 
#define GTMA_MAY_ENTER_IRREVOCABLE   (1u << 5)
 
#define GTMA_DOES_GO_IRREVOCABLE   (1u << 6)
 
#define GTMA_HAS_NO_INSTRUMENTATION   (1u << 7)
 
#define DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP)   SYM,
 
#define GIMPLE_DEBUG_BIND_NOVALUE   NULL_TREE /* error_mark_node @endverbatim */
 
#define CASE_GIMPLE_OMP
 

Typedefs

typedef gimplegimple_seq_node
 
typedef struct gimple_temp_hash_elt elt_t
 

Enumerations

enum  gimple_code { LAST_AND_UNUSED_GIMPLE_CODE }
 
enum  gimple_rhs_class {
  GIMPLE_INVALID_RHS , GIMPLE_TERNARY_RHS , GIMPLE_BINARY_RHS , GIMPLE_UNARY_RHS ,
  GIMPLE_SINGLE_RHS
}
 
enum  gf_mask {
  GF_ASM_INPUT = 1 << 0 , GF_ASM_VOLATILE = 1 << 1 , GF_ASM_INLINE = 1 << 2 , GF_CALL_FROM_THUNK = 1 << 0 ,
  GF_CALL_RETURN_SLOT_OPT = 1 << 1 , GF_CALL_TAILCALL = 1 << 2 , GF_CALL_VA_ARG_PACK = 1 << 3 , GF_CALL_NOTHROW = 1 << 4 ,
  GF_CALL_ALLOCA_FOR_VAR = 1 << 5 , GF_CALL_INTERNAL = 1 << 6 , GF_CALL_CTRL_ALTERING = 1 << 7 , GF_CALL_MUST_TAIL_CALL = 1 << 9 ,
  GF_CALL_BY_DESCRIPTOR = 1 << 10 , GF_CALL_NOCF_CHECK = 1 << 11 , GF_CALL_FROM_NEW_OR_DELETE = 1 << 12 , GF_CALL_XTHROW = 1 << 13 ,
  GF_OMP_PARALLEL_COMBINED = 1 << 0 , GF_OMP_TASK_TASKLOOP = 1 << 0 , GF_OMP_TASK_TASKWAIT = 1 << 1 , GF_OMP_FOR_KIND_MASK = (1 << 3) - 1 ,
  GF_OMP_FOR_KIND_FOR = 0 , GF_OMP_FOR_KIND_DISTRIBUTE = 1 , GF_OMP_FOR_KIND_TASKLOOP = 2 , GF_OMP_FOR_KIND_OACC_LOOP = 4 ,
  GF_OMP_FOR_KIND_SIMD = 5 , GF_OMP_FOR_COMBINED = 1 << 3 , GF_OMP_FOR_COMBINED_INTO = 1 << 4 , GF_OMP_TARGET_KIND_MASK = (1 << 5) - 1 ,
  GF_OMP_TARGET_KIND_REGION = 0 , GF_OMP_TARGET_KIND_DATA = 1 , GF_OMP_TARGET_KIND_UPDATE = 2 , GF_OMP_TARGET_KIND_ENTER_DATA = 3 ,
  GF_OMP_TARGET_KIND_EXIT_DATA = 4 , GF_OMP_TARGET_KIND_OACC_PARALLEL = 5 , GF_OMP_TARGET_KIND_OACC_KERNELS = 6 , GF_OMP_TARGET_KIND_OACC_SERIAL = 7 ,
  GF_OMP_TARGET_KIND_OACC_DATA = 8 , GF_OMP_TARGET_KIND_OACC_UPDATE = 9 , GF_OMP_TARGET_KIND_OACC_ENTER_DATA = 10 , GF_OMP_TARGET_KIND_OACC_EXIT_DATA = 11 ,
  GF_OMP_TARGET_KIND_OACC_DECLARE = 12 , GF_OMP_TARGET_KIND_OACC_HOST_DATA = 13 , GF_OMP_TARGET_KIND_OACC_PARALLEL_KERNELS_PARALLELIZED = 14 , GF_OMP_TARGET_KIND_OACC_PARALLEL_KERNELS_GANG_SINGLE = 15 ,
  GF_OMP_TARGET_KIND_OACC_DATA_KERNELS = 16 , GF_OMP_TEAMS_HOST = 1 << 0 , GF_OMP_RETURN_NOWAIT = 1 << 0 , GF_OMP_SECTION_LAST = 1 << 0 ,
  GF_OMP_ORDERED_STANDALONE = 1 << 0 , GF_OMP_ATOMIC_MEMORY_ORDER = (1 << 6) - 1 , GF_OMP_ATOMIC_NEED_VALUE = 1 << 6 , GF_OMP_ATOMIC_WEAK = 1 << 7 ,
  GF_PREDICT_TAKEN = 1 << 15
}
 
enum  gimple_debug_subcode { GIMPLE_DEBUG_BIND = 0 , GIMPLE_DEBUG_SOURCE_BIND = 1 , GIMPLE_DEBUG_BEGIN_STMT = 2 , GIMPLE_DEBUG_INLINE_ENTRY = 3 }
 
enum  plf_mask { GF_PLF_1 = 1 << 0 , GF_PLF_2 = 1 << 1 }
 
enum  gimple_try_flags { GIMPLE_TRY_CATCH = 1 << 0 , GIMPLE_TRY_FINALLY = 1 << 1 , GIMPLE_TRY_KIND = GIMPLE_TRY_CATCH | GIMPLE_TRY_FINALLY , GIMPLE_TRY_CATCH_IS_CLEANUP = 1 << 2 }
 
enum  gimple_statement_structure_enum { LAST_GSS_ENUM }
 
enum  gimple_alloc_kind {
  gimple_alloc_kind_assign , gimple_alloc_kind_phi , gimple_alloc_kind_cond , gimple_alloc_kind_rest ,
  gimple_alloc_kind_all
}
 

Functions

template<typename T >
T GIMPLE_CHECK2 (gimple *gs)
 
template<typename T >
T GIMPLE_CHECK2 (const gimple *gs)
 
size_t gimple_size (enum gimple_code code, unsigned num_ops=0)
 
void gimple_init (gimple *g, enum gimple_code code, unsigned num_ops)
 
gimplegimple_alloc (enum gimple_code, unsigned CXX_MEM_STAT_INFO)
 
greturngimple_build_return (tree)
 
void gimple_call_reset_alias_info (gcall *)
 
gcallgimple_build_call_vec (tree, const vec< tree > &)
 
gcallgimple_build_call (tree, unsigned,...)
 
gcallgimple_build_call_valist (tree, unsigned, va_list)
 
gcallgimple_build_call_internal (enum internal_fn, unsigned,...)
 
gcallgimple_build_call_internal_vec (enum internal_fn, const vec< tree > &)
 
gcallgimple_build_call_from_tree (tree, tree)
 
gassigngimple_build_assign (tree, tree CXX_MEM_STAT_INFO)
 
gassigngimple_build_assign (tree, enum tree_code, tree, tree, tree CXX_MEM_STAT_INFO)
 
gassigngimple_build_assign (tree, enum tree_code, tree, tree CXX_MEM_STAT_INFO)
 
gassigngimple_build_assign (tree, enum tree_code, tree CXX_MEM_STAT_INFO)
 
gcondgimple_build_cond (enum tree_code, tree, tree, tree, tree)
 
gcondgimple_build_cond_from_tree (tree, tree, tree)
 
void gimple_cond_set_condition_from_tree (gcond *, tree)
 
glabelgimple_build_label (tree label)
 
ggotogimple_build_goto (tree dest)
 
gimplegimple_build_nop (void)
 
gbindgimple_build_bind (tree, gimple_seq, tree)
 
gasmgimple_build_asm_vec (const char *, vec< tree, va_gc > *, vec< tree, va_gc > *, vec< tree, va_gc > *, vec< tree, va_gc > *)
 
gcatchgimple_build_catch (tree, gimple_seq)
 
geh_filtergimple_build_eh_filter (tree, gimple_seq)
 
geh_mntgimple_build_eh_must_not_throw (tree)
 
geh_elsegimple_build_eh_else (gimple_seq, gimple_seq)
 
gtrygimple_build_try (gimple_seq, gimple_seq, enum gimple_try_flags)
 
gimplegimple_build_wce (gimple_seq)
 
gresxgimple_build_resx (int)
 
gswitchgimple_build_switch_nlabels (unsigned, tree, tree)
 
gswitchgimple_build_switch (tree, tree, const vec< tree > &)
 
geh_dispatchgimple_build_eh_dispatch (int)
 
gdebuggimple_build_debug_bind (tree, tree, gimple *CXX_MEM_STAT_INFO)
 
gdebuggimple_build_debug_source_bind (tree, tree, gimple *CXX_MEM_STAT_INFO)
 
gdebuggimple_build_debug_begin_stmt (tree, location_t CXX_MEM_STAT_INFO)
 
gdebuggimple_build_debug_inline_entry (tree, location_t CXX_MEM_STAT_INFO)
 
gomp_criticalgimple_build_omp_critical (gimple_seq, tree, tree)
 
gomp_forgimple_build_omp_for (gimple_seq, int, tree, size_t, gimple_seq)
 
gomp_parallelgimple_build_omp_parallel (gimple_seq, tree, tree, tree)
 
gomp_taskgimple_build_omp_task (gimple_seq, tree, tree, tree, tree, tree, tree)
 
gimplegimple_build_omp_section (gimple_seq)
 
gimplegimple_build_omp_structured_block (gimple_seq)
 
gimplegimple_build_omp_scope (gimple_seq, tree)
 
gimplegimple_build_omp_master (gimple_seq)
 
gimplegimple_build_omp_masked (gimple_seq, tree)
 
gimplegimple_build_omp_taskgroup (gimple_seq, tree)
 
gomp_continuegimple_build_omp_continue (tree, tree)
 
gomp_orderedgimple_build_omp_ordered (gimple_seq, tree)
 
gimplegimple_build_omp_return (bool)
 
gomp_scangimple_build_omp_scan (gimple_seq, tree)
 
gomp_sectionsgimple_build_omp_sections (gimple_seq, tree)
 
gimplegimple_build_omp_sections_switch (void)
 
gomp_singlegimple_build_omp_single (gimple_seq, tree)
 
gomp_targetgimple_build_omp_target (gimple_seq, int, tree)
 
gomp_teamsgimple_build_omp_teams (gimple_seq, tree)
 
gomp_atomic_loadgimple_build_omp_atomic_load (tree, tree, enum omp_memory_order)
 
gomp_atomic_storegimple_build_omp_atomic_store (tree, enum omp_memory_order)
 
gimplegimple_build_assume (tree, gimple_seq)
 
gtransactiongimple_build_transaction (gimple_seq)
 
void gimple_seq_add_stmt (gimple_seq *, gimple *)
 
void gimple_seq_add_stmt_without_update (gimple_seq *, gimple *)
 
void gimple_seq_add_seq (gimple_seq *, gimple_seq)
 
void gimple_seq_add_seq_without_update (gimple_seq *, gimple_seq)
 
void annotate_all_with_location_after (gimple_seq, gimple_stmt_iterator, location_t)
 
void annotate_all_with_location (gimple_seq, location_t)
 
bool empty_body_p (gimple_seq)
 
gimple_seq gimple_seq_copy (gimple_seq)
 
bool gimple_call_same_target_p (const gimple *, const gimple *)
 
int gimple_call_flags (const gimple *)
 
int gimple_call_arg_flags (const gcall *, unsigned)
 
int gimple_call_retslot_flags (const gcall *)
 
int gimple_call_static_chain_flags (const gcall *)
 
int gimple_call_return_flags (const gcall *)
 
bool gimple_call_nonnull_result_p (gcall *)
 
tree gimple_call_nonnull_arg (gcall *)
 
bool gimple_assign_copy_p (gimple *)
 
bool gimple_assign_ssa_name_copy_p (gimple *)
 
bool gimple_assign_unary_nop_p (gimple *)
 
bool gimple_assign_load_p (const gimple *)
 
void gimple_set_bb (gimple *, basic_block)
 
void gimple_assign_set_rhs_from_tree (gimple_stmt_iterator *, tree)
 
void gimple_assign_set_rhs_with_ops (gimple_stmt_iterator *, enum tree_code, tree, tree, tree)
 
tree gimple_get_lhs (const gimple *)
 
void gimple_set_lhs (gimple *, tree)
 
gimplegimple_copy (gimple *)
 
void gimple_move_vops (gimple *, gimple *)
 
bool gimple_has_side_effects (const gimple *)
 
bool gimple_could_trap_p_1 (const gimple *, bool, bool)
 
bool gimple_could_trap_p (const gimple *)
 
bool gimple_assign_rhs_could_trap_p (gimple *)
 
void dump_gimple_statistics (void)
 
unsigned get_gimple_rhs_num_ops (enum tree_code)
 
gcallgimple_call_copy_skip_args (gcall *, bitmap)
 
bool gimple_compare_field_offset (tree, tree)
 
tree gimple_unsigned_type (tree)
 
tree gimple_signed_type (tree)
 
alias_set_type gimple_get_alias_set (tree)
 
bool gimple_ior_addresses_taken (bitmap, gimple *)
 
bool gimple_builtin_call_types_compatible_p (const gimple *, tree)
 
combined_fn gimple_call_combined_fn (const gimple *)
 
bool gimple_call_operator_delete_p (const gcall *)
 
bool gimple_call_builtin_p (const gimple *)
 
bool gimple_call_builtin_p (const gimple *, enum built_in_class)
 
bool gimple_call_builtin_p (const gimple *, enum built_in_function)
 
bool gimple_asm_clobbers_memory_p (const gasm *)
 
void dump_decl_set (FILE *, bitmap)
 
bool nonfreeing_call_p (gimple *)
 
bool nonbarrier_call_p (gimple *)
 
bool infer_nonnull_range (gimple *, tree)
 
bool infer_nonnull_range_by_dereference (gimple *, tree)
 
bool infer_nonnull_range_by_attribute (gimple *, tree)
 
void sort_case_labels (vec< tree > &)
 
void preprocess_case_label_vec_for_gimple (vec< tree > &, tree, tree *)
 
void gimple_seq_set_location (gimple_seq, location_t)
 
void gimple_seq_discard (gimple_seq)
 
void maybe_remove_unused_call_args (struct function *, gimple *)
 
bool gimple_inexpensive_call_p (gcall *)
 
bool stmt_can_terminate_bb_p (gimple *)
 
location_t gimple_or_expr_nonartificial_location (gimple *, tree)
 
gcallgimple_build_builtin_unreachable (location_t)
 
bool warning_suppressed_p (const gimple *, opt_code=all_warnings) ATTRIBUTE_NONNULL(1)
 
void suppress_warning (gimple *, opt_code=all_warnings, bool=true) ATTRIBUTE_NONNULL(1)
 
void copy_warning (gimple *, const gimple *) ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2)
 
void copy_warning (gimple *, const_tree) ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2)
 
void copy_warning (tree, const gimple *) ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2)
 
unsigned int gimple_stmt_max_uid (struct function *fn)
 
void set_gimple_stmt_max_uid (struct function *fn, unsigned int maxid)
 
unsigned int inc_gimple_stmt_max_uid (struct function *fn)
 
gimple_seq_node gimple_seq_first (gimple_seq s)
 
gimplegimple_seq_first_stmt (gimple_seq s)
 
gbindgimple_seq_first_stmt_as_a_bind (gimple_seq s)
 
gimple_seq_node gimple_seq_last (gimple_seq s)
 
gimplegimple_seq_last_stmt (gimple_seq s)
 
void gimple_seq_set_last (gimple_seq *ps, gimple_seq_node last)
 
void gimple_seq_set_first (gimple_seq *ps, gimple_seq_node first)
 
bool gimple_seq_empty_p (gimple_seq s)
 
gimple_seq gimple_seq_alloc_with_stmt (gimple *stmt)
 
gimple_seq bb_seq (const_basic_block bb)
 
gimple_seqbb_seq_addr (basic_block bb)
 
void set_bb_seq (basic_block bb, gimple_seq seq)
 
enum gimple_code gimple_code (const gimple *g)
 
enum gimple_statement_structure_enum gss_for_code (enum gimple_code code)
 
enum gimple_statement_structure_enum gimple_statement_structure (gimple *gs)
 
bool gimple_has_substatements (gimple *g)
 
basic_block gimple_bb (const gimple *g)
 
tree gimple_block (const gimple *g)
 
void gimple_set_location (gimple *, location_t)
 
void gimple_set_block (gimple *g, tree block)
 
location_t gimple_location (const gimple *g)
 
location_t gimple_location_safe (const gimple *g)
 
location_t * gimple_location_ptr (gimple *g)
 
bool gimple_has_location (const gimple *g)
 
location_t gimple_nonartificial_location (const gimple *g)
 
const char * gimple_filename (const gimple *stmt)
 
int gimple_lineno (const gimple *stmt)
 
bool gimple_seq_singleton_p (gimple_seq seq)
 
bool gimple_no_warning_p (const gimple *stmt)
 
void gimple_set_no_warning (gimple *stmt, bool no_warning)
 
void gimple_set_visited (gimple *stmt, bool visited_p)
 
bool gimple_visited_p (gimple *stmt)
 
void gimple_set_plf (gimple *stmt, enum plf_mask plf, bool val_p)
 
unsigned int gimple_plf (gimple *stmt, enum plf_mask plf)
 
void gimple_set_uid (gimple *g, unsigned uid)
 
unsigned gimple_uid (const gimple *g)
 
void gimple_init_singleton (gimple *g)
 
bool gimple_has_ops (const gimple *g)
 
bool gimple_has_mem_ops (const gimple *g)
 
struct use_optype_dgimple_use_ops (const gimple *g)
 
void gimple_set_use_ops (gimple *g, struct use_optype_d *use)
 
tree gimple_vuse (const gimple *g)
 
tree gimple_vdef (const gimple *g)
 
treegimple_vuse_ptr (gimple *g)
 
treegimple_vdef_ptr (gimple *g)
 
void gimple_set_vuse (gimple *g, tree vuse)
 
void gimple_set_vdef (gimple *g, tree vdef)
 
bool gimple_modified_p (const gimple *g)
 
void gimple_set_modified (gimple *s, bool modifiedp)
 
bool gimple_has_volatile_ops (const gimple *stmt)
 
void gimple_set_has_volatile_ops (gimple *stmt, bool volatilep)
 
bool gimple_in_transaction (const gimple *stmt)
 
bool gimple_references_memory_p (gimple *stmt)
 
unsigned gimple_omp_subcode (const gimple *s)
 
void gimple_omp_set_subcode (gimple *s, unsigned int subcode)
 
void gimple_omp_return_set_nowait (gimple *s)
 
bool gimple_omp_return_nowait_p (const gimple *g)
 
void gimple_omp_return_set_lhs (gimple *g, tree lhs)
 
tree gimple_omp_return_lhs (const gimple *g)
 
treegimple_omp_return_lhs_ptr (gimple *g)
 
bool gimple_omp_section_last_p (const gimple *g)
 
void gimple_omp_section_set_last (gimple *g)
 
bool gimple_omp_ordered_standalone_p (const gimple *g)
 
void gimple_omp_ordered_standalone (gimple *g)
 
bool gimple_omp_parallel_combined_p (const gimple *g)
 
void gimple_omp_parallel_set_combined_p (gimple *g, bool combined_p)
 
bool gimple_omp_atomic_need_value_p (const gimple *g)
 
void gimple_omp_atomic_set_need_value (gimple *g)
 
bool gimple_omp_atomic_weak_p (const gimple *g)
 
void gimple_omp_atomic_set_weak (gimple *g)
 
enum omp_memory_order gimple_omp_atomic_memory_order (const gimple *g)
 
void gimple_omp_atomic_set_memory_order (gimple *g, enum omp_memory_order mo)
 
unsigned gimple_num_ops (const gimple *gs)
 
void gimple_set_num_ops (gimple *gs, unsigned num_ops)
 
treegimple_ops (gimple *gs)
 
tree gimple_op (const gimple *gs, unsigned i)
 
treegimple_op_ptr (gimple *gs, unsigned i)
 
void gimple_set_op (gimple *gs, unsigned i, tree op)
 
bool is_gimple_assign (const gimple *gs)
 
enum gimple_rhs_class get_gimple_rhs_class (enum tree_code code)
 
tree gimple_assign_lhs (const gassign *gs)
 
tree gimple_assign_lhs (const gimple *gs)
 
treegimple_assign_lhs_ptr (gassign *gs)
 
treegimple_assign_lhs_ptr (gimple *gs)
 
void gimple_assign_set_lhs (gassign *gs, tree lhs)
 
void gimple_assign_set_lhs (gimple *gs, tree lhs)
 
tree gimple_assign_rhs1 (const gassign *gs)
 
tree gimple_assign_rhs1 (const gimple *gs)
 
treegimple_assign_rhs1_ptr (gassign *gs)
 
treegimple_assign_rhs1_ptr (gimple *gs)
 
void gimple_assign_set_rhs1 (gassign *gs, tree rhs)
 
void gimple_assign_set_rhs1 (gimple *gs, tree rhs)
 
tree gimple_assign_rhs2 (const gassign *gs)
 
tree gimple_assign_rhs2 (const gimple *gs)
 
treegimple_assign_rhs2_ptr (gassign *gs)
 
treegimple_assign_rhs2_ptr (gimple *gs)
 
void gimple_assign_set_rhs2 (gassign *gs, tree rhs)
 
void gimple_assign_set_rhs2 (gimple *gs, tree rhs)
 
tree gimple_assign_rhs3 (const gassign *gs)
 
tree gimple_assign_rhs3 (const gimple *gs)
 
treegimple_assign_rhs3_ptr (gimple *gs)
 
void gimple_assign_set_rhs3 (gassign *gs, tree rhs)
 
void gimple_assign_set_rhs3 (gimple *gs, tree rhs)
 
void gimple_assign_set_rhs_with_ops (gimple_stmt_iterator *gsi, enum tree_code code, tree op1, tree op2)
 
void gimple_assign_set_rhs_with_ops (gimple_stmt_iterator *gsi, enum tree_code code, tree op1)
 
bool gimple_assign_nontemporal_move_p (const gassign *gs)
 
void gimple_assign_set_nontemporal_move (gimple *gs, bool nontemporal)
 
enum tree_code gimple_assign_rhs_code (const gassign *gs)
 
enum tree_code gimple_assign_rhs_code (const gimple *gs)
 
void gimple_assign_set_rhs_code (gimple *s, enum tree_code code)
 
enum gimple_rhs_class gimple_assign_rhs_class (const gimple *gs)
 
bool gimple_assign_single_p (const gimple *gs)
 
bool gimple_store_p (const gimple *gs)
 
bool gimple_assign_cast_p (const gimple *s)
 
bool gimple_clobber_p (const gimple *s)
 
bool gimple_clobber_p (const gimple *s, enum clobber_kind kind)
 
bool is_gimple_call (const gimple *gs)
 
tree gimple_call_lhs (const gcall *gs)
 
tree gimple_call_lhs (const gimple *gs)
 
treegimple_call_lhs_ptr (gcall *gs)
 
treegimple_call_lhs_ptr (gimple *gs)
 
void gimple_call_set_lhs (gcall *gs, tree lhs)
 
void gimple_call_set_lhs (gimple *gs, tree lhs)
 
bool gimple_call_internal_p (const gcall *gs)
 
bool gimple_call_internal_p (const gimple *gs)
 
bool gimple_call_nocf_check_p (const gcall *gs)
 
void gimple_call_set_nocf_check (gcall *gs, bool nocf_check)
 
enum internal_fn gimple_call_internal_fn (const gcall *gs)
 
enum internal_fn gimple_call_internal_fn (const gimple *gs)
 
bool gimple_call_internal_unique_p (const gcall *gs)
 
bool gimple_call_internal_unique_p (const gimple *gs)
 
bool gimple_call_internal_p (const gimple *gs, internal_fn fn)
 
void gimple_call_set_ctrl_altering (gcall *s, bool ctrl_altering_p)
 
void gimple_call_set_ctrl_altering (gimple *s, bool ctrl_altering_p)
 
bool gimple_call_ctrl_altering_p (const gcall *gs)
 
bool gimple_call_ctrl_altering_p (const gimple *gs)
 
tree gimple_call_fntype (const gcall *gs)
 
tree gimple_call_fntype (const gimple *gs)
 
void gimple_call_set_fntype (gcall *call_stmt, tree fntype)
 
tree gimple_call_fn (const gcall *gs)
 
tree gimple_call_fn (const gimple *gs)
 
treegimple_call_fn_ptr (gcall *gs)
 
treegimple_call_fn_ptr (gimple *gs)
 
void gimple_call_set_fn (gcall *gs, tree fn)
 
void gimple_call_set_fndecl (gcall *gs, tree decl)
 
void gimple_call_set_fndecl (gimple *gs, tree decl)
 
void gimple_call_set_internal_fn (gcall *call_stmt, enum internal_fn fn)
 
tree gimple_call_fndecl (const gcall *gs)
 
tree gimple_call_fndecl (const gimple *gs)
 
tree gimple_call_return_type (const gcall *gs)
 
tree gimple_call_chain (const gcall *gs)
 
tree gimple_call_chain (const gimple *gs)
 
treegimple_call_chain_ptr (gcall *call_stmt)
 
void gimple_call_set_chain (gcall *call_stmt, tree chain)
 
unsigned gimple_call_num_args (const gcall *gs)
 
unsigned gimple_call_num_args (const gimple *gs)
 
tree gimple_call_arg (const gcall *gs, unsigned index)
 
tree gimple_call_arg (const gimple *gs, unsigned index)
 
treegimple_call_arg_ptr (gcall *gs, unsigned index)
 
treegimple_call_arg_ptr (gimple *gs, unsigned index)
 
void gimple_call_set_arg (gcall *gs, unsigned index, tree arg)
 
void gimple_call_set_arg (gimple *gs, unsigned index, tree arg)
 
void gimple_call_set_tail (gcall *s, bool tail_p)
 
bool gimple_call_tail_p (const gcall *s)
 
void gimple_call_set_must_tail (gcall *s, bool must_tail_p)
 
bool gimple_call_must_tail_p (const gcall *s)
 
void gimple_call_set_return_slot_opt (gcall *s, bool return_slot_opt_p)
 
bool gimple_call_return_slot_opt_p (const gcall *s)
 
void gimple_call_set_from_thunk (gcall *s, bool from_thunk_p)
 
bool gimple_call_from_thunk_p (gcall *s)
 
void gimple_call_set_from_new_or_delete (gcall *s, bool from_new_or_delete_p)
 
bool gimple_call_from_new_or_delete (const gcall *s)
 
void gimple_call_set_va_arg_pack (gcall *s, bool pass_arg_pack_p)
 
bool gimple_call_va_arg_pack_p (const gcall *s)
 
bool gimple_call_noreturn_p (const gcall *s)
 
bool gimple_call_noreturn_p (const gimple *s)
 
void gimple_call_set_nothrow (gcall *s, bool nothrow_p)
 
bool gimple_call_nothrow_p (gcall *s)
 
static void gimple_call_set_expected_throw (gcall *s, bool expected_throw_p)
 
static bool gimple_call_expected_throw_p (gcall *s)
 
void gimple_call_set_alloca_for_var (gcall *s, bool for_var)
 
bool gimple_call_alloca_for_var_p (gcall *s)
 
bool gimple_call_alloca_for_var_p (gimple *s)
 
void gimple_call_set_by_descriptor (gcall *s, bool by_descriptor_p)
 
bool gimple_call_by_descriptor_p (gcall *s)
 
void gimple_call_copy_flags (gcall *dest_call, gcall *orig_call)
 
struct pt_solutiongimple_call_use_set (gcall *call_stmt)
 
const pt_solutiongimple_call_use_set (const gcall *call_stmt)
 
struct pt_solutiongimple_call_clobber_set (gcall *call_stmt)
 
const pt_solutiongimple_call_clobber_set (const gcall *call_stmt)
 
bool gimple_has_lhs (const gimple *stmt)
 
enum tree_code gimple_cond_code (const gcond *gs)
 
enum tree_code gimple_cond_code (const gimple *gs)
 
void gimple_cond_set_code (gcond *gs, enum tree_code code)
 
tree gimple_cond_lhs (const gcond *gs)
 
tree gimple_cond_lhs (const gimple *gs)
 
treegimple_cond_lhs_ptr (gcond *gs)
 
void gimple_cond_set_lhs (gcond *gs, tree lhs)
 
tree gimple_cond_rhs (const gcond *gs)
 
tree gimple_cond_rhs (const gimple *gs)
 
treegimple_cond_rhs_ptr (gcond *gs)
 
void gimple_cond_set_rhs (gcond *gs, tree rhs)
 
tree gimple_cond_true_label (const gcond *gs)
 
void gimple_cond_set_true_label (gcond *gs, tree label)
 
void gimple_cond_set_false_label (gcond *gs, tree label)
 
tree gimple_cond_false_label (const gcond *gs)
 
void gimple_cond_make_false (gcond *gs)
 
void gimple_cond_make_true (gcond *gs)
 
bool gimple_cond_true_p (const gcond *gs)
 
bool gimple_cond_false_p (const gcond *gs)
 
void gimple_cond_set_condition (gcond *stmt, enum tree_code code, tree lhs, tree rhs)
 
enum tree_code gimple_expr_code (const gimple *stmt)
 
tree gimple_label_label (const glabel *gs)
 
void gimple_label_set_label (glabel *gs, tree label)
 
tree gimple_goto_dest (const gimple *gs)
 
void gimple_goto_set_dest (ggoto *gs, tree dest)
 
tree gimple_bind_vars (const gbind *bind_stmt)
 
void gimple_bind_set_vars (gbind *bind_stmt, tree vars)
 
void gimple_bind_append_vars (gbind *bind_stmt, tree vars)
 
gimple_seqgimple_bind_body_ptr (gbind *bind_stmt)
 
gimple_seq gimple_bind_body (const gbind *gs)
 
void gimple_bind_set_body (gbind *bind_stmt, gimple_seq seq)
 
void gimple_bind_add_stmt (gbind *bind_stmt, gimple *stmt)
 
void gimple_bind_add_seq (gbind *bind_stmt, gimple_seq seq)
 
tree gimple_bind_block (const gbind *bind_stmt)
 
void gimple_bind_set_block (gbind *bind_stmt, tree block)
 
unsigned gimple_asm_ninputs (const gasm *asm_stmt)
 
unsigned gimple_asm_noutputs (const gasm *asm_stmt)
 
unsigned gimple_asm_nclobbers (const gasm *asm_stmt)
 
unsigned gimple_asm_nlabels (const gasm *asm_stmt)
 
tree gimple_asm_input_op (const gasm *asm_stmt, unsigned index)
 
void gimple_asm_set_input_op (gasm *asm_stmt, unsigned index, tree in_op)
 
tree gimple_asm_output_op (const gasm *asm_stmt, unsigned index)
 
void gimple_asm_set_output_op (gasm *asm_stmt, unsigned index, tree out_op)
 
tree gimple_asm_clobber_op (const gasm *asm_stmt, unsigned index)
 
void gimple_asm_set_clobber_op (gasm *asm_stmt, unsigned index, tree clobber_op)
 
tree gimple_asm_label_op (const gasm *asm_stmt, unsigned index)
 
void gimple_asm_set_label_op (gasm *asm_stmt, unsigned index, tree label_op)
 
const char * gimple_asm_string (const gasm *asm_stmt)
 
bool gimple_asm_volatile_p (const gasm *asm_stmt)
 
void gimple_asm_set_volatile (gasm *asm_stmt, bool volatile_p)
 
bool gimple_asm_inline_p (const gasm *asm_stmt)
 
void gimple_asm_set_inline (gasm *asm_stmt, bool inline_p)
 
void gimple_asm_set_input (gasm *asm_stmt, bool input_p)
 
bool gimple_asm_input_p (const gasm *asm_stmt)
 
tree gimple_catch_types (const gcatch *catch_stmt)
 
treegimple_catch_types_ptr (gcatch *catch_stmt)
 
gimple_seqgimple_catch_handler_ptr (gcatch *catch_stmt)
 
gimple_seq gimple_catch_handler (const gcatch *catch_stmt)
 
void gimple_catch_set_types (gcatch *catch_stmt, tree t)
 
void gimple_catch_set_handler (gcatch *catch_stmt, gimple_seq handler)
 
tree gimple_eh_filter_types (const gimple *gs)
 
treegimple_eh_filter_types_ptr (gimple *gs)
 
gimple_seqgimple_eh_filter_failure_ptr (gimple *gs)
 
gimple_seq gimple_eh_filter_failure (const gimple *gs)
 
void gimple_eh_filter_set_types (geh_filter *eh_filter_stmt, tree types)
 
void gimple_eh_filter_set_failure (geh_filter *eh_filter_stmt, gimple_seq failure)
 
tree gimple_eh_must_not_throw_fndecl (const geh_mnt *eh_mnt_stmt)
 
void gimple_eh_must_not_throw_set_fndecl (geh_mnt *eh_mnt_stmt, tree decl)
 
gimple_seqgimple_eh_else_n_body_ptr (geh_else *eh_else_stmt)
 
gimple_seq gimple_eh_else_n_body (const geh_else *eh_else_stmt)
 
gimple_seqgimple_eh_else_e_body_ptr (geh_else *eh_else_stmt)
 
gimple_seq gimple_eh_else_e_body (const geh_else *eh_else_stmt)
 
void gimple_eh_else_set_n_body (geh_else *eh_else_stmt, gimple_seq seq)
 
void gimple_eh_else_set_e_body (geh_else *eh_else_stmt, gimple_seq seq)
 
enum gimple_try_flags gimple_try_kind (const gimple *gs)
 
void gimple_try_set_kind (gtry *gs, enum gimple_try_flags kind)
 
bool gimple_try_catch_is_cleanup (const gimple *gs)
 
gimple_seqgimple_try_eval_ptr (gimple *gs)
 
gimple_seq gimple_try_eval (const gimple *gs)
 
gimple_seqgimple_try_cleanup_ptr (gimple *gs)
 
gimple_seq gimple_try_cleanup (const gimple *gs)
 
void gimple_try_set_catch_is_cleanup (gtry *g, bool catch_is_cleanup)
 
void gimple_try_set_eval (gtry *try_stmt, gimple_seq eval)
 
void gimple_try_set_cleanup (gtry *try_stmt, gimple_seq cleanup)
 
gimple_seqgimple_wce_cleanup_ptr (gimple *gs)
 
gimple_seq gimple_wce_cleanup (gimple *gs)
 
void gimple_wce_set_cleanup (gimple *gs, gimple_seq cleanup)
 
bool gimple_wce_cleanup_eh_only (const gimple *gs)
 
void gimple_wce_set_cleanup_eh_only (gimple *gs, bool eh_only_p)
 
unsigned gimple_phi_capacity (const gimple *gs)
 
unsigned gimple_phi_num_args (const gimple *gs)
 
tree gimple_phi_result (const gphi *gs)
 
tree gimple_phi_result (const gimple *gs)
 
treegimple_phi_result_ptr (gphi *gs)
 
treegimple_phi_result_ptr (gimple *gs)
 
void gimple_phi_set_result (gphi *phi, tree result)
 
struct phi_arg_d * gimple_phi_arg (gphi *gs, unsigned index)
 
const phi_arg_d * gimple_phi_arg (const gphi *gs, unsigned index)
 
const phi_arg_d * gimple_phi_arg (const gimple *gs, unsigned index)
 
struct phi_arg_d * gimple_phi_arg (gimple *gs, unsigned index)
 
void gimple_phi_set_arg (gphi *phi, unsigned index, struct phi_arg_d *phiarg)
 
gimple_seq phi_nodes (const_basic_block bb)
 
gimple_seqphi_nodes_ptr (basic_block bb)
 
tree gimple_phi_arg_def (const gphi *gs, size_t index)
 
tree gimple_phi_arg_def (const gimple *gs, size_t index)
 
tree gimple_phi_arg_def_from_edge (const gphi *gs, const_edge e)
 
tree gimple_phi_arg_def_from_edge (const gimple *gs, const_edge e)
 
treegimple_phi_arg_def_ptr (gphi *phi, size_t index)
 
edge gimple_phi_arg_edge (const gphi *phi, size_t i)
 
location_t gimple_phi_arg_location (const gphi *phi, size_t i)
 
location_t gimple_phi_arg_location_from_edge (gphi *phi, edge e)
 
void gimple_phi_arg_set_location (gphi *phi, size_t i, location_t loc)
 
location_t * gimple_phi_arg_location_ptr (gphi *phi, size_t i)
 
bool gimple_phi_arg_has_location (const gphi *phi, size_t i)
 
unsigned gimple_num_args (const gimple *gs)
 
tree gimple_arg (const gimple *gs, unsigned int i)
 
treegimple_arg_ptr (gimple *gs, unsigned int i)
 
int gimple_resx_region (const gresx *resx_stmt)
 
void gimple_resx_set_region (gresx *resx_stmt, int region)
 
int gimple_eh_dispatch_region (const geh_dispatch *eh_dispatch_stmt)
 
void gimple_eh_dispatch_set_region (geh_dispatch *eh_dispatch_stmt, int region)
 
unsigned gimple_switch_num_labels (const gswitch *gs)
 
void gimple_switch_set_num_labels (gswitch *g, unsigned nlabels)
 
tree gimple_switch_index (const gswitch *gs)
 
treegimple_switch_index_ptr (gswitch *gs)
 
void gimple_switch_set_index (gswitch *gs, tree index)
 
tree gimple_switch_label (const gswitch *gs, unsigned index)
 
void gimple_switch_set_label (gswitch *gs, unsigned index, tree label)
 
tree gimple_switch_default_label (const gswitch *gs)
 
void gimple_switch_set_default_label (gswitch *gs, tree label)
 
bool is_gimple_debug (const gimple *gs)
 
gimplegimple_seq_first_nondebug_stmt (gimple_seq s)
 
gimplegimple_seq_last_nondebug_stmt (gimple_seq s)
 
bool gimple_debug_bind_p (const gimple *s)
 
tree gimple_debug_bind_get_var (const gimple *dbg)
 
tree gimple_debug_bind_get_value (const gimple *dbg)
 
treegimple_debug_bind_get_value_ptr (gimple *dbg)
 
void gimple_debug_bind_set_var (gimple *dbg, tree var)
 
void gimple_debug_bind_set_value (gimple *dbg, tree value)
 
void gimple_debug_bind_reset_value (gimple *dbg)
 
bool gimple_debug_bind_has_value_p (gimple *dbg)
 
bool gimple_debug_source_bind_p (const gimple *s)
 
tree gimple_debug_source_bind_get_var (const gimple *dbg)
 
tree gimple_debug_source_bind_get_value (const gimple *dbg)
 
treegimple_debug_source_bind_get_value_ptr (gimple *dbg)
 
void gimple_debug_source_bind_set_var (gimple *dbg, tree var)
 
void gimple_debug_source_bind_set_value (gimple *dbg, tree value)
 
bool gimple_debug_begin_stmt_p (const gimple *s)
 
bool gimple_debug_inline_entry_p (const gimple *s)
 
bool gimple_debug_nonbind_marker_p (const gimple *s)
 
int get_lineno (const gimple *stmt)
 
gimple_seqgimple_omp_body_ptr (gimple *gs)
 
gimple_seq gimple_omp_body (const gimple *gs)
 
void gimple_omp_set_body (gimple *gs, gimple_seq body)
 
tree gimple_omp_critical_name (const gomp_critical *crit_stmt)
 
treegimple_omp_critical_name_ptr (gomp_critical *crit_stmt)
 
void gimple_omp_critical_set_name (gomp_critical *crit_stmt, tree name)
 
tree gimple_omp_critical_clauses (const gomp_critical *crit_stmt)
 
treegimple_omp_critical_clauses_ptr (gomp_critical *crit_stmt)
 
void gimple_omp_critical_set_clauses (gomp_critical *crit_stmt, tree clauses)
 
tree gimple_omp_ordered_clauses (const gomp_ordered *ord_stmt)
 
treegimple_omp_ordered_clauses_ptr (gomp_ordered *ord_stmt)
 
void gimple_omp_ordered_set_clauses (gomp_ordered *ord_stmt, tree clauses)
 
tree gimple_omp_scan_clauses (const gomp_scan *scan_stmt)
 
treegimple_omp_scan_clauses_ptr (gomp_scan *scan_stmt)
 
void gimple_omp_scan_set_clauses (gomp_scan *scan_stmt, tree clauses)
 
tree gimple_omp_taskgroup_clauses (const gimple *gs)
 
treegimple_omp_taskgroup_clauses_ptr (gimple *gs)
 
void gimple_omp_taskgroup_set_clauses (gimple *gs, tree clauses)
 
tree gimple_omp_masked_clauses (const gimple *gs)
 
treegimple_omp_masked_clauses_ptr (gimple *gs)
 
void gimple_omp_masked_set_clauses (gimple *gs, tree clauses)
 
tree gimple_omp_scope_clauses (const gimple *gs)
 
treegimple_omp_scope_clauses_ptr (gimple *gs)
 
void gimple_omp_scope_set_clauses (gimple *gs, tree clauses)
 
int gimple_omp_for_kind (const gimple *g)
 
void gimple_omp_for_set_kind (gomp_for *g, int kind)
 
bool gimple_omp_for_combined_p (const gimple *g)
 
void gimple_omp_for_set_combined_p (gomp_for *g, bool combined_p)
 
bool gimple_omp_for_combined_into_p (const gimple *g)
 
void gimple_omp_for_set_combined_into_p (gomp_for *g, bool combined_p)
 
tree gimple_omp_for_clauses (const gimple *gs)
 
treegimple_omp_for_clauses_ptr (gimple *gs)
 
void gimple_omp_for_set_clauses (gimple *gs, tree clauses)
 
size_t gimple_omp_for_collapse (const gimple *gs)
 
enum tree_code gimple_omp_for_cond (const gimple *gs, size_t i)
 
void gimple_omp_for_set_cond (gimple *gs, size_t i, enum tree_code cond)
 
tree gimple_omp_for_index (const gimple *gs, size_t i)
 
treegimple_omp_for_index_ptr (gimple *gs, size_t i)
 
void gimple_omp_for_set_index (gimple *gs, size_t i, tree index)
 
tree gimple_omp_for_initial (const gimple *gs, size_t i)
 
treegimple_omp_for_initial_ptr (gimple *gs, size_t i)
 
void gimple_omp_for_set_initial (gimple *gs, size_t i, tree initial)
 
tree gimple_omp_for_final (const gimple *gs, size_t i)
 
treegimple_omp_for_final_ptr (gimple *gs, size_t i)
 
void gimple_omp_for_set_final (gimple *gs, size_t i, tree final)
 
tree gimple_omp_for_incr (const gimple *gs, size_t i)
 
treegimple_omp_for_incr_ptr (gimple *gs, size_t i)
 
void gimple_omp_for_set_incr (gimple *gs, size_t i, tree incr)
 
gimple_seqgimple_omp_for_pre_body_ptr (gimple *gs)
 
gimple_seq gimple_omp_for_pre_body (const gimple *gs)
 
void gimple_omp_for_set_pre_body (gimple *gs, gimple_seq pre_body)
 
tree gimple_omp_parallel_clauses (const gimple *gs)
 
treegimple_omp_parallel_clauses_ptr (gomp_parallel *omp_parallel_stmt)
 
void gimple_omp_parallel_set_clauses (gomp_parallel *omp_parallel_stmt, tree clauses)
 
tree gimple_omp_parallel_child_fn (const gomp_parallel *omp_parallel_stmt)
 
treegimple_omp_parallel_child_fn_ptr (gomp_parallel *omp_parallel_stmt)
 
void gimple_omp_parallel_set_child_fn (gomp_parallel *omp_parallel_stmt, tree child_fn)
 
tree gimple_omp_parallel_data_arg (const gomp_parallel *omp_parallel_stmt)
 
treegimple_omp_parallel_data_arg_ptr (gomp_parallel *omp_parallel_stmt)
 
void gimple_omp_parallel_set_data_arg (gomp_parallel *omp_parallel_stmt, tree data_arg)
 
tree gimple_omp_task_clauses (const gimple *gs)
 
treegimple_omp_task_clauses_ptr (gimple *gs)
 
void gimple_omp_task_set_clauses (gimple *gs, tree clauses)
 
bool gimple_omp_task_taskloop_p (const gimple *g)
 
void gimple_omp_task_set_taskloop_p (gimple *g, bool taskloop_p)
 
bool gimple_omp_task_taskwait_p (const gimple *g)
 
void gimple_omp_task_set_taskwait_p (gimple *g, bool taskwait_p)
 
tree gimple_omp_task_child_fn (const gimple *gs)
 
treegimple_omp_task_child_fn_ptr (gimple *gs)
 
void gimple_omp_task_set_child_fn (gimple *gs, tree child_fn)
 
tree gimple_omp_task_data_arg (const gimple *gs)
 
treegimple_omp_task_data_arg_ptr (gimple *gs)
 
void gimple_omp_task_set_data_arg (gimple *gs, tree data_arg)
 
tree gimple_omp_taskreg_clauses (const gimple *gs)
 
treegimple_omp_taskreg_clauses_ptr (gimple *gs)
 
void gimple_omp_taskreg_set_clauses (gimple *gs, tree clauses)
 
tree gimple_omp_taskreg_child_fn (const gimple *gs)
 
treegimple_omp_taskreg_child_fn_ptr (gimple *gs)
 
void gimple_omp_taskreg_set_child_fn (gimple *gs, tree child_fn)
 
tree gimple_omp_taskreg_data_arg (const gimple *gs)
 
treegimple_omp_taskreg_data_arg_ptr (gimple *gs)
 
void gimple_omp_taskreg_set_data_arg (gimple *gs, tree data_arg)
 
tree gimple_omp_task_copy_fn (const gimple *gs)
 
treegimple_omp_task_copy_fn_ptr (gimple *gs)
 
void gimple_omp_task_set_copy_fn (gimple *gs, tree copy_fn)
 
tree gimple_omp_task_arg_size (const gimple *gs)
 
treegimple_omp_task_arg_size_ptr (gimple *gs)
 
void gimple_omp_task_set_arg_size (gimple *gs, tree arg_size)
 
tree gimple_omp_task_arg_align (const gimple *gs)
 
treegimple_omp_task_arg_align_ptr (gimple *gs)
 
void gimple_omp_task_set_arg_align (gimple *gs, tree arg_align)
 
tree gimple_omp_single_clauses (const gimple *gs)
 
treegimple_omp_single_clauses_ptr (gimple *gs)
 
void gimple_omp_single_set_clauses (gomp_single *omp_single_stmt, tree clauses)
 
tree gimple_omp_target_clauses (const gimple *gs)
 
treegimple_omp_target_clauses_ptr (gimple *gs)
 
void gimple_omp_target_set_clauses (gomp_target *omp_target_stmt, tree clauses)
 
int gimple_omp_target_kind (const gimple *g)
 
void gimple_omp_target_set_kind (gomp_target *g, int kind)
 
tree gimple_omp_target_child_fn (const gomp_target *omp_target_stmt)
 
treegimple_omp_target_child_fn_ptr (gomp_target *omp_target_stmt)
 
void gimple_omp_target_set_child_fn (gomp_target *omp_target_stmt, tree child_fn)
 
tree gimple_omp_target_data_arg (const gomp_target *omp_target_stmt)
 
treegimple_omp_target_data_arg_ptr (gomp_target *omp_target_stmt)
 
void gimple_omp_target_set_data_arg (gomp_target *omp_target_stmt, tree data_arg)
 
tree gimple_omp_teams_clauses (const gimple *gs)
 
treegimple_omp_teams_clauses_ptr (gimple *gs)
 
void gimple_omp_teams_set_clauses (gomp_teams *omp_teams_stmt, tree clauses)
 
tree gimple_omp_teams_child_fn (const gomp_teams *omp_teams_stmt)
 
treegimple_omp_teams_child_fn_ptr (gomp_teams *omp_teams_stmt)
 
void gimple_omp_teams_set_child_fn (gomp_teams *omp_teams_stmt, tree child_fn)
 
tree gimple_omp_teams_data_arg (const gomp_teams *omp_teams_stmt)
 
treegimple_omp_teams_data_arg_ptr (gomp_teams *omp_teams_stmt)
 
void gimple_omp_teams_set_data_arg (gomp_teams *omp_teams_stmt, tree data_arg)
 
bool gimple_omp_teams_host (const gomp_teams *omp_teams_stmt)
 
void gimple_omp_teams_set_host (gomp_teams *omp_teams_stmt, bool value)
 
tree gimple_omp_sections_clauses (const gimple *gs)
 
treegimple_omp_sections_clauses_ptr (gimple *gs)
 
void gimple_omp_sections_set_clauses (gimple *gs, tree clauses)
 
tree gimple_omp_sections_control (const gimple *gs)
 
treegimple_omp_sections_control_ptr (gimple *gs)
 
void gimple_omp_sections_set_control (gimple *gs, tree control)
 
void gimple_omp_atomic_store_set_val (gomp_atomic_store *store_stmt, tree val)
 
tree gimple_omp_atomic_store_val (const gomp_atomic_store *store_stmt)
 
treegimple_omp_atomic_store_val_ptr (gomp_atomic_store *store_stmt)
 
void gimple_omp_atomic_load_set_lhs (gomp_atomic_load *load_stmt, tree lhs)
 
tree gimple_omp_atomic_load_lhs (const gomp_atomic_load *load_stmt)
 
treegimple_omp_atomic_load_lhs_ptr (gomp_atomic_load *load_stmt)
 
void gimple_omp_atomic_load_set_rhs (gomp_atomic_load *load_stmt, tree rhs)
 
tree gimple_omp_atomic_load_rhs (const gomp_atomic_load *load_stmt)
 
treegimple_omp_atomic_load_rhs_ptr (gomp_atomic_load *load_stmt)
 
tree gimple_omp_continue_control_def (const gomp_continue *cont_stmt)
 
treegimple_omp_continue_control_def_ptr (gomp_continue *cont_stmt)
 
void gimple_omp_continue_set_control_def (gomp_continue *cont_stmt, tree def)
 
tree gimple_omp_continue_control_use (const gomp_continue *cont_stmt)
 
treegimple_omp_continue_control_use_ptr (gomp_continue *cont_stmt)
 
void gimple_omp_continue_set_control_use (gomp_continue *cont_stmt, tree use)
 
tree gimple_assume_guard (const gimple *gs)
 
void gimple_assume_set_guard (gimple *gs, tree guard)
 
treegimple_assume_guard_ptr (gimple *gs)
 
gimple_seqgimple_assume_body_ptr (gimple *gs)
 
gimple_seq gimple_assume_body (const gimple *gs)
 
gimple_seqgimple_transaction_body_ptr (gtransaction *transaction_stmt)
 
gimple_seq gimple_transaction_body (const gtransaction *transaction_stmt)
 
tree gimple_transaction_label_norm (const gtransaction *transaction_stmt)
 
treegimple_transaction_label_norm_ptr (gtransaction *transaction_stmt)
 
tree gimple_transaction_label_uninst (const gtransaction *transaction_stmt)
 
treegimple_transaction_label_uninst_ptr (gtransaction *transaction_stmt)
 
tree gimple_transaction_label_over (const gtransaction *transaction_stmt)
 
treegimple_transaction_label_over_ptr (gtransaction *transaction_stmt)
 
unsigned int gimple_transaction_subcode (const gtransaction *transaction_stmt)
 
void gimple_transaction_set_body (gtransaction *transaction_stmt, gimple_seq body)
 
void gimple_transaction_set_label_norm (gtransaction *transaction_stmt, tree label)
 
void gimple_transaction_set_label_uninst (gtransaction *transaction_stmt, tree label)
 
void gimple_transaction_set_label_over (gtransaction *transaction_stmt, tree label)
 
void gimple_transaction_set_subcode (gtransaction *transaction_stmt, unsigned int subcode)
 
treegimple_return_retval_ptr (greturn *gs)
 
tree gimple_return_retval (const greturn *gs)
 
void gimple_return_set_retval (greturn *gs, tree retval)
 
bool is_gimple_omp (const gimple *stmt)
 
bool is_gimple_omp_oacc (const gimple *stmt)
 
bool is_gimple_omp_offloaded (const gimple *stmt)
 
bool gimple_nop_p (const gimple *g)
 
bool is_gimple_resx (const gimple *gs)
 
enum gimple_alloc_kind gimple_alloc_kind (enum gimple_code code)
 
bool gimple_do_not_emit_location_p (gimple *g)
 
void gimple_set_do_not_emit_location (gimple *g)
 

Variables

const char *const gimple_code_name []
 
const unsigned char gimple_rhs_class_table []
 
size_t const gimple_ops_offset_ []
 
enum gimple_statement_structure_enum const gss_for_code_ []
 
gimplecurrently_expanding_gimple_stmt
 
uint64_t gimple_alloc_counts []
 
uint64_t gimple_alloc_sizes []
 

Macro Definition Documentation

◆ CASE_GIMPLE_OMP

#define CASE_GIMPLE_OMP
Value:
case GIMPLE_OMP_PARALLEL: \
case GIMPLE_OMP_TASK: \
case GIMPLE_OMP_FOR: \
case GIMPLE_OMP_SECTIONS: \
case GIMPLE_OMP_SECTIONS_SWITCH: \
case GIMPLE_OMP_SINGLE: \
case GIMPLE_OMP_TARGET: \
case GIMPLE_OMP_TEAMS: \
case GIMPLE_OMP_SCOPE: \
case GIMPLE_OMP_SECTION: \
case GIMPLE_OMP_STRUCTURED_BLOCK: \
case GIMPLE_OMP_MASTER: \
case GIMPLE_OMP_MASKED: \
case GIMPLE_OMP_TASKGROUP: \
case GIMPLE_OMP_ORDERED: \
case GIMPLE_OMP_CRITICAL: \
case GIMPLE_OMP_SCAN: \
case GIMPLE_OMP_RETURN: \
case GIMPLE_OMP_ATOMIC_LOAD: \
case GIMPLE_OMP_ATOMIC_STORE: \
case GIMPLE_OMP_CONTINUE
Returns true when the gimple statement STMT is any of the OMP types.   

Referenced by is_ctrl_altering_stmt(), is_gimple_omp(), make_edges_bb(), and verify_gimple_stmt().

◆ DEFGSCODE

#define DEFGSCODE ( SYM,
STRING,
STRUCT )   SYM,

◆ DEFGSSTRUCT

#define DEFGSSTRUCT ( SYM,
STRUCT,
HAS_TREE_OP )   SYM,

◆ gcc_gimple_checking_assert

#define gcc_gimple_checking_assert ( EXPR)    ((void)(0 && (EXPR)))
Error out if a gimple tuple is addressed incorrectly.   

Referenced by gimple_asm_clobber_op(), gimple_asm_input_op(), gimple_asm_label_op(), gimple_asm_output_op(), gimple_asm_set_clobber_op(), gimple_asm_set_input_op(), gimple_asm_set_label_op(), gimple_asm_set_output_op(), gimple_assign_rhs2_ptr(), gimple_assign_rhs3_ptr(), gimple_assign_set_rhs2(), gimple_assign_set_rhs3(), gimple_bind_set_block(), gimple_call_arg(), gimple_call_arg_ptr(), gimple_call_internal_fn(), gimple_call_set_arg(), gimple_call_set_fn(), gimple_call_set_fndecl(), gimple_call_set_fntype(), gimple_call_set_internal_fn(), gimple_debug_bind_get_value(), gimple_debug_bind_get_value_ptr(), gimple_debug_bind_get_var(), gimple_debug_bind_has_value_p(), gimple_debug_bind_reset_value(), gimple_debug_bind_set_value(), gimple_debug_bind_set_var(), gimple_debug_source_bind_get_value(), gimple_debug_source_bind_get_value_ptr(), gimple_debug_source_bind_get_var(), gimple_debug_source_bind_set_value(), gimple_debug_source_bind_set_var(), gimple_expr_code(), gimple_omp_for_cond(), gimple_omp_for_final(), gimple_omp_for_final_ptr(), gimple_omp_for_incr(), gimple_omp_for_incr_ptr(), gimple_omp_for_index(), gimple_omp_for_index_ptr(), gimple_omp_for_initial(), gimple_omp_for_initial_ptr(), gimple_omp_for_set_cond(), gimple_omp_for_set_final(), gimple_omp_for_set_incr(), gimple_omp_for_set_index(), gimple_omp_for_set_initial(), gimple_omp_set_subcode(), gimple_omp_subcode(), gimple_op(), gimple_op_ptr(), gimple_ops(), gimple_phi_arg(), gimple_phi_arg(), gimple_phi_set_arg(), gimple_set_op(), gimple_switch_label(), gimple_switch_num_labels(), gimple_switch_set_index(), gimple_switch_set_label(), gimple_try_catch_is_cleanup(), gimple_try_set_catch_is_cleanup(), gimple_try_set_kind(), and gss_for_code().

◆ GIMPLE_CHECK

#define GIMPLE_CHECK ( GS,
CODE )   (void)0

Referenced by dump_gimple_switch(), gimple_assign_set_nontemporal_move(), gimple_assign_set_rhs_code(), gimple_debug_bind_get_value(), gimple_debug_bind_get_value_ptr(), gimple_debug_bind_get_var(), gimple_debug_bind_has_value_p(), gimple_debug_bind_reset_value(), gimple_debug_bind_set_value(), gimple_debug_bind_set_var(), gimple_debug_source_bind_get_value(), gimple_debug_source_bind_get_value_ptr(), gimple_debug_source_bind_get_var(), gimple_debug_source_bind_set_value(), gimple_debug_source_bind_set_var(), gimple_goto_dest(), gimple_omp_atomic_memory_order(), gimple_omp_atomic_need_value_p(), gimple_omp_atomic_set_memory_order(), gimple_omp_atomic_set_need_value(), gimple_omp_atomic_set_weak(), gimple_omp_atomic_weak_p(), gimple_omp_for_combined_into_p(), gimple_omp_for_combined_p(), gimple_omp_for_kind(), gimple_omp_masked_clauses(), gimple_omp_masked_clauses_ptr(), gimple_omp_masked_set_clauses(), gimple_omp_ordered_standalone(), gimple_omp_ordered_standalone_p(), gimple_omp_parallel_combined_p(), gimple_omp_parallel_set_combined_p(), gimple_omp_return_nowait_p(), gimple_omp_return_set_nowait(), gimple_omp_scope_clauses(), gimple_omp_scope_clauses_ptr(), gimple_omp_scope_set_clauses(), gimple_omp_section_last_p(), gimple_omp_section_set_last(), gimple_omp_target_kind(), gimple_omp_task_set_taskloop_p(), gimple_omp_task_set_taskwait_p(), gimple_omp_task_taskloop_p(), gimple_omp_task_taskwait_p(), gimple_omp_taskgroup_clauses(), gimple_omp_taskgroup_clauses_ptr(), gimple_omp_taskgroup_set_clauses(), gimple_predict_outcome(), gimple_predict_predictor(), gimple_predict_set_outcome(), gimple_predict_set_predictor(), gimple_switch_num_labels(), gimple_switch_set_num_labels(), gimple_try_kind(), gimple_wce_cleanup_eh_only(), and gimple_wce_set_cleanup_eh_only().

◆ GIMPLE_DEBUG_BIND_NOVALUE

#define GIMPLE_DEBUG_BIND_NOVALUE   NULL_TREE /* error_mark_node @endverbatim */
The second operand of a GIMPLE_DEBUG_BIND, when the value was
optimized away.   

Referenced by gimple_debug_bind_has_value_p(), and gimple_debug_bind_reset_value().

◆ GTMA_DECLARATION_MASK

#define GTMA_DECLARATION_MASK   (GTMA_IS_OUTER | GTMA_IS_RELAXED)

◆ GTMA_DOES_GO_IRREVOCABLE

#define GTMA_DOES_GO_IRREVOCABLE   (1u << 6)
The transaction WILL enter serial irrevocable mode.
An irrevocable block post-dominates the entire transaction, such
that all invocations of the transaction will go serial-irrevocable.
In such case, we don't bother instrumenting the transaction, and
tell the runtime that it should begin the transaction in
serial-irrevocable mode.   

Referenced by dump_gimple_transaction(), execute_tm_mark(), expand_transaction(), generate_tm_state(), and ipa_tm_transform_transaction().

◆ GTMA_HAS_NO_INSTRUMENTATION

#define GTMA_HAS_NO_INSTRUMENTATION   (1u << 7)
The transaction contains no instrumentation code whatsover, most
likely because it is guaranteed to go irrevocable upon entry.   

Referenced by dump_gimple_transaction(), expand_transaction(), generate_tm_state(), and ipa_tm_transform_transaction().

◆ GTMA_HAVE_ABORT

#define GTMA_HAVE_ABORT   (1u << 2)

◆ GTMA_HAVE_LOAD

#define GTMA_HAVE_LOAD   (1u << 3)
The transaction is seen to have loads or stores.   

Referenced by dump_gimple_transaction(), examine_assign_tm(), examine_call_tm(), expand_assign_tm(), expand_call_tm(), and propagate_tm_flags_out().

◆ GTMA_HAVE_STORE

◆ GTMA_IS_OUTER

#define GTMA_IS_OUTER   (1u << 0)
GIMPLE_TRANSACTION.   
Bits to be stored in the GIMPLE_TRANSACTION subcode.   
The __transaction_atomic was declared [[outer]] or it is
__transaction_relaxed.   

Referenced by diagnose_tm_1(), dump_gimple_transaction(), expand_transaction(), gimplify_transaction(), lower_transaction(), and make_edges_bb().

◆ GTMA_IS_RELAXED

#define GTMA_IS_RELAXED   (1u << 1)

◆ GTMA_MAY_ENTER_IRREVOCABLE

#define GTMA_MAY_ENTER_IRREVOCABLE   (1u << 5)

Typedef Documentation

◆ elt_t

typedef struct gimple_temp_hash_elt elt_t
Formal (expression) temporary table handling: multiple occurrences of
the same scalar expression are evaluated into the same temporary.   

◆ gimple_seq_node

Gimple IR definitions.

   Copyright (C) 2007-2024 Free Software Foundation, Inc.
   Contributed by Aldy Hernandez <aldyh@redhat.com>

This file is part of GCC.

GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 3, or (at your option) any later
version.

GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
for more details.

You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3.  If not see
<http://www.gnu.org/licenses/>.   

Enumeration Type Documentation

◆ gf_mask

enum gf_mask
Specific flags for individual GIMPLE statements.  These flags are
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
are never used in the same statement class.

The maximum mask value that can be defined is 1 << 15 (i.e., each
statement code can hold up to 16 bitflags).

Keep this list sorted.   
Enumerator
GF_ASM_INPUT 
GF_ASM_VOLATILE 
GF_ASM_INLINE 
GF_CALL_FROM_THUNK 
GF_CALL_RETURN_SLOT_OPT 
GF_CALL_TAILCALL 
GF_CALL_VA_ARG_PACK 
GF_CALL_NOTHROW 
GF_CALL_ALLOCA_FOR_VAR 
GF_CALL_INTERNAL 
GF_CALL_CTRL_ALTERING 
GF_CALL_MUST_TAIL_CALL 
GF_CALL_BY_DESCRIPTOR 
GF_CALL_NOCF_CHECK 
GF_CALL_FROM_NEW_OR_DELETE 
GF_CALL_XTHROW 
GF_OMP_PARALLEL_COMBINED 
GF_OMP_TASK_TASKLOOP 
GF_OMP_TASK_TASKWAIT 
GF_OMP_FOR_KIND_MASK 
GF_OMP_FOR_KIND_FOR 
GF_OMP_FOR_KIND_DISTRIBUTE 
GF_OMP_FOR_KIND_TASKLOOP 
GF_OMP_FOR_KIND_OACC_LOOP 
GF_OMP_FOR_KIND_SIMD 
GF_OMP_FOR_COMBINED 
GF_OMP_FOR_COMBINED_INTO 
GF_OMP_TARGET_KIND_MASK 
GF_OMP_TARGET_KIND_REGION 
GF_OMP_TARGET_KIND_DATA 
GF_OMP_TARGET_KIND_UPDATE 
GF_OMP_TARGET_KIND_ENTER_DATA 
GF_OMP_TARGET_KIND_EXIT_DATA 
GF_OMP_TARGET_KIND_OACC_PARALLEL 
GF_OMP_TARGET_KIND_OACC_KERNELS 
GF_OMP_TARGET_KIND_OACC_SERIAL 
GF_OMP_TARGET_KIND_OACC_DATA 
GF_OMP_TARGET_KIND_OACC_UPDATE 
GF_OMP_TARGET_KIND_OACC_ENTER_DATA 
GF_OMP_TARGET_KIND_OACC_EXIT_DATA 
GF_OMP_TARGET_KIND_OACC_DECLARE 
GF_OMP_TARGET_KIND_OACC_HOST_DATA 
GF_OMP_TARGET_KIND_OACC_PARALLEL_KERNELS_PARALLELIZED 
GF_OMP_TARGET_KIND_OACC_PARALLEL_KERNELS_GANG_SINGLE 
GF_OMP_TARGET_KIND_OACC_DATA_KERNELS 
GF_OMP_TEAMS_HOST 
GF_OMP_RETURN_NOWAIT 
GF_OMP_SECTION_LAST 
GF_OMP_ORDERED_STANDALONE 
GF_OMP_ATOMIC_MEMORY_ORDER 
GF_OMP_ATOMIC_NEED_VALUE 
GF_OMP_ATOMIC_WEAK 
GF_PREDICT_TAKEN 

◆ gimple_alloc_kind

Enum and arrays used for allocation stats.  Keep in sync with
gimple.cc:gimple_alloc_kind_names.   
Enumerator
gimple_alloc_kind_assign 
gimple_alloc_kind_phi 
gimple_alloc_kind_cond 
gimple_alloc_kind_rest 
gimple_alloc_kind_all 

◆ gimple_code

Enumerator
LAST_AND_UNUSED_GIMPLE_CODE 

◆ gimple_debug_subcode

This subcode tells apart different kinds of stmts that are not used
for codegen, but rather to retain debug information.   
Enumerator
GIMPLE_DEBUG_BIND 
GIMPLE_DEBUG_SOURCE_BIND 
GIMPLE_DEBUG_BEGIN_STMT 
GIMPLE_DEBUG_INLINE_ENTRY 

◆ gimple_rhs_class

Class of GIMPLE expressions suitable for the RHS of assignments.  See
get_gimple_rhs_class.   
Enumerator
GIMPLE_INVALID_RHS 
GIMPLE_TERNARY_RHS 
GIMPLE_BINARY_RHS 
GIMPLE_UNARY_RHS 
GIMPLE_SINGLE_RHS 

◆ gimple_statement_structure_enum

Enumerator
LAST_GSS_ENUM 

◆ gimple_try_flags

Kind of GIMPLE_TRY statements.   
Enumerator
GIMPLE_TRY_CATCH 
GIMPLE_TRY_FINALLY 
GIMPLE_TRY_KIND 
GIMPLE_TRY_CATCH_IS_CLEANUP 

◆ plf_mask

enum plf_mask
Masks for selecting a pass local flag (PLF) to work on.  These
masks are used by gimple_set_plf and gimple_plf.   
Enumerator
GF_PLF_1 
GF_PLF_2 

Function Documentation

◆ annotate_all_with_location()

void annotate_all_with_location ( gimple_seq stmt_p,
location_t location )
extern

◆ annotate_all_with_location_after()

void annotate_all_with_location_after ( gimple_seq seq,
gimple_stmt_iterator gsi,
location_t location )
extern
Set LOCATION for all the statements after iterator GSI in sequence
SEQ.  If GSI is pointing to the end of the sequence, start with the
first statement in SEQ.   

References annotate_one_with_location(), gsi_end_p(), gsi_next(), gsi_start(), and gsi_stmt().

Referenced by gimplify_expr().

◆ bb_seq()

◆ bb_seq_addr()

◆ copy_warning() [1/3]

void copy_warning ( gimple * to,
const gimple * from )
extern
Copy the warning disposition mapping from one statement to another.   

References copy_warning().

Referenced by gimple_set_location().

◆ copy_warning() [2/3]

void copy_warning ( gimple * to,
const_tree from )
extern
Copy the warning disposition mapping from an expression to a statement.   

References copy_warning().

◆ copy_warning() [3/3]

void copy_warning ( tree to,
const gimple * from )
extern
Copy the warning disposition mapping from a statement to an expression.   

References copy_warning().

◆ dump_decl_set()

void dump_decl_set ( FILE * file,
bitmap set )
extern
Dump bitmap SET (assumed to contain VAR_DECLs) to FILE.   

References EXECUTE_IF_SET_IN_BITMAP, and i.

Referenced by debug_decl_set(), dump_points_to_solution(), and dump_update_ssa().

◆ dump_gimple_statistics()

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

References gimple_alloc_counts, gimple_alloc_kind_all, gimple_alloc_kind_names, gimple_alloc_sizes, i, PRIu64, and SIZE_AMOUNT.

Referenced by dump_memory_report().

◆ empty_body_p()

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

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

Referenced by empty_stmt_p(), scan_omp_parallel(), and scan_omp_task().

◆ get_gimple_rhs_class()

◆ get_gimple_rhs_num_ops()

unsigned get_gimple_rhs_num_ops ( enum tree_code code)
Return the number of operands needed on the RHS of a GIMPLE
assignment for an expression with tree code CODE.   

References gcc_unreachable, get_gimple_rhs_class(), GIMPLE_BINARY_RHS, GIMPLE_SINGLE_RHS, GIMPLE_TERNARY_RHS, and GIMPLE_UNARY_RHS.

Referenced by fold_stmt_1(), gimple_assign_set_rhs_with_ops(), gimple_build_assign_1(), replace_stmt_with_simplification(), and rewrite_use_nonlinear_expr().

◆ get_lineno()

int get_lineno ( const gimple * stmt)
inline
Return the line number for EXPR, or return -1 if we have no line
number information for it.   

References gimple_location(), LOCATION_LINE, and UNKNOWN_LOCATION.

Referenced by dump_gimple_bb_header().

◆ gimple_alloc()

gimple * gimple_alloc ( enum gimple_code,
unsigned CXX_MEM_STAT_INFO )

◆ gimple_alloc_kind()

Return the allocation kind for a given stmt CODE.   

References gimple_alloc_kind_assign, gimple_alloc_kind_cond, gimple_alloc_kind_phi, and gimple_alloc_kind_rest.

◆ gimple_arg()

tree gimple_arg ( const gimple * gs,
unsigned int i )
inline
GS must be an assignment, a call, or a PHI.
If it's an assignment, return rhs operand I.
If it's a call, return function argument I.
If it's a PHI, return the value of PHI argument I.   

References as_a(), dyn_cast(), gimple_call_arg(), gimple_op(), gimple_phi_arg_def(), and i.

Referenced by compatible_complex_nodes_p(), gimple_equal_p(), ifcvt_can_hoist(), vect_build_slp_tree_1(), vect_get_and_check_slp_defs(), and vect_widened_op_tree().

◆ gimple_arg_ptr()

tree * gimple_arg_ptr ( gimple * gs,
unsigned int i )
inline
Return a pointer to gimple_arg (GS, I).   

References as_a(), dyn_cast(), gimple_call_arg_ptr(), gimple_op_ptr(), gimple_phi_arg_def_ptr(), and i.

◆ gimple_asm_clobber_op()

tree gimple_asm_clobber_op ( const gasm * asm_stmt,
unsigned index )
inline

◆ gimple_asm_clobbers_memory_p()

bool gimple_asm_clobbers_memory_p ( const gasm * stmt)
extern

◆ gimple_asm_inline_p()

bool gimple_asm_inline_p ( const gasm * asm_stmt)
inline
Return true if ASM_STMT is marked inline.   

References GF_ASM_INLINE, and gimple::subcode.

Referenced by ipa_icf_gimple::func_checker::compare_gimple_asm(), dump_gimple_asm(), and estimate_num_insns().

◆ gimple_asm_input_op()

◆ gimple_asm_input_p()

bool gimple_asm_input_p ( const gasm * asm_stmt)
inline

◆ gimple_asm_label_op()

tree gimple_asm_label_op ( const gasm * asm_stmt,
unsigned index )
inline

◆ gimple_asm_nclobbers()

unsigned gimple_asm_nclobbers ( const gasm * asm_stmt)
inline
Return the number of clobber operands for GIMPLE_ASM ASM_STMT.   

References gasm::nc.

Referenced by ipa_icf_gimple::func_checker::compare_gimple_asm(), dump_gimple_asm(), expand_asm_stmt(), gimple_asm_clobbers_memory_p(), and output_gimple_stmt().

◆ gimple_asm_ninputs()

◆ gimple_asm_nlabels()

◆ gimple_asm_noutputs()

◆ gimple_asm_output_op()

◆ gimple_asm_set_clobber_op()

void gimple_asm_set_clobber_op ( gasm * asm_stmt,
unsigned index,
tree clobber_op )
inline
Set CLOBBER_OP to be clobber operand INDEX in GIMPLE_ASM ASM_STMT.   

References gcc_gimple_checking_assert, gasm::ni, gasm::no, gasm::op, and TREE_CODE.

Referenced by gimple_build_asm_vec().

◆ gimple_asm_set_inline()

void gimple_asm_set_inline ( gasm * asm_stmt,
bool inline_p )
inline
If INLINE_P is true, mark asm statement ASM_STMT as inline.   

References GF_ASM_INLINE, and gimple::subcode.

Referenced by gimplify_asm_expr().

◆ gimple_asm_set_input()

void gimple_asm_set_input ( gasm * asm_stmt,
bool input_p )
inline
If INPUT_P is true, mark asm ASM_STMT as an ASM_INPUT.   

References GF_ASM_INPUT, and gimple::subcode.

Referenced by gimplify_asm_expr().

◆ gimple_asm_set_input_op()

void gimple_asm_set_input_op ( gasm * asm_stmt,
unsigned index,
tree in_op )
inline
Set IN_OP to be input operand INDEX in GIMPLE_ASM ASM_STMT.   

References gcc_gimple_checking_assert, gasm::no, gasm::op, and TREE_CODE.

Referenced by gimple_build_asm_vec().

◆ gimple_asm_set_label_op()

void gimple_asm_set_label_op ( gasm * asm_stmt,
unsigned index,
tree label_op )
inline
Set LABEL_OP to be label operand INDEX in GIMPLE_ASM ASM_STMT.   

References gcc_gimple_checking_assert, gasm::nc, gasm::ni, gasm::no, gasm::op, and TREE_CODE.

Referenced by gimple_build_asm_vec().

◆ gimple_asm_set_output_op()

void gimple_asm_set_output_op ( gasm * asm_stmt,
unsigned index,
tree out_op )
inline
Set OUT_OP to be output operand INDEX in GIMPLE_ASM ASM_STMT.   

References gcc_gimple_checking_assert, gasm::op, and TREE_CODE.

Referenced by gimple_build_asm_vec().

◆ gimple_asm_set_volatile()

void gimple_asm_set_volatile ( gasm * asm_stmt,
bool volatile_p )
inline
If VOLATILE_P is true, mark asm statement ASM_STMT as volatile.   

References GF_ASM_VOLATILE, and gimple::subcode.

Referenced by gimplify_asm_expr().

◆ gimple_asm_string()

const char * gimple_asm_string ( const gasm * asm_stmt)
inline
Return the string representing the assembly instruction in
GIMPLE_ASM ASM_STMT.   

References gasm::string.

Referenced by ipa_icf_gimple::func_checker::compare_gimple_asm(), dump_gimple_asm(), estimate_num_insns(), expand_asm_stmt(), gimple_asm_clobbers_memory_p(), and output_gimple_stmt().

◆ gimple_asm_volatile_p()

◆ gimple_assign_cast_p()

◆ gimple_assign_copy_p()

◆ gimple_assign_lhs() [1/2]

tree gimple_assign_lhs ( const gassign * gs)
inline
Return the LHS of assignment statement GS.   

References gimple_statement_with_memory_ops::op.

Referenced by add_scope_conflicts_1(), adjust_bool_pattern(), adjust_bool_pattern_cast(), adjust_bool_stmts(), adjust_imagpart_expr(), adjust_iv_update_pos(), aff_combination_expand(), all_uses_feed_or_dominated_by_stmt(), analyze_agg_content_value(), analyze_candidates_and_replace(), analyze_function_body(), analyze_increments(), and_var_with_comparison_1(), arith_overflow_check_p(), asan_expand_check_ifn(), asan_expand_mark_ifn(), bb_no_side_effects_p(), find_candidates_dom_walker::before_dom_children(), nontrapping_dom_walker::before_dom_children(), bitfields_to_lower_p(), branch_fixup(), break_up_subtract_bb(), addsub_pattern::build(), build_accesses_from_assign(), build_assign(), build_assign(), build_assign(), build_assign(), build_bitint_stmt_ssa_conflicts(), build_shadow_mem_access(), build_ssa_conflict_graph(), build_type_cast(), loop_cand::can_interchange_p(), ccmp_candidate_p(), cfun_returns(), check_all_va_list_escapes(), strlen_pass::check_and_optimize_stmt(), check_scan_store(), loop_distribution::classify_partition(), pcom_worker::combinable_refs_p(), compute_complex_assign_jump_func(), compute_live_vars_1(), cond_if_else_store_replacement_1(), cond_removal_in_builtin_zero_pattern(), cond_store_replacement(), constant_after_peeling(), constant_pointer_difference(), convert_atomic_bit_not(), convert_expand_mult_copysign(), convert_local_reference_stmt(), convert_mult_to_fma(), convert_mult_to_fma_1(), convert_mult_to_highpart(), convert_mult_to_widen(), convert_nonlocal_reference_stmt(), convert_plusminus_to_widen(), convert_scalar_cond_reduction(), copy_prop_visit_assignment(), create_coalesce_list_for_region(), create_phi_basis_1(), decompose_kernels_region_body(), decompose_param_expr(), derive_constant_upper_bound_assign(), derive_constant_upper_bound_ops(), divmod_candidate_p(), dse_optimize_redundant_stores(), dse_optimize_stmt(), dump_gimple_assign(), dump_unary_rhs(), eliminate_redundant_comparison(), eliminate_redundant_computations(), eliminate_dom_walker::eliminate_stmt(), eliminated_by_inlining_prob(), empty_bb_or_one_feeding_into_p(), estimate_num_insns(), evaluate_stmt(), examine_assign_tm(), execute_cse_conv_1(), execute_cse_reciprocals_1(), execute_update_addresses_taken(), exist_non_indexing_operands_for_use_p(), expand_assign_tm(), expand_complex_comparison(), expand_complex_libcall(), expand_complex_move(), expand_expr_real_gassign(), expand_gimple_stmt_1(), expand_omp_atomic_cas(), expand_omp_atomic_fetch_op(), expand_omp_for_generic(), expand_omp_for_static_chunk(), expand_omp_for_static_nochunk(), expand_omp_sections(), expand_omp_target(), expand_omp_taskreg(), expand_vector_comparison(), expand_vector_condition(), expand_vector_operations_1(), expand_vector_scalar_condition(), expr_expected_value_1(), expr_hash_elt::expr_hash_elt(), extr_type_from_vtbl_ptr_store(), extract_mem_content(), factor_out_conditional_operation(), final_range_test_p(), pcom_worker::find_associative_operation_root(), find_basis_for_base_expr(), find_func_aliases(), find_givs_in_stmt(), find_givs_in_stmt_scev(), pcom_worker::find_looparound_phi(), find_replaceable_in_bb(), find_return_bb(), find_tail_calls(), find_uninit_use(), pcom_worker::find_use_stmt(), fold_builtin_atomic_compare_exchange(), fold_gimple_assign(), ccp_folder::fold_stmt(), fold_stmt_1(), scev_dfs::follow_ssa_edge_expr(), force_into_ssa_name(), forward_propagate_addr_expr(), forward_propagate_addr_expr_1(), forward_propagate_into_comparison(), gather_memory_references(), tree_switch_conversion::switch_conversion::gen_inbound_check(), get_bitfield_rep(), get_computation_aff_1(), get_mem_ref_of_assignment(), get_references_in_stmt(), get_string_length(), get_val_for(), gimple_assign_lhs(), gimple_assign_nonnegative_warnv_p(), gimple_assign_rhs_to_tree(), gimple_assign_set_rhs_with_ops(), gimple_assign_ssa_name_copy_p(), gimple_assign_unary_nop_p(), gimple_could_trap_p_1(), gimple_divmod_fixed_value(), gimple_divmod_fixed_value_transform(), gimple_divmod_values_to_profile(), gimple_expand_vec_cond_expr(), gimple_expand_vec_set_extract_expr(), gimple_extract(), gimple_fold_stmt_to_constant_1(), gimple_get_lhs(), gimple_lower_bitint(), gimple_mod_pow2(), gimple_mod_pow2_value_transform(), gimple_mod_subtract(), gimple_mod_subtract_transform(), gimple_nop_conversion_p(), gimple_regimplify_operands(), gsi_replace_with_seq_vops(), handle_builtin_alloca(), strlen_pass::handle_integral_assign(), strlen_pass::handle_pointer_plus(), strlen_pass::handle_store(), hardcfr_scan_block(), if_convertible_gimple_assign_stmt_p(), ifcvt_can_predicate(), ifcvt_can_use_mask_load_store(), ifcvt_local_dce(), infer_loop_bounds_from_array(), infer_loop_bounds_from_pointer_arith(), infer_loop_bounds_from_signedness(), init_dont_simulate_again(), init_vn_nary_op_from_stmt(), initialize_root_vars(), insert_clobber_before_stack_restore(), insert_init_stmt(), insert_trap(), instrument_bool_enum_load(), instrument_builtin(), instrument_builtin_call(), instrument_gimple(), instrument_nonnull_arg(), instrument_si_overflow(), interpret_gimple_assign(), ipa_simd_modify_stmt_ops(), ipa_tm_scan_irr_block(), is_addr_local(), is_feasible_trace(), is_reassociable_op(), is_rshift_by_1(), is_vtable_assignment_stmt(), is_widening_mult_p(), legal_cast_p(), linearize_expr(), load_or_store_of_ptr_parameter(), avail_exprs_stack::lookup_avail_expr(), lower_bitfield(), lower_omp_1(), lower_vec_perm(), mark_all_reaching_defs_necessary_1(), ipa_param_body_adjustments::mark_dead_statements(), match_arith_overflow(), match_single_bit_test(), match_uaddc_usubc(), match_unsigned_saturation_add(), match_unsigned_saturation_sub(), match_unsigned_saturation_trunc(), may_propagate_copy_into_stmt(), maybe_cast_to_ptrmode(), maybe_create_ssa_name(), maybe_diag_stxncpy_trunc(), maybe_fold_comparisons_from_match_pd(), maybe_instrument_assignment(), gimple_range_op_handler::maybe_non_standard(), maybe_optimize_guarding_check(), maybe_optimize_range_tests(), maybe_trim_complex_store(), maybe_trim_constructor_store(), maybe_trim_partially_dead_store(), strlen_pass::maybe_warn_overflow(), minmax_replacement(), move_computations_worker(), movement_possibility_1(), name_for_ref(), negate_value(), no_side_effect_bb(), noncall_stmt_may_be_vtbl_ptr_store(), oacc_entry_exit_ok_1(), oacc_rewrite_var_decl(), omp_sese_split_blocks(), optimize_atomic_bit_test_and(), optimize_atomic_op_fetch_cmp_0(), optimize_memcpy(), optimize_range_tests_cmp_bitwise(), optimize_range_tests_to_bit_test(), optimize_range_tests_var_bound(), dom_opt_dom_walker::optimize_stmt(), optimize_va_list_gpr_fpr_size(), optimize_vec_cond_expr(), optimize_vector_constructor(), optimize_vector_load(), or_var_with_comparison_1(), parloops_is_simple_reduction(), parloops_is_slp_reduction(), phi_incr_cost_1(), phiopt_early_allow(), phiprop_insert_phi(), predicate_load_or_store(), predicate_rhs_code(), predicate_statements(), process_assignment(), propagate_bias_p(), propagate_op_to_single_use(), propagate_with_phi(), purge_all_uses(), reassociate_bb(), pcom_worker::reassociate_to_the_same_stmt(), recognize_single_bit_test(), record_equivalences_from_stmt(), jump_threader::record_temporary_equivalences_from_stmts_at_dest(), reduc_stmt_res(), remap_gimple_stmt(), remove_dead_stmt(), remove_indirect_clobbers(), pcom_worker::remove_stmt(), remove_unused_locals(), replace_conditional_candidate(), replace_mult_candidate(), replace_one_candidate(), replace_profitable_candidates(), replace_ref_with(), replace_unconditional_candidate(), repropagate_negates(), rewrite_bittest(), rewrite_expr_tree(), rewrite_expr_tree_parallel(), rewrite_reciprocal(), rewrite_to_defined_overflow(), rewrite_use_nonlinear_expr(), should_break_up_subtract(), simd_clone_adjust(), simd_clone_linear_addend(), simple_iv_increment_p(), simplify_using_ranges::simplify(), avail_exprs_stack::simplify_binary_operation(), simplify_builtin_call(), simplify_conversion_using_ranges(), simplify_count_trailing_zeroes(), simplify_using_ranges::simplify_float_conversion_using_ranges(), simplify_using_ranges::simplify_internal_call_using_ranges(), simplify_rotate(), simplify_using_ranges::simplify_truth_ops_using_ranges(), simplify_vector_constructor(), sink_clobbers(), sink_common_stores_to_bb(), slsr_process_cast(), slsr_process_ref(), spaceship_replacement(), split_function(), sra_modify_assign(), sra_modify_constructor_assign(), stmt_cost(), stmt_could_throw_1_p(), stmt_may_be_vtbl_ptr_store(), stmt_may_clobber_global_p(), stmt_may_clobber_ref_p_1(), stmt_may_generate_copy(), suitable_cond_bb(), supportable_widening_operation(), task_reduction_read(), loop_distribution::transform_reduction_loop(), tree_estimate_loop_size(), uaddc_cast(), uaddc_ne0(), ubsan_expand_null_ifn(), ubsan_expand_objsize_ifn(), ubsan_expand_vptr_ifn(), undistribute_bitref_for_vector(), undistribute_ops_list(), update_range_test(), va_list_counter_bump(), value_replacement(), var_is_used_for_virtual_call_p(), vect_add_slp_permutation(), vect_build_slp_instance(), vect_create_vectorized_promotion_stmts(), vect_determine_precisions_from_range(), vect_finish_stmt_generation(), vect_get_operand_map(), vect_get_smallest_scalar_type(), vect_is_extending_load(), vect_is_integer_truncation(), vect_nop_conversion_p(), vect_reassociating_reduction_p(), vect_recog_abd_pattern(), vect_recog_average_pattern(), vect_recog_bitfield_ref_pattern(), vect_recog_bool_pattern(), vect_recog_cast_forwprop_pattern(), vect_recog_cond_expr_convert_pattern(), vect_recog_divmod_pattern(), vect_recog_mask_conversion_pattern(), vect_recog_mixed_size_cond_pattern(), vect_recog_mulhs_pattern(), vect_recog_over_widening_pattern(), vect_recog_popcount_clz_ctz_ffs_pattern(), vect_recog_rotate_pattern(), vect_recog_sat_add_pattern(), vect_recog_sat_sub_pattern(), vect_recog_sat_trunc_pattern(), vect_recog_vector_vector_shift_pattern(), vect_recog_widen_abd_pattern(), vect_setup_realignment(), vect_slp_check_for_roots(), vect_transform_slp_perm_load_1(), vectorizable_assignment(), vectorizable_bb_reduc_epilogue(), vectorizable_condition(), vectorizable_early_exit(), vectorizable_induction(), vectorizable_load(), vectorizable_operation(), vectorizable_scan_store(), vectorizable_shift(), vectorizable_simd_clone_call(), vectorizable_store(), verify_bb_vtables(), verify_gimple_assign(), verify_gimple_assign_binary(), verify_gimple_assign_single(), verify_gimple_assign_ternary(), verify_gimple_assign_unary(), copy_prop::visit_stmt(), pointer_equiv_analyzer::visit_stmt(), visit_stmt(), vn_nary_build_or_lookup_1(), vn_reference_lookup_3(), walk_gimple_op(), walk_stmt_load_store_addr_ops(), warn_uninit(), warn_uninitialized_vars(), and widening_mult_conversion_strippable_p().

◆ gimple_assign_lhs() [2/2]

tree gimple_assign_lhs ( const gimple * gs)
inline

◆ gimple_assign_lhs_ptr() [1/2]

◆ gimple_assign_lhs_ptr() [2/2]

tree * gimple_assign_lhs_ptr ( gimple * gs)
inline

◆ gimple_assign_load_p()

◆ gimple_assign_nontemporal_move_p()

bool gimple_assign_nontemporal_move_p ( const gassign * gs)
inline
Returns true if GS is a nontemporal move.   

References gimple::nontemporal_move.

Referenced by dump_gimple_assign(), expand_gimple_stmt_1(), output_gimple_stmt(), and verify_gimple_assign().

◆ gimple_assign_rhs1() [1/2]

tree gimple_assign_rhs1 ( const gassign * gs)
inline
Return the first operand on the RHS of assignment statement GS.   

References gimple_statement_with_memory_ops::op.

Referenced by add_scope_conflicts_2(), address_compare(), adjust_bool_pattern(), adjust_imagpart_expr(), strlen_pass::adjust_last_stmt(), adjust_pointer_diff_expr(), adjust_realpart_expr(), autofdo::afdo_propagate_circuit(), aff_combination_expand(), analyze_agg_content_value(), analyze_and_compute_bitop_with_inv_effect(), and_var_with_comparison_1(), ao_ref_init_from_ptr_and_range(), arith_cast_equal_p(), arith_overflow_check_p(), find_candidates_dom_walker::before_dom_children(), ipcp_modif_dom_walker::before_dom_children(), nontrapping_dom_walker::before_dom_children(), substitute_and_fold_dom_walker::before_dom_children(), bitfields_to_lower_p(), branch_fixup(), break_up_subtract(), break_up_subtract_bb(), addsub_pattern::build(), build_accesses_from_assign(), build_ssa_conflict_graph(), can_interpret_as_conditional_op_p(), can_propagate_from(), ccmp_candidate_p(), cfun_returns(), chain_of_csts_start(), check_all_va_list_escapes(), strlen_pass::check_and_optimize_stmt(), check_bool_pattern(), check_defs(), check_for_plus_in_loops(), check_for_plus_in_loops_1(), check_pow(), check_redundant_cond_expr(), check_scan_store(), classify_builtin_st(), loop_distribution::classify_partition(), loop_cand::classify_simple_reduction(), collect_object_sizes_for(), pcom_worker::combinable_refs_p(), compute_avail(), compute_builtin_object_size(), compute_complex_assign_jump_func(), compute_invariantness(), cond_expr_object_size(), cond_if_else_store_replacement_1(), cond_removal_in_builtin_zero_pattern(), cond_store_replacement(), fold_using_range::condexpr_adjust(), constant_after_peeling(), constant_byte_string(), constant_pointer_difference(), convert_expand_mult_copysign(), convert_mult_to_highpart(), convert_plusminus_to_widen(), convert_scalar_cond_reduction(), convert_to_divmod(), strlen_pass::count_nonzero_bytes(), create_coalesce_list_for_region(), decompose_param_expr(), defcodefor_name(), derive_constant_upper_bound_assign(), edge_info::derive_equivalences(), difference_cannot_overflow_p(), divmod_candidate_p(), do_cond(), do_store_flag(), do_warn_nonnull_compare(), dse_classify_store(), dse_optimize_redundant_stores(), dse_optimize_stmt(), dump_binary_rhs(), dump_gimple_assign(), dump_ternary_rhs(), dump_unary_rhs(), edge_forwards_cmp_to_conditional_jump_through_empty_bb_p(), eliminate_dom_walker::eliminate_avail(), eliminate_dom_walker::eliminate_insert(), eliminate_redundant_comparison(), eliminate_dom_walker::eliminate_stmt(), eliminated_by_inlining_prob(), emit_warn_switch_unreachable(), estimate_num_insns(), evaluate_stmt(), examine_assign_tm(), execute_cse_conv_1(), execute_cse_reciprocals_1(), pcom_worker::execute_pred_commoning_chain(), execute_update_addresses_taken(), exist_non_indexing_operands_for_use_p(), expand_assign_tm(), expand_call_inline(), expand_call_mem_ref(), expand_call_stmt(), expand_case(), expand_ccmp_expr_1(), expand_complex_move(), expand_complex_operations_1(), expand_cond_expr_using_cmove(), expand_expr_force_mode(), expand_expr_real_1(), expand_expr_real_2(), expand_expr_real_gassign(), expand_gimple_cond(), expand_gimple_stmt_1(), expand_omp_atomic_cas(), expand_omp_atomic_fetch_op(), expand_omp_for_generic(), expand_omp_for_static_chunk(), expand_omp_for_static_nochunk(), expand_omp_sections(), expand_omp_target(), expand_omp_taskreg(), expand_simple_operations(), expand_single_bit_test(), expand_vector_comparison(), expand_vector_condition(), expand_vector_operation(), expand_vector_operations_1(), expr_expected_value_1(), expr_hash_elt::expr_hash_elt(), extr_type_from_vtbl_ptr_store(), factor_out_conditional_operation(), final_range_test_p(), find_conditions(), find_deriving_biv_for_expr(), find_equal_ptrs(), find_foldable_builtin_expect(), find_func_aliases(), find_func_clobbers(), pcom_worker::find_looparound_phi(), find_reduc_addr(), find_replaceable_in_bb(), find_return_bb(), find_retval(), find_tail_calls(), pcom_worker::find_use_stmt(), fold_gimple_assign(), fold_stmt_1(), fold_strstr_to_strncmp(), follow_copies_to_constant(), scev_dfs::follow_ssa_edge_expr(), forward_propagate_addr_expr(), forward_propagate_addr_expr_1(), forward_propagate_into_comparison(), fuse_memset_builtins(), gather_memory_references(), gen_conditions_for_pow_int_base(), gen_simplified_condition(), generate_memset_builtin(), get_ancestor_addr_info(), get_attr_nonstring_decl(), get_base_decl(), get_bit_field_ref_def(), get_bitfield_rep(), get_compare_parts(), scalar_cond_masked_key::get_cond_ops_from_tree(), get_default_value(), ipa_polymorphic_call_context::get_dynamic_type(), get_mem_ref_of_assignment(), get_min_precision(), get_name_for_bit_test(), get_ops(), get_pred_info_from_cmp(), get_prop_source_stmt(), get_range_pos_neg(), get_range_strlen(), get_reassociation_width(), access_ref::get_ref(), get_references_in_stmt(), get_ssa_def_if_simple_copy(), get_stridx(), get_unary_op(), get_val_for(), gimple_assign_integer_valued_real_p(), gimple_assign_load_p(), gimple_assign_nonnegative_warnv_p(), gimple_assign_rhs1(), gimple_assign_rhs_to_tree(), gimple_assign_ssa_name_copy_p(), gimple_assign_unary_nop_p(), gimple_bitwise_inverted_equal_p(), gimple_clobber_p(), gimple_clobber_p(), gimple_could_trap_p_1(), gimple_divmod_fixed_value(), gimple_divmod_values_to_profile(), gimple_equal_p(), gimple_expand_vec_cond_expr(), gimple_expand_vec_set_extract_expr(), gimple_extract(), gimple_fold_stmt_to_constant_1(), gimple_lower_bitint(), gimple_mod_pow2(), gimple_mod_subtract(), gimple_nop_conversion_p(), gimple_range_base_of_assignment(), gimple_range_ssa_names(), strlen_pass::handle_builtin_memcpy(), strlen_pass::handle_integral_assign(), handle_min_max_size(), strlen_pass::handle_pointer_plus(), handle_ssa_name(), strlen_pass::handle_store(), has_stmt_been_instrumented_p(), hoist_adjacent_loads(), ifcvt_can_predicate(), ifcvt_can_use_mask_load_store(), infer_loop_bounds_from_array(), infer_loop_bounds_from_pointer_arith(), access_ref::inform_access(), init_dont_simulate_again(), init_range_entry(), init_vn_nary_op_from_stmt(), initialize_root_vars_store_elim_1(), initialize_root_vars_store_elim_2(), insert_init_stmt(), insert_stmt_before_use(), instantiate_scev_name(), instrument_bool_enum_load(), instrument_gimple(), instrument_object_size(), instrument_si_overflow(), interpret_gimple_assign(), interpret_rhs_expr(), ipa_analyze_controlled_uses(), ipa_analyze_indirect_call_uses(), ipa_get_stmt_member_ptr_load_param(), ipa_polymorphic_call_context::ipa_polymorphic_call_context(), ipa_tm_scan_irr_block(), is_addr_local(), is_cond_scalar_reduction(), is_division_by(), is_division_by_square(), is_feasible_trace(), is_gimple_logical_p(), is_inv_store_elimination_chain(), is_mult_by(), is_reassociable_op(), is_strlen_related_p(), is_vptr_store(), is_vtable_assignment_stmt(), is_widening_mult_p(), is_widening_mult_rhs_p(), jump_function_from_stmt(), linearize_expr(), linearize_expr_tree(), load_from_unmodified_param(), load_from_unmodified_param_or_agg(), load_or_store_of_ptr_parameter(), avail_exprs_stack::lookup_avail_expr(), loop_iter_phi_semi_invariant_p(), lower_bitfield(), lower_vec_perm(), match_arith_overflow(), match_single_bit_test(), match_uaddc_usubc(), may_propagate_copy_into_stmt(), maybe_instrument_assignment(), gimple_range_op_handler::maybe_non_standard(), maybe_optimize_arith_overflow(), maybe_optimize_asan_check_ifn(), maybe_optimize_guarding_check(), maybe_optimize_mod_cmp(), maybe_optimize_pow2p_mod_cmp(), maybe_optimize_range_tests(), maybe_optimize_sub_cmp_0(), maybe_remove_writeonly_store(), maybe_set_nonzero_bits(), maybe_set_strlen_range(), maybe_set_vectorized_backedge_value(), maybe_trim_complex_store(), maybe_trim_constructor_store(), maybe_warn_operand(), minmax_replacement(), ipa_param_adjustments::modify_call(), movement_possibility_1(), multiple_of_p(), name_for_ref(), negate_value(), predicate::normalize(), number_of_iterations_cltz(), number_of_iterations_cltz_complement(), number_of_iterations_popcount(), oacc_entry_exit_ok_1(), operand_equal_for_value_replacement(), ops_equal_values_p(), optimize_atomic_bit_test_and(), optimize_atomic_op_fetch_cmp_0(), optimize_bitfield_assignment_op(), optimize_memcpy(), optimize_pow_to_exp(), optimize_range_tests_var_bound(), optimize_recip_sqrt(), dom_opt_dom_walker::optimize_stmt(), optimize_va_list_gpr_fpr_size(), optimize_vector_constructor(), optimize_vector_load(), or_var_with_comparison_1(), ovce_extract_ops(), overflow_comparison_p_1(), parloops_is_simple_reduction(), parloops_is_slp_reduction(), parse_predicate(), phiprop_insert_phi(), plus_stmt_object_size(), predicate_load_or_store(), predicate_statements(), predict_loops(), ipa_param_body_adjustments::prepare_debug_expressions(), process_assignment(), propagate_necessity(), propagate_tree_value_into_stmt(), propagate_with_phi(), fold_using_range::range_of_address(), fold_using_range::range_of_cond_expr(), rank_ops_for_fma(), reassociate_bb(), pcom_worker::reassociate_to_the_same_stmt(), recognize_bits_test(), recognize_single_bit_test(), record_equivalences_from_stmt(), record_increment(), reduce_vector_comparison_to_scalar_comparison(), ref_maybe_used_by_stmt_p(), jt_state::register_equivs_stmt(), fur_relation::register_relation(), remap_gimple_stmt(), remove_dead_stmt(), remove_name_from_operation(), remove_prop_source_from_use(), pcom_worker::remove_stmt(), remove_visited_stmt_chain(), replace_mult_candidate(), replace_one_candidate(), replace_ref_with(), repropagate_negates(), rewrite_bittest(), rewrite_expr_tree(), rewrite_expr_tree_parallel(), rewrite_reciprocal(), rewrite_use_nonlinear_expr(), rhs_is_fed_for_value_replacement(), rhs_to_tree(), same_bool_comparison_p(), scan_operand_equal_p(), sccopy_propagate(), should_break_up_subtract(), should_duplicate_loop_header_p(), simple_iv_increment_p(), simplify_using_ranges::simplify(), simplify_1a(), predicate::simplify_4(), simplify_using_ranges::simplify_abs_using_ranges(), avail_exprs_stack::simplify_binary_operation(), simplify_using_ranges::simplify_bit_ops_using_ranges(), simplify_bitfield_ref(), simplify_builtin_call(), simplify_using_ranges::simplify_casted_compare(), simplify_using_ranges::simplify_compare_assign_using_ranges_1(), jump_threader::simplify_control_stmt_condition_1(), simplify_conversion_using_ranges(), simplify_count_trailing_zeroes(), simplify_using_ranges::simplify_div_or_mod_using_ranges(), simplify_using_ranges::simplify_float_conversion_using_ranges(), simplify_gimple_switch(), simplify_using_ranges::simplify_min_or_max_using_ranges(), simplify_permutation(), simplify_rotate(), simplify_using_ranges::simplify_truth_ops_using_ranges(), simplify_vector_constructor(), sink_common_stores_to_bb(), slsr_process_ref(), sm_seq_valid_bb(), spaceship_replacement(), split_address_to_core_and_offset(), split_constant_offset_1(), sra_modify_assign(), sra_modify_constructor_assign(), ssa_defined_by_minus_one_stmt_p(), ssa_is_replaceable_p(), ssa_undefined_value_p(), ssa_uniform_vector_p(), statement_sink_location(), stmt_cost(), stmt_cost(), stmt_could_throw_1_p(), stmt_is_replaceable_p(), stmt_may_generate_copy(), stmt_may_generate_copy(), store_field(), strip_bit_not(), strip_conversion(), strip_nop_cond_scalar_reduction(), strub_from_body_p(), dom_opt_dom_walker::test_for_singularity(), thread_private_new_memory(), tidy_after_forward_propagate_addr(), loop_distribution::transform_reduction_loop(), transform_stmt_to_copy(), tree_estimate_loop_size(), try_special_add_to_ops(), try_transform_to_exit_first_loop_alt(), type_conversion_p(), uaddc_cast(), uaddc_is_cplxpart(), uaddc_ne0(), unadjusted_ptr_and_unit_offset(), undistribute_bitref_for_vector(), unmodified_parm(), unmodified_parm_or_parm_agg_item(), update_ops(), use_in_zero_equality(), va_list_counter_bump(), value_replacement(), valueized_wider_op(), var_is_used_for_virtual_call_p(), vect_build_slp_tree_1(), vect_build_slp_tree_2(), vect_check_gather_scatter(), vect_comparison_type(), vect_create_epilog_for_reduction(), vect_determine_mask_precision(), vect_embedded_comparison_type(), vect_find_stmt_data_reference(), vect_get_operand_map(), vect_get_smallest_scalar_type(), vect_get_store_rhs(), vect_is_emulated_mixed_dot_prod(), vect_is_extending_load(), vect_is_integer_truncation(), vect_is_nonlinear_iv_evolution(), vect_is_simple_use(), vect_look_through_possible_promotion(), vect_mark_stmts_to_be_vectorized(), vect_nop_conversion_p(), vect_reassociating_reduction_p(), vect_recog_abd_pattern(), vect_recog_absolute_difference(), vect_recog_average_pattern(), vect_recog_bit_insert_pattern(), vect_recog_bitfield_ref_pattern(), vect_recog_bool_pattern(), vect_recog_cast_forwprop_pattern(), vect_recog_divmod_pattern(), vect_recog_mask_conversion_pattern(), vect_recog_mixed_size_cond_pattern(), vect_recog_mulhs_pattern(), vect_recog_mult_pattern(), vect_recog_popcount_clz_ctz_ffs_pattern(), vect_recog_rotate_pattern(), vect_recog_vector_vector_shift_pattern(), vect_recog_widen_abd_pattern(), vect_schedule_scc(), vect_simd_lane_linear(), vect_slp_analyze_operations(), vect_slp_check_for_roots(), vect_slp_is_lane_insert(), vector_element(), vectorizable_condition(), vectorizable_load(), vectorizable_scan_store(), vectorize_slp_instance_root_stmt(), verify_bb_vtables(), verify_gimple_assign_binary(), verify_gimple_assign_single(), verify_gimple_assign_ternary(), verify_gimple_assign_unary(), visit_nary_op(), complex_propagate::visit_stmt(), pointer_equiv_analyzer::visit_stmt(), visit_stmt(), vn_get_stmt_kind(), vn_nary_length_from_stmt(), vn_reference_lookup_3(), vn_reference_maybe_forwprop_address(), vuse_semi_invariant_p(), walk_gimple_op(), walk_ssa_copies(), walk_stmt_load_store_addr_ops(), warn_uninit(), warn_uninitialized_vars(), widening_mult_conversion_strippable_p(), will_be_nonconstant_predicate(), zero_one_minusone(), and zero_one_operation().

◆ gimple_assign_rhs1() [2/2]

tree gimple_assign_rhs1 ( const gimple * gs)
inline

◆ gimple_assign_rhs1_ptr() [1/2]

◆ gimple_assign_rhs1_ptr() [2/2]

tree * gimple_assign_rhs1_ptr ( gimple * gs)
inline

◆ gimple_assign_rhs2() [1/2]

tree gimple_assign_rhs2 ( const gassign * gs)
inline
Return the second operand on the RHS of assignment statement GS.
If GS does not have two operands, NULL is returned instead.   

References gimple_num_ops(), NULL_TREE, and gimple_statement_with_memory_ops::op.

Referenced by adjust_bool_pattern(), strlen_pass::adjust_last_stmt(), adjust_pointer_diff_expr(), aff_combination_expand(), analyze_agg_content_value(), analyze_and_compute_bitop_with_inv_effect(), and_var_with_comparison_1(), ao_ref_init_from_ptr_and_range(), arith_overflow_check_p(), bb_no_side_effects_p(), find_candidates_dom_walker::before_dom_children(), branch_fixup(), break_up_subtract(), break_up_subtract_bb(), addsub_pattern::build(), can_interpret_as_conditional_op_p(), ccmp_candidate_p(), check_all_va_list_escapes(), check_bool_pattern(), check_for_plus_in_loops(), check_for_plus_in_loops_1(), check_redundant_cond_expr(), check_retval_uses(), check_scan_store(), compute_builtin_object_size(), compute_complex_assign_jump_func(), compute_invariantness(), cond_expr_object_size(), fold_using_range::condexpr_adjust(), constant_after_peeling(), constant_byte_string(), constant_pointer_difference(), convert_expand_mult_copysign(), convert_mult_to_highpart(), convert_plusminus_to_widen(), convert_to_divmod(), defcodefor_name(), derive_constant_upper_bound_assign(), edge_info::derive_equivalences(), difference_cannot_overflow_p(), divmod_candidate_p(), do_store_flag(), do_warn_nonnull_compare(), dump_binary_rhs(), dump_gimple_assign(), dump_ternary_rhs(), eliminate_dom_walker::eliminate_insert(), eliminate_redundant_comparison(), estimate_num_insns(), evaluate_stmt(), execute_cse_reciprocals_1(), expand_ccmp_expr_1(), expand_complex_move(), expand_complex_operations_1(), expand_cond_expr_using_cmove(), expand_expr_real_1(), expand_expr_real_2(), expand_expr_real_gassign(), expand_gimple_cond(), expand_omp_atomic_cas(), expand_omp_atomic_fetch_op(), expand_simple_operations(), expand_single_bit_test(), expand_vector_comparison(), expand_vector_condition(), expand_vector_operation(), expand_vector_operations_1(), expand_vector_scalar_condition(), expr_expected_value_1(), expr_hash_elt::expr_hash_elt(), find_conditions(), find_deriving_biv_for_expr(), find_func_aliases(), fold_gimple_assign(), fold_stmt_1(), scev_dfs::follow_ssa_edge_expr(), forward_propagate_addr_expr_1(), forward_propagate_into_comparison(), gen_simplified_condition(), get_compare_parts(), scalar_cond_masked_key::get_cond_ops_from_tree(), get_ops(), get_pred_info_from_cmp(), get_range_strlen(), get_reassociation_width(), access_ref::get_ref(), get_stridx(), get_val_for(), gimple_assign_integer_valued_real_p(), gimple_assign_nonnegative_warnv_p(), gimple_assign_rhs2(), gimple_assign_rhs_to_tree(), gimple_bitwise_inverted_equal_p(), gimple_could_trap_p_1(), gimple_divmod_fixed_value(), gimple_divmod_fixed_value_transform(), gimple_divmod_values_to_profile(), gimple_expand_vec_cond_expr(), gimple_extract(), gimple_fold_stmt_to_constant_1(), gimple_lower_bitint(), gimple_mod_pow2(), gimple_mod_pow2_value_transform(), gimple_mod_subtract(), gimple_range_ssa_names(), strlen_pass::handle_builtin_memcpy(), strlen_pass::handle_integral_assign(), handle_min_max_size(), strlen_pass::handle_pointer_plus(), handle_ssa_name(), infer_loop_bounds_from_pointer_arith(), access_ref::inform_access(), init_dont_simulate_again(), init_range_entry(), insert_stmt_before_use(), instantiate_scev_name(), instrument_object_size(), instrument_si_overflow(), interpret_gimple_assign(), interpret_rhs_expr(), ipa_analyze_indirect_call_uses(), is_addr_local(), is_cond_scalar_reduction(), is_division_by(), is_division_by_square(), is_divmod_with_given_divisor(), is_lshift_by_1(), is_mult_by(), is_reassociable_op(), is_rshift_by_1(), is_strlen_related_p(), is_widening_mult_p(), is_widening_mult_rhs_p(), linearize_expr(), linearize_expr_tree(), lower_vec_perm(), match_arith_overflow(), match_single_bit_test(), match_uaddc_usubc(), gimple_range_op_handler::maybe_non_standard(), maybe_optimize_guarding_check(), maybe_optimize_mod_cmp(), maybe_optimize_pow2p_mod_cmp(), maybe_optimize_sub_cmp_0(), maybe_set_nonzero_bits(), minmax_replacement(), movement_possibility_1(), multiple_of_p(), negate_value(), predicate::normalize(), number_of_iterations_cltz(), number_of_iterations_popcount(), op1_range(), operand_equal_for_value_replacement(), optimize_atomic_bit_test_and(), optimize_atomic_op_fetch_cmp_0(), optimize_bitfield_assignment_op(), optimize_pow_to_exp(), optimize_range_tests_var_bound(), optimize_recip_sqrt(), optimize_successive_divisions_p(), optimize_va_list_gpr_fpr_size(), optimize_vector_constructor(), or_var_with_comparison_1(), ovce_extract_ops(), overflow_comparison_p_1(), parloops_is_simple_reduction(), parloops_is_slp_reduction(), parse_predicate(), plus_stmt_object_size(), process_assignment(), fold_using_range::range_of_cond_expr(), reassociate_bb(), pcom_worker::reassociate_to_the_same_stmt(), recognize_bits_test(), recognize_single_bit_test(), record_equivalences_from_stmt(), record_increment(), fur_relation::register_relation(), remove_name_from_operation(), replace_mult_candidate(), replace_one_candidate(), repropagate_negates(), rewrite_bittest(), rewrite_expr_tree(), rewrite_reciprocal(), rewrite_use_nonlinear_expr(), rhs_is_fed_for_value_replacement(), rhs_to_tree(), same_bool_comparison_p(), scan_operand_equal_p(), should_break_up_subtract(), should_duplicate_loop_header_p(), simplify_using_ranges::simplify(), simplify_1a(), predicate::simplify_4(), avail_exprs_stack::simplify_binary_operation(), simplify_using_ranges::simplify_bit_ops_using_ranges(), simplify_bitfield_ref(), simplify_builtin_call(), simplify_using_ranges::simplify_compare_assign_using_ranges_1(), jump_threader::simplify_control_stmt_condition_1(), simplify_using_ranges::simplify_div_or_mod_using_ranges(), simplify_using_ranges::simplify_min_or_max_using_ranges(), simplify_permutation(), simplify_rotate(), simplify_using_ranges::simplify_truth_ops_using_ranges(), spaceship_replacement(), split_constant_offset_1(), ssa_defined_by_minus_one_stmt_p(), ssa_undefined_value_p(), stmt_cost(), stmt_could_throw_1_p(), dom_opt_dom_walker::test_for_singularity(), thread_private_new_memory(), tree_estimate_loop_size(), try_transform_to_exit_first_loop_alt(), uaddc_ne0(), unadjusted_ptr_and_unit_offset(), update_ops(), use_in_zero_equality(), va_list_counter_bump(), value_replacement(), vect_build_slp_tree_1(), vect_check_gather_scatter(), vect_determine_precisions_from_users(), vect_is_emulated_mixed_dot_prod(), vect_is_nonlinear_iv_evolution(), vect_reassociating_reduction_p(), vect_recog_abd_pattern(), vect_recog_average_pattern(), vect_recog_bit_insert_pattern(), vect_recog_bool_pattern(), vect_recog_divmod_pattern(), vect_recog_mask_conversion_pattern(), vect_recog_mixed_size_cond_pattern(), vect_recog_mulhs_pattern(), vect_recog_mult_pattern(), vect_recog_rotate_pattern(), vect_recog_vector_vector_shift_pattern(), vect_simd_lane_linear(), vect_slp_check_for_roots(), vect_slp_is_lane_insert(), vectorizable_conversion(), vectorizable_scan_store(), vectorizable_shift(), verify_gimple_assign_binary(), verify_gimple_assign_ternary(), visit_nary_op(), complex_propagate::visit_stmt(), vn_reference_lookup_3(), vn_reference_maybe_forwprop_address(), warn_uninit(), and zero_one_operation().

◆ gimple_assign_rhs2() [2/2]

tree gimple_assign_rhs2 ( const gimple * gs)
inline

◆ gimple_assign_rhs2_ptr() [1/2]

◆ gimple_assign_rhs2_ptr() [2/2]

tree * gimple_assign_rhs2_ptr ( gimple * gs)
inline

◆ gimple_assign_rhs3() [1/2]

◆ gimple_assign_rhs3() [2/2]

tree gimple_assign_rhs3 ( const gimple * gs)
inline

◆ gimple_assign_rhs3_ptr()

tree * gimple_assign_rhs3_ptr ( gimple * gs)
inline
Return a pointer to the third operand on the RHS of assignment
statement GS.   

References gcc_gimple_checking_assert, GIMPLE_CHECK2(), gimple_num_ops(), and gimple_statement_with_memory_ops::op.

Referenced by optimize_vec_cond_expr(), parloops_is_simple_reduction(), and vect_determine_min_output_precision_1().

◆ gimple_assign_rhs_class()

◆ gimple_assign_rhs_code() [1/2]

enum tree_code gimple_assign_rhs_code ( const gassign * gs)
inline
Return the code of the expression computed on the rhs of assignment
statement GS.  In case that the RHS is a single object, returns the
tree code of the object.   

References get_gimple_rhs_class(), GIMPLE_SINGLE_RHS, gimple_statement_with_memory_ops::op, gimple::subcode, and TREE_CODE.

Referenced by adjust_bool_pattern(), adjust_imagpart_expr(), strlen_pass::adjust_last_stmt(), adjust_realpart_expr(), aff_combination_expand(), analyze_agg_content_value(), analyze_and_compute_bitop_with_inv_effect(), analyze_and_compute_bitwise_induction_effect(), loop_cand::analyze_iloop_reduction_var(), and_var_with_comparison_1(), ao_ref_init_from_ptr_and_range(), arith_overflow_check_p(), bb_no_side_effects_p(), find_candidates_dom_walker::before_dom_children(), branch_fixup(), break_up_subtract_bb(), build_bitint_stmt_ssa_conflicts(), build_new_reduction(), can_interpret_as_conditional_op_p(), can_propagate_from(), ccmp_candidate_p(), ccmp_tree_comparison_p(), chain_of_csts_start(), check_all_va_list_escapes(), strlen_pass::check_and_optimize_stmt(), check_bool_pattern(), check_defs(), check_for_plus_in_loops(), check_for_plus_in_loops_1(), check_pow(), check_redundant_cond_expr(), check_retval_uses(), check_scan_store(), collect_object_sizes_for(), pcom_worker::combinable_refs_p(), ipa_icf_gimple::func_checker::compare_gimple_assign(), compatible_complex_nodes_p(), compute_avail(), compute_builtin_object_size(), compute_complex_assign_jump_func(), compute_invariantness(), cond_expr_object_size(), cond_removal_in_builtin_zero_pattern(), fold_using_range::condexpr_adjust(), constant_byte_string(), constant_pointer_difference(), convert_atomic_bit_not(), convert_mult_to_fma(), convert_mult_to_fma_1(), convert_mult_to_highpart(), convert_plusminus_to_widen(), convert_scalar_cond_reduction(), convert_to_divmod(), decompose_param_expr(), defcodefor_name(), derive_constant_upper_bound_assign(), edge_info::derive_equivalences(), difference_cannot_overflow_p(), do_warn_nonnull_compare(), dump_binary_rhs(), dump_gimple_assign(), dump_ternary_rhs(), dump_unary_rhs(), edge_forwards_cmp_to_conditional_jump_through_empty_bb_p(), eliminate_dom_walker::eliminate_insert(), eliminate_plus_minus_pair(), eliminate_redundant_comparison(), eliminate_dom_walker::eliminate_stmt(), eliminated_by_inlining_prob(), estimate_num_insns(), evaluate_stmt(), execute_cse_reciprocals_1(), expand_call_inline(), expand_call_stmt(), expand_case(), expand_ccmp_expr_1(), expand_complex_move(), expand_complex_operations_1(), expand_cond_expr_using_cmove(), expand_expr_force_mode(), expand_expr_real_2(), expand_expr_real_gassign(), expand_gimple_cond(), expand_mul_overflow(), expand_omp_atomic_cas(), expand_omp_atomic_fetch_op(), expand_simple_operations(), expand_vector_comparison(), expand_vector_condition(), expand_vector_operations_1(), expr_expected_value_1(), expr_hash_elt::expr_hash_elt(), factor_out_conditional_operation(), final_range_test_p(), final_value_replacement_loop(), pcom_worker::find_associative_operation_root(), find_conditions(), find_deriving_biv_for_expr(), find_equal_ptrs(), find_foldable_builtin_expect(), find_func_aliases(), find_interesting_uses_stmt(), find_replaceable_in_bb(), pcom_worker::find_use_stmt(), fold_gimple_assign(), fold_using_range::fold_stmt(), fold_stmt_1(), fold_strstr_to_strncmp(), scev_dfs::follow_ssa_edge_expr(), forward_propagate_addr_expr_1(), forward_propagate_into_comparison(), forward_propagate_into_comparison_1(), gen_simplified_condition(), get_attr_nonstring_decl(), get_bit_field_ref_def(), get_code(), get_compare_parts(), scalar_cond_masked_key::get_cond_ops_from_tree(), get_def_for_expr(), get_def_for_expr_class(), get_min_precision(), get_name_for_bit_test(), get_pred_info_from_cmp(), get_prop_source_stmt(), get_range_pos_neg(), get_range_strlen(), get_reassociation_width(), access_ref::get_ref(), get_stridx(), get_unary_op(), get_val_for(), gimple_assign_cast_p(), gimple_assign_integer_valued_real_p(), gimple_assign_nonnegative_warnv_p(), gimple_assign_rhs_class(), gimple_assign_rhs_code(), gimple_assign_rhs_to_tree(), gimple_assign_unary_nop_p(), gimple_bitwise_inverted_equal_p(), gimple_could_trap_p_1(), gimple_divmod_fixed_value(), gimple_divmod_fixed_value_transform(), gimple_divmod_values_to_profile(), gimple_equal_p(), gimple_expand_vec_cond_expr(), gimple_expr_code(), gimple_extract(), gimple_fold_stmt_to_constant_1(), gimple_lower_bitint(), gimple_mod_pow2(), gimple_mod_pow2_value_transform(), gimple_mod_subtract(), gimple_mod_subtract_transform(), gimple_nop_conversion_p(), gimple_range_base_of_assignment(), gimple_range_ssa_names(), strlen_pass::handle_builtin_memcpy(), strlen_pass::handle_integral_assign(), handle_min_max_size(), handle_ssa_name(), ipa_icf::sem_function::hash_stmt(), if_convertible_gimple_assign_stmt_p(), ifcvt_can_hoist(), ifcvt_can_predicate(), infer_loop_bounds_from_pointer_arith(), access_ref::inform_access(), init_dont_simulate_again(), init_range_entry(), init_vn_nary_op_from_stmt(), insert_init_stmt(), instantiate_scev_name(), instrument_object_size(), instrument_si_overflow(), interpret_gimple_assign(), interpret_rhs_expr(), ipa_analyze_indirect_call_uses(), is_addr_local(), is_cond_scalar_reduction(), is_degenerate_phi(), is_division_by(), is_division_by_square(), is_divmod_with_given_divisor(), is_feasible_trace(), is_lshift_by_1(), is_mult_by(), is_reassociable_op(), is_rshift_by_1(), is_strlen_related_p(), is_widening_mult_rhs_p(), jump_function_from_stmt(), lane_reducing_stmt_p(), legal_cast_p(), likely_value(), linearize_expr(), linearize_expr_tree(), lower_vec_perm(), match_arith_overflow(), match_single_bit_test(), match_uaddc_usubc(), gimple_range_op_handler::maybe_non_standard(), maybe_optimize_arith_overflow(), maybe_optimize_guarding_check(), maybe_optimize_mod_cmp(), maybe_optimize_range_tests(), maybe_set_nonzero_bits(), maybe_set_strlen_range(), maybe_trim_partially_dead_store(), maybe_warn_operand(), minmax_replacement(), move_computations_worker(), movement_possibility_1(), multiple_of_p(), negate_value(), predicate::normalize(), predicate::normalize(), number_of_iterations_cltz(), number_of_iterations_popcount(), operand_equal_for_value_replacement(), optimize_atomic_bit_test_and(), optimize_atomic_op_fetch_cmp_0(), optimize_bitfield_assignment_op(), optimize_pow_to_exp(), optimize_range_tests_var_bound(), optimize_recip_sqrt(), optimize_successive_divisions_p(), optimize_va_list_gpr_fpr_size(), optimize_vector_constructor(), optimize_vector_load(), or_var_with_comparison_1(), ovce_extract_ops(), overflow_comparison_p_1(), parloops_is_simple_reduction(), parloops_is_slp_reduction(), parse_predicate(), phiopt_early_allow(), phiprop_insert_phi(), plus_stmt_object_size(), possible_vector_mask_operation_p(), predicate_rhs_code(), predicate_statements(), predict_loops(), process_assignment(), propagate_bias_p(), propagate_with_phi(), fold_using_range::range_of_address(), fold_using_range::range_of_cond_expr(), rank_ops_for_fma(), reassociate_bb(), pcom_worker::reassociate_to_the_same_stmt(), recognize_bits_test(), recognize_single_bit_test(), record_equivalences_from_stmt(), record_increment(), ref_maybe_used_by_stmt_p(), reorder_operands(), replace_mult_candidate(), replace_one_candidate(), replace_profitable_candidates(), repropagate_negates(), rewrite_bittest(), rewrite_expr_tree_parallel(), rewrite_to_defined_overflow(), rewrite_use_nonlinear_expr(), rhs_is_fed_for_value_replacement(), rhs_to_tree(), same_bool_comparison_p(), same_succ_hash(), scan_operand_equal_p(), should_break_up_subtract(), should_duplicate_loop_header_p(), simple_iv_increment_p(), simplify_using_ranges::simplify(), simplify_1a(), predicate::simplify_4(), simplify_using_ranges::simplify_bit_ops_using_ranges(), simplify_bitfield_ref(), simplify_builtin_call(), simplify_using_ranges::simplify_casted_compare(), simplify_using_ranges::simplify_compare_assign_using_ranges_1(), jump_threader::simplify_control_stmt_condition_1(), simplify_conversion_using_ranges(), simplify_using_ranges::simplify_div_or_mod_using_ranges(), simplify_using_ranges::simplify_min_or_max_using_ranges(), simplify_permutation(), simplify_rotate(), simplify_using_ranges::simplify_truth_ops_using_ranges(), slsr_process_add(), spaceship_replacement(), split_address_to_core_and_offset(), split_constant_offset_1(), split_loop(), ssa_defined_by_minus_one_stmt_p(), ssa_is_replaceable_p(), ssa_undefined_value_p(), stmt_cost(), stmt_cost(), stmt_could_throw_1_p(), strip_bit_not(), strip_conversion(), strip_nop_cond_scalar_reduction(), dom_opt_dom_walker::test_for_singularity(), thread_private_new_memory(), try_special_add_to_ops(), try_to_simplify(), try_transform_to_exit_first_loop_alt(), type_conversion_p(), uaddc_is_cplxpart(), uaddc_ne0(), unadjusted_ptr_and_unit_offset(), undistribute_bitref_for_vector(), undistribute_ops_list(), update_ops(), update_range_test(), use_in_zero_equality(), va_list_counter_bump(), value_replacement(), valueized_wider_op(), vect_build_slp_tree_1(), vect_build_slp_tree_2(), vect_check_gather_scatter(), vect_comparison_type(), vect_create_epilog_for_reduction(), vect_determine_mask_precision(), vect_determine_min_output_precision_1(), vect_determine_precisions_from_range(), vect_determine_precisions_from_users(), vect_embedded_comparison_type(), vect_find_stmt_data_reference(), vect_get_and_check_slp_defs(), vect_get_operand_map(), vect_get_smallest_scalar_type(), vect_is_emulated_mixed_dot_prod(), vect_is_extending_load(), vect_is_integer_truncation(), vect_is_nonlinear_iv_evolution(), vect_is_simple_use(), vect_look_through_possible_promotion(), vect_mark_stmts_to_be_vectorized(), vect_match_expression_p(), vect_nop_conversion_p(), vect_reassociating_reduction_p(), vect_recog_absolute_difference(), vect_recog_average_pattern(), vect_recog_bit_insert_pattern(), vect_recog_bitfield_ref_pattern(), vect_recog_bool_pattern(), vect_recog_cast_forwprop_pattern(), vect_recog_divmod_pattern(), vect_recog_mask_conversion_pattern(), vect_recog_mixed_size_cond_pattern(), vect_recog_mulhs_pattern(), vect_recog_mult_pattern(), vect_recog_over_widening_pattern(), vect_recog_popcount_clz_ctz_ffs_pattern(), vect_recog_rotate_pattern(), vect_recog_vector_vector_shift_pattern(), vect_recog_widen_abd_pattern(), vect_simd_lane_linear(), vect_slp_check_for_roots(), vect_slp_is_lane_insert(), vect_slp_linearize_chain(), vect_slp_region(), vect_transform_slp_perm_load_1(), vect_widened_op_tree(), vector_element(), vectorizable_assignment(), vectorizable_bb_reduc_epilogue(), vectorizable_comparison(), vectorizable_condition(), vectorizable_conversion(), vectorizable_load(), vectorizable_operation(), vectorizable_scan_store(), vectorizable_shift(), vectorize_slp_instance_root_stmt(), verify_gimple_assign_binary(), verify_gimple_assign_single(), verify_gimple_assign_ternary(), verify_gimple_assign_unary(), visit_nary_op(), pointer_equiv_analyzer::visit_stmt(), visit_stmt(), vn_get_stmt_kind(), vn_nary_length_from_stmt(), vn_reference_lookup_3(), vn_reference_maybe_forwprop_address(), warn_uninit(), warn_uninitialized_vars(), widening_mult_conversion_strippable_p(), zero_one_minusone(), and zero_one_operation().

◆ gimple_assign_rhs_code() [2/2]

enum tree_code gimple_assign_rhs_code ( const gimple * gs)
inline

◆ gimple_assign_rhs_could_trap_p()

bool gimple_assign_rhs_could_trap_p ( gimple * s)
Return true if RHS of a GIMPLE_ASSIGN S can trap.   

References gcc_assert, gimple_could_trap_p_1(), and is_gimple_assign().

Referenced by no_side_effect_bb().

◆ gimple_assign_set_lhs() [1/2]

◆ gimple_assign_set_lhs() [2/2]

void gimple_assign_set_lhs ( gimple * gs,
tree lhs )
inline

◆ gimple_assign_set_nontemporal_move()

void gimple_assign_set_nontemporal_move ( gimple * gs,
bool nontemporal )
inline
Sets nontemporal move flag of GS to NONTEMPORAL.   

References GIMPLE_CHECK, and gimple::nontemporal_move.

Referenced by mark_nontemporal_store().

◆ gimple_assign_set_rhs1() [1/2]

void gimple_assign_set_rhs1 ( gassign * gs,
tree rhs )
inline

◆ gimple_assign_set_rhs1() [2/2]

void gimple_assign_set_rhs1 ( gimple * gs,
tree rhs )
inline

◆ gimple_assign_set_rhs2() [1/2]

◆ gimple_assign_set_rhs2() [2/2]

void gimple_assign_set_rhs2 ( gimple * gs,
tree rhs )
inline

◆ gimple_assign_set_rhs3() [1/2]

void gimple_assign_set_rhs3 ( gassign * gs,
tree rhs )
inline
Set RHS to be the third operand on the RHS of assignment statement GS.   

References gcc_gimple_checking_assert, gimple_num_ops(), and gimple_statement_with_memory_ops::op.

Referenced by gimple_assign_set_rhs3(), gimple_assign_set_rhs_with_ops(), gimple_build_assign_1(), and lower_vec_perm().

◆ gimple_assign_set_rhs3() [2/2]

void gimple_assign_set_rhs3 ( gimple * gs,
tree rhs )
inline

◆ gimple_assign_set_rhs_code()

◆ gimple_assign_set_rhs_from_tree()

void gimple_assign_set_rhs_from_tree ( gimple_stmt_iterator * gsi,
tree expr )
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.   

References extract_ops_from_tree(), and gimple_assign_set_rhs_with_ops().

Referenced by ipcp_modif_dom_walker::before_dom_children(), convert_to_divmod(), eliminate_dom_walker::eliminate_cleanup(), execute_update_addresses_taken(), expand_complex_comparison(), expand_complex_operations_1(), expand_vector_condition(), expand_vector_operations_1(), expand_vector_scalar_condition(), ccp_folder::fold_stmt(), fold_stmt_1(), forward_propagate_addr_expr_1(), forward_propagate_into_comparison(), gimple_divmod_fixed_value_transform(), gimple_mod_pow2_value_transform(), gimple_mod_subtract_transform(), strlen_pass::handle_integral_assign(), instrument_bool_enum_load(), lower_vec_perm(), optimize_memcpy(), optimize_recip_sqrt(), propagate_tree_value_into_stmt(), remove_name_from_operation(), replace_ref_with(), rewrite_use_nonlinear_expr(), simplify_using_ranges::simplify(), simplify_using_ranges::simplify_div_or_mod_using_ranges(), simplify_using_ranges::simplify_min_or_max_using_ranges(), simplify_permutation(), simplify_vector_constructor(), sra_modify_assign(), transform_stmt_to_copy(), and vectorize_slp_instance_root_stmt().

◆ gimple_assign_set_rhs_with_ops() [1/3]

void gimple_assign_set_rhs_with_ops ( gimple_stmt_iterator * gsi,
enum tree_code code,
tree op1,
tree op2,
tree op3 )

◆ gimple_assign_set_rhs_with_ops() [2/3]

void gimple_assign_set_rhs_with_ops ( gimple_stmt_iterator * gsi,
enum tree_code code,
tree op1 )
inline
A wrapper around 3 operand gimple_assign_set_rhs_with_ops, for callers
which expect to see only one operands.   

References gimple_assign_set_rhs_with_ops(), and NULL.

◆ gimple_assign_set_rhs_with_ops() [3/3]

void gimple_assign_set_rhs_with_ops ( gimple_stmt_iterator * gsi,
enum tree_code code,
tree op1,
tree op2 )
inline
A wrapper around 3 operand gimple_assign_set_rhs_with_ops, for callers
which expect to see only two operands.   

References gimple_assign_set_rhs_with_ops(), and NULL.

◆ gimple_assign_single_p()

bool gimple_assign_single_p ( const gimple * gs)
inline
Return true if GS is an assignment with a singleton RHS, i.e.,
there is no operator associated with the assignment itself.
Unlike gimple_assign_copy_p, this predicate returns true for
any RHS operand, including those that perform an operation
and do not have the semantics of a copy, such as COND_EXPR.   

References gimple_assign_rhs_class(), GIMPLE_SINGLE_RHS, and is_gimple_assign().

Referenced by autofdo::afdo_propagate_circuit(), ao_ref_init_from_ptr_and_range(), find_candidates_dom_walker::before_dom_children(), nontrapping_dom_walker::before_dom_children(), substitute_and_fold_dom_walker::before_dom_children(), build_accesses_from_assign(), can_group_stmts_p(), loop_cand::can_interchange_p(), can_propagate_from(), strlen_pass::check_and_optimize_stmt(), check_for_plus_in_loops_1(), collect_object_sizes_for(), cond_if_else_store_replacement_1(), cond_store_replacement(), strlen_pass::count_nonzero_bytes(), dse_optimize_redundant_stores(), dse_optimize_stmt(), eliminate_dom_walker::eliminate_stmt(), emit_warn_switch_unreachable(), evaluate_stmt(), execute_update_addresses_taken(), expand_block_tm(), expand_call_inline(), expand_call_mem_ref(), extr_type_from_vtbl_ptr_store(), find_func_aliases(), find_func_clobbers(), find_reduc_addr(), find_replaceable_in_bb(), find_return_bb(), find_single_drs(), ccp_folder::fold_stmt(), follow_copies_to_constant(), get_ancestor_addr_info(), get_base_decl(), get_default_value(), get_mem_ref_of_assignment(), get_range_strlen(), get_ssa_def_if_simple_copy(), gimple_assign_copy_p(), gimple_assign_load_p(), gimple_assign_ssa_name_copy_p(), gimple_clobber_p(), gimple_lower_bitint(), gimple_regimplify_operands(), gsi_replace_with_seq_vops(), strlen_pass::handle_pointer_plus(), hardcfr_scan_block(), has_stmt_been_instrumented_p(), hoist_adjacent_loads(), ifcvt_can_predicate(), access_ref::inform_access(), init_vn_nary_op_from_stmt(), ipa_analyze_controlled_uses(), ipa_analyze_indirect_call_uses(), ipa_get_stmt_member_ptr_load_param(), ipa_polymorphic_call_context::ipa_polymorphic_call_context(), ipa_tm_scan_irr_block(), is_inv_store_elimination_chain(), is_maybe_undefined(), is_vptr_store(), load_from_unmodified_param(), avail_exprs_stack::lookup_avail_expr(), lower_sequence_tm(), mark_all_reaching_defs_necessary_1(), may_propagate_copy_into_stmt(), maybe_get_single_definition(), maybe_instrument_assignment(), maybe_remove_writeonly_store(), ipa_param_body_adjustments::modify_assignment(), movement_possibility_1(), optimize_memcpy(), dom_opt_dom_walker::optimize_stmt(), predicate_statements(), propagate_necessity(), propagate_tree_value_into_stmt(), propagate_with_phi(), record_equivalences_from_stmt(), reduce_vector_comparison_to_scalar_comparison(), ref_maybe_used_by_stmt_p(), jt_state::register_equivs_stmt(), remap_gimple_stmt(), remove_dead_stmt(), replace_ref_with(), simple_mem_ref_in_stmt(), simplify_builtin_call(), sra_modify_assign(), ssa_uniform_vector_p(), statement_sink_location(), stmt_is_replaceable_p(), stmt_may_clobber_ref_p_1(), stmt_may_generate_copy(), stmt_may_generate_copy(), loop_distribution::transform_reduction_loop(), transform_statements(), unadjusted_ptr_and_unit_offset(), unmodified_parm(), unmodified_parm_or_parm_agg_item(), vect_build_slp_tree_2(), vect_get_load_store_mask(), vect_get_store_rhs(), vectorizable_assignment(), vn_reference_lookup_3(), walk_ssa_copies(), walk_stmt_load_store_addr_ops(), and warn_uninit().

◆ gimple_assign_ssa_name_copy_p()

◆ gimple_assign_unary_nop_p()

bool gimple_assign_unary_nop_p ( gimple * gs)
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 CONVERT_EXPR_CODE_P, error_mark_node, gimple_assign_lhs(), gimple_assign_rhs1(), gimple_assign_rhs_code(), is_gimple_assign(), TREE_TYPE, and TYPE_MODE.

Referenced by check_for_plus_in_loops_1(), collect_object_sizes_for(), and get_range_strlen().

◆ gimple_assume_body()

gimple_seq gimple_assume_body ( const gimple * gs)
inline
Return the GIMPLE sequence contained in the GIMPLE_ASSUME statement GS.   

References as_a(), and gimple_statement_assume::body.

Referenced by dump_gimple_assume(), gimple_copy(), lower_assumption(), remap_gimple_stmt(), and verify_gimple_in_seq_2().

◆ gimple_assume_body_ptr()

gimple_seq * gimple_assume_body_ptr ( gimple * gs)
inline
Return the address of the GIMPLE sequence contained in the GIMPLE_ASSUME
statement GS.   

References as_a(), and gimple_statement_assume::body.

Referenced by gimple_build_assume(), gimple_copy(), lower_assumption(), lower_omp_1(), and walk_gimple_stmt().

◆ gimple_assume_guard()

tree gimple_assume_guard ( const gimple * gs)
inline
Return the guard associated with the GIMPLE_ASSUME statement GS.   

References as_a(), and gimple_statement_assume::guard.

Referenced by dump_gimple_assume(), gimple_copy(), lower_assumption(), and remap_gimple_stmt().

◆ gimple_assume_guard_ptr()

tree * gimple_assume_guard_ptr ( gimple * gs)
inline

References as_a(), and gimple_statement_assume::guard.

Referenced by walk_gimple_op().

◆ gimple_assume_set_guard()

void gimple_assume_set_guard ( gimple * gs,
tree guard )
inline
Set the guard associated with the GIMPLE_ASSUME statement GS.   

References as_a(), and gimple_statement_assume::guard.

Referenced by gimple_build_assume(), and gimple_copy().

◆ gimple_bb()

basic_block gimple_bb ( const gimple * g)
inline
Return the basic block holding statement G.   

References g.

Referenced by abnormal_edge_after_stmt_p(), add_autoinc_candidates(), add_dependency(), add_exit_phi(), add_exit_phis(), add_exit_phis_var(), add_iv_candidate_for_biv(), add_phi_arg(), infer_range_manager::add_range(), add_ssa_edge(), adjust_before_returns_twice_call(), adjust_debug_stmts_now(), adjust_iv_update_pos(), adjust_phi_and_debug_stmts(), all_phi_incrs_profitable_1(), all_uses_feed_or_dominated_by_stmt(), analyze_and_compute_bitop_with_inv_effect(), analyze_and_compute_bitwise_induction_effect(), loop_cand::analyze_iloop_reduction_var(), loop_cand::analyze_oloop_reduction_var(), analyze_scalar_evolution_1(), tree_switch_conversion::switch_decision_tree::analyze_switch_statement(), and_comparisons_1(), ranger_cache::apply_inferred_ranges(), tree_switch_conversion::switch_conversion::array_value_type(), back_propagate_equivalences(), base_names_in_chain_on(), ranger_cache::block_range(), branch_fixup(), addsub_pattern::build(), complex_pattern::build(), vect_optimize_slp_pass::build_vertices(), gori_map::calculate_gori(), assume_query::calculate_stmt(), can_guard_call_p(), can_remove_asan_check(), cand_already_replaced(), cand_cmp(), ccmp_candidate_p(), ccmp_tree_comparison_p(), cgraph_update_edges_for_call_stmt_node(), chain_of_csts_start(), rt_bb_visited::check(), check_exit_phi(), check_forbidden_calls(), check_loop_closed_ssa_def(), check_name(), check_reduction_path(), check_scan_store(), chk_uses(), classify_builtin_st(), loop_cand::classify_simple_reduction(), clean_up_after_unswitching(), cleanup_empty_eh_merge_phis(), tree_switch_conversion::switch_conversion::collect(), uninit_analysis::collect_phi_def_edges(), pcom_worker::combinable_refs_p(), compute_access_range(), compute_access_stride(), compute_added_num_insns(), compute_avail(), compute_complex_ancestor_jump_func(), hybrid_jt_simplifier::compute_exit_dependencies(), path_range_query::compute_exit_dependencies(), constant_after_peeling(), vect_optimize_slp_pass::containing_loop(), convert_mult_to_fma(), convert_mult_to_highpart(), convert_plusminus_to_widen(), convert_single_case_switch(), convert_to_divmod(), copy_cfg_body(), copy_edges_for_bb(), copy_prop_visit_cond_stmt(), cprop_operand(), create_loads_for_reductions(), create_new_def_for(), create_parallel_loop(), create_phi_basis_1(), create_rdg_cd_edges(), cgraph_node::create_version_clone(), path_range_query::defined_outside_path(), delete_dead_or_redundant_assignment(), delete_dead_or_redundant_call(), determine_max_movement(), discover_iteration_bound_by_body_walk(), disqualify_if_bad_bb_terminating_stmt(), do_invalidate(), do_warn_aggressive_loop_optimizations(), drop_profile(), dse_classify_store(), equiv_oracle::dump(), range_def_chain::dump(), gimple_ranger::dump_bb(), dump_candidate(), dump_data_reference(), dump_gimple_cond(), dump_gimple_switch(), easy_exit_values(), edge_forwards_cmp_to_conditional_jump_through_empty_bb_p(), rpo_elim::eliminate_avail(), eliminate_dom_walker::eliminate_cleanup(), eliminate_dom_walker::eliminate_insert(), eliminate_dom_walker::eliminate_stmt(), eliminate_tail_call(), eliminate_temp_copies(), eliminate_unnecessary_stmts(), tree_switch_conversion::switch_decision_tree::emit(), emit_phi_nodes(), estimate_threading_killed_stmts(), evaluate_control_stmt_using_entry_checks(), execute_cse_conv_1(), execute_cse_reciprocals_1(), execute_cse_sincos_1(), ranger_cache::exit_range(), expand_asm_stmt(), expand_call_tm(), expand_case(), expand_ccmp_expr_1(), expand_complex_comparison(), expand_complex_libcall(), expand_omp_for_generic(), expand_simple_operations(), expand_transaction(), expr_invariant_in_loop_p(), expr_invariant_in_region_p(), extract_true_false_args_from_phi(), factor_out_conditional_operation(), ranger_cache::fill_block_cache(), final_range_test_p(), find_basis_for_base_expr(), find_basis_for_candidate(), find_deps_in_bb_for_stmt(), find_deriving_biv_for_expr(), find_doloop_use(), find_explicit_erroneous_behavior(), find_implicit_erroneous_behavior(), find_interesting_uses_stmt(), find_inv_vars_cb(), find_loop_guard(), find_or_create_guard_phi(), back_threader::find_paths_to_names(), find_ref_loc_in_loop_cmp(), find_single_drs(), find_ssa_names_to_propagate(), find_subloop_latch_edge_by_ivs(), back_threader::find_taken_edge_cond(), find_taken_edge_cond_expr(), back_threader::find_taken_edge_switch(), find_taken_edge_switch_expr(), find_uninit_use(), find_unswitching_predicates_for_bb(), find_uses_to_rename_stmt(), find_uses_to_rename_use(), find_var_cmp_const(), find_vdef_in_loop(), fixup_noreturn_call(), dom_opt_dom_walker::fold_cond(), simplify_using_ranges::fold_cond(), fold_loop_internal_call(), gimple_ranger::fold_stmt(), follow_outer_ssa_edges(), for_all_locs_in_loop(), forward_propagate_into_gimple_cond(), fully_replaceable(), tree_switch_conversion::switch_conversion::gen_inbound_check(), get_computation_cost(), get_cond_invariant_branch(), get_continuation_for_phi(), range_def_chain::get_def_chain(), get_initial_def_for_reduction(), get_iv(), get_nth_most_common_value(), get_rank(), get_reassociation_width(), get_references_in_stmt(), get_representative_for(), get_scaled_computation_cost_at(), get_value_locus_in_path(), get_ws_args_for(), gimple_build_valueize(), gimple_divmod_fixed_value(), gimple_divmod_fixed_value_transform(), gimple_equal_p(), gimple_expand_builtin_cabs(), gimple_expand_vec_set_extract_expr(), gimple_find_sub_bbs(), gimple_fold_builtin_strcat(), gimple_ic(), gimple_in_transaction(), gimple_lower_bitint(), gimple_mod_pow2(), gimple_mod_pow2_value_transform(), gimple_mod_subtract(), gimple_mod_subtract_transform(), gimple_phi_arg_def_from_edge(), gimple_phi_arg_def_from_edge(), gimple_phi_arg_edge(), gimple_phi_arg_imm_use_ptr_from_edge(), gimple_redirect_edge_and_branch(), gimple_stringop_fixed_value(), gimple_stringops_transform(), gimple_switch_edge(), gimple_value_profile_transformations(), gori_calc_operands(), gori_name_helper(), group_case_labels_stmt(), gsi_end(), gsi_for_phi(), gsi_for_stmt(), gsi_last(), gsi_start(), gsi_start_phis(), remove_unreachable::handle_early(), handle_return_addr_local_phi_arg(), hardcfr_sibcall_search_preds(), hash_memrefs_baserefs_and_store_DRs_read_written_info(), hoist_adjacent_loads(), hoist_defs_of_uses(), hoist_memory_references(), idx_infer_loop_bounds(), ifcombine_ifandif(), ifcvt_available_on_edge_p(), ifcvt_can_predicate(), ifcvt_local_dce(), in_loop_p(), independent_of_stmt_p(), uninit_analysis::init_from_phi_def(), insert_backedge_copies(), insert_debug_temp_for_var_def(), insert_initializers(), insert_into_preds_of_block(), insert_phi_nodes(), insert_stmt_after(), insert_trap(), instantiate_scev_name(), instrument_bool_enum_load(), path_range_query::internal_range_of_expr(), interpret_rhs_expr(), ipa_analyze_indirect_call_uses(), ipa_analyze_node(), ipa_merge_profiles(), ipa_simd_modify_function_body(), ipa_tm_insert_gettmclone_call(), ipa_tm_insert_irr_call(), ipa_tm_note_irrevocable(), vect_optimize_slp_pass::is_cfg_latch_edge(), is_cond_scalar_reduction(), is_feasible_trace(), is_inv_store_elimination_chain(), is_maybe_undefined(), is_reassociable_op(), uninit_analysis::is_use_guarded(), iv_elimination_compare(), latch_dominated_by_data_ref(), simplify_using_ranges::legacy_fold_cond(), live_vars_at_stmt(), local_mem_dependence(), loop_combined_static_and_iv_p(), loop_containing_stmt(), loop_invariant_op_p(), loop_iter_phi_semi_invariant_p(), loop_phi_node_p(), loop_static_op_p(), loop_static_stmt_p(), make_eh_dispatch_edges(), make_eh_edge(), mark_aliased_reaching_defs_necessary(), mark_aliased_reaching_defs_necessary_1(), mark_bivs(), ipa_param_body_adjustments::mark_dead_statements(), mark_operand_necessary(), mark_stmt_if_obviously_necessary(), mark_stmt_necessary(), mark_use_interesting(), match_arith_overflow(), may_eliminate_iv(), gori_map::maybe_add_gori(), maybe_diag_stxncpy_trunc(), maybe_duplicate_ssa_info_at_copy(), maybe_get_dominating_check(), maybe_optimize_asan_check_ifn(), maybe_optimize_guarding_check(), maybe_optimize_mod_cmp(), maybe_optimize_range_tests(), maybe_optimize_ubsan_null_ifn(), maybe_record_sincos(), remove_unreachable::maybe_register(), path_range_query::maybe_register_phi_relation(), maybe_set_vectorized_backedge_value(), maybe_skip_until(), ipa_param_body_adjustments::modify_cfun_body(), n_of_executions_at_most(), ncd_of_cand_and_phis(), nearest_common_dominator_of_uses(), nested_in_vect_loop_p(), neuter_worker_single(), vec_info::new_stmt_vec_info(), no_side_effect_bb(), number_of_iterations_cltz(), number_of_iterations_cltz_complement(), number_of_iterations_popcount(), omp_sese_split_blocks(), ref_in_loop_hot_body::operator()(), sm_set_flag_if_changed::operator()(), optimize_cands_for_speed_p(), optimize_mask_stores(), optimize_range_tests_to_bit_test(), optimize_range_tests_var_bound(), optimize_recip_sqrt(), optimize_spaceship(), dom_opt_dom_walker::optimize_stmt(), or_comparisons_1(), outermost_invariant_loop(), outermost_invariant_loop_for_expr(), output_ssa_names(), param_change_prob(), parloops_is_simple_reduction(), parloops_is_slp_reduction(), parloops_valid_reduction_input_p(), parm_preserved_before_stmt_p(), parm_ref_data_pass_through_p(), parm_ref_data_preserved_p(), pcom_stmt_dominates_stmt_p(), loop_distribution::pg_add_dependence_edges(), phi_add_costs_1(), phi_rank(), phi_translate_1(), phivn_valid_p(), rvrp_folder::pre_fold_stmt(), predicate_bbs(), predicate_scalar_phi(), gimple_ranger::prefill_stmt_dependencies(), ipa_param_body_adjustments::prepare_debug_expressions(), prepare_def_site_for(), prepare_use_sites_for(), process_bb(), process_use(), propagate_bias_p(), propagate_necessity(), propagate_with_phi(), prune_clobbered_mems(), uninit_analysis::prune_phi_opnds(), relation_oracle::query(), path_range_query::range_defined_in_block(), ranger_cache::range_from_dom(), ranger_cache::range_of_def(), dom_ranger::range_of_expr(), gimple_ranger::range_of_expr(), ranger_cache::range_of_expr(), fold_using_range::range_of_phi(), fold_using_range::range_of_range_op(), gimple_ranger::range_of_stmt(), gimple_ranger::range_on_exit(), rank_ops_for_fma(), reassoc_remove_stmt(), reassoc_stmt_dominates_stmt_p(), relation_oracle::record(), record_edge_info(), record_estimate(), record_increment(), record_invariant(), record_modified(), record_nonwrapping_iv(), tree_switch_conversion::switch_decision_tree::record_phi_operand_mapping(), jump_threader::record_temporary_equivalences_from_phis(), cgraph_edge::redirect_call_stmt_to_callee(), range_def_chain::register_dependency(), equiv_oracle::register_initial_def(), fur_source::register_outgoing_edges(), release_bb_predicate(), remap_gimple_stmt(), remove_exits_and_undefined_stmts(), remove_prop_source_from_use(), remove_redundant_iv_tests(), remove_unused_ivs(), replace_phi_edge_with_variable(), replace_reciprocal(), replace_reciprocal_squares(), replace_ref_with(), replace_uncond_cands_and_profitable_phis(), replace_uses_by(), replace_uses_in_bb_by(), replacement_internal_fn(), tree_switch_conversion::switch_decision_tree::reset_out_edges_aux(), ranger_cache::resolve_dom(), returning_call_p(), rewrite_debug_stmt_uses(), rewrite_use_nonlinear_expr(), scan_function(), scev_var_range_cant_overflow(), sese_build_liveouts_use(), sese_reset_debug_liveouts(), set_autoinc_for_original_candidates(), ranger_cache::set_global_range(), dom_opt_dom_walker::set_global_ranges_from_unreachable_edges(), set_level(), set_profitable_level(), set_var_live_on_entry(), shrink_wrap_one_built_in_call_with_conds(), simple_dce_from_worklist(), simplify_builtin_call(), simplify_gimple_switch_label_vec(), simplify_using_ranges::simplify_switch_using_ranges(), ssa_propagation_engine::simulate_stmt(), single_trailing_store_in_bb(), single_use_in_loop(), sink_code_in_bb(), slsr_process_phi(), sm_seq_valid_bb(), sort_by_operand_rank(), sort_locs_in_loop_postorder_cmp(), spaceship_replacement(), split_bb_make_tm_edge(), pcom_worker::split_data_refs_to_components(), split_function(), split_part_set_ssa_name_p(), sra_modify_function_body(), path_range_query::ssa_defined_in_bb(), ssa_name_any_use_dominates_bb_p(), ssa_name_has_uses_outside_loop_p(), ssa_propagation_engine::ssa_propagate(), path_range_query::ssa_range_in_phi(), ssa_semi_invariant_p(), ana::supernode::start_phis(), statement_sink_location(), static_loop_exit(), stmt_after_inc_pos(), stmt_after_ip_normal_pos(), stmt_can_terminate_bb_p(), stmt_dominates_stmt_p(), stmt_in_inner_loop_p(), stmt_in_sese_p(), stmt_local_def(), stmt_semi_invariant_p_1(), stmt_update_dep_bb(), pcom_worker::suitable_component_p(), ter_is_replaceable_p(), thread_private_new_memory(), tidy_after_forward_propagate_addr(), tm_log_add(), tm_memopt_accumulate_memops(), transaction_invariant_address_p(), translate_vuse_through_block(), tree_function_versioning(), tree_if_conversion(), trivially_conflicts_p(), try_create_reduction_list(), tree_switch_conversion::switch_decision_tree::try_switch_expansion(), try_transform_to_exit_first_loop_alt(), ubsan_create_edge(), loop_cand::undo_simple_reduction(), unroll_jam_possible_p(), unswitch_predicate::unswitch_predicate(), update_complex_assignment(), update_debug_stmt(), update_dep_bb(), update_epilogue_loop_vinfo(), update_range_test(), used_outside_loop_p(), uses_in_bb(), value_available_p(), value_replacement(), vect_analyze_data_ref_accesses(), vect_analyze_loop_form(), vect_bb_vectorization_profitable_p(), vect_build_slp_instance(), vect_build_slp_tree_1(), vect_build_slp_tree_2(), vect_compute_data_ref_alignment(), vect_create_constant_vectors(), vect_create_data_ref_ptr(), vect_create_epilog_for_reduction(), vect_do_peeling(), vect_find_reusable_accumulator(), vect_get_and_check_slp_defs(), vect_get_external_def_edge(), vect_init_pattern_stmt(), vect_is_simple_iv_evolution(), vect_is_simple_reduction(), vect_loop_kill_debug_uses(), vect_loop_versioning(), vect_phi_first_order_recurrence_p(), vect_phi_initial_value(), vect_recog_divmod_pattern(), vect_remove_slp_scalar_calls(), vect_schedule_scc(), vect_schedule_slp_node(), vect_setup_realignment(), vect_slp_node_weight(), vect_stmt_dominates_stmt_p(), vect_stmt_relevant_p(), vectorizable_early_exit(), vectorizable_induction(), vectorizable_lc_phi(), vectorizable_live_operation(), vectorizable_load(), vectorizable_nonlinear_induction(), vectorizable_phi(), vectorizable_recurr(), vectorizable_reduction(), verify_eh_dispatch_edge(), verify_eh_edges(), verify_gimple_in_cfg(), verify_gimple_label(), verify_live_on_entry(), cgraph_node::verify_node(), verify_ssa(), visit_cond_stmt(), visit_nary_op(), ccp_propagate::visit_phi(), visit_phi(), vn_phi_insert(), vn_phi_lookup(), vn_reference_lookup_3(), vn_valueize_for_srt(), vuse_semi_invariant_p(), and warn_uninit_phi_uses().

◆ gimple_bind_add_seq()

void gimple_bind_add_seq ( gbind * bind_stmt,
gimple_seq seq )
inline
Append a sequence of statements to the end of a GIMPLE_BIND's body.   

References gbind::body, and gimple_seq_add_seq().

Referenced by lower_omp_critical(), lower_omp_master(), lower_omp_ordered(), lower_omp_target(), lower_omp_taskgroup(), and lower_omp_taskreg().

◆ gimple_bind_add_stmt()

void gimple_bind_add_stmt ( gbind * bind_stmt,
gimple * stmt )
inline
Append a statement to the end of a GIMPLE_BIND's body.   

References gbind::body, and gimple_seq_add_stmt().

Referenced by lower_omp_critical(), lower_omp_master(), lower_omp_ordered(), lower_omp_target(), lower_omp_taskgroup(), and lower_omp_taskreg().

◆ gimple_bind_append_vars()

void gimple_bind_append_vars ( gbind * bind_stmt,
tree vars )
inline
Append VARS to the set of variables declared in the GIMPLE_BIND
statement GS.   

References chainon(), gbind::vars, and pt_solution::vars.

Referenced by lower_omp_critical(), lower_omp_for(), lower_omp_master(), lower_omp_ordered(), lower_omp_scope(), lower_omp_sections(), lower_omp_single(), lower_omp_taskgroup(), and lower_omp_teams().

◆ gimple_bind_block()

tree gimple_bind_block ( const gbind * bind_stmt)
inline
Return the TREE_BLOCK node associated with GIMPLE_BIND statement
GS.  This is analogous to the BIND_EXPR_BLOCK field in trees.   

References gbind::block.

Referenced by copy_gimple_bind(), declare_vars(), finalize_nesting_tree_1(), gimple_copy(), lower_gimple_bind(), lower_omp_for(), lower_omp_target(), lower_omp_taskreg(), and replace_locals_stmt().

◆ gimple_bind_body()

◆ gimple_bind_body_ptr()

gimple_seq * gimple_bind_body_ptr ( gbind * bind_stmt)
inline

◆ gimple_bind_set_block()

void gimple_bind_set_block ( gbind * bind_stmt,
tree block )
inline
Set BLOCK to be the TREE_BLOCK node associated with GIMPLE_BIND
statement GS.   

References gbind::block, gcc_gimple_checking_assert, NULL_TREE, and TREE_CODE.

Referenced by gimple_build_bind(), gimple_copy(), and replace_locals_stmt().

◆ gimple_bind_set_body()

void gimple_bind_set_body ( gbind * bind_stmt,
gimple_seq seq )
inline

◆ gimple_bind_set_vars()

void gimple_bind_set_vars ( gbind * bind_stmt,
tree vars )
inline
Set VARS to be the set of variables declared in the GIMPLE_BIND
statement GS.   

References gbind::vars, and pt_solution::vars.

Referenced by declare_vars(), gimple_build_bind(), gimple_copy(), lower_omp_for(), maybe_remove_omp_member_access_dummy_vars(), replace_locals_stmt(), and scan_omp_simd().

◆ gimple_bind_vars()

◆ gimple_block()

◆ gimple_build_asm_vec()

gasm * 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_asm_set_clobber_op(), gimple_asm_set_input_op(), gimple_asm_set_label_op(), gimple_asm_set_output_op(), gimple_build_asm_1(), i, and vec_safe_length().

Referenced by detach_value(), gimplify_asm_expr(), and rt_bb_visited::vset().

◆ gimple_build_assign() [1/4]

gassign * gimple_build_assign ( tree ,
enum tree_code,
tree CXX_MEM_STAT_INFO )

◆ gimple_build_assign() [2/4]

gassign * gimple_build_assign ( tree ,
enum tree_code,
tree ,
tree CXX_MEM_STAT_INFO )

◆ gimple_build_assign() [3/4]

gassign * gimple_build_assign ( tree ,
enum tree_code,
tree ,
tree ,
tree CXX_MEM_STAT_INFO )

◆ gimple_build_assign() [4/4]

gassign * gimple_build_assign ( tree ,
tree CXX_MEM_STAT_INFO )

◆ gimple_build_assume()

gimple * gimple_build_assume ( tree guard,
gimple_seq body )
Build a GIMPLE_ASSUME statement.   

References as_a(), gimple_alloc(), gimple_assume_body_ptr(), and gimple_assume_set_guard().

Referenced by gimplify_call_expr(), and remap_gimple_stmt().

◆ gimple_build_bind()

◆ gimple_build_builtin_unreachable()

gcall * gimple_build_builtin_unreachable ( location_t loc)

◆ gimple_build_call()

gcall * gimple_build_call ( tree fn,
unsigned nargs,
... )
Build a GIMPLE_CALL statement to function FN.  NARGS is the number of
arguments.  The ... are the arguments.   

References ap, gcc_assert, gimple_build_call_1(), gimple_call_set_arg(), i, is_gimple_call_addr(), and TREE_CODE.

Referenced by add_wait(), adjust_simduid_builtins(), asan_expand_check_ifn(), asan_expand_mark_ifn(), asan_expand_poison_ifn(), attempt_builtin_copysign(), attempt_builtin_powi(), build_and_insert_call(), build_init_call_stmt(), build_instrumentation_call(), build_stack_save_restore(), build_tm_load(), build_tm_store(), rt_bb_visited::check(), convert_nl_goto_reference(), convert_tramp_reference_op(), do_vec_conversion(), emit_mfence_after_loop(), execute_cse_sincos_1(), execute_omp_device_lower(), expand_assign_tm(), expand_call_inline(), expand_complex_libcall(), expand_omp_atomic_load(), expand_omp_atomic_store(), expand_omp_for_generic(), expand_omp_for_static_chunk(), expand_omp_for_static_nochunk(), expand_omp_ordered_source(), expand_omp_sections(), expand_transaction(), finalize_nesting_tree_1(), fold_strstr_to_strncmp(), gen_counter_update(), gen_emutls_addr(), generate_memcpy_builtin(), generate_memset_builtin(), generate_strlen_builtin(), get_string_length(), gimple_add_padding_init_for_auto_var(), gimple_build(), gimple_build(), gimple_build(), gimple_build(), gimple_build_builtin_unreachable(), gimple_expand_builtin_cabs(), gimple_fold_builtin_bcmp(), gimple_fold_builtin_bcopy(), gimple_fold_builtin_bzero(), gimple_fold_builtin_fprintf(), gimple_fold_builtin_fputs(), gimple_fold_builtin_memory_chk(), gimple_fold_builtin_printf(), gimple_fold_builtin_realloc(), gimple_fold_builtin_snprintf(), gimple_fold_builtin_sprintf(), gimple_fold_builtin_stpcpy(), gimple_fold_builtin_strcat(), gimple_fold_builtin_strcat_chk(), gimple_fold_builtin_strchr(), gimple_fold_builtin_strcpy(), gimple_fold_builtin_string_compare(), gimple_fold_builtin_strncat(), gimple_fold_builtin_strncat_chk(), gimple_fold_builtin_strncpy(), gimple_fold_builtin_strstr(), gimple_fold_builtin_stxcpy_chk(), gimple_fold_builtin_stxncpy_chk(), gimple_gen_average_profiler(), gimple_gen_ic_func_profiler(), gimple_gen_interval_profiler(), gimple_gen_ior_profiler(), gimple_gen_pow2_profiler(), gimple_gen_topn_values_profiler(), gimple_lower_bitint(), gimplify_expr(), gimplify_modify_expr_to_memcpy(), gimplify_modify_expr_to_memset(), gimplify_omp_workshare(), handle_builtin_alloca(), handle_builtin_stack_restore(), insert_check_and_trap(), insert_trap(), instrument_bool_enum_load(), instrument_builtin(), instrument_decisions(), instrument_expr(), instrument_func_entry(), instrument_func_exit(), instrument_nonnull_arg(), instrument_nonnull_return(), ipa_tm_insert_gettmclone_call(), ipa_tm_insert_irr_call(), issue_prefetch_ref(), lower_builtin_posix_memalign(), lower_builtin_setjmp(), lower_eh_dispatch(), lower_omp_for(), lower_omp_for_scan(), lower_omp_ordered(), lower_omp_scope(), lower_omp_sections(), lower_omp_single_simple(), lower_omp_task_reductions(), lower_omp_taskgroup(), lower_omp_teams(), lower_private_allocate(), lower_rec_input_clauses(), lower_reduction_clauses(), lower_resx(), lower_transaction(), make_data_region_try_statement(), maybe_instrument_call(), maybe_push_res_to_seq(), neuter_worker_single(), omp_build_barrier(), replace_func_exit(), simd_clone_adjust(), tm_log_emit_stmt(), ubsan_expand_bounds_ifn(), ubsan_expand_null_ifn(), ubsan_expand_objsize_ifn(), ubsan_expand_ptr_ifn(), ubsan_expand_vptr_ifn(), vect_build_one_gather_load_call(), vect_build_one_scatter_store_call(), vect_recog_pow_pattern(), vect_recog_rotate_pattern(), vect_setup_realignment(), verify_bb_vtables(), worker_single_copy(), and worker_single_simple().

◆ gimple_build_call_from_tree()

◆ gimple_build_call_internal()

gcall * gimple_build_call_internal ( enum internal_fn fn,
unsigned nargs,
... )
Build a GIMPLE_CALL statement to internal function FN.  NARGS is
the number of arguments.  The ... are the arguments.   

References ap, gimple_build_call_internal_1(), gimple_call_set_arg(), and i.

Referenced by asan_expand_poison_ifn(), asan_poison_variable(), attempt_builtin_copysign(), addsub_pattern::build(), build_call_internal(), build_check_stmt(), build_saturation_binary_arith_call(), build_saturation_binary_arith_call(), cond_removal_in_builtin_zero_pattern(), convert_expand_mult_copysign(), convert_mult_to_fma_1(), convert_scalar_cond_reduction(), convert_to_divmod(), execute_update_addresses_taken(), expand_oacc_collapse_init(), expand_oacc_for(), expand_omp_atomic_cas(), expand_omp_for_init_vars(), expand_omp_simd(), expand_omp_target(), fold_builtin_atomic_compare_exchange(), generate_rawmemchr_builtin(), generate_strlen_builtin_using_rawmemchr(), generate_subtree_deferred_init(), gimple_build(), gimple_build(), gimple_build(), gimple_build(), gimple_expand_vec_cond_expr(), gimple_expand_vec_set_extract_expr(), gimplify_expr(), gimplify_function_tree(), gimplify_modify_expr(), handle_abnormal_edges(), handle_builtin_stack_restore(), instrument_mem_ref(), instrument_object_size(), instrument_pointer_overflow(), instrument_si_overflow(), lower_lastprivate_clauses(), lower_oacc_head_tail(), lower_oacc_loop_marker(), lower_omp_for_scan(), lower_omp_ordered(), lower_omp_scan(), lower_rec_input_clauses(), match_arith_overflow(), match_single_bit_test(), match_uaddc_usubc(), match_unsigned_saturation_trunc(), maybe_add_asan_poison_write(), oacc_dim_call(), oacc_entry_exit_single_gang(), ompdevlow_adjust_simt_enter(), optimize_atomic_bit_test_and(), optimize_atomic_op_fetch_cmp_0(), optimize_spaceship(), predicate_load_or_store(), scan_omp_simd(), simplify_count_trailing_zeroes(), split_function(), use_internal_fn(), vect_create_epilog_for_reduction(), vect_gen_loop_len_mask(), vect_gen_while(), vect_gimple_build(), vect_recog_abd_pattern(), vect_recog_average_pattern(), vect_recog_build_binary_gimple_stmt(), vect_recog_ctz_ffs_pattern(), vect_recog_divmod_pattern(), vect_recog_gather_scatter_pattern(), vect_recog_mulhs_pattern(), vect_recog_popcount_clz_ctz_ffs_pattern(), vect_recog_pow_pattern(), vect_recog_sat_sub_pattern_transform(), vect_recog_sat_trunc_pattern(), vect_recog_widen_abd_pattern(), vect_transform_reduction(), vectorizable_condition(), vectorizable_load(), vectorizable_store(), vectorize_fold_left_reduction(), version_loop_by_alias_check(), and version_loop_for_if_conversion().

◆ gimple_build_call_internal_vec()

◆ gimple_build_call_valist()

gcall * gimple_build_call_valist ( tree fn,
unsigned nargs,
va_list ap )
Build a GIMPLE_CALL statement to function FN.  NARGS is the number of
arguments.  AP contains the arguments.   

References ap, gcc_assert, gimple_build_call_1(), gimple_call_set_arg(), i, is_gimple_call_addr(), and TREE_CODE.

Referenced by update_gimple_call().

◆ gimple_build_call_vec()

◆ gimple_build_catch()

gcatch * gimple_build_catch ( tree types,
gimple_seq handler )
Build a GIMPLE_CATCH statement.

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

References as_a(), gimple_alloc(), gimple_catch_set_handler(), and gimple_catch_set_types().

Referenced by gimplify_expr(), and remap_gimple_stmt().

◆ gimple_build_cond()

gcond * 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.   

References as_a(), gcc_assert, gimple_build_with_ops, gimple_cond_set_false_label(), gimple_cond_set_lhs(), gimple_cond_set_rhs(), gimple_cond_set_true_label(), tcc_comparison, and TREE_CODE_CLASS.

Referenced by asan_expand_check_ifn(), branch_fixup(), build_instrumentation_call(), rt_bb_visited::check(), clear_padding_emit_loop(), connect_loops(), convert_single_case_switch(), create_empty_loop_on_edge(), tree_switch_conversion::switch_decision_tree::do_jump_if_equal(), do_split_loop_on_cond(), dom_opt_dom_walker::dom_opt_dom_walker(), tree_switch_conversion::jump_table_cluster::emit(), tree_switch_conversion::switch_decision_tree::emit_cmp_and_jump_insns(), execute_sm_if_changed(), expand_complex_div_wide(), expand_complex_multiplication(), expand_omp_build_cond(), expand_omp_for_init_vars(), expand_omp_for_static_nochunk(), expand_omp_ordered_sink(), expand_omp_simd(), expand_thunk(), expand_transaction(), extract_omp_for_update_vars(), gen_conditions_for_pow_int_base(), tree_switch_conversion::switch_conversion::gen_inbound_check(), gimple_build_cond_empty(), gimple_build_cond_from_tree(), gimple_divmod_fixed_value(), gimple_gen_ic_func_profiler(), gimple_gen_time_profiler(), gimple_ic(), gimple_lower_bitint(), gimple_mod_pow2(), gimple_mod_subtract(), gimple_stringop_fixed_value(), gimplify_cond_expr(), gimplify_init_ctor_eval_range(), gimplify_omp_loop_xform(), hoist_guard(), insert_check_and_trap(), rt_bb_visited::insert_exit_check_on_edge(), instrument_bool_enum_load(), instrument_builtin(), instrument_nonnull_arg(), instrument_nonnull_return(), jump_threader::jump_threader(), lower_builtin_posix_memalign(), lower_eh_dispatch(), lower_lastprivate_clauses(), lower_omp_1(), lower_omp_for_scan(), lower_omp_ordered(), lower_omp_single_simple(), lower_omp_task_reductions(), lower_omp_teams(), lower_rec_input_clauses(), lower_reduction_clauses(), maybe_add_implicit_barrier_cancel(), move_sese_in_condition(), oacc_entry_exit_single_gang(), omp_sese_split_blocks(), optimize_atomic_bit_test_and(), optimize_mask_stores(), scan_omp_simd(), simd_clone_adjust(), tree_transform_and_unroll_loop(), ubsan_expand_bounds_ifn(), ubsan_expand_null_ifn(), ubsan_expand_objsize_ifn(), ubsan_expand_ptr_ifn(), ubsan_expand_vptr_ifn(), use_internal_fn(), vect_loop_versioning(), vect_recog_bitfield_ref_pattern(), vect_recog_gcond_pattern(), vect_set_loop_condition_normal(), vect_set_loop_condition_partial_vectors(), vect_set_loop_condition_partial_vectors_avx512(), worker_single_copy(), and worker_single_simple().

◆ gimple_build_cond_from_tree()

gcond * gimple_build_cond_from_tree ( tree cond,
tree t_label,
tree f_label )

◆ gimple_build_debug_begin_stmt()

gdebug * gimple_build_debug_begin_stmt ( tree ,
location_t CXX_MEM_STAT_INFO )

◆ gimple_build_debug_bind()

gdebug * gimple_build_debug_bind ( tree ,
tree ,
gimple * CXX_MEM_STAT_INFO )

◆ gimple_build_debug_inline_entry()

gdebug * gimple_build_debug_inline_entry ( tree ,
location_t CXX_MEM_STAT_INFO )

◆ gimple_build_debug_source_bind()

gdebug * gimple_build_debug_source_bind ( tree ,
tree ,
gimple * CXX_MEM_STAT_INFO )

◆ gimple_build_eh_dispatch()

geh_dispatch * gimple_build_eh_dispatch ( int region)
Build a GIMPLE_EH_DISPATCH statement.   

References as_a(), gimple_build_with_ops, and gimple_statement_eh_ctrl::region.

Referenced by lower_catch(), and lower_eh_filter().

◆ gimple_build_eh_else()

geh_else * gimple_build_eh_else ( gimple_seq n_body,
gimple_seq e_body )
Build a GIMPLE_EH_ELSE statement.   

References as_a(), gimple_alloc(), gimple_eh_else_set_e_body(), and gimple_eh_else_set_n_body().

Referenced by gimplify_expr(), and lower_transaction().

◆ gimple_build_eh_filter()

geh_filter * gimple_build_eh_filter ( tree types,
gimple_seq failure )
Build a GIMPLE_EH_FILTER statement.

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

References as_a(), failure, gimple_alloc(), gimple_eh_filter_set_failure(), and gimple_eh_filter_set_types().

Referenced by gimplify_expr(), and remap_gimple_stmt().

◆ gimple_build_eh_must_not_throw()

geh_mnt * gimple_build_eh_must_not_throw ( tree decl)

◆ gimple_build_goto()

◆ gimple_build_label()

◆ gimple_build_nop()

◆ gimple_build_omp_atomic_load()

gomp_atomic_load * gimple_build_omp_atomic_load ( tree lhs,
tree rhs,
enum omp_memory_order mo )

◆ gimple_build_omp_atomic_store()

gomp_atomic_store * gimple_build_omp_atomic_store ( tree val,
enum omp_memory_order mo )
Build a GIMPLE_OMP_ATOMIC_STORE statement.

VAL is the value we are storing.   

References as_a(), gimple_alloc(), gimple_omp_atomic_set_memory_order(), and gimple_omp_atomic_store_set_val().

Referenced by create_call_for_reduction_1(), and gimplify_omp_atomic().

◆ gimple_build_omp_continue()

gomp_continue * gimple_build_omp_continue ( tree control_def,
tree control_use )
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 as_a(), gimple_alloc(), gimple_omp_continue_set_control_def(), and gimple_omp_continue_set_control_use().

Referenced by create_parallel_loop(), expand_omp_for_generic(), lower_omp_for(), lower_omp_for_scan(), lower_omp_sections(), and lower_omp_taskreg().

◆ gimple_build_omp_critical()

gomp_critical * gimple_build_omp_critical ( gimple_seq body,
tree name,
tree clauses )
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.
CLAUSES are clauses for this critical block.   

References as_a(), gimple_alloc(), gimple_omp_critical_set_clauses(), gimple_omp_critical_set_name(), and gimple_omp_set_body().

Referenced by gimplify_expr(), and remap_gimple_stmt().

◆ gimple_build_omp_for()

gomp_for * 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 construct's clauses.
COLLAPSE is the collapse count.
PRE_BODY is the sequence of statements that are loop invariant.   

References as_a(), gomp_for::collapse, ggc_cleared_vec_alloc(), gimple_alloc(), gimple_omp_for_set_clauses(), gimple_omp_for_set_kind(), gimple_omp_for_set_pre_body(), gimple_omp_set_body(), and gomp_for::iter.

Referenced by create_parallel_loop(), gimplify_omp_for(), and remap_gimple_stmt().

◆ gimple_build_omp_masked()

gimple * gimple_build_omp_masked ( gimple_seq body,
tree clauses )
Build a GIMPLE_OMP_MASKED statement.

BODY is the sequence of statements to be executed by the selected thread(s).   

References gimple_alloc(), gimple_omp_masked_set_clauses(), and gimple_omp_set_body().

Referenced by gimplify_expr(), and remap_gimple_stmt().

◆ gimple_build_omp_master()

gimple * gimple_build_omp_master ( gimple_seq body)
Build a GIMPLE_OMP_MASTER statement.

BODY is the sequence of statements to be executed by just the master.   

References gimple_alloc(), and gimple_omp_set_body().

Referenced by gimplify_expr(), and remap_gimple_stmt().

◆ gimple_build_omp_ordered()

gomp_ordered * gimple_build_omp_ordered ( gimple_seq body,
tree clauses )
Build a GIMPLE_OMP_ORDERED statement.

BODY is the sequence of statements inside a loop that will executed in
sequence.
CLAUSES are clauses for this statement.   

References as_a(), gimple_alloc(), gimple_omp_ordered_set_clauses(), and gimple_omp_set_body().

Referenced by gimplify_omp_ordered(), and remap_gimple_stmt().

◆ gimple_build_omp_parallel()

gomp_parallel * 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 as_a(), gimple_alloc(), gimple_omp_parallel_set_child_fn(), gimple_omp_parallel_set_clauses(), gimple_omp_parallel_set_data_arg(), and gimple_omp_set_body().

Referenced by create_parallel_loop(), gimplify_omp_parallel(), and remap_gimple_stmt().

◆ gimple_build_omp_return()

gimple * gimple_build_omp_return ( bool wait_p)

◆ gimple_build_omp_scan()

gomp_scan * gimple_build_omp_scan ( gimple_seq body,
tree clauses )
Build a GIMPLE_OMP_SCAN statement.

BODY is the sequence of statements to be executed by the scan
construct.
CLAUSES are any of the construct's clauses.   

References as_a(), gimple_alloc(), gimple_omp_scan_set_clauses(), and gimple_omp_set_body().

Referenced by gimplify_expr(), remap_gimple_stmt(), and scan_omp_simd_scan().

◆ gimple_build_omp_scope()