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

Go to the source code of this file.

Data Structures

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)
#define gcc_gimple_checking_assert(EXPR)
#define GIMPLE_CHECK(GS, CODE)
#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)
#define GIMPLE_DEBUG_BIND_NOVALUE   NULL_TREE
#define CASE_GIMPLE_OMP

Typedefs

typedef gimplegimple_seq_node
typedef struct gimple_temp_hash_elt elt_t

Enumerations

enum  gimple_code { DEFGSCODE , DEFGSCODE }
enum  gimple_rhs_class {
  GIMPLE_INVALID_RHS , GIMPLE_TERNARY_RHS , GIMPLE_BINARY_RHS , GIMPLE_UNARY_RHS ,
  GIMPLE_SINGLE_RHS
}
enum  gf_mask {
  GF_ASM_BASIC = 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>
GIMPLE_CHECK2 (gimple *gs)
template<typename 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_dispatch (gimple_seq, tree)
gimplegimple_build_omp_interop (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, gimple_seq=NULL)
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, tree *=NULL, tree *=NULL)
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 (const 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_true_canonical_p (const gcond *gs)
bool gimple_cond_false_p (const gcond *gs)
bool gimple_cond_false_canonical_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_basic (gasm *asm_stmt, bool basic_p)
bool gimple_asm_basic_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)
tree gimple_omp_dispatch_clauses (const gimple *gs)
treegimple_omp_dispatch_clauses_ptr (gimple *gs)
void gimple_omp_dispatch_set_clauses (gimple *gs, tree clauses)
tree gimple_omp_interop_clauses (const gimple *gs)
treegimple_omp_interop_clauses_ptr (gimple *gs)
void gimple_omp_interop_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)
gimple_seq gimple_omp_target_iterator_loops (const gomp_target *omp_target_stmt)
gimple_seqgimple_omp_target_iterator_loops_ptr (gimple *gs)
void gimple_omp_target_set_iterator_loops (gomp_target *omp_target_stmt, gimple_seq iterator_loops)
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_DISPATCH: \
case GIMPLE_OMP_INTEROP: \
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 )
Value:
SYM,

◆ DEFGSSTRUCT

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

◆ gcc_gimple_checking_assert

#define gcc_gimple_checking_assert ( EXPR)
Value:
((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_cond_set_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_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 )
Value:
(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_dispatch_clauses(), gimple_omp_dispatch_clauses_ptr(), gimple_omp_dispatch_set_clauses(), gimple_omp_for_combined_into_p(), gimple_omp_for_combined_p(), gimple_omp_for_kind(), gimple_omp_interop_clauses(), gimple_omp_interop_clauses_ptr(), gimple_omp_interop_set_clauses(), 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
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 whatsoever, 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-2026 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_BASIC 
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
DEFGSCODE 
This file contains the definitions of the GIMPLE IR tuples used in GCC.

   Copyright (C) 2007-2026 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/>.   
The format of this file is
DEFGSCODE(GIMPLE_symbol, printable name, GSS_symbol).   
Error marker.  This is used in similar ways as ERROR_MARK in tree.def.   
IMPORTANT.  Do not rearrange the codes between GIMPLE_COND and
GIMPLE_RETURN.  The ordering is exposed by gimple_has_ops calls.
These are all the GIMPLE statements with register operands.   
GIMPLE_COND <COND_CODE, OP1, OP2, TRUE_LABEL, FALSE_LABEL>
represents the conditional jump:

if (OP1 COND_CODE OP2) goto TRUE_LABEL else goto FALSE_LABEL

COND_CODE is the tree code used as the comparison predicate.  It
must be of class tcc_comparison.

OP1 and OP2 are the operands used in the comparison.  They must be
accepted by is_gimple_operand.

TRUE_LABEL and FALSE_LABEL are the LABEL_DECL nodes used as the
jump target for the comparison.   
GIMPLE_DEBUG represents a debug statement.   
GIMPLE_GOTO <TARGET> represents unconditional jumps.
TARGET is a LABEL_DECL or an expression node for computed GOTOs.   
GIMPLE_LABEL <LABEL> represents label statements.  LABEL is a
LABEL_DECL representing a jump target.   
GIMPLE_SWITCH <INDEX, DEFAULT_LAB, LAB1, ..., LABN> represents the
multiway branch:

switch (INDEX)
{
  case LAB1: ...; break;
  ...
  case LABN: ...; break;
  default: ...
}

INDEX is the variable evaluated to decide which label to jump to.

DEFAULT_LAB, LAB1 ... LABN are the tree nodes representing case labels.
They must be CASE_LABEL_EXPR nodes.   
IMPORTANT.

Do not rearrange the codes between GIMPLE_ASSIGN and GIMPLE_RETURN.
It's exposed by GIMPLE_RANGE_CHECK calls. These are all the GIMPLE
statements with memory and register operands.   
GIMPLE_ASSIGN <SUBCODE, LHS, RHS1[, RHS2]> represents the assignment
statement

LHS = RHS1 SUBCODE RHS2.

SUBCODE is the tree code for the expression computed by the RHS of the
assignment.  It must be one of the tree codes accepted by
get_gimple_rhs_class.  If LHS is not a gimple register according to
is_gimple_reg, SUBCODE must be of class GIMPLE_SINGLE_RHS.

LHS is the operand on the LHS of the assignment.  It must be a tree node
accepted by is_gimple_lvalue.

RHS1 is the first operand on the RHS of the assignment.  It must always be
present.  It must be a tree node accepted by is_gimple_val.

RHS2 is the second operand on the RHS of the assignment.  It must be a tree
node accepted by is_gimple_val.  This argument exists only if SUBCODE is
of class GIMPLE_BINARY_RHS.   
GIMPLE_ASM <STRING, I1, ..., IN, O1, ... OM, C1, ..., CP>
represents inline assembly statements.

STRING is the string containing the assembly statements.
I1 ... IN are the N input operands.
O1 ... OM are the M output operands.
C1 ... CP are the P clobber operands.
L1 ... LQ are the Q label operands.   
GIMPLE_CALL <FN, LHS, ARG1, ..., ARGN[, CHAIN]> represents function
calls.

FN is the callee.  It must be accepted by is_gimple_call_addr.

LHS is the operand where the return value from FN is stored.  It may
be NULL.

ARG1 ... ARGN are the arguments.  They must all be accepted by
is_gimple_operand.

 CHAIN is the optional static chain link for nested functions.   
GIMPLE_TRANSACTION <BODY, LABEL> represents __transaction_atomic and
__transaction_relaxed blocks.
BODY is the sequence of statements inside the transaction.
LABEL is a label for the statement immediately following the
transaction.  This is before RETURN so that it has MEM_OPS,
so that it can clobber global memory.   
GIMPLE_RETURN <RETVAL> represents return statements.

RETVAL is the value to return or NULL.  If a value is returned it
must be accepted by is_gimple_operand.   
GIMPLE_BIND <VARS, BLOCK, BODY> represents a lexical scope.
VARS is the set of variables declared in that scope.
BLOCK is the symbol binding block used for debug information.
BODY is the sequence of statements in the scope.   
GIMPLE_CATCH <TYPES, HANDLER> represents a typed exception handler.
TYPES is the type (or list of types) handled.  HANDLER is the
sequence of statements that handle these types.   
GIMPLE_EH_FILTER <TYPES, FAILURE> represents an exception
specification.  TYPES is a list of allowed types and FAILURE is the
sequence of statements to execute on failure.   
GIMPLE_EH_MUST_NOT_THROW <DECL> represents an exception barrier.
DECL is a noreturn function decl taking no arguments that will
be invoked if an exception propagates to this point.   
GIMPLE_EH_ELSE <N_BODY, E_BODY> must be the sole contents of
a GIMPLE_TRY_FINALLY node.  For all normal exits from the try block,
N_BODY is run; for all exception exits from the try block,
E_BODY is run.   
GIMPLE_RESX resumes execution after an exception.   
GIMPLE_EH_DISPATCH demultiplexes an exception edge based on
the FILTER argument.   
GIMPLE_PHI <RESULT, ARG1, ..., ARGN> represents the PHI node

RESULT = PHI <ARG1, ..., ARGN>

RESULT is the SSA name created by this PHI node.

ARG1 ... ARGN are the arguments to the PHI node.  N must be
exactly the same as the number of incoming edges to the basic block
holding the PHI node.  Every argument is either an SSA name or a
tree node of class tcc_constant.   
GIMPLE_TRY <TRY_KIND, EVAL, CLEANUP>
represents a try/catch or a try/finally statement.

TRY_KIND is either GIMPLE_TRY_CATCH or GIMPLE_TRY_FINALLY.

EVAL is the sequence of statements to execute on entry to GIMPLE_TRY.

CLEANUP is the sequence of statements to execute according to
TRY_KIND.  If TRY_KIND is GIMPLE_TRY_CATCH, CLEANUP is only executed
if an exception is thrown during execution of EVAL.  If TRY_KIND is
GIMPLE_TRY_FINALLY, CLEANUP is always executed after executing EVAL
(regardless of whether EVAL finished normally, or jumped out or an
exception was thrown).   
GIMPLE_NOP represents the "do nothing" statement.   
IMPORTANT.

Do not rearrange any of the GIMPLE_OMP_* codes.  This ordering is
exposed by the range check in gimple_omp_subcode().   
Tuples used for lowering of OMP_ATOMIC.  Although the form of the OMP_ATOMIC
expression is very simple (just in form mem op= expr), various implicit
conversions may cause the expression to become more complex, so that it does
not fit the gimple grammar very well.  To overcome this problem, OMP_ATOMIC
is rewritten as a sequence of two codes in gimplification:

GIMPLE_OMP_LOAD (tmp, mem)
val = some computations involving tmp;
GIMPLE_OMP_STORE (val).   
DEFGSCODE 
This file contains the definitions of the GIMPLE IR tuples used in GCC.

   Copyright (C) 2007-2026 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/>.   
The format of this file is
DEFGSCODE(GIMPLE_symbol, printable name, GSS_symbol).   
Error marker.  This is used in similar ways as ERROR_MARK in tree.def.   
IMPORTANT.  Do not rearrange the codes between GIMPLE_COND and
GIMPLE_RETURN.  The ordering is exposed by gimple_has_ops calls.
These are all the GIMPLE statements with register operands.   
GIMPLE_COND <COND_CODE, OP1, OP2, TRUE_LABEL, FALSE_LABEL>
represents the conditional jump:

if (OP1 COND_CODE OP2) goto TRUE_LABEL else goto FALSE_LABEL

COND_CODE is the tree code used as the comparison predicate.  It
must be of class tcc_comparison.

OP1 and OP2 are the operands used in the comparison.  They must be
accepted by is_gimple_operand.

TRUE_LABEL and FALSE_LABEL are the LABEL_DECL nodes used as the
jump target for the comparison.   
GIMPLE_DEBUG represents a debug statement.   
GIMPLE_GOTO <TARGET> represents unconditional jumps.
TARGET is a LABEL_DECL or an expression node for computed GOTOs.   
GIMPLE_LABEL <LABEL> represents label statements.  LABEL is a
LABEL_DECL representing a jump target.   
GIMPLE_SWITCH <INDEX, DEFAULT_LAB, LAB1, ..., LABN> represents the
multiway branch:

switch (INDEX)
{
  case LAB1: ...; break;
  ...
  case LABN: ...; break;
  default: ...
}

INDEX is the variable evaluated to decide which label to jump to.

DEFAULT_LAB, LAB1 ... LABN are the tree nodes representing case labels.
They must be CASE_LABEL_EXPR nodes.   
IMPORTANT.

Do not rearrange the codes between GIMPLE_ASSIGN and GIMPLE_RETURN.
It's exposed by GIMPLE_RANGE_CHECK calls. These are all the GIMPLE
statements with memory and register operands.   
GIMPLE_ASSIGN <SUBCODE, LHS, RHS1[, RHS2]> represents the assignment
statement

LHS = RHS1 SUBCODE RHS2.

SUBCODE is the tree code for the expression computed by the RHS of the
assignment.  It must be one of the tree codes accepted by
get_gimple_rhs_class.  If LHS is not a gimple register according to
is_gimple_reg, SUBCODE must be of class GIMPLE_SINGLE_RHS.

LHS is the operand on the LHS of the assignment.  It must be a tree node
accepted by is_gimple_lvalue.

RHS1 is the first operand on the RHS of the assignment.  It must always be
present.  It must be a tree node accepted by is_gimple_val.

RHS2 is the second operand on the RHS of the assignment.  It must be a tree
node accepted by is_gimple_val.  This argument exists only if SUBCODE is
of class GIMPLE_BINARY_RHS.   
GIMPLE_ASM <STRING, I1, ..., IN, O1, ... OM, C1, ..., CP>
represents inline assembly statements.

STRING is the string containing the assembly statements.
I1 ... IN are the N input operands.
O1 ... OM are the M output operands.
C1 ... CP are the P clobber operands.
L1 ... LQ are the Q label operands.   
GIMPLE_CALL <FN, LHS, ARG1, ..., ARGN[, CHAIN]> represents function
calls.

FN is the callee.  It must be accepted by is_gimple_call_addr.

LHS is the operand where the return value from FN is stored.  It may
be NULL.

ARG1 ... ARGN are the arguments.  They must all be accepted by
is_gimple_operand.

 CHAIN is the optional static chain link for nested functions.   
GIMPLE_TRANSACTION <BODY, LABEL> represents __transaction_atomic and
__transaction_relaxed blocks.
BODY is the sequence of statements inside the transaction.
LABEL is a label for the statement immediately following the
transaction.  This is before RETURN so that it has MEM_OPS,
so that it can clobber global memory.   
GIMPLE_RETURN <RETVAL> represents return statements.

RETVAL is the value to return or NULL.  If a value is returned it
must be accepted by is_gimple_operand.   
GIMPLE_BIND <VARS, BLOCK, BODY> represents a lexical scope.
VARS is the set of variables declared in that scope.
BLOCK is the symbol binding block used for debug information.
BODY is the sequence of statements in the scope.   
GIMPLE_CATCH <TYPES, HANDLER> represents a typed exception handler.
TYPES is the type (or list of types) handled.  HANDLER is the
sequence of statements that handle these types.   
GIMPLE_EH_FILTER <TYPES, FAILURE> represents an exception
specification.  TYPES is a list of allowed types and FAILURE is the
sequence of statements to execute on failure.   
GIMPLE_EH_MUST_NOT_THROW <DECL> represents an exception barrier.
DECL is a noreturn function decl taking no arguments that will
be invoked if an exception propagates to this point.   
GIMPLE_EH_ELSE <N_BODY, E_BODY> must be the sole contents of
a GIMPLE_TRY_FINALLY node.  For all normal exits from the try block,
N_BODY is run; for all exception exits from the try block,
E_BODY is run.   
GIMPLE_RESX resumes execution after an exception.   
GIMPLE_EH_DISPATCH demultiplexes an exception edge based on
the FILTER argument.   
GIMPLE_PHI <RESULT, ARG1, ..., ARGN> represents the PHI node

RESULT = PHI <ARG1, ..., ARGN>

RESULT is the SSA name created by this PHI node.

ARG1 ... ARGN are the arguments to the PHI node.  N must be
exactly the same as the number of incoming edges to the basic block
holding the PHI node.  Every argument is either an SSA name or a
tree node of class tcc_constant.   
GIMPLE_TRY <TRY_KIND, EVAL, CLEANUP>
represents a try/catch or a try/finally statement.

TRY_KIND is either GIMPLE_TRY_CATCH or GIMPLE_TRY_FINALLY.

EVAL is the sequence of statements to execute on entry to GIMPLE_TRY.

CLEANUP is the sequence of statements to execute according to
TRY_KIND.  If TRY_KIND is GIMPLE_TRY_CATCH, CLEANUP is only executed
if an exception is thrown during execution of EVAL.  If TRY_KIND is
GIMPLE_TRY_FINALLY, CLEANUP is always executed after executing EVAL
(regardless of whether EVAL finished normally, or jumped out or an
exception was thrown).   
GIMPLE_NOP represents the "do nothing" statement.   
IMPORTANT.

Do not rearrange any of the GIMPLE_OMP_* codes.  This ordering is
exposed by the range check in gimple_omp_subcode().   
Tuples used for lowering of OMP_ATOMIC.  Although the form of the OMP_ATOMIC
expression is very simple (just in form mem op= expr), various implicit
conversions may cause the expression to become more complex, so that it does
not fit the gimple grammar very well.  To overcome this problem, OMP_ATOMIC
is rewritten as a sequence of two codes in gimplification:

GIMPLE_OMP_LOAD (tmp, mem)
val = some computations involving tmp;
GIMPLE_OMP_STORE (val).   

◆ 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 
This file contains the definitions for the gimple IR structure
   enumeration used in GCC.

   Copyright (C) 2007-2026 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/>.   
The format of this file is
DEFGSSTRUCT(GSS enumeration value, structure name, has-tree-operands).
Each enum value should correspond with a single member of the union
gimple_statement_d.   

◆ 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()

◆ 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_all_with_location_after(), annotate_one_with_location(), gsi_end_p(), gsi_next(), gsi_start(), and gsi_stmt().

Referenced by annotate_all_with_location_after(), gimple_build_debug_inline_entry(), and 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().

◆ 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 dump_decl_set(), EXECUTE_IF_SET_IN_BITMAP, and i.

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

◆ dump_gimple_statistics()

void dump_gimple_statistics ( void )
extern

◆ empty_body_p()

◆ get_gimple_rhs_class()

◆ get_gimple_rhs_num_ops()

unsigned get_gimple_rhs_num_ops ( enum tree_code code)

◆ 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 get_lineno(), gimple_location(), LOCATION_LINE, and UNKNOWN_LOCATION.

Referenced by dump_gimple_bb_header(), and get_lineno().

◆ gimple_alloc()

◆ 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_arg(), gimple_call_arg(), gimple_op(), gimple_phi_arg_def(), and i.

Referenced by compatible_complex_nodes_p(), slp_oprnds::get_op_for_slp_child(), gimple_arg(), gimple_equal_p(), ifcvt_can_hoist(), predicate_rhs_code(), vect_analyze_slp_reduc_chain(), vect_build_slp_tree_3(), vect_get_and_check_slp_defs(), vect_recog_cond_store_pattern(), vect_widened_op_tree(), and vectorizable_conversion().

◆ 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_arg_ptr(), gimple_call_arg_ptr(), gimple_op_ptr(), gimple_phi_arg_def_ptr(), and i.

Referenced by gimple_arg_ptr().

◆ gimple_asm_basic_p()

bool gimple_asm_basic_p ( const gasm * asm_stmt)
inline

◆ gimple_asm_clobber_op()

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

◆ gimple_asm_clobbers_memory_p()

◆ gimple_asm_inline_p()

bool gimple_asm_inline_p ( const gasm * asm_stmt)
inline

◆ gimple_asm_input_op()

◆ gimple_asm_label_op()

◆ gimple_asm_nclobbers()

unsigned gimple_asm_nclobbers ( const gasm * asm_stmt)
inline

◆ gimple_asm_ninputs()

◆ gimple_asm_nlabels()

◆ gimple_asm_noutputs()

◆ gimple_asm_output_op()

◆ gimple_asm_set_basic()

void gimple_asm_set_basic ( gasm * asm_stmt,
bool basic_p )
inline
Mark whether asm ASM_STMT is a basic asm or an extended asm, based on
BASIC_P.   

References GF_ASM_BASIC, gimple_asm_set_basic(), and gimple::subcode.

Referenced by gimple_asm_set_basic(), and gimplify_asm_expr().

◆ 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, gimple_asm_set_clobber_op(), gasm::ni, gasm::no, gasm::op, and TREE_CODE.

Referenced by gimple_asm_set_clobber_op(), and 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, gimple_asm_set_inline(), and gimple::subcode.

Referenced by gimple_asm_set_inline(), and 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, gimple_asm_set_input_op(), gasm::no, gasm::op, and TREE_CODE.

Referenced by gimple_asm_set_input_op(), and 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, gimple_asm_set_label_op(), gasm::nc, gasm::ni, gasm::no, gasm::op, and TREE_CODE.

Referenced by gimple_asm_set_label_op(), and 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, gimple_asm_set_output_op(), gasm::op, and TREE_CODE.

Referenced by gimple_asm_set_output_op(), and 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, gimple_asm_set_volatile(), and gimple::subcode.

Referenced by gimple_asm_set_volatile(), and gimplify_asm_expr().

◆ gimple_asm_string()

const char * gimple_asm_string ( const gasm * asm_stmt)
inline

◆ 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_assign_lhs(), and gimple_statement_with_memory_ops::op.

Referenced by add_scope_conflicts_1(), 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(), blend_vec_perm_simplify_seqs(), 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(), calc_perm_vec_perm_simplify_seqs(), can_blend_vec_perm_simplify_seqs_p(), can_combine_bbs_with_short_circuit(), 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(), comparison_combine(), compute_complex_assign_jump_func(), compute_live_vars_1(), cond_if_else_store_replacement_1(), cond_removal_in_builtin_zero_pattern(), cond_store_replacement(), cond_store_replacement_limited(), constant_after_peeling(), constant_pointer_difference(), 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_mul_high_seq(), create_mul_low_seq(), create_phi_basis_1(), decompose_kernels_region_body(), decompose_param_expr(), derive_constant_upper_bound_assign(), derive_constant_upper_bound_ops(), divmod_candidate_p(), do_simple_agr_dse(), 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(), crc_symbolic_execution::execute_assign_statement(), execute_cse_conv_1(), execute_cse_reciprocals_1(), execute_sm_exit(), execute_update_addresses_taken(), exist_non_indexing_operands_for_use_p(), expand_assign_tm(), expand_call_inline(), 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_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(), finish_long_mul_low_half(), 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_lhs(), gimple_assign_nonnegative_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_needing_rewrite_undefined(), 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(), hoist_adjacent_loads(), 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_analyze_stmt_uses(), ipa_simd_modify_stmt_ops(), ipa_tm_scan_irr_block(), is_addr_local(), is_reassociable_op(), is_self_write(), is_vtable_assignment_stmt(), is_widening_mult_p(), ana::impl_sm_context::is_zero_assignment(), legal_cast_p(), linearize_expr(), load_or_store_of_ptr_parameter(), long_mul_apply_extras(), long_mul_check_low_plus_defer(), long_mul_high_half_uses(), lower_bitfield(), lower_long_mul_high_chain(), lower_omp_1(), lower_vec_perm(), make_bit_field_load(), mark_all_reaching_defs_necessary_1(), ipa_param_body_adjustments::mark_dead_statements(), match_arith_overflow(), match_long_mul(), match_saturation_add_with_assign(), match_simplify_replacement(), match_single_bit_test(), match_uaddc_usubc(), match_unsigned_saturation_mul(), 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_duplicate_comparison(), maybe_fold_comparisons_from_match_pd(), maybe_instrument_assignment(), maybe_optimize_guarding_check(), maybe_optimize_range_tests(), maybe_trim_complex_store(), maybe_trim_constructor_store(), maybe_trim_partially_dead_store(), maybe_warn_operand(), strlen_pass::maybe_warn_overflow(), move_computations_worker(), movement_possibility_1(), name_for_ref(), narrow_long_mul_halves(), narrow_long_mul_low_half(), 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(), one_feeding_comparison_into_p(), optimize_aggr_zeroprop(), optimize_aggr_zeroprop_1(), optimize_agr_copyprop(), optimize_agr_copyprop_1(), 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(), phi_incr_cost_1(), 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(), fold_using_range::range_from_readonly_var(), reassociate_bb(), pcom_worker::reassociate_to_the_same_stmt(), recognise_vec_perm_simplify_seq(), 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_rhs_if_not_dup(), replace_unconditional_candidate(), repropagate_negates(), rewrite_bittest(), rewrite_expr_tree(), rewrite_expr_tree_parallel(), rewrite_reciprocal(), rewrite_to_defined_unconditional(), 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_builtin_memcpy_memset(), simplify_conversion_using_ranges(), simplify_count_zeroes(), simplify_using_ranges::simplify_float_conversion_using_ranges(), simplify_using_ranges::simplify_internal_call_using_ranges(), simplify_phi_result_movdiv(), 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(), 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(), unexpandable_long_mul_p(), update_complex_assignment(), va_list_counter_bump(), value_replacement(), var_is_used_for_virtual_call_p(), vect_add_slp_permutation(), vect_analyze_slp_reduc_chain(), vect_determine_precisions_from_range(), vect_finish_stmt_generation(), vect_get_operand_map(), vect_is_extending_load(), vect_is_integer_truncation(), vect_is_truncating_store(), 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_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_lane_reducing(), 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(), 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(), widening_mult_conversion_strippable_p(), and crc_optimization::xor_calculates_crc().

◆ 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

◆ 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_assign_rhs1(), and gimple_statement_with_memory_ops::op.

Referenced by address_compare(), 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(), blend_vec_perm_simplify_seqs(), branch_fixup(), break_up_subtract(), break_up_subtract_bb(), addsub_pattern::build(), build_accesses_from_assign(), build_bitint_stmt_ssa_conflicts(), build_ssa_conflict_graph(), can_blend_vec_perm_simplify_seqs_p(), can_handle_load(), 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_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(), comparison_combine(), compatible_complex_nodes_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(), cond_store_replacement_limited(), 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(), decode_field_reference(), 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(), eliminate_dom_walker::eliminate_avail(), eliminate_dom_walker::eliminate_insert(), eliminate_redundant_comparison(), eliminate_dom_walker::eliminate_stmt(), eliminated_by_inlining_prob(), emit_cmp_and_jump_insns(), estimate_num_insns(), evaluate_stmt(), examine_assign_tm(), crc_symbolic_execution::execute_assign_statement(), 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_vec_cond_mask_optab_fn(), 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_load(), 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(), finish_long_mul_low_half(), fold_gimple_assign(), fold_using_range::fold_stmt(), 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_known_nonzero_bits(), get_mem_ref_of_assignment(), get_min_precision(), get_name_for_bit_test(), get_nonzero_bits(), 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_p(), gimple_assign_rhs1(), gimple_assign_rhs1(), gimple_assign_rhs_to_tree(), gimple_assign_ssa_name_copy_p(), gimple_assign_unary_nop_p(), gimple_binop_def_p(), gimple_bitwise_inverted_equal_p(), gimple_clobber_p(), gimple_clobber_p(), gimple_convert_def_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_needing_rewrite_undefined(), 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_backedge_copies(), insert_init_stmt(), insert_predicates_for_cond(), 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_analyze_stmt_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_gimple_logical_p(), is_inv_store_elimination_chain(), is_mult_by(), is_reassociable_op(), is_self_write(), 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(), long_mul_check_low_plus_defer(), long_mul_high_half_uses(), long_mul_is_lshift_def(), long_mul_linearize_chain(), long_mul_op_fits_p(), long_mul_split_operand(), loop_iter_phi_semi_invariant_p(), loop_niter_by_eval(), lower_bitfield(), lower_long_mul_high_chain(), lower_vec_perm(), make_bit_field_load(), match_arith_overflow(), match_long_mul_phi(), 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_trim_complex_store(), maybe_trim_constructor_store(), maybe_trim_partially_dead_store(), maybe_warn_operand(), ipa_param_adjustments::modify_call(), movement_possibility_1(), multiple_of_p(), name_for_ref(), narrow_long_mul_halves(), narrow_long_mul_low_half(), 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(), vars_ssa_cache::operator()(), ops_equal_values_p(), optimize_aggr_zeroprop(), optimize_aggr_zeroprop_1(), optimize_agr_copyprop(), optimize_agr_copyprop_1(), optimize_bitfield_assignment_op(), 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(), parse_predicate(), phi_arg_from_cmp_p(), phiprop_insert_phi(), plus_stmt_object_size(), predicate_load_or_store(), predicate_statements(), predict_loops(), ipa_param_body_adjustments::prepare_debug_expressions(), process_assignment(), scc_copy_prop::propagate(), propagate_necessity(), propagate_tree_value_into_stmt(), propagate_with_phi(), fold_using_range::range_from_readonly_var(), 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(), recognise_vec_perm_simplify_seq(), 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(), replace_stmt_with_simplification(), repropagate_negates(), rewrite_bittest(), rewrite_expr_tree(), rewrite_expr_tree_parallel(), rewrite_reciprocal(), rewrite_to_defined_unconditional(), rewrite_use_nonlinear_expr(), rhs_is_fed_for_value_replacement(), rhs_to_tree(), same_bool_comparison_p(), scan_operand_equal_p(), crc_optimization::set_defs(), 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_builtin_call(), simplify_builtin_memcpy_memset(), simplify_using_ranges::simplify_casted_compare(), simplify_using_ranges::simplify_compare_assign_using_ranges_1(), simplify_conversion_using_ranges(), simplify_count_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_phi_result_movdiv(), simplify_rotate(), simplify_using_ranges::simplify_truth_ops_using_ranges(), simplify_vector_constructor(), sink_common_stores_to_bb(), skip_a_safe_conversion_op(), 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_integral_conversion_op(), 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_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(), 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(), va_list_counter_bump(), value_replacement(), valueized_wider_op(), var_is_used_for_virtual_call_p(), vect_analyze_slp_reduc_chain(), vect_build_slp_tree_2(), vect_build_slp_tree_3(), 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_store_rhs(), vect_is_emulated_mixed_dot_prod(), vect_is_extending_load(), vect_is_integer_truncation(), vect_is_nonlinear_iv_evolution(), vect_is_truncating_store(), 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_cond_store_pattern(), vect_recog_divmod_pattern(), vect_recog_mask_conversion_pattern(), vect_recog_mod_var_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(), 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_switch_unreachable_and_auto_init_r(), warn_uninit(), warn_uninitialized_vars(), widening_mult_conversion_strippable_p(), will_be_nonconstant_predicate(), crc_optimization::xor_calculates_crc(), 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_assign_rhs2(), gimple_num_ops(), NULL_TREE, and gimple_statement_with_memory_ops::op.

Referenced by 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(), blend_vec_perm_simplify_seqs(), branch_fixup(), break_up_subtract(), break_up_subtract_bb(), addsub_pattern::build(), crc_optimization::can_be_crc_shift(), can_interpret_as_conditional_op_p(), ccmp_candidate_p(), check_all_va_list_escapes(), check_for_plus_in_loops(), check_for_plus_in_loops_1(), check_redundant_cond_expr(), check_retval_uses(), check_scan_store(), comparison_combine(), 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(), emit_cmp_and_jump_insns(), estimate_num_insns(), evaluate_stmt(), crc_symbolic_execution::execute_assign_statement(), execute_cse_reciprocals_1(), crc_optimization::exists_shift_for_opp_xor_shift(), 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_vec_cond_mask_optab_fn(), 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(), finish_long_mul_low_half(), 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_known_nonzero_bits(), get_nonzero_bits(), 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_p(), gimple_assign_rhs2(), gimple_assign_rhs2(), gimple_assign_rhs_to_tree(), gimple_binop_def_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_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_backedge_copies(), insert_predicates_for_cond(), 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(), long_mul_check_low_plus_defer(), long_mul_high_half_uses(), long_mul_is_lshift_def(), long_mul_linearize_chain(), long_mul_split_operand(), lower_long_mul_high_chain(), lower_vec_perm(), match_arith_overflow(), match_long_mul_phi(), 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(), movement_possibility_1(), multiple_of_p(), narrow_long_mul_halves(), narrow_long_mul_low_half(), negate_value(), predicate::normalize(), number_of_iterations_cltz(), number_of_iterations_popcount(), op1_range(), operand_equal_for_value_replacement(), 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(), parse_predicate(), plus_stmt_object_size(), process_assignment(), fold_using_range::range_of_cond_expr(), reassociate_bb(), pcom_worker::reassociate_to_the_same_stmt(), recognise_vec_perm_simplify_seq(), 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(), replace_stmt_with_simplification(), 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(), crc_optimization::set_defs(), 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_builtin_call(), simplify_using_ranges::simplify_compare_assign_using_ranges_1(), simplify_using_ranges::simplify_div_or_mod_using_ranges(), simplify_using_ranges::simplify_min_or_max_using_ranges(), simplify_permutation(), simplify_phi_result_movdiv(), 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_3(), 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_mod_var_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_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(), crc_optimization::xor_calculates_crc(), 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

◆ 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_assign_rhs_code(), GIMPLE_SINGLE_RHS, gimple_statement_with_memory_ops::op, gimple::subcode, and TREE_CODE.

Referenced by 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(), phi_group::calculate_using_modifier(), crc_optimization::can_be_crc_shift(), can_blend_vec_perm_simplify_seqs_p(), can_combine_bbs_with_short_circuit(), can_interpret_as_conditional_op_p(), crc_optimization::can_not_be_crc_stmt(), 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_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(), comparison_combine(), 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_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(), eliminate_dom_walker::eliminate_insert(), eliminate_plus_minus_pair(), eliminate_redundant_comparison(), eliminate_dom_walker::eliminate_stmt(), eliminated_by_inlining_prob(), emit_cmp_and_jump_insns(), estimate_num_insns(), evaluate_stmt(), crc_symbolic_execution::execute_assign_statement(), execute_cse_reciprocals_1(), crc_optimization::exists_shift_for_opp_xor_shift(), 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_vec_cond_mask_optab_fn(), expand_vector_operations_1(), expr_expected_value_1(), expr_hash_elt::expr_hash_elt(), factor_out_conditional_operation(), final_range_test_p(), 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(), find_tail_calls(), 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_known_nonzero_bits(), get_min_precision(), get_name_for_bit_test(), get_nonzero_bits(), 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_p(), gimple_assign_rhs_class(), gimple_assign_rhs_code(), gimple_assign_rhs_code(), gimple_assign_rhs_to_tree(), gimple_assign_unary_nop_p(), gimple_binop_def_p(), gimple_bitwise_inverted_equal_p(), gimple_convert_def_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_needing_rewrite_undefined(), 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(), 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_backedge_copies(), insert_init_stmt(), insert_predicates_for_cond(), 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_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(), long_mul_check_low_plus_defer(), long_mul_high_half_uses(), long_mul_is_lshift_def(), long_mul_linearize_chain(), long_mul_op_fits_p(), long_mul_split_operand(), crc_optimization::loop_may_calculate_crc(), loop_niter_by_eval(), lower_vec_perm(), match_arith_overflow(), match_long_mul(), match_long_mul_phi(), match_simplify_replacement(), match_single_bit_test(), match_uaddc_usubc(), maybe_duplicate_comparison(), 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(), movement_possibility_1(), multiple_of_p(), narrow_long_mul_operands(), negate_value(), predicate::normalize(), predicate::normalize(), number_of_iterations_cltz(), number_of_iterations_popcount(), one_feeding_comparison_into_p(), operand_equal_for_value_replacement(), 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(), parse_predicate(), phi_arg_from_cmp_p(), phiopt_early_allow(), phiprop_insert_phi(), plus_stmt_object_size(), possible_vector_mask_operation_p(), predicate_rhs_code(), 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(), recognise_vec_perm_simplify_seq(), 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(), replace_stmt_with_simplification(), repropagate_negates(), rewrite_bittest(), rewrite_expr_tree_parallel(), rewrite_to_defined_unconditional(), 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_builtin_call(), simplify_using_ranges::simplify_casted_compare(), simplify_using_ranges::simplify_compare_assign_using_ranges_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(), skip_a_safe_conversion_op(), slsr_process_add(), spaceship_replacement(), split_address_to_core_and_offset(), split_constant_offset_1(), ssa_defined_by_minus_one_stmt_p(), ssa_integral_conversion_op(), ssa_is_replaceable_p(), ssa_undefined_value_p(), ssa_uniform_vector_p(), stmt_cost(), stmt_cost(), stmt_could_throw_1_p(), 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(), uaddc_is_cplxpart(), uaddc_ne0(), unadjusted_ptr_and_unit_offset(), undistribute_bitref_for_vector(), undistribute_ops_list(), unexpandable_long_mul_p(), update_ops(), use_in_zero_equality(), va_list_counter_bump(), value_replacement(), valueized_wider_op(), vect_analyze_slp_reduc_chain(), vect_build_slp_tree_2(), vect_build_slp_tree_3(), 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_is_emulated_mixed_dot_prod(), vect_is_extending_load(), vect_is_integer_truncation(), vect_is_nonlinear_iv_evolution(), vect_is_truncating_store(), 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_cond_store_pattern(), vect_recog_divmod_pattern(), vect_recog_mask_conversion_pattern(), vect_recog_mod_var_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_lane_reducing(), 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(), 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)

◆ 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_assign_set_nontemporal_move(), GIMPLE_CHECK, and gimple::nontemporal_move.

Referenced by gimple_assign_set_nontemporal_move(), and 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]

◆ 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(), gimple_assign_set_rhs_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_assign_set_rhs_from_tree(), gimple_build_debug_inline_entry(), 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_aggr_zeroprop_1(), optimize_agr_copyprop_1(), 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_assign_single_p(), 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(), cond_store_replacement_limited(), strlen_pass::count_nonzero_bytes(), dse_optimize_redundant_stores(), dse_optimize_stmt(), eliminate_dom_walker::eliminate_stmt(), 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_single_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_analyze_stmt_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_vptr_store(), load_from_unmodified_param(), 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(), vars_ssa_cache::operator()(), optimize_aggr_zeroprop(), 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_memcpy_memset(), 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(), warn_switch_unreachable_and_auto_init_r(), 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(), gimple_assign_unary_nop_p(), is_gimple_assign(), TREE_TYPE, and TYPE_MODE.

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

◆ 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(), gimple_statement_assume::body, and gimple_assume_body().

Referenced by dump_gimple_assume(), gimple_assume_body(), 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(), gimple_statement_assume::body, and gimple_assume_body_ptr().

Referenced by gimple_assume_body_ptr(), 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(), gimple_assume_guard(), and gimple_statement_assume::guard.

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

◆ gimple_assume_guard_ptr()

tree * gimple_assume_guard_ptr ( gimple * gs)
inline

◆ 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(), gimple_assume_set_guard(), and gimple_statement_assume::guard.

Referenced by gimple_assume_set_guard(), 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, and gimple_bb().

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(), autofdo::afdo_indirect_call(), afdo_vpt_for_early_inline(), 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(), assume_query::assume_query(), back_propagate_equivalences(), base_names_in_chain_on(), ranger_cache::block_range(), branch_fixup(), addsub_pattern::build(), complex_pattern::build_common(), vect_optimize_slp_pass::build_vertices(), gori_map::calculate_gori(), assume_query::calculate_op(), assume_query::calculate_phi(), can_blend_vec_perm_simplify_seqs_p(), can_guard_call_p(), can_handle_load(), 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(), compute_final_value_from_loop_phi_latch(), crc_optimization::cond_depends_on_crc(), cond_on_phi_p(), cond_store_replacement(), cond_store_replacement_limited(), condition_info::condition_info(), 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_debug_stmts(), 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_simple_agr_dse(), 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(), 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(), tree_switch_conversion::switch_conversion::exp_index_transform(), 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_load(), 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(), crc_optimization::find_shift_after_xor(), find_single_drs(), find_ssa_names_to_propagate(), find_subloop_latch_edge_by_ivs(), find_tail_calls(), back_threader::find_taken_edge_cond(), find_taken_edge_cond_expr(), back_threader::find_taken_edge_goto(), 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(), remove_unreachable::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_iv(), get_later_stmt(), 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_bb(), 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_match_ctx(), 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(), gsi_end(), gsi_for_phi(), gsi_for_stmt(), gsi_last(), gsi_start(), gsi_start_phis(), strlen_pass::handle_assign(), strlen_pass::handle_builtin_memset(), 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(), ifcombine_mark_ssa_name(), ifcombine_replace_cond(), 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(), tree_switch_conversion::switch_conversion::is_exp_index_transform_viable(), is_factor_profitable(), 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(), long_mul_split_phi(), 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(), lazy_diagnostic_context_path::make_inner_path(), 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(), match_cond_with_binary_phi(), match_long_mul(), match_long_mul_phi(), may_eliminate_iv(), gori_map::maybe_add_gori(), maybe_diag_stxncpy_trunc(), maybe_duplicate_comparison(), 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_remove_forwarder_block(), 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_aggr_zeroprop_1(), optimize_agr_copyprop_1(), optimize_cands_for_speed_p(), crc_optimization::optimize_crc_loop(), 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_valid_reduction_input_p(), parm_preserved_before_stmt_p(), parm_ref_data_pass_through_p(), parm_ref_data_preserved_p(), crc_optimization::passes_checks_for_def_chain(), pcom_stmt_dominates_stmt_p(), loop_distribution::pg_add_dependence_edges(), phi_add_costs_1(), phi_rank(), phi_translate_1(), 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(), scc_copy_prop::propagate(), 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(), recognise_vec_perm_simplify_seq(), dom_oracle::recomputed_relation(), 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(), crc_optimization::set_crc_and_data_phi(), crc_optimization::set_defs(), 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_memchr(), simplify_builtin_memcpy_memset(), simplify_gimple_switch_label_vec(), simplify_using_ranges::simplify_switch_using_ranges(), ssa_propagation_engine::simulate_stmt(), single_use_in_loop(), sink_code_in_bb(), slpeel_tree_duplicate_loop_to_edge_cfg(), 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_loop(), 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(), 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(), substitute_and_fold_engine::substitute_and_fold(), 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(), trailing_store_in_bb(), 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(), unlikely_executed_stmt_p(), 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_analyze_slp_reduc_chain(), vect_bb_slp_mark_live_stmts(), vect_bb_vectorization_profitable_p(), vect_build_slp_tree_2(), vect_build_slp_tree_3(), 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_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_analyze_instance_dependence(), vect_slp_can_convert_to_external(), vect_slp_node_weight(), vect_stmt_dominates_stmt_p(), vect_stmt_relevant_p(), vect_transform_lc_phi(), vectorizable_early_exit(), vectorizable_induction(), 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(), warn_uninit_phi_uses(), and crc_optimization::xor_calculates_crc().

◆ gimple_bind_add_seq()

void gimple_bind_add_seq ( gbind * bind_stmt,
gimple_seq seq )
inline

◆ gimple_bind_add_stmt()

void gimple_bind_add_stmt ( gbind * bind_stmt,
gimple * stmt )
inline

◆ gimple_bind_append_vars()

void gimple_bind_append_vars ( gbind * bind_stmt,
tree vars )
inline

◆ 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, and gimple_bind_block().

Referenced by copy_gimple_bind(), declare_vars(), finalize_nesting_tree_1(), gimple_bind_block(), 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_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, gimple_bind_set_block(), NULL_TREE, and TREE_CODE.

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

◆ gimple_bind_set_body()

◆ gimple_bind_set_vars()

void gimple_bind_set_vars ( gbind * bind_stmt,
tree vars )
inline

◆ 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(), gimple_build_asm_vec(), i, and vec_safe_length().

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

◆ gimple_build_assign() [1/4]

◆ 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_build_bind()

◆ gimple_build_builtin_unreachable()

◆ 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(), 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_alloc(), gimple_build(), gimple_build(), gimple_build(), gimple_build(), gimple_build_builtin_unreachable(), gimple_build_call(), 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_fwrite(), gimple_fold_builtin_memory_chk(), gimple_fold_builtin_mempcpy(), gimple_fold_builtin_omp_get_initial_device(), gimple_fold_builtin_printf(), gimple_fold_builtin_realloc(), gimple_fold_builtin_snprintf(), gimple_fold_builtin_sprintf(), gimple_fold_builtin_stdarg(), 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_dispatch(), 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_interop(), lower_omp_master(), lower_omp_ordered(), lower_omp_scope(), lower_omp_sections(), lower_omp_single(), lower_omp_single_simple(), lower_omp_target(), 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(), optimize_tail_call(), replace_func_exit(), simd_clone_adjust(), split_update_decision_counter(), 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(), 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_and_insert(), build_saturation_binary_arith_call_and_replace(), 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_alloc(), gimple_build(), gimple_build(), gimple_build(), gimple_build(), gimple_build_call_internal(), 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_saturation_trunc(), match_single_bit_test(), match_spaceship(), match_uaddc_usubc(), match_unsigned_saturation_trunc(), maybe_add_asan_poison_write(), oacc_dim_call(), oacc_entry_exit_single_gang(), ompdevlow_adjust_simt_enter(), crc_optimization::optimize_crc_loop(), optimize_spaceship(), predicate_load_or_store(), scan_omp_simd(), simplify_count_zeroes(), split_function(), use_internal_fn(), vect_create_epilog_for_reduction(), vect_do_peeling(), vect_gen_loop_len_mask(), vect_gen_while(), vect_get_loop_iv_increment(), vect_gimple_build(), vect_recog_abd_pattern(), vect_recog_average_pattern(), vect_recog_build_binary_gimple_stmt(), vect_recog_cond_store_pattern(), 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_early_exit(), 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_build_call_valist(), gimple_call_set_arg(), i, is_gimple_call_addr(), and TREE_CODE.

Referenced by gimple_alloc(), gimple_build_call_valist(), and 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_build_catch(), gimple_catch_set_handler(), and gimple_catch_set_types().

Referenced by gimple_build_assign(), gimple_build_catch(), 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_cond(), 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(), tree_switch_conversion::switch_conversion::exp_index_transform(), 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(), gen_zero_len_conditions(), gimple_build_assign(), gimple_build_cond(), 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(), gimplify_omp_workshare(), 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_mask_stores(), scan_omp_simd(), simd_clone_adjust(), slpeel_tree_duplicate_loop_to_edge_cfg(), 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()

◆ 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 )

References all_warnings, annotate_all_with_location(), annotate_all_with_location_after(), copy_warning(), CXX_MEM_STAT_INFO, dump_decl_set(), dump_gimple_statistics(), empty_body_p(), get_gimple_rhs_num_ops(), gimple_asm_clobbers_memory_p(), gimple_assign_copy_p(), gimple_assign_load_p(), gimple_assign_rhs_could_trap_p(), gimple_assign_set_rhs_from_tree(), gimple_assign_set_rhs_with_ops(), gimple_assign_ssa_name_copy_p(), gimple_assign_unary_nop_p(), gimple_build_assume(), gimple_build_builtin_unreachable(), gimple_build_debug_inline_entry(), gimple_build_omp_atomic_load(), gimple_build_omp_atomic_store(), gimple_build_omp_continue(), gimple_build_omp_critical(), gimple_build_omp_dispatch(), gimple_build_omp_for(), gimple_build_omp_interop(), gimple_build_omp_masked(), gimple_build_omp_master(), gimple_build_omp_ordered(), gimple_build_omp_parallel(), gimple_build_omp_return(), gimple_build_omp_scan(), gimple_build_omp_scope(), gimple_build_omp_section(), gimple_build_omp_sections(), gimple_build_omp_sections_switch(), gimple_build_omp_single(), gimple_build_omp_structured_block(), gimple_build_omp_target(), gimple_build_omp_task(), gimple_build_omp_taskgroup(), gimple_build_omp_teams(), gimple_build_transaction(), gimple_builtin_call_types_compatible_p(), gimple_call_arg_flags(), gimple_call_builtin_p(), gimple_call_combined_fn(), gimple_call_copy_skip_args(), gimple_call_flags(), gimple_call_nonnull_arg(), gimple_call_nonnull_result_p(), gimple_call_operator_delete_p(), gimple_call_retslot_flags(), gimple_call_return_flags(), gimple_call_same_target_p(), gimple_call_static_chain_flags(), gimple_compare_field_offset(), gimple_copy(), gimple_could_trap_p(), gimple_could_trap_p_1(), gimple_get_alias_set(), gimple_get_lhs(), gimple_has_side_effects(), gimple_inexpensive_call_p(), gimple_ior_addresses_taken(), gimple_move_vops(), gimple_or_expr_nonartificial_location(), gimple_seq_add_seq(), gimple_seq_add_seq_without_update(), gimple_seq_add_stmt(), gimple_seq_add_stmt_without_update(), gimple_seq_copy(), gimple_seq_discard(), gimple_seq_set_location(), gimple_set_bb(), gimple_set_lhs(), gimple_signed_type(), gimple_unsigned_type(), infer_nonnull_range(), infer_nonnull_range_by_attribute(), infer_nonnull_range_by_dereference(), maybe_remove_unused_call_args(), nonbarrier_call_p(), nonfreeing_call_p(), NULL, preprocess_case_label_vec_for_gimple(), sort_case_labels(), stmt_can_terminate_bb_p(), suppress_warning(), and warning_suppressed_p().

◆ 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)

◆ gimple_build_eh_else()

◆ 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(), gimple_alloc(), gimple_build_eh_filter(), gimple_eh_filter_set_failure(), and gimple_eh_filter_set_types().

Referenced by gimple_build_assign(), gimple_build_eh_filter(), gimplify_expr(), and remap_gimple_stmt().

◆ gimple_build_eh_must_not_throw()

◆ gimple_build_goto()

◆ gimple_build_label()

glabel * gimple_build_label ( tree label)

◆ gimple_build_nop()

◆ gimple_build_omp_atomic_load()

◆ gimple_build_omp_atomic_store()

gomp_atomic_store * gimple_build_omp_atomic_store ( tree val,
enum omp_memory_order mo )

◆ 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_build_omp_continue(), gimple_omp_continue_set_control_def(), and gimple_omp_continue_set_control_use().

Referenced by create_parallel_loop(), expand_omp_for_generic(), gimple_build_debug_inline_entry(), gimple_build_omp_continue(), 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_build_omp_critical(), gimple_omp_critical_set_clauses(), gimple_omp_critical_set_name(), and gimple_omp_set_body().

Referenced by gimple_build_debug_inline_entry(), gimple_build_omp_critical(), gimplify_expr(), and remap_gimple_stmt().

◆ gimple_build_omp_dispatch()

gimple * gimple_build_omp_dispatch ( gimple_seq body,
tree clauses )
Build a GIMPLE_OMP_DISPATCH statement.

BODY is the target function call to be dispatched.
CLAUSES are any of the OMP dispatch construct's clauses.   

References gimple_alloc(), gimple_build_omp_dispatch(), gimple_omp_dispatch_set_clauses(), and gimple_omp_set_body().

Referenced by gimple_build_debug_inline_entry(), gimple_build_omp_dispatch(), gimplify_omp_dispatch(), 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_build_omp_for(), 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(), gimple_build_debug_inline_entry(), gimple_build_omp_for(), gimplify_omp_for(), and remap_gimple_stmt().

◆ gimple_build_omp_interop()

gimple * gimple_build_omp_interop ( tree clauses)
Build a GIMPLE_OMP_INTEROP statement.

CLAUSES are any of the OMP interop construct's clauses.   

References gimple_alloc(), gimple_build_omp_interop(), and gimple_omp_interop_set_clauses().

Referenced by gimple_build_debug_inline_entry(), gimple_build_omp_interop(), and gimplify_omp_interop().

◆ 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_build_omp_masked(), gimple_omp_masked_set_clauses(), and gimple_omp_set_body().

Referenced by gimple_build_debug_inline_entry(), gimple_build_omp_masked(), 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(), gimple_build_omp_master(), and gimple_omp_set_body().

Referenced by gimple_build_debug_inline_entry(), gimple_build_omp_master(), 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_build_omp_ordered(), gimple_omp_ordered_set_clauses(), and gimple_omp_set_body().

Referenced by gimple_build_debug_inline_entry(), gimple_build_omp_ordered(), 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_build_omp_parallel(), 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(), gimple_build_debug_inline_entry(), gimple_build_omp_parallel(), gimplify_omp_parallel(), and remap_gimple_stmt().

◆ gimple_build_omp_return()

◆ 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_build_omp_scan(), gimple_omp_scan_set_clauses(), and gimple_omp_set_body().

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

◆ gimple_build_omp_scope()

gimple * gimple_build_omp_scope ( gimple_seq body,
tree clauses )
Build a GIMPLE_OMP_SCOPE statement.

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

References gimple_alloc(), gimple_build_omp_scope(), gimple_omp_scope_set_clauses(), and gimple_omp_set_body().

Referenced by gimple_build_debug_inline_entry(), gimple_build_omp_scope(), gimplify_omp_workshare(), and remap_gimple_stmt().

◆ gimple_build_omp_section()

gimple * gimple_build_omp_section ( gimple_seq body)
Build a GIMPLE_OMP_SECTION statement for a sections statement.

BODY is the sequence of statements in the section.   

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

Referenced by gimple_build_debug_inline_entry(), gimple_build_omp_section(), gimplify_expr(), and remap_gimple_stmt().

◆ gimple_build_omp_sections()

gomp_sections * gimple_build_omp_sections ( gimple_seq body,
tree clauses )
Build a GIMPLE_OMP_SECTIONS statement.

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

References as_a(), gimple_alloc(), gimple_build_omp_sections(), gimple_omp_sections_set_clauses(), and gimple_omp_set_body().

Referenced by gimple_build_debug_inline_entry(), gimple_build_omp_sections(), gimplify_omp_workshare(), and remap_gimple_stmt().

◆ gimple_build_omp_sections_switch()

gimple * gimple_build_omp_sections_switch ( void )

◆ gimple_build_omp_single()

gomp_single * gimple_build_omp_single ( gimple_seq body,
tree clauses )
Build a GIMPLE_OMP_SINGLE statement.

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

References as_a(), gimple_alloc(), gimple_build_omp_single(), gimple_omp_set_body(), and gimple_omp_single_set_clauses().

Referenced by gimple_build_debug_inline_entry(), gimple_build_omp_single(), gimplify_omp_workshare(), and remap_gimple_stmt().

◆ gimple_build_omp_structured_block()

gimple * gimple_build_omp_structured_block ( gimple_seq body)
Build a GIMPLE_OMP_STRUCTURED_BLOCK statement.

BODY is the structured block sequence.   

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

Referenced by gimple_build_debug_inline_entry(), gimple_build_omp_structured_block(), gimplify_expr(), and remap_gimple_stmt().

◆ gimple_build_omp_target()

gomp_target * gimple_build_omp_target ( gimple_seq body,
int kind,
tree clauses,
gimple_seq iterator_loops )
Build a GIMPLE_OMP_TARGET statement.

BODY is the sequence of statements that will be executed.
KIND is the kind of the region.
CLAUSES are any of the construct's clauses.
ITERATOR_LOOPS is an optional sequence containing constructed loops
for OpenMP iterators.   

References as_a(), gimple_alloc(), gimple_build_omp_target(), gimple_omp_set_body(), gimple_omp_target_set_clauses(), gimple_omp_target_set_iterator_loops(), and gimple_omp_target_set_kind().

Referenced by gimple_build_debug_inline_entry(), gimple_build_omp_target(), gimplify_bind_expr(), gimplify_oacc_declare(), gimplify_omp_target_update(), gimplify_omp_workshare(), make_region_loop_nest(), make_region_seq(), maybe_build_inner_data_region(), omp_oacc_kernels_decompose_1(), and remap_gimple_stmt().

◆ gimple_build_omp_task()

gomp_task * gimple_build_omp_task ( gimple_seq body,
tree clauses,
tree child_fn,
tree data_arg,
tree copy_fn,
tree arg_size,
tree arg_align )
Build a GIMPLE_OMP_TASK statement.

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

References as_a(), copy_fn(), gimple_alloc(), gimple_build_omp_task(), gimple_omp_set_body(), gimple_omp_task_set_arg_align(), gimple_omp_task_set_arg_size(), gimple_omp_task_set_child_fn(), gimple_omp_task_set_clauses(), gimple_omp_task_set_copy_fn(), and gimple_omp_task_set_data_arg().

Referenced by gimple_build_debug_inline_entry(), gimple_build_omp_task(), gimplify_omp_for(), gimplify_omp_task(), and remap_gimple_stmt().

◆ gimple_build_omp_taskgroup()

gimple * gimple_build_omp_taskgroup ( gimple_seq body,
tree clauses )
Build a GIMPLE_OMP_TASKGROUP statement.

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

References gimple_alloc(), gimple_build_omp_taskgroup(), gimple_omp_set_body(), and gimple_omp_taskgroup_set_clauses().

Referenced by gimple_build_debug_inline_entry(), gimple_build_omp_taskgroup(), gimplify_expr(), and remap_gimple_stmt().

◆ gimple_build_omp_teams()

gomp_teams * gimple_build_omp_teams ( gimple_seq body,
tree clauses )
Build a GIMPLE_OMP_TEAMS statement.

BODY is the sequence of statements that will be executed.
CLAUSES are any of the OMP teams construct's clauses.   

References as_a(), gimple_alloc(), gimple_build_omp_teams(), gimple_omp_set_body(), and gimple_omp_teams_set_clauses().

Referenced by gimple_build_debug_inline_entry(), gimple_build_omp_teams(), gimplify_omp_workshare(), and remap_gimple_stmt().

◆ gimple_build_resx()

gresx * gimple_build_resx ( int region)

◆ gimple_build_return()

◆ gimple_build_switch()

gswitch * gimple_build_switch ( tree index,
tree default_label,
const vec< tree > & args )
Build a GIMPLE_SWITCH statement.

INDEX is the switch's index.
DEFAULT_LABEL is the default label
ARGS is a vector of labels excluding the default.   

References gimple_build_switch(), gimple_build_switch_nlabels(), gimple_switch_set_label(), and i.

Referenced by convert_if_conditions_to_switch(), tree_switch_conversion::jump_table_cluster::emit(), expand_omp_sections(), gimple_build_assign(), gimple_build_switch(), gimplify_switch_expr(), lower_eh_dispatch(), and lower_try_finally_switch().

◆ gimple_build_switch_nlabels()

gswitch * gimple_build_switch_nlabels ( unsigned nlabels,
tree index,
tree default_label )
The helper for constructing a gimple switch statement.
INDEX is the switch's index.
NLABELS is the number of labels in the switch excluding the default.
DEFAULT_LABEL is the default label for the switch statement.   

References as_a(), gcc_checking_assert, gimple_build_switch_nlabels(), gimple_build_with_ops, gimple_switch_set_default_label(), and gimple_switch_set_index().

Referenced by gimple_build_assign(), gimple_build_switch(), and gimple_build_switch_nlabels().

◆ gimple_build_transaction()

◆ gimple_build_try()

gtry * gimple_build_try ( gimple_seq eval,
gimple_seq cleanup,
enum gimple_try_flags kind )

◆ gimple_build_wce()

gimple * gimple_build_wce ( gimple_seq cleanup)
Construct a GIMPLE_WITH_CLEANUP_EXPR statement.

CLEANUP is the cleanup expression.   

References gimple_alloc(), gimple_build_wce(), and gimple_wce_set_cleanup().

Referenced by gimple_build_assign(), gimple_build_wce(), gimple_push_cleanup(), and remap_gimple_stmt().

◆ gimple_builtin_call_types_compatible_p()

◆ gimple_call_alloca_for_var_p() [1/2]

◆ gimple_call_alloca_for_var_p() [2/2]

bool gimple_call_alloca_for_var_p ( gimple * s)
inline

◆ gimple_call_arg() [1/2]

tree gimple_call_arg ( const gcall * gs,
unsigned index )
inline
Return the argument at position INDEX for call statement GS.   

References gcc_gimple_checking_assert, gimple_call_arg(), gimple_num_ops(), and gcall::op.

Referenced by _loop_vec_info::_loop_vec_info(), acceptable_pow_call(), access_with_size_object_size(), add_mask_else_and_len_args(), strlen_pass::adjust_last_stmt(), adjust_pointer_diff_expr(), adjust_simduid_builtins(), alloc_object_size(), alloca_call_type(), analyze_function_body(), arith_overflow_arg_kind(), asan_expand_check_ifn(), asan_expand_mark_ifn(), asan_mark_p(), attempt_builtin_copysign(), bit_value_assume_aligned(), addsub_pattern::build(), builtin_call_nomodifying_p(), builtin_setjmp_setup_bb(), call_arg(), call_may_clobber_ref_p_1(), callback_is_special_cased(), can_group_stmts_p(), can_interpret_as_conditional_op_p(), can_remove_asan_check(), can_shrink_wrap_len_p(), gimple_infer_range::check_assume_func(), check_builtin_call(), check_fnspec(), check_omp_nesting_restrictions(), check_pow(), check_reduction_path(), check_stmt_for_type_change(), ipa_icf_gimple::func_checker::compare_gimple_call(), compatible_calls_p(), cond_removal_in_builtin_zero_pattern(), convert_expand_mult_copysign(), convert_gimple_call(), copy_edges_for_bb(), copy_reference_ops_from_call(), decompose_param_expr(), decrement_power(), default_goacc_reduction(), delete_dead_or_redundant_call(), direct_internal_fn_types(), discover_nonconstant_array_refs(), dse_optimize_redundant_stores(), dse_optimize_stmt(), dump_gimple_call(), dump_gimple_call_args(), dump_oacc_loop_part(), dynamic_object_sizes_execute_one(), early_object_sizes_execute_one(), eliminate_tail_call(), eliminate_unnecessary_stmts(), emit_cmp_and_jump_insns(), estimate_num_insns(), evaluate_properties_for_edge(), evaluate_stmt(), execute_early_expand_coro_ifns(), execute_oacc_device_lower(), execute_omp_device_lower(), execute_omp_oacc_neuter_broadcast(), execute_update_addresses_taken(), exist_non_indexing_operands_for_use_p(), expand_ACCESS_WITH_SIZE(), expand_arith_overflow(), expand_BITINTTOFLOAT(), expand_bitquery(), expand_block_edges(), expand_BUILTIN_EXPECT(), expand_call_inline(), expand_call_mem_ref(), expand_call_stmt(), expand_crc_optab_fn(), expand_DEFERRED_INIT(), expand_DIVMOD(), expand_DIVMODBITINT(), expand_FLOATTOBITINT(), expand_fn_using_insn(), expand_gather_load_optab_fn(), expand_GOACC_DIM_POS(), expand_GOACC_DIM_SIZE(), expand_GOMP_SIMT_ENTER_ALLOC(), expand_GOMP_SIMT_EXIT(), expand_GOMP_SIMT_LAST_LANE(), expand_GOMP_SIMT_ORDERED_PRED(), expand_GOMP_SIMT_VOTE_ANY(), expand_GOMP_SIMT_XCHG_BFLY(), expand_GOMP_SIMT_XCHG_IDX(), expand_HWASAN_ALLOCA_POISON(), expand_HWASAN_ALLOCA_UNPOISON(), expand_HWASAN_MARK(), expand_HWASAN_SET_TAG(), expand_ifn_atomic_bit_test_and(), expand_ifn_atomic_compare_exchange(), expand_ifn_atomic_compare_exchange_into_call(), expand_ifn_atomic_op_fetch_cmp_0(), expand_ifn_va_arg_1(), expand_LAUNDER(), expand_load_lanes_optab_fn(), expand_MULBITINT(), expand_partial_load_optab_fn(), expand_partial_store_optab_fn(), expand_POPCOUNT(), expand_RAWMEMCHR(), expand_reduc_sbool_optab_fn(), expand_scatter_store_optab_fn(), expand_SPACESHIP(), expand_store_lanes_optab_fn(), expand_strided_load_optab_fn(), expand_strided_store_optab_fn(), expand_UADDC(), expand_UBSAN_CHECK_ADD(), expand_UBSAN_CHECK_MUL(), expand_UBSAN_CHECK_SUB(), expand_UNIQUE(), expand_vec_cond_mask_optab_fn(), expand_vec_set_optab_fn(), expand_vector_conversion(), expand_while_optab_fn(), expr_expected_value_1(), expr_hash_elt::expr_hash_elt(), find_foldable_builtin_expect(), find_func_aliases_for_builtin_call(), find_func_aliases_for_call(), find_func_clobbers(), find_gang_private_vars(), find_tail_calls(), fold_builtin_alloca_with_align(), fold_builtin_atomic_compare_exchange(), ccp_folder::fold_stmt(), fold_stmt_1(), fold_strstr_to_strncmp(), gen_conditions_for_pow(), gen_shrink_wrap_conditions(), get_alias_ptr_type_for_ptr_address(), modref_access_node::get_call_arg(), get_mem_refs_of_builtin_call(), get_mem_type_for_internal_fn(), get_references_in_stmt(), get_string_length(), get_upper_bound_based_on_builtin_expr_with_prob(), gimple_arg(), gimple_builtin_call_types_compatible_p(), gimple_call_alloc_size(), gimple_call_arg(), gimple_call_arg(), gimple_call_copy_skip_args(), gimple_call_integer_valued_real_p(), gimple_call_nonnegative_p(), gimple_call_nonnull_arg(), gimple_call_return_array(), gimple_equal_p(), gimple_expand_builtin_cabs(), gimple_extract(), gimple_fold_builtin(), gimple_fold_builtin_bcmp(), gimple_fold_builtin_bcopy(), gimple_fold_builtin_bzero(), gimple_fold_builtin_call_info(), gimple_fold_builtin_clear_padding(), gimple_fold_builtin_constant_p(), gimple_fold_builtin_fwrite(), gimple_fold_builtin_memchr(), gimple_fold_builtin_memory_op(), gimple_fold_builtin_mempcpy(), gimple_fold_builtin_memset(), gimple_fold_builtin_realloc(), gimple_fold_builtin_snprintf(), gimple_fold_builtin_snprintf_chk(), gimple_fold_builtin_sprintf(), gimple_fold_builtin_sprintf_chk(), gimple_fold_builtin_stdarg(), gimple_fold_builtin_stpcpy(), gimple_fold_builtin_strcat_chk(), gimple_fold_builtin_strchr(), gimple_fold_builtin_string_compare(), gimple_fold_builtin_strlen(), gimple_fold_builtin_strncat(), gimple_fold_builtin_strncat_chk(), gimple_fold_builtin_strstr(), gimple_fold_call(), gimple_fold_partial_load_store(), gimple_fold_partial_load_store_mem_ref(), gimple_fold_stmt_to_constant_1(), gimple_infer_range::gimple_infer_range(), gimple_lower_bitint(), gimple_stringop_fixed_value(), gimple_stringops_transform(), gimple_stringops_values_to_profile(), strlen_pass::handle_assign(), handle_builtin_alloca(), strlen_pass::handle_builtin_memcpy(), strlen_pass::handle_builtin_memset(), handle_builtin_stack_restore(), strlen_pass::handle_builtin_strcat(), strlen_pass::handle_builtin_strchr(), strlen_pass::handle_builtin_strcpy(), strlen_pass::handle_builtin_string_cmp(), strlen_pass::handle_builtin_strlen(), strlen_pass::handle_builtin_stxncpy_strncat(), handle_lhs_call(), handle_printf_call(), handle_rhs_call(), has_dominating_ubsan_ptr_check(), infer_loop_bounds_from_array(), infer_nonnull_range_by_attribute(), initialize_ao_ref_for_dse(), initialize_inlined_parameters(), instrument_builtin(), instrument_builtin_call(), instrument_nonnull_arg(), ipa_analyze_controlled_uses(), ipa_compute_jump_functions_for_edge(), ipa_modref_callee_reads_no_memory_p(), ipa_pta_execute(), is_addr_local(), is_asan_mark_p(), is_copysign_call_with_1(), is_exit_with_zero_arg(), is_removable_allocation_p(), is_removable_cxa_atexit_call(), is_strlen_related_p(), lower_builtin_assume_aligned(), lower_builtin_posix_memalign(), lower_builtin_setjmp(), lower_coro_builtin(), lower_stmt(), mark_reachable_handlers(), mark_stmt_if_obviously_necessary(), match_single_bit_test(), match_uaddc_usubc(), gimple_range_op_handler::maybe_builtin_call(), maybe_dead_abnormal_edge_p(), maybe_diag_stxncpy_trunc(), maybe_instrument_call(), maybe_optimize_arith_overflow(), maybe_optimize_asan_check_ifn(), maybe_optimize_ubsan_null_ifn(), maybe_optimize_ubsan_ptr_ifn(), maybe_optimize_ubsan_vptr_ifn(), maybe_trim_memstar_call(), strlen_pass::maybe_warn_overflow(), maybe_warn_pass_by_reference(), ipa_param_adjustments::modify_call(), ipa_param_body_adjustments::modify_call_stmt(), move_sese_region_to_fn(), move_stmt_r(), neuter_worker_single(), new_oacc_loop(), nonfreeing_call_p(), note_simd_array_uses(), oacc_get_ifn_dim_arg(), oacc_loop_discover_walk(), oacc_loop_process(), oacc_loop_xform_head_tail(), oacc_xform_loop(), oacc_xform_tile(), object_sizes_execute(), omp_sese_find_par(), omp_sese_split_blocks(), ompdevlow_adjust_simt_enter(), optimize_aggr_zeroprop(), optimize_aggr_zeroprop_1(), optimize_atomic_compare_exchange_p(), optimize_mask_stores(), optimize_recip_sqrt(), optimize_stack_restore(), optimize_strlen_comp(), optimize_va_list_gpr_fpr_size(), param_change_prob(), partial_load_store_mask_state(), pass_through_call(), predicate_statements(), predict_loops(), propagate_necessity(), cgraph_edge::redirect_call_stmt_to_callee(), ref_maybe_used_by_call_p_1(), remap_gimple_stmt(), replace_loop_annotate(), replace_loop_annotate_in_block(), same_handler_p(), same_succ_hash(), scan_function(), set_cond_stmt_execution_predicate(), set_uid_loop_bbs(), shrink_wrap_conditional_dead_built_in_calls(), shrink_wrap_len_call(), simplify_builtin_call(), simplify_builtin_memchr(), simplify_builtin_memcmp(), simplify_builtin_memcpy_memset(), simplify_using_ranges::simplify_internal_call_using_ranges(), sra_modify_deferred_init(), stmt_is_power_of_op(), stmt_kills_ref_p(), strdup_object_size(), strip_predict_hints(), suitable_for_tail_call_opt_p(), tm_memopt_accumulate_memops(), tm_memopt_value_number(), try_vectorize_loop_1(), ubsan_expand_bounds_ifn(), ubsan_expand_null_ifn(), ubsan_expand_objsize_ifn(), ubsan_expand_ptr_ifn(), ubsan_expand_vptr_ifn(), use_internal_fn(), validate_gimple_arglist(), vect_analyze_loop_form(), vect_build_slp_tree_3(), vect_describe_gather_scatter_call(), vect_find_stmt_data_reference(), vect_get_datarefs_in_loop(), vect_get_load_store_mask(), vect_get_store_rhs(), vect_loop_dist_alias_call(), vect_loop_vectorized_call(), vect_mark_stmts_to_be_vectorized(), vect_recog_ctz_ffs_pattern(), vect_recog_mask_conversion_pattern(), vect_recog_popcount_clz_ctz_ffs_pattern(), vect_recog_pow_pattern(), vect_recog_rotate_pattern(), vect_recog_sad_pattern(), vect_recog_widen_abd_pattern(), vect_simd_lane_linear(), vect_transform_loop(), vectorizable_call(), vectorizable_simd_clone_call(), verify_gimple_call(), visit_reference_op_call(), vn_reference_lookup_3(), walk_gimple_op(), walk_stmt_load_store_addr_ops(), warn_switch_unreachable_and_auto_init_r(), and warn_uninit().

◆ gimple_call_arg() [2/2]

tree gimple_call_arg ( const gimple * gs,
unsigned index )
inline

◆ gimple_call_arg_flags()

◆ gimple_call_arg_ptr() [1/2]

◆ gimple_call_arg_ptr() [2/2]

tree * gimple_call_arg_ptr ( gimple * gs,
unsigned index )
inline

◆ gimple_call_builtin_p() [1/3]

bool gimple_call_builtin_p ( const gimple * stmt)
extern
Return true when STMT is builtins call.   

References DECL_BUILT_IN_CLASS, gimple_builtin_call_types_compatible_p(), gimple_call_builtin_p(), gimple_call_fndecl(), is_gimple_call(), NOT_BUILT_IN, and NULL_TREE.

Referenced by back_threader_profitability::account_bb(), adjust_pointer_diff_expr(), alloc_object_size(), alloca_call_type(), analyze_function_body(), branch_prob(), builtin_call_nomodifying_p(), builtin_setjmp_setup_bb(), builtin_unreachable_bb_p(), call_object_size(), can_shrink_wrap_len_p(), strlen_pass::check_and_optimize_call(), check_call(), check_defs(), check_fnspec(), check_forbidden_calls(), cleanup_empty_eh(), create_expression_by_pieces(), decide_copy_try_finally(), dse_classify_store(), dse_optimize_redundant_stores(), dse_optimize_stmt(), eliminate_unnecessary_stmts(), empty_eh_cleanup(), estimate_num_insns(), evaluate_stmt(), execute_cleanup_cfg_post_optimizing(), execute_omp_device_lower(), expand_block_edges(), find_foldable_builtin_expect(), find_func_aliases_for_builtin_call(), find_func_clobbers(), find_tail_calls(), fixup_noreturn_call(), ccp_folder::fold_stmt(), fold_strstr_to_strncmp(), get_mem_refs_of_builtin_call(), get_references_in_stmt(), gimple_build_debug_inline_entry(), gimple_call_alloc_size(), gimple_call_builtin_p(), gimple_call_builtin_p(), gimple_call_builtin_p(), gimple_call_fnspec(), gimple_call_initialize_ctrl_altering(), gimple_call_return_array(), gimple_could_trap_p_1(), gimple_fold_call(), gimple_seq_unreachable_p(), gimple_stringops_transform(), gimple_stringops_values_to_profile(), gimple_verify_flow_info(), handle_printf_call(), has_stmt_been_instrumented_p(), if_convertible_stmt_p(), ifcvt_can_predicate(), access_ref::inform_access(), initialize_ao_ref_for_dse(), insert_clobber_before_stack_restore(), insert_clobbers_for_var(), instrument_builtin_call(), instrument_func_exit(), instrument_gimple(), instrument_object_size(), ipa_pta_execute(), is_addr_local(), is_exit_with_zero_arg(), is_strlen_related_p(), is_sync_builtin_call(), lower_stmt(), make_edges(), make_edges_bb(), mark_reachable_handlers(), mark_stmt_if_obviously_necessary(), maybe_dead_abnormal_edge_p(), maybe_fold_stmt(), maybe_instrument_call(), maybe_warn_operand(), strlen_pass::maybe_warn_overflow(), maybe_warn_pass_by_reference(), nonfreeing_call_p(), object_sizes_execute(), optimize_aggr_zeroprop(), optimize_aggr_zeroprop_1(), optimize_atomic_compare_exchange_p(), optimize_clobbers(), pass_through_call(), predicate_statements(), propagate_necessity(), jump_threader::record_temporary_equivalences_from_stmts_at_dest(), replacement_internal_fn(), sanopt_optimize_walker(), set_cond_stmt_execution_predicate(), split_critical_edges(), stmt_kills_ref_p(), unlikely_executed_stmt_p(), valid_builtin_call(), vect_recog_pow_pattern(), vect_recog_rotate_pattern(), vect_transform_loop(), vectorizable_call(), vn_reference_lookup_3(), and warn_switch_unreachable_and_auto_init_r().

◆ gimple_call_builtin_p() [2/3]

bool gimple_call_builtin_p ( const gimple * stmt,
enum built_in_class klass )
extern

◆ gimple_call_builtin_p() [3/3]

bool gimple_call_builtin_p ( const gimple * stmt,
enum built_in_function code )
extern
Return true when STMT is builtins call to CODE of CLASS.   

References fndecl_built_in_p(), gimple_builtin_call_types_compatible_p(), gimple_call_builtin_p(), gimple_call_fndecl(), is_gimple_call(), and NULL_TREE.

◆ gimple_call_by_descriptor_p()

bool gimple_call_by_descriptor_p ( gcall * s)
inline
Return true if S is a by-descriptor call.   

References GF_CALL_BY_DESCRIPTOR, and gimple_call_by_descriptor_p().

Referenced by expand_call_stmt(), and gimple_call_by_descriptor_p().

◆ gimple_call_chain() [1/2]

◆ gimple_call_chain() [2/2]

tree gimple_call_chain ( const gimple * gs)
inline

◆ gimple_call_chain_ptr()

tree * gimple_call_chain_ptr ( gcall * call_stmt)
inline
Return a pointer to the static chain for call statement CALL_STMT.   

References gimple_call_chain_ptr(), and gcall::op.

Referenced by gimple_call_chain_ptr(), sra_modify_function_body(), and walk_gimple_op().

◆ gimple_call_clobber_set() [1/2]

const pt_solution * gimple_call_clobber_set ( const gcall * call_stmt)
inline
As above, but const.   

References gcall::call_clobbered, and gimple_call_clobber_set().

◆ gimple_call_clobber_set() [2/2]

struct pt_solution * gimple_call_clobber_set ( gcall * call_stmt)
inline

◆ gimple_call_combined_fn()

◆ gimple_call_copy_flags()

void gimple_call_copy_flags ( gcall * dest_call,
gcall * orig_call )
inline

◆ gimple_call_copy_skip_args()

◆ gimple_call_ctrl_altering_p() [1/2]

◆ gimple_call_ctrl_altering_p() [2/2]

bool gimple_call_ctrl_altering_p ( const gimple * gs)
inline

◆ gimple_call_expected_throw_p()

bool gimple_call_expected_throw_p ( gcall * s)
inlinestatic
Return true if S is a call that is more likely to end by
propagating an exception than by other means.   

References ECF_XTHROW, and gimple_call_flags().

◆ gimple_call_flags()

int gimple_call_flags ( const gimple * stmt)
Detect flags from a GIMPLE_CALL.  This is just like
call_expr_flags, but for gimple tuples.   

References ECF_BY_DESCRIPTOR, ECF_NOTHROW, ECF_XTHROW, flags_from_decl_or_type(), GF_CALL_BY_DESCRIPTOR, GF_CALL_NOTHROW, GF_CALL_XTHROW, gimple_call_flags(), gimple_call_fndecl(), gimple_call_fntype(), gimple_call_internal_fn(), gimple_call_internal_p(), and internal_fn_flags().

Referenced by auto_simd_check_stmt(), branch_prob(), build_access_from_call_arg(), build_and_add_sum(), call_can_make_abnormal_goto(), call_may_clobber_ref_p_1(), check_call(), check_stmt_for_type_change(), cleanup_call_ctrl_altering_flag(), compute_avail(), compute_points_to_sets(), copy_edges_for_bb(), determine_max_movement(), determine_unlikely_bbs(), do_simple_agr_dse(), dse_optimize_call(), edge_before_returns_twice_call(), execute_fixup_cfg(), expand_block_edges(), expr_hash_elt::expr_hash_elt(), find_func_aliases_for_call(), ccp_folder::fold_stmt(), gather_memory_references(), get_references_in_stmt(), gimple_build_debug_inline_entry(), gimple_call_expected_throw_p(), gimple_call_flags(), gimple_call_initialize_ctrl_altering(), gimple_call_noreturn_p(), gimple_call_nothrow_p(), gimple_call_reset_alias_info(), gimple_call_return_flags(), gimple_can_duplicate_bb_p(), gimple_has_side_effects(), gimple_regimplify_operands(), gimple_verify_flow_info(), gsi_replace_with_seq_vops(), gsi_safe_insert_before(), gsi_safe_insert_seq_before(), if_convertible_stmt_p(), ipa_modref_callee_reads_no_memory_p(), ipa_pta_execute(), is_tm_pure_call(), make_edges(), operands_scanner::maybe_add_call_vops(), maybe_warn_pass_by_reference(), nonbarrier_call_p(), nonfreeing_call_p(), notice_special_calls(), cgraph_edge::rebuild_edges(), ref_maybe_used_by_call_p_1(), should_duplicate_loop_header_p(), statement_sink_location(), stmt_can_terminate_bb_p(), stmt_may_terminate_function_p(), stmt_starts_bb_p(), thread_private_new_memory(), tree_estimate_loop_size(), vect_finish_stmt_generation(), vect_slp_function(), visit_reference_op_call(), visit_stmt(), and will_be_nonconstant_predicate().

◆ gimple_call_fn() [1/2]

tree gimple_call_fn ( const gcall * gs)
inline

◆ gimple_call_fn() [2/2]

tree gimple_call_fn ( const gimple * gs)
inline

◆ gimple_call_fn_ptr() [1/2]

tree * gimple_call_fn_ptr ( gcall * gs)
inline
Return a pointer to the tree node representing the function called by call
statement GS.   

References gimple_call_fn_ptr(), and gcall::op.

Referenced by gimple_call_fn_ptr(), gimple_call_fn_ptr(), and walk_gimple_op().

◆ gimple_call_fn_ptr() [2/2]

tree * gimple_call_fn_ptr ( gimple * gs)
inline

◆ gimple_call_fndecl() [1/2]

tree gimple_call_fndecl ( const gcall * gs)
inline
If a given GIMPLE_CALL's callee is a FUNCTION_DECL, return it.
Otherwise return NULL.  This function is analogous to
get_callee_fndecl in tree land.   

References gimple_call_addr_fndecl(), gimple_call_fn(), and gimple_call_fndecl().

Referenced by add_call_edges_for_seq(), strlen_pass::adjust_last_stmt(), autofdo::afdo_indirect_call(), alloc_object_size(), attempt_builtin_copysign(), auto_simd_check_stmt(), builtin_call_nomodifying_p(), call_may_clobber_ref_p_1(), can_test_argument_range(), cgraph_update_edges_for_call_stmt_node(), strlen_pass::check_and_optimize_call(), check_bounds_or_overlap(), check_call(), check_defs(), check_fnspec(), check_omp_nesting_restrictions(), check_stmt_for_type_change(), cgraph_edge::clone(), convert_gimple_call(), convert_tramp_reference_stmt(), copy_bb(), pointer_analysis::determine_global_memory_access(), do_warn_unused_result(), dse_optimize_call(), dse_optimize_redundant_stores(), dse_optimize_stmt(), dump_ic_profile(), edom_only_function(), effective_strub_mode_for_call(), estimate_bb_frequencies(), estimate_num_insns(), evaluate_stmt(), examine_call_tm(), execute_fixup_cfg(), execute_omp_device_lower(), expand_call_stmt(), expand_call_tm(), expr_expected_value_1(), find_func_aliases_for_builtin_call(), find_func_aliases_for_call(), find_func_clobbers(), find_replaceable_in_bb(), find_tail_calls(), fold_builtin_atomic_compare_exchange(), fold_call_stmt(), fold_marked_statements(), gen_shrink_wrap_conditions(), get_callee_fndecl(), get_mem_refs_of_builtin_call(), get_modref_function_summary(), get_string_length(), get_upper_bound_based_on_builtin_expr_with_prob(), gimple_alloca_call_p(), gimple_call_alloc_p(), gimple_call_alloc_size(), gimple_call_arg_flags(), gimple_call_builtin_p(), gimple_call_builtin_p(), gimple_call_builtin_p(), gimple_call_combined_fn(), gimple_call_flags(), gimple_call_fndecl(), gimple_call_fndecl(), gimple_call_fnspec(), gimple_call_initialize_ctrl_altering(), gimple_call_nonnull_arg(), gimple_call_nonnull_result_p(), gimple_call_operator_delete_p(), gimple_call_retslot_flags(), gimple_call_return_array(), gimple_call_same_target_p(), gimple_call_static_chain_flags(), gimple_could_trap_p_1(), gimple_fold_builtin(), gimple_fold_builtin_stdarg(), gimple_fold_builtin_strcpy(), gimple_fold_builtin_string_compare(), gimple_fold_builtin_strncat(), gimple_fold_builtin_strncpy(), gimple_fold_builtin_stxcpy_chk(), gimple_fold_call(), gimple_indirect_call_to_profile(), gimple_inexpensive_call_p(), gimple_maybe_alloca_call_p(), gimple_regimplify_operands(), gimple_stringops_transform(), strlen_pass::handle_assign(), handle_builtin_alloca(), strlen_pass::handle_builtin_memset(), strlen_pass::handle_builtin_strlen(), strlen_pass::handle_builtin_stxncpy_strncat(), handle_printf_call(), if_convertible_simdclone_stmt_p(), ifcvt_can_predicate(), access_ref::inform_access(), initialize_ao_ref_for_dse(), inline_forbidden_p_stmt(), instrument_builtin(), instrument_builtin_call(), instrument_gimple(), interesting_stringop_to_profile_p(), ipa_profile_generate_summary(), ipa_pta_execute(), ipa_tm_decrement_clone_counts(), ipa_tm_diagnose_transaction(), ipa_tm_scan_calls_block(), ipa_tm_transform_calls_redirect(), is_addr_local(), is_removable_allocation_p(), is_removable_cxa_atexit_call(), is_strlen_related_p(), is_sync_builtin_call(), is_tm_ending(), is_tm_load(), is_tm_simple_load(), is_tm_simple_store(), is_tm_store(), loop_body_includes_call(), lower_coro_builtin(), lower_eh_constructs_2(), lower_omp_1(), lower_stmt(), malloc_candidate_p_1(), mark_all_reaching_defs_necessary_1(), mark_stmt_if_obviously_necessary(), autofdo::function_instance::match(), matching_alloc_calls_p(), maybe_diag_stxncpy_trunc(), maybe_instrument_call(), maybe_invalidate(), maybe_remove_unused_call_args(), maybe_trim_memstar_call(), maybe_warn_operand(), strlen_pass::maybe_warn_overflow(), maybe_warn_pass_by_reference(), maybe_warn_pointless_strcmp(), ipa_param_adjustments::modify_call(), move_stmt_r(), nonfreeing_call_p(), oacc_loop_discover_walk(), omp_sese_active_worker_call(), optimize_atomic_compare_exchange_p(), optimize_omp_library_calls(), optimize_stack_restore(), dom_opt_dom_walker::optimize_stmt(), optimize_va_list_gpr_fpr_size(), predicate_rhs_code(), predict_loops(), propagate_necessity(), fold_using_range::range_of_call(), cgraph_edge::rebuild_edges(), jump_threader::record_temporary_equivalences_from_stmts_at_dest(), cgraph_edge::redirect_call_stmt_to_callee(), ref_maybe_used_by_call_p_1(), remap_gimple_stmt(), replacement_internal_fn(), scan_omp_1_stmt(), cgraph_edge::set_call_stmt(), simplify_builtin_memcmp(), simplify_builtin_memcpy_memset(), stack_protect_return_slot_p(), stmt_can_terminate_bb_p(), stmt_cost(), stmt_kills_ref_p(), strip_predict_hints(), strub_call_fntype_override_p(), surely_varying_stmt_p(), tm_region_init_1(), tree_bb_level_predictions(), tree_estimate_probability_bb(), tree_profiling(), ubsan_create_edge(), unlikely_executed_stmt_p(), valid_builtin_call(), valid_new_delete_pair_p(), vect_get_datarefs_in_loop(), vect_recog_pow_pattern(), vect_recog_rotate_pattern(), vectorizable_call(), vectorizable_simd_clone_call(), verify_gimple_call(), cgraph_node::verify_node(), visit_bb(), and warn_dealloc_offset().

◆ gimple_call_fndecl() [2/2]

tree gimple_call_fndecl ( const gimple * gs)
inline

◆ gimple_call_fntype() [1/2]

◆ gimple_call_fntype() [2/2]

tree gimple_call_fntype ( const gimple * gs)
inline

◆ gimple_call_from_new_or_delete()

bool gimple_call_from_new_or_delete ( const gcall * s)
inline

◆ gimple_call_from_thunk_p()

bool gimple_call_from_thunk_p ( gcall * s)
inline

◆ gimple_call_internal_fn() [1/2]

enum internal_fn gimple_call_internal_fn ( const gcall * gs)
inline
Return the target of internal call GS.   

References gcc_gimple_checking_assert, gimple_call_internal_fn(), gimple_call_internal_p(), and gcall::u.

Referenced by _loop_vec_info::_loop_vec_info(), inchash::add_hashable_expr(), add_mask_else_and_len_args(), adjust_imagpart_expr(), adjust_simduid_builtins(), arith_overflow_arg_kind(), branch_prob(), build_bitint_stmt_ssa_conflicts(), call_may_clobber_ref_p_1(), can_group_stmts_p(), can_interpret_as_conditional_op_p(), check_defs(), ipa_icf_gimple::func_checker::compare_gimple_call(), copy_bb(), copy_edges_for_bb(), copy_reference_ops_from_call(), direct_internal_fn_supported_p(), discover_nonconstant_array_refs(), dse_optimize_stmt(), dump_gimple_call(), dump_gimple_call_args(), eliminate_unnecessary_stmts(), emit_cmp_and_jump_insns(), execute_early_expand_coro_ifns(), execute_oacc_device_lower(), execute_omp_device_lower(), execute_omp_oacc_neuter_broadcast(), exist_non_indexing_operands_for_use_p(), expand_ifn_atomic_bit_test_and(), expand_ifn_atomic_op_fetch_cmp_0(), expand_internal_call(), expand_scatter_store_optab_fn(), expand_strided_store_optab_fn(), expr_expected_value_1(), fold_internal_goacc_dim(), get_address_cost(), get_alias_ptr_type_for_ptr_address(), get_mem_type_for_internal_fn(), get_references_in_stmt(), gimple_call_combined_fn(), gimple_call_copy_skip_args(), gimple_call_flags(), gimple_call_fnspec(), gimple_call_internal_fn(), gimple_call_internal_fn(), gimple_call_internal_p(), gimple_call_internal_unique_p(), gimple_call_same_target_p(), gimple_extract(), gimple_fold_call(), gimple_fold_partial_load_store(), gimple_fold_stmt_to_constant_1(), gimple_infer_range::gimple_infer_range(), gimple_lower_bitint(), ifcvt_can_hoist(), initialize_ao_ref_for_dse(), input_function(), likely_value(), lower_coro_builtin(), match_uaddc_usubc(), merge_stmts_p(), nonfreeing_call_p(), note_simd_array_uses(), oacc_get_ifn_dim_arg(), oacc_loop_discover_walk(), oacc_loop_process(), output_gimple_stmt(), partial_load_store_mask_state(), expr_hash_elt::print(), ref_maybe_used_by_call_p_1(), remap_gimple_stmt(), replace_loop_annotate(), replace_loop_annotate_in_block(), same_succ_hash(), sanopt_optimize_walker(), simplify_using_ranges::simplify_internal_call_using_ranges(), ssa_is_replaceable_p(), strip_predict_hints(), try_vectorize_loop_1(), vect_analyze_slp(), vect_analyze_slp_instance(), vect_build_slp_tree_2(), vect_check_gather_scatter(), vect_check_store_rhs(), vect_describe_gather_scatter_call(), vect_find_stmt_data_reference(), vect_get_and_check_slp_defs(), vect_get_load_store_mask(), vect_get_operand_map(), vect_get_store_rhs(), vect_get_vector_types_for_stmt(), vect_recog_mask_conversion_pattern(), vect_recog_sad_pattern(), vect_recog_widen_abd_pattern(), vect_transform_loop(), vectorizable_call(), vectorizable_conversion(), vectorizable_load(), vectorizable_store(), and vn_reference_lookup_3().

◆ gimple_call_internal_fn() [2/2]

enum internal_fn gimple_call_internal_fn ( const gimple * gs)
inline

◆ gimple_call_internal_p() [1/3]

bool gimple_call_internal_p ( const gcall * gs)
inline
Return true if call GS calls an internal-only function, as enumerated
by internal_fn.   

References GF_CALL_INTERNAL, gimple_call_internal_p(), and gimple::subcode.

Referenced by _loop_vec_info::_loop_vec_info(), access_with_size_object_size(), back_threader_profitability::account_bb(), inchash::add_hashable_expr(), adjust_imagpart_expr(), adjust_simduid_builtins(), autofdo::afdo_indirect_call(), analyze_function_body(), arith_overflow_arg_kind(), asan_expand_poison_ifn(), asan_mark_p(), attempt_builtin_copysign(), auto_simd_check_stmt(), branch_prob(), build_bitint_stmt_ssa_conflicts(), call_may_clobber_ref_p_1(), call_object_size(), can_group_stmts_p(), can_interpret_as_conditional_op_p(), check_call(), check_defs(), cleanup_call_ctrl_altering_flag(), cleanup_control_flow_pre(), collect_fallthrough_labels(), ipa_icf_gimple::func_checker::compare_gimple_call(), compatible_calls_p(), cond_removal_in_builtin_zero_pattern(), convert_mult_to_fma_1(), copy_bb(), copy_edges_for_bb(), copy_reference_ops_from_call(), vect_optimize_slp_pass::decide_masked_load_lanes(), diagnose_tm_1(), discover_nonconstant_array_refs(), do_warn_unused_result(), dse_optimize_stmt(), dump_gimple_call(), dump_gimple_call_args(), dump_ic_profile(), dump_oacc_loop_part(), edge_before_returns_twice_call(), eliminate_unnecessary_stmts(), emit_cmp_and_jump_insns(), estimate_num_insns(), execute_early_expand_coro_ifns(), execute_oacc_device_lower(), execute_omp_device_lower(), execute_omp_oacc_neuter_broadcast(), execute_split_functions(), execute_update_addresses_taken(), exist_non_indexing_operands_for_use_p(), expand_call_inline(), expand_call_stmt(), expand_expr_real_1(), expand_FALLTHROUGH_r(), expand_ifn_va_arg(), expand_ifn_va_arg_1(), expand_vector_operations(), expand_vector_operations_1(), expr_expected_value_1(), find_address_like_use(), find_foldable_builtin_expect(), find_func_aliases_for_call(), find_gang_private_vars(), find_loop_dist_alias(), find_return_bb(), find_tail_calls(), ccp_folder::fold_stmt(), get_abnormal_succ_dispatcher(), get_address_cost(), get_references_in_stmt(), gimple_call_combined_fn(), gimple_call_copy_skip_args(), gimple_call_flags(), gimple_call_fnspec(), gimple_call_fntype(), gimple_call_initialize_ctrl_altering(), gimple_call_internal_fn(), gimple_call_internal_p(), gimple_call_internal_p(), gimple_call_internal_p(), gimple_call_same_target_p(), gimple_call_set_fn(), gimple_call_set_fndecl(), gimple_call_set_fntype(), gimple_call_set_internal_fn(), gimple_can_duplicate_bb_p(), gimple_could_trap_p_1(), gimple_expand_calls_inline(), gimple_extract(), gimple_fold_call(), gimple_fold_stmt_to_constant_1(), gimple_indirect_call_to_profile(), gimple_inexpensive_call_p(), gimple_infer_range::gimple_infer_range(), gimple_lower_bitint(), has_stmt_been_instrumented_p(), ifcvt_can_hoist(), infer_nonnull_range_by_attribute(), initialize_ao_ref_for_dse(), input_function(), input_gimple_stmt(), instrument_memory_accesses(), ipa_analyze_controlled_uses(), is_asan_mark_p(), last_stmt_in_scope(), likely_value(), loop_body_includes_call(), lower_coro_builtin(), lower_stmt(), mark_stmt_if_obviously_necessary(), match_uaddc_usubc(), maybe_add_asan_poison_write(), gimple_range_op_handler::maybe_builtin_call(), maybe_dead_abnormal_edge_p(), maybe_instrument_call(), merge_stmts_p(), neuter_worker_single(), nonfreeing_call_p(), note_simd_array_uses(), oacc_entry_exit_ok_1(), oacc_loop_discover_walk(), oacc_loop_xform_head_tail(), omp_sese_find_par(), omp_sese_split_blocks(), ompdevlow_adjust_simt_enter(), optimize_mask_stores(), optimize_stack_restore(), output_gimple_stmt(), predict_loops(), expr_hash_elt::print(), cgraph_edge::rebuild_edges(), jump_threader::record_temporary_equivalences_from_stmts_at_dest(), ref_maybe_used_by_call_p_1(), remap_gimple_stmt(), remove_unused_locals(), replace_loop_annotate(), replace_loop_annotate_in_block(), same_succ_hash(), sanopt_optimize_walker(), scan_function(), should_duplicate_loop_header_p(), should_warn_for_implicit_fallthrough(), simplify_using_ranges::simplify(), sra_modify_function_body(), ssa_is_replaceable_p(), ssa_undefined_value_p(), stack_protect_return_slot_p(), stmt_starts_bb_p(), strip_predict_hints(), strub_call_fntype_override_p(), tree_profiling(), try_vectorize_loop_1(), vect_analyze_slp(), vect_analyze_slp_instance(), vect_build_slp_tree_2(), vect_check_gather_scatter(), vect_check_store_rhs(), vect_find_stmt_data_reference(), vect_get_and_check_slp_defs(), vect_get_datarefs_in_loop(), vect_get_operand_map(), vect_get_vector_types_for_stmt(), vect_loop_dist_alias_call(), vect_loop_vectorized_call(), vect_recog_ctz_ffs_pattern(), vect_recog_mask_conversion_pattern(), vect_recog_popcount_clz_ctz_ffs_pattern(), vect_recog_sad_pattern(), vect_recog_widen_abd_pattern(), vect_set_loop_condition(), vect_simd_lane_linear(), vect_transform_loop(), vectorizable_call(), vectorizable_conversion(), vectorizable_load(), vectorizable_simd_clone_call(), vectorizable_store(), verify_gimple_call(), visit_stmt(), vn_reference_lookup_3(), warn_implicit_fallthrough_r(), warn_switch_unreachable_and_auto_init_r(), warn_uninit(), and warn_uninitialized_vars().

◆ gimple_call_internal_p() [2/3]

bool gimple_call_internal_p ( const gimple * gs)
inline

◆ gimple_call_internal_p() [3/3]

bool gimple_call_internal_p ( const gimple * gs,
internal_fn fn )
inline
Return true if GS is an internal function FN.   

References gimple_call_internal_fn(), gimple_call_internal_p(), and is_gimple_call().

◆ gimple_call_internal_unique_p() [1/2]

◆ gimple_call_internal_unique_p() [2/2]

bool gimple_call_internal_unique_p ( const gimple * gs)
inline

◆ gimple_call_lhs() [1/2]

tree gimple_call_lhs ( const gcall * gs)
inline
Return the LHS of call statement GS.   

References gimple_call_lhs(), and gcall::op.

Referenced by adjust_simduid_builtins(), analyze_function_body(), asan_expand_poison_ifn(), bit_value_assume_aligned(), build_bitint_stmt_ssa_conflicts(), strlen_pass::check_and_optimize_call(), check_forbidden_calls(), cleanup_control_flow_bb(), compatible_calls_p(), convert_mult_to_fma_1(), copy_bb(), copy_reference_ops_from_call(), default_goacc_reduction(), delete_dead_or_redundant_call(), dest_safe_for_nrv_p(), direct_internal_fn_types(), discover_nonconstant_array_refs(), do_simple_agr_dse(), do_warn_unused_result(), dse_optimize_call(), dump_gimple_call(), early_object_sizes_execute_one(), eliminate_redundant_computations(), eliminate_tail_call(), eliminate_unnecessary_stmts(), empty_bb_or_one_feeding_into_p(), estimate_num_insns(), evaluate_stmt(), execute_cse_sincos_1(), execute_early_expand_coro_ifns(), execute_oacc_device_lower(), execute_omp_device_lower(), expand_ACCESS_WITH_SIZE(), expand_arith_overflow(), expand_BITINTTOFLOAT(), expand_bitquery(), expand_BUILTIN_EXPECT(), expand_call_inline(), expand_call_stmt(), expand_call_tm(), expand_complex_move(), expand_crc_optab_fn(), expand_DEFERRED_INIT(), expand_DIVMOD(), expand_fn_using_insn(), expand_gather_load_optab_fn(), expand_GOACC_DIM_POS(), expand_GOACC_DIM_SIZE(), expand_GOMP_SIMT_ENTER_ALLOC(), expand_GOMP_SIMT_EXIT(), expand_GOMP_SIMT_LANE(), expand_GOMP_SIMT_LAST_LANE(), expand_GOMP_SIMT_ORDERED_PRED(), expand_GOMP_SIMT_VOTE_ANY(), expand_GOMP_SIMT_XCHG_BFLY(), expand_GOMP_SIMT_XCHG_IDX(), expand_HWASAN_ALLOCA_POISON(), expand_HWASAN_CHOOSE_TAG(), expand_HWASAN_SET_TAG(), expand_ifn_atomic_bit_test_and(), expand_ifn_atomic_compare_exchange(), expand_ifn_atomic_compare_exchange_into_call(), expand_ifn_atomic_op_fetch_cmp_0(), expand_ifn_va_arg_1(), expand_LAUNDER(), expand_load_lanes_optab_fn(), expand_omp_for_generic(), expand_partial_load_optab_fn(), expand_POPCOUNT(), expand_RAWMEMCHR(), expand_reduc_sbool_optab_fn(), expand_SPACESHIP(), expand_store_lanes_optab_fn(), expand_strided_load_optab_fn(), expand_UADDC(), expand_UBSAN_CHECK_ADD(), expand_UBSAN_CHECK_MUL(), expand_UBSAN_CHECK_SUB(), expand_UNIQUE(), expand_vec_cond_mask_optab_fn(), expand_vec_set_optab_fn(), expand_vector_conversion(), expand_while_optab_fn(), expr_hash_elt::expr_hash_elt(), find_foldable_builtin_expect(), find_func_aliases_for_builtin_call(), find_func_aliases_for_call(), find_tail_calls(), finish_update_gimple_call(), fixup_noreturn_call(), fold_builtin_alloca_with_align(), fold_builtin_atomic_compare_exchange(), fold_internal_goacc_dim(), fold_loop_internal_call(), ccp_folder::fold_stmt(), get_default_value(), get_mem_refs_of_builtin_call(), get_mem_type_for_internal_fn(), get_references_in_stmt(), get_string_length(), gimple_builtin_call_types_compatible_p(), gimple_call_copy_skip_args(), gimple_call_lhs(), gimple_call_lhs(), gimple_call_nonnegative_p(), gimple_call_return_type(), gimple_expand_builtin_cabs(), gimple_extract(), gimple_fold_builtin(), gimple_fold_builtin_fprintf(), gimple_fold_builtin_fputs(), gimple_fold_builtin_fwrite(), gimple_fold_builtin_memchr(), gimple_fold_builtin_memory_chk(), gimple_fold_builtin_memory_op(), gimple_fold_builtin_mempcpy(), gimple_fold_builtin_memset(), gimple_fold_builtin_printf(), gimple_fold_builtin_snprintf(), gimple_fold_builtin_sprintf(), gimple_fold_builtin_stpcpy(), gimple_fold_builtin_strcat(), gimple_fold_builtin_strchr(), gimple_fold_builtin_string_compare(), gimple_fold_builtin_strlen(), gimple_fold_builtin_strstr(), gimple_fold_builtin_stxcpy_chk(), gimple_fold_builtin_stxncpy_chk(), gimple_fold_call(), gimple_fold_partial_load_store(), gimple_get_lhs(), gimple_has_lhs(), gimple_ic(), gimple_lower_bitint(), gimple_stringop_fixed_value(), gimplify_and_update_call_from_tree(), strlen_pass::handle_alloc_call(), handle_builtin_alloca(), strlen_pass::handle_builtin_memcpy(), strlen_pass::handle_builtin_memset(), strlen_pass::handle_builtin_strcat(), strlen_pass::handle_builtin_strchr(), strlen_pass::handle_builtin_strcpy(), strlen_pass::handle_builtin_string_cmp(), strlen_pass::handle_builtin_strlen(), handle_call_arg(), handle_rhs_call(), strlen_pass::handle_store(), hardcfr_sibcall_search_block(), has_stmt_been_instrumented_p(), increment_start_addr(), infer_loop_bounds_from_array(), access_ref::inform_access(), init_dont_simulate_again(), initialize_ao_ref_for_dse(), insert_clobbers_for_var(), instrument_builtin_call(), ipa_tm_insert_gettmclone_call(), ipa_tm_scan_irr_block(), lower_builtin_assume_aligned(), lower_builtin_posix_memalign(), lower_builtin_setjmp(), lower_coro_builtin(), lower_eh_constructs_2(), lower_omp_1(), match_single_bit_test(), match_uaddc_usubc(), may_propagate_copy_into_stmt(), gimple_range_op_handler::maybe_builtin_call(), maybe_diag_stxncpy_trunc(), maybe_instrument_call(), maybe_optimize_arith_overflow(), strlen_pass::maybe_warn_overflow(), maybe_warn_pointless_strcmp(), ipa_param_adjustments::modify_call(), ipa_param_body_adjustments::modify_call_stmt(), movement_possibility_1(), note_simd_array_uses(), oacc_xform_loop(), oacc_xform_tile(), object_sizes_execute(), ompdevlow_adjust_simt_enter(), optimize_recip_sqrt(), dom_opt_dom_walker::optimize_stmt(), optimize_strlen_comp(), predicate_statements(), propagate_op_to_single_use(), propagate_tree_value_into_stmt(), fold_using_range::range_of_call(), jump_threader::record_temporary_equivalences_from_stmts_at_dest(), cgraph_edge::redirect_call_stmt_to_callee(), ref_maybe_used_by_call_p_1(), remap_gimple_stmt(), remove_unused_locals(), replace_call_with_call_and_fold(), replace_call_with_value(), replace_loop_annotate(), replace_loop_annotate_in_block(), returning_call_p(), same_handler_p(), scan_function(), shrink_wrap_conditional_dead_built_in_calls(), shrink_wrap_len_call(), shrink_wrap_one_built_in_call_with_conds(), simd_clone_adjust(), simplify_builtin_call(), simplify_builtin_memchr(), simplify_builtin_memcmp(), simplify_builtin_memcpy_memset(), simplify_count_zeroes(), simplify_using_ranges::simplify_internal_call_using_ranges(), sra_modify_deferred_init(), sra_modify_function_body(), stmt_could_throw_p(), stmt_kills_ref_p(), stmt_may_clobber_ref_p_1(), strip_predict_hints(), surely_varying_stmt_p(), use_internal_fn(), vect_analyze_stmt(), vect_finish_stmt_generation(), vect_get_datarefs_in_loop(), vect_loop_versioning(), vect_recog_ctz_ffs_pattern(), vect_recog_mask_conversion_pattern(), vect_recog_pow_pattern(), vect_recog_rotate_pattern(), vect_remove_slp_scalar_calls(), vect_setup_realignment(), vect_transform_loop(), vectorizable_call(), vectorizable_load(), vectorizable_simd_clone_call(), verify_gimple_call(), visit_reference_op_call(), ccp_propagate::visit_stmt(), visit_stmt(), vn_reference_lookup_call(), walk_gimple_op(), and walk_stmt_load_store_addr_ops().

◆ gimple_call_lhs() [2/2]

tree gimple_call_lhs ( const gimple * gs)
inline

◆ gimple_call_lhs_ptr() [1/2]

tree * gimple_call_lhs_ptr ( gcall * gs)
inline

◆ gimple_call_lhs_ptr() [2/2]

tree * gimple_call_lhs_ptr ( gimple * gs)
inline

◆ gimple_call_must_tail_p()

◆ gimple_call_nocf_check_p()

bool gimple_call_nocf_check_p ( const gcall * gs)
inline
Return true if call GS is marked as nocf_check.   

References GF_CALL_NOCF_CHECK, gimple_call_nocf_check_p(), and gimple::subcode.

Referenced by expand_call_stmt(), gimple_call_nocf_check_p(), and ipa_icf::sem_function::hash_stmt().

◆ gimple_call_nonnull_arg()

◆ gimple_call_nonnull_result_p()

◆ gimple_call_noreturn_p() [1/2]

◆ gimple_call_noreturn_p() [2/2]

bool gimple_call_noreturn_p ( const gimple * s)
inline

◆ gimple_call_nothrow_p()

◆ gimple_call_num_args() [1/2]

unsigned gimple_call_num_args ( const gcall * gs)
inline
Return the number of arguments used by call statement GS.   

References gimple_call_num_args(), and gimple_num_ops().

Referenced by _loop_vec_info::_loop_vec_info(), alloc_object_size(), analyze_function_body(), bit_value_assume_aligned(), builtin_call_nomodifying_p(), call_nargs(), can_interpret_as_conditional_op_p(), can_shrink_wrap_len_p(), gimple_infer_range::check_assume_func(), check_fnspec(), check_pow(), check_reduction_path(), check_stmt_for_type_change(), ipa_icf_gimple::func_checker::compare_gimple_call(), compatible_calls_p(), cond_removal_in_builtin_zero_pattern(), convert_tramp_reference_stmt(), copy_bb(), copy_reference_ops_from_call(), decompose_param_expr(), dump_gimple_call(), dump_gimple_call_args(), dynamic_object_sizes_execute_one(), eliminate_unnecessary_stmts(), estimate_num_insns(), evaluate_properties_for_edge(), evaluate_stmt(), execute_oacc_device_lower(), execute_omp_oacc_neuter_broadcast(), execute_update_addresses_taken(), expand_call_inline(), expand_call_stmt(), expand_ifn_atomic_bit_test_and(), expand_ifn_atomic_op_fetch_cmp_0(), expand_ifn_va_arg_1(), expand_POPCOUNT(), expr_expected_value_1(), expr_hash_elt::expr_hash_elt(), find_func_aliases_for_call(), find_func_clobbers(), find_gang_private_vars(), find_tail_calls(), fold_call_stmt(), ccp_folder::fold_stmt(), fold_stmt_1(), modref_access_node::get_call_arg(), get_references_in_stmt(), get_string_length(), get_upper_bound_based_on_builtin_expr_with_prob(), gimple_alloca_call_p(), gimple_builtin_call_types_compatible_p(), gimple_call_alloc_size(), gimple_call_copy_skip_args(), gimple_call_integer_valued_real_p(), gimple_call_nonnegative_p(), gimple_call_nonnull_arg(), gimple_call_num_args(), gimple_call_num_args(), gimple_call_return_array(), gimple_equal_p(), gimple_extract(), gimple_fold_builtin(), gimple_fold_builtin_clear_padding(), gimple_fold_builtin_constant_p(), gimple_fold_builtin_snprintf(), gimple_fold_builtin_snprintf_chk(), gimple_fold_builtin_sprintf(), gimple_fold_builtin_sprintf_chk(), gimple_fold_builtin_stdarg(), gimple_fold_builtin_string_compare(), gimple_fold_stmt_to_constant_1(), gimple_infer_range::gimple_infer_range(), gimple_lower_bitint(), gimple_num_args(), strlen_pass::handle_builtin_strcpy(), strlen_pass::handle_builtin_string_cmp(), handle_lhs_call(), handle_printf_call(), handle_rhs_call(), infer_loop_bounds_from_array(), infer_nonnull_range_by_attribute(), initialize_inlined_parameters(), instrument_builtin_call(), instrument_nonnull_arg(), ipa_analyze_controlled_uses(), ipa_compute_jump_functions_for_edge(), ipa_modref_callee_reads_no_memory_p(), is_addr_local(), is_removable_allocation_p(), is_removable_cxa_atexit_call(), lower_builtin_assume_aligned(), lower_stmt(), gimple_range_op_handler::maybe_builtin_call(), maybe_instrument_call(), maybe_optimize_asan_check_ifn(), maybe_optimize_ubsan_null_ifn(), maybe_optimize_ubsan_ptr_ifn(), maybe_optimize_ubsan_vptr_ifn(), maybe_remove_unused_call_args(), maybe_trim_memstar_call(), maybe_warn_pass_by_reference(), ipa_param_adjustments::modify_call(), ipa_param_body_adjustments::modify_call_stmt(), oacc_loop_discover_walk(), ompdevlow_adjust_simt_enter(), optimize_agr_copyprop_arg(), optimize_atomic_compare_exchange_p(), optimize_omp_library_calls(), optimize_stack_restore(), pass_through_call(), predicate_statements(), propagate_necessity(), ref_maybe_used_by_call_p_1(), replace_stmt_with_simplification(), same_handler_p(), same_succ_hash(), scan_function(), set_cond_stmt_execution_predicate(), simplify_builtin_call(), simplify_builtin_memchr(), simplify_builtin_memcmp(), simplify_builtin_memcpy_memset(), sra_modify_function_body(), strip_predict_hints(), suitable_for_tail_call_opt_p(), ubsan_expand_bounds_ifn(), ubsan_expand_null_ifn(), ubsan_expand_objsize_ifn(), ubsan_expand_ptr_ifn(), ubsan_expand_vptr_ifn(), use_internal_fn(), validate_gimple_arglist(), vect_get_datarefs_in_loop(), vect_get_operand_map(), vect_mark_stmts_to_be_vectorized(), vect_recog_ctz_ffs_pattern(), vect_recog_mask_conversion_pattern(), vect_recog_popcount_clz_ctz_ffs_pattern(), vect_recog_sad_pattern(), vect_transform_loop(), vectorizable_call(), vectorizable_conversion(), vectorizable_simd_clone_call(), verify_gimple_call(), visit_reference_op_call(), vn_reference_lookup_3(), walk_gimple_op(), and walk_stmt_load_store_addr_ops().

◆ gimple_call_num_args() [2/2]

unsigned gimple_call_num_args ( const gimple * gs)
inline

◆ gimple_call_operator_delete_p()

bool gimple_call_operator_delete_p ( const gcall * stmt)
extern

◆ gimple_call_reset_alias_info()

◆ gimple_call_retslot_flags()

◆ gimple_call_return_flags()

◆ gimple_call_return_slot_opt_p()

◆ gimple_call_return_type()

◆ gimple_call_same_target_p()

◆ gimple_call_set_alloca_for_var()

void gimple_call_set_alloca_for_var ( gcall * s,
bool for_var )
inline
If FOR_VAR is true, GIMPLE_CALL S is a call to builtin_alloca that
is known to be emitted for VLA objects.  Those are wrapped by
stack_save/stack_restore calls and hence can't lead to unbounded
stack growth even when they occur in loops.   

References GF_CALL_ALLOCA_FOR_VAR, and gimple_call_set_alloca_for_var().

Referenced by gimple_build_call_from_tree(), gimple_call_set_alloca_for_var(), and gimplify_modify_expr_to_memcpy().

◆ gimple_call_set_arg() [1/2]

◆ gimple_call_set_arg() [2/2]

void gimple_call_set_arg ( gimple * gs,
unsigned index,
tree arg )
inline

◆ gimple_call_set_by_descriptor()

void gimple_call_set_by_descriptor ( gcall * s,
bool by_descriptor_p )
inline
If BY_DESCRIPTOR_P is true, GIMPLE_CALL S is an indirect call for which
pointers to nested function are descriptors instead of trampolines.   

References GF_CALL_BY_DESCRIPTOR, and gimple_call_set_by_descriptor().

Referenced by gimple_build_call_from_tree(), and gimple_call_set_by_descriptor().

◆ gimple_call_set_chain()

◆ gimple_call_set_ctrl_altering() [1/2]

◆ gimple_call_set_ctrl_altering() [2/2]

void gimple_call_set_ctrl_altering ( gimple * s,
bool ctrl_altering_p )
inline

◆ gimple_call_set_expected_throw()

void gimple_call_set_expected_throw ( gcall * s,
bool expected_throw_p )
inlinestatic
If EXPECTED_THROW_P is true, GIMPLE_CALL S is a call that is known
to be more likely to throw than to run forever, terminate the
program or return by other means.   

References GF_CALL_XTHROW.

◆ gimple_call_set_fn()

void gimple_call_set_fn ( gcall * gs,
tree fn )
inline

◆ gimple_call_set_fndecl() [1/2]

◆ gimple_call_set_fndecl() [2/2]

void gimple_call_set_fndecl ( gimple * gs,
tree decl )
inline

◆ gimple_call_set_fntype()

◆ gimple_call_set_from_new_or_delete()

void gimple_call_set_from_new_or_delete ( gcall * s,
bool from_new_or_delete_p )
inline
If FROM_NEW_OR_DELETE_P is true, mark GIMPLE_CALL S as being a call
to operator new or delete created from a new or delete expression.   

References GF_CALL_FROM_NEW_OR_DELETE, and gimple_call_set_from_new_or_delete().

Referenced by gimple_build_call_from_tree(), and gimple_call_set_from_new_or_delete().

◆ gimple_call_set_from_thunk()

void gimple_call_set_from_thunk ( gcall * s,
bool from_thunk_p )
inline
If FROM_THUNK_P is true, mark GIMPLE_CALL S as being the jump from a
thunk to the thunked-to function.   

References GF_CALL_FROM_THUNK, and gimple_call_set_from_thunk().

Referenced by expand_thunk(), gimple_build_call_from_tree(), gimple_call_set_from_thunk(), and remap_gimple_stmt().

◆ gimple_call_set_internal_fn()

void gimple_call_set_internal_fn ( gcall * call_stmt,
enum internal_fn fn )
inline
Set internal function FN to be the function called by call statement CALL_STMT.   

References gcc_gimple_checking_assert, gimple_call_internal_p(), gimple_call_set_internal_fn(), and gcall::u.

Referenced by gimple_build_call_internal_1(), gimple_call_set_internal_fn(), input_function(), and input_gimple_stmt().

◆ gimple_call_set_lhs() [1/2]

void gimple_call_set_lhs ( gcall * gs,
tree lhs )
inline
Set LHS to be the LHS operand of call statement GS.   

References gimple_call_set_lhs(), gcall::op, SSA_NAME_DEF_STMT, and TREE_CODE.

Referenced by attempt_builtin_copysign(), attempt_builtin_powi(), addsub_pattern::build(), complex_pattern::build_common(), build_instrumentation_call(), build_saturation_binary_arith_call_and_insert(), build_saturation_binary_arith_call_and_replace(), build_stack_save_restore(), build_tm_load(), cond_removal_in_builtin_zero_pattern(), convert_scalar_cond_reduction(), convert_to_divmod(), copy_bb(), create_expression_by_pieces(), do_simple_agr_dse(), do_vec_conversion(), dse_optimize_stmt(), early_object_sizes_execute_one(), eliminate_unnecessary_stmts(), execute_cse_sincos_1(), execute_fixup_cfg(), execute_omp_device_lower(), execute_update_addresses_taken(), expand_call_inline(), expand_call_tm(), expand_complex_libcall(), expand_oacc_collapse_init(), expand_oacc_for(), expand_omp_atomic_cas(), expand_omp_atomic_load(), expand_omp_atomic_store(), expand_omp_for_generic(), expand_omp_for_init_vars(), expand_omp_for_static_chunk(), expand_omp_for_static_nochunk(), expand_omp_sections(), expand_omp_simd(), expand_thunk(), expand_transaction(), finish_update_gimple_call(), fixup_noreturn_call(), fold_builtin_atomic_compare_exchange(), fold_strstr_to_strncmp(), gen_counter_update(), gen_emutls_addr(), generate_rawmemchr_builtin(), generate_strlen_builtin(), generate_strlen_builtin_using_rawmemchr(), generate_subtree_deferred_init(), get_string_length(), gimple_build(), gimple_build(), gimple_build(), gimple_build(), gimple_call_copy_skip_args(), gimple_call_set_lhs(), gimple_call_set_lhs(), gimple_expand_builtin_cabs(), gimple_expand_vec_set_extract_expr(), gimple_fold_builtin_stdarg(), gimple_fold_builtin_strcat(), gimple_fold_builtin_strchr(), gimple_fold_call(), gimple_ic(), gimple_set_lhs(), gimple_stringop_fixed_value(), gimplify_expr(), gimplify_modify_expr(), gimplify_modify_expr_to_memcpy(), gimplify_modify_expr_to_memset(), gimplify_omp_dispatch(), handle_builtin_alloca(), increment_start_addr(), init_tmp_var_with_call(), instrument_builtin_call(), instrument_func_entry(), instrument_si_overflow(), ipa_tm_insert_gettmclone_call(), lower_builtin_posix_memalign(), lower_eh_dispatch(), lower_lastprivate_clauses(), lower_oacc_head_tail(), lower_omp_1(), lower_omp_for_scan(), lower_omp_ordered(), lower_omp_scan(), lower_omp_single_simple(), lower_omp_task_reductions(), lower_omp_teams(), lower_private_allocate(), lower_rec_input_clauses(), lower_resx(), lower_transaction(), match_arith_overflow(), match_saturation_trunc(), match_single_bit_test(), match_spaceship(), match_uaddc_usubc(), match_unsigned_saturation_trunc(), maybe_push_res_to_seq(), ipa_param_adjustments::modify_call(), oacc_dim_call(), oacc_entry_exit_single_gang(), omp_build_barrier(), ompdevlow_adjust_simt_enter(), crc_optimization::optimize_crc_loop(), optimize_spaceship(), predicate_load_or_store(), predicate_rhs_code(), predicate_statements(), cgraph_edge::redirect_call_stmt_to_callee(), replace_call_with_call_and_fold(), scan_omp_simd(), shrink_wrap_len_call(), shrink_wrap_one_built_in_call_with_conds(), simd_clone_adjust(), simple_dce_from_worklist(), simplify_builtin_call(), simplify_builtin_memcpy_memset(), split_function(), sra_modify_deferred_init(), use_internal_fn(), vect_build_one_gather_load_call(), vect_create_epilog_for_reduction(), vect_do_peeling(), vect_gen_loop_len_mask(), vect_gen_while(), vect_get_loop_iv_increment(), 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_mask_conversion_pattern(), vect_recog_mulhs_pattern(), vect_recog_popcount_clz_ctz_ffs_pattern(), vect_recog_pow_pattern(), vect_recog_rotate_pattern(), vect_recog_sat_sub_pattern_transform(), vect_recog_sat_trunc_pattern(), vect_recog_widen_abd_pattern(), vect_setup_realignment(), vect_transform_reduction(), vectorizable_call(), vectorizable_condition(), vectorizable_early_exit(), vectorizable_load(), vectorizable_operation(), vectorizable_simd_clone_call(), vectorizable_store(), verify_bb_vtables(), version_loop_by_alias_check(), version_loop_for_if_conversion(), worker_single_copy(), and worker_single_simple().

◆ gimple_call_set_lhs() [2/2]

void gimple_call_set_lhs ( gimple * gs,
tree lhs )
inline

◆ gimple_call_set_must_tail()

void gimple_call_set_must_tail ( gcall * s,
bool must_tail_p )
inline
Mark (or clear) call statement S as requiring tail call optimization.   

References GF_CALL_MUST_TAIL_CALL, and gimple_call_set_must_tail().

Referenced by gimple_build_call_from_tree(), gimple_call_set_must_tail(), maybe_error_musttail(), remap_gimple_stmt(), and split_function().

◆ gimple_call_set_nocf_check()

void gimple_call_set_nocf_check ( gcall * gs,
bool nocf_check )
inline
Mark statement GS as nocf_check call.   

References GF_CALL_NOCF_CHECK, gimple_call_set_nocf_check(), and gimple::subcode.

Referenced by gimple_build_call_from_tree(), and gimple_call_set_nocf_check().

◆ gimple_call_set_nothrow()

◆ gimple_call_set_return_slot_opt()

void gimple_call_set_return_slot_opt ( gcall * s,
bool return_slot_opt_p )
inline
If RETURN_SLOT_OPT_P is true mark GIMPLE_CALL S as valid for return
slot optimization.  This transformation uses the target of the call
expansion as the return slot for calls that return in memory.   

References GF_CALL_RETURN_SLOT_OPT, and gimple_call_set_return_slot_opt().

Referenced by expand_thunk(), gimple_build_call_from_tree(), gimple_call_set_return_slot_opt(), and split_function().

◆ gimple_call_set_tail()

void gimple_call_set_tail ( gcall * s,
bool tail_p )
inline
If TAIL_P is true, mark call statement S as being a tail call
(i.e., a call just before the exit of a function).  These calls are
candidate for tail call optimization.   

References GF_CALL_TAILCALL, and gimple_call_set_tail().

Referenced by expand_block_edges(), expand_gimple_basic_block(), expand_thunk(), gimple_build_call_from_tree(), gimple_call_set_tail(), instrument_gimple(), maybe_error_musttail(), optimize_tail_call(), and remap_gimple_stmt().

◆ gimple_call_set_va_arg_pack()

void gimple_call_set_va_arg_pack ( gcall * s,
bool pass_arg_pack_p )
inline
If PASS_ARG_PACK_P is true, GIMPLE_CALL S is a stdarg call that needs the
argument pack in its argument list.   

References GF_CALL_VA_ARG_PACK, and gimple_call_set_va_arg_pack().

Referenced by copy_bb(), gimple_build_call_from_tree(), and gimple_call_set_va_arg_pack().

◆ gimple_call_static_chain_flags()

◆ gimple_call_tail_p()

◆ gimple_call_use_set() [1/2]

const pt_solution * gimple_call_use_set ( const gcall * call_stmt)
inline
As above, but const.   

References gcall::call_used, and gimple_call_use_set().

◆ gimple_call_use_set() [2/2]

struct pt_solution * gimple_call_use_set ( gcall * call_stmt)
inline

◆ gimple_call_va_arg_pack_p()

bool gimple_call_va_arg_pack_p ( const gcall * s)
inline
Return true if GIMPLE_CALL S is a stdarg call that needs the
argument pack in its argument list.   

References GF_CALL_VA_ARG_PACK, and gimple_call_va_arg_pack_p().

Referenced by ipa_icf_gimple::func_checker::compare_gimple_call(), copy_bb(), dump_gimple_call_args(), expand_call_stmt(), fold_call_stmt(), and gimple_call_va_arg_pack_p().

◆ gimple_catch_handler()

gimple_seq gimple_catch_handler ( const gcatch * catch_stmt)
inline

◆ gimple_catch_handler_ptr()

gimple_seq * gimple_catch_handler_ptr ( gcatch * catch_stmt)
inline
Return a pointer to the GIMPLE sequence representing the body of
the handler of GIMPLE_CATCH statement CATCH_STMT.   

References gimple_catch_handler_ptr(), and gcatch::handler.

Referenced by gimple_catch_handler(), gimple_catch_handler_ptr(), lower_omp_1(), lower_try_catch(), replace_goto_queue_1(), and walk_gimple_stmt().

◆ gimple_catch_set_handler()

void gimple_catch_set_handler ( gcatch * catch_stmt,
gimple_seq handler )
inline
Set HANDLER to be the body of GIMPLE_CATCH CATCH_STMT.   

References gimple_catch_set_handler(), and gcatch::handler.

Referenced by gimple_build_catch(), gimple_catch_set_handler(), and gimple_copy().

◆ gimple_catch_set_types()

void gimple_catch_set_types ( gcatch * catch_stmt,
tree t )
inline
Set T to be the set of types handled by GIMPLE_CATCH CATCH_STMT.   

References gimple_catch_set_types(), and gcatch::types.

Referenced by gimple_build_catch(), gimple_catch_set_types(), and gimple_copy().

◆ gimple_catch_types()

tree gimple_catch_types ( const gcatch * catch_stmt)
inline
Return the types handled by GIMPLE_CATCH statement CATCH_STMT.   

References gimple_catch_types(), and gcatch::types.

Referenced by dump_gimple_catch(), gimple_catch_types(), gimple_copy(), lower_catch(), and remap_gimple_stmt().

◆ gimple_catch_types_ptr()

tree * gimple_catch_types_ptr ( gcatch * catch_stmt)
inline
Return a pointer to the types handled by GIMPLE_CATCH statement CATCH_STMT.   

References gimple_catch_types_ptr(), and gcatch::types.

Referenced by gimple_catch_types_ptr(), and walk_gimple_op().

◆ GIMPLE_CHECK2() [1/2]

template<typename T>
T GIMPLE_CHECK2 ( const gimple * gs)
inline

References as_a(), and GIMPLE_CHECK2().

◆ GIMPLE_CHECK2() [2/2]

◆ gimple_clobber_p() [1/2]

bool gimple_clobber_p ( const gimple * s)
inline
Return true if S is a clobber statement.   

References gimple_assign_rhs1(), gimple_assign_single_p(), gimple_clobber_p(), and TREE_CLOBBER_P.

Referenced by add_scope_conflicts_1(), build_accesses_from_assign(), builtin_unreachable_bb_p(), can_handle_load(), cfun_returns(), strlen_pass::check_and_optimize_stmt(), check_defs(), check_stmt(), clear_unused_block_pointer(), clobber_only_eh_bb_p(), compute_live_vars_1(), cond_if_else_store_replacement_1(), cond_store_replacement_limited(), convert_local_reference_stmt(), convert_nonlocal_reference_stmt(), decide_copy_try_finally(), determine_reduction_stmt_1(), do_simple_agr_dse(), dse_classify_store(), dse_optimize_stmt(), eliminate_local_variables_stmt(), eliminate_unnecessary_stmts(), empty_eh_cleanup(), estimate_num_insns(), execute_omp_device_lower(), execute_update_addresses_taken(), expand_block_tm(), expand_vector_operations_1(), find_return_bb(), find_retval(), find_seed_stmts_for_distribution(), find_tail_calls(), forward_propagate_addr_expr_1(), get_mem_ref_of_assignment(), gimple_clobber_p(), gimple_clobber_p(), gimple_infer_range::gimple_infer_range(), gimple_lower_bitint(), gimple_regimplify_operands(), gimple_seq_unreachable_p(), hardcfr_scan_block(), infer_nonnull_range_by_dereference(), insert_debug_temp_for_var_def(), instrument_gimple(), lower_omp_1(), mark_aliased_reaching_defs_necessary_1(), mark_all_reaching_defs_necessary_1(), ipa_param_body_adjustments::mark_clobbers_dead(), ipa_param_body_adjustments::mark_dead_statements(), mark_stmt_if_obviously_necessary(), maybe_register_def(), noncall_stmt_may_be_vtbl_ptr_store(), optimize_aggr_zeroprop(), optimize_clobbers(), ipa_param_body_adjustments::prepare_debug_expressions(), record_modified(), redirection_block_p(), remap_gimple_stmt(), remove_indirect_clobbers(), remove_unused_locals(), ipa_param_body_adjustments::reset_debug_stmts(), rewrite_stmt(), sink_clobbers(), sink_common_stores_to_bb(), sm_seq_valid_bb(), split_function(), sra_modify_constructor_assign(), stmt_could_throw_p(), stmt_loc_used_by_debug_info(), stmt_may_be_vtbl_ptr_store(), transform_statements(), vect_find_stmt_data_reference(), vect_stmt_relevant_p(), vect_transform_loop(), verify_gimple_assign_single(), visit_bb(), and vn_reference_lookup_3().

◆ gimple_clobber_p() [2/2]

bool gimple_clobber_p ( const gimple * s,
enum clobber_kind kind )
inline
Return true if S is a clobber statement.   

References CLOBBER_KIND, gimple_assign_rhs1(), and gimple_clobber_p().

◆ gimple_code()

enum gimple_code gimple_code ( const gimple * g)
inline
Return the code for GIMPLE statement G.   

References g.

◆ gimple_compare_field_offset()

bool gimple_compare_field_offset ( tree f1,
tree f2 )
extern

◆ gimple_cond_code() [1/2]

enum tree_code gimple_cond_code ( const gcond * gs)
inline
Return the code of the predicate computed by conditional statement GS.   

References gimple_cond_code(), and gimple::subcode.

Referenced by crc_symbolic_execution::add_condition(), autofdo::afdo_propagate_circuit(), arith_overflow_check_p(), associate_equivalences_with_edges(), bound_difference(), canonicalize_bool_cond(), strlen_pass::check_and_optimize_stmt(), check_forbidden_calls(), checks_return_value_of_removable_allocation_p(), ipa_icf_gimple::func_checker::compare_gimple_cond(), comparison_combine(), compute_complex_ancestor_jump_func(), cond_on_phi_p(), cond_removal_in_builtin_zero_pattern(), cond_stmts_equal_p(), crc_optimization::cond_true_is_checked_for_bit_one(), connect_loops(), copy_prop_visit_cond_stmt(), create_parallel_loop(), determine_max_movement(), determine_value_range(), do_split_loop_on_cond(), do_warn_nonnull_compare(), dump_gimple_cond(), estimate_num_insns(), evaluate_control_stmt_using_entry_checks(), evaluate_stmt(), execute_early_expand_coro_ifns(), expand_gimple_cond(), expr_hash_elt::expr_hash_elt(), find_conditions(), find_tail_calls(), fold_stmt_1(), forward_propagate_into_gimple_cond(), get_code(), get_pred_info_from_cond_edge(), get_upper_bound_based_on_builtin_expr_with_prob(), gimple_cond_code(), gimple_cond_code(), gimple_cond_false_canonical_p(), gimple_cond_false_p(), gimple_cond_true_canonical_p(), gimple_cond_true_p(), gimple_could_trap_p_1(), gimple_equal_p(), gimple_expr_code(), gimple_extract(), gimple_simplify_phiopt(), hoist_guard(), ifcombine_ifandif(), init_range_entry(), insert_backedge_copies(), ipa_analyze_indirect_call_uses(), is_comparison_with_loop_invariant_p(), last_stmt_ptr_check(), simplify_using_ranges::legacy_fold_cond_overflow(), long_mul_check_low_plus_defer(), loop_niter_by_eval(), match_simplify_replacement(), match_single_bit_test(), maybe_optimize_guarding_check(), maybe_optimize_range_tests(), maybe_set_nonzero_bits(), move_computations_worker(), number_of_iterations_exit_assumptions(), optimize_range_tests_var_bound(), optimize_spaceship(), dom_opt_dom_walker::optimize_stmt(), possible_vector_mask_operation_p(), predicate_bbs(), predict_extra_loop_exits(), predict_loops(), process_bb(), recognize_bits_test(), recognize_single_bit_test(), record_edge_info(), remap_gimple_stmt(), replace_stmt_with_simplification(), rewrite_bittest(), set_cond_stmt_execution_predicate(), simplify_builtin_call(), simplify_using_ranges::simplify_cond_using_ranges_1(), jump_threader::simplify_control_stmt_condition(), simplify_using_initial_conditions(), spaceship_replacement(), split_at_bb_p(), stmt_could_throw_p(), dom_opt_dom_walker::test_for_singularity(), loop_distribution::transform_reduction_loop(), tree_predict_by_opcode(), unswitch_predicate::unswitch_predicate(), use_in_zero_equality(), value_replacement(), vect_analyze_slp(), vect_determine_mask_precision(), vect_mark_stmts_to_be_vectorized(), vect_recog_bitfield_ref_pattern(), vect_recog_gcond_pattern(), vectorizable_early_exit(), and verify_gimple_cond().

◆ gimple_cond_code() [2/2]

enum tree_code gimple_cond_code ( const gimple * gs)
inline

◆ gimple_cond_false_canonical_p()

bool gimple_cond_false_canonical_p ( const gcond * gs)
inline
Check if conditional statement GS is in the caonical form of 'if (0 != 0)'.  

References boolean_false_node, gimple_cond_code(), gimple_cond_false_canonical_p(), gimple_cond_lhs(), and gimple_cond_rhs().

Referenced by gimple_cond_false_canonical_p(), and replace_stmt_with_simplification().

◆ gimple_cond_false_label()

◆ gimple_cond_false_p()

◆ gimple_cond_lhs() [1/2]

tree gimple_cond_lhs ( const gcond * gs)
inline
Return the LHS of the predicate computed by conditional statement GS.   

References gimple_cond_lhs(), and gimple_statement_with_ops::op.

Referenced by crc_symbolic_execution::add_condition(), autofdo::afdo_propagate_circuit(), arith_overflow_check_p(), associate_equivalences_with_edges(), bound_difference(), gori_map::calculate_gori(), canonicalize_bool_cond(), strlen_pass::check_and_optimize_stmt(), checks_return_value_of_removable_allocation_p(), ipa_icf_gimple::func_checker::compare_gimple_cond(), comparison_combine(), compute_complex_ancestor_jump_func(), cond_on_phi_p(), cond_removal_in_builtin_zero_pattern(), connect_loops(), copy_prop_visit_cond_stmt(), create_empty_loop_on_edge(), create_parallel_loop(), determine_max_movement(), determine_value_range(), do_split_loop_on_cond(), do_warn_nonnull_compare(), do_while_loop_p(), dump_gimple_cond(), eliminate_unnecessary_stmts(), evaluate_control_stmt_using_entry_checks(), evaluate_stmt(), expand_complex_operations_1(), expand_gimple_cond(), expr_hash_elt::expr_hash_elt(), factor_out_conditional_operation(), infinite_recursion_diagnostic::fedge_uses_conjured_svalue_p(), find_conditions(), find_tail_calls(), find_unswitching_predicates_for_bb(), simplify_using_ranges::fold_cond(), fold_stmt_1(), forward_propagate_into_gimple_cond(), get_pred_info_from_cond_edge(), get_upper_bound_based_on_builtin_expr_with_prob(), gimple_cond_false_canonical_p(), gimple_cond_false_p(), gimple_cond_lhs(), gimple_cond_lhs(), gimple_cond_true_canonical_p(), gimple_cond_true_p(), gimple_could_trap_p_1(), gimple_equal_p(), gimple_extract(), gimple_simplify_phiopt(), remove_unreachable::handle_early(), hoist_guard(), ifcombine_ifandif(), init_dont_simulate_again(), init_range_entry(), insert_backedge_copies(), ipa_analyze_indirect_call_uses(), is_comparison_with_loop_invariant_p(), crc_optimization::is_crc_checked(), known_succ_p(), last_stmt_ptr_check(), simplify_using_ranges::legacy_fold_cond_overflow(), long_mul_check_low_plus_defer(), loop_niter_by_eval(), match_simplify_replacement(), match_single_bit_test(), maybe_optimize_guarding_check(), maybe_optimize_range_tests(), remove_unreachable::maybe_register(), maybe_set_nonzero_bits(), move_computations_worker(), number_of_iterations_cltz(), number_of_iterations_cltz_complement(), number_of_iterations_exit_assumptions(), number_of_iterations_popcount(), omp_sese_split_blocks(), op1_range(), operand_equal_for_value_replacement(), optimize_range_tests_var_bound(), optimize_spaceship(), dom_opt_dom_walker::optimize_stmt(), phi_result_unknown_predicate(), possible_vector_mask_operation_p(), predicate_bbs(), predict_extra_loop_exits(), predict_loops(), process_bb(), recognize_bits_test(), recognize_single_bit_test(), record_edge_info(), reduce_vector_comparison_to_scalar_comparison(), fur_relation::register_relation(), remap_gimple_stmt(), remove_unreachable::remove(), replace_stmt_with_simplification(), rewrite_bittest(), set_cond_stmt_execution_predicate(), dom_opt_dom_walker::set_global_ranges_from_unreachable_edges(), should_duplicate_loop_header_p(), simplify_builtin_call(), simplify_using_ranges::simplify_cond_using_ranges_1(), jump_threader::simplify_control_stmt_condition(), simplify_using_initial_conditions(), spaceship_replacement(), split_at_bb_p(), stmt_could_throw_p(), dom_opt_dom_walker::test_for_singularity(), loop_distribution::transform_reduction_loop(), transform_to_exit_first_loop(), transform_to_exit_first_loop_alt(), tree_estimate_loop_size(), tree_predict_by_opcode(), try_transform_to_exit_first_loop_alt(), unswitch_predicate::unswitch_predicate(), value_replacement(), vect_analyze_slp(), vect_determine_mask_precision(), vect_mark_stmts_to_be_vectorized(), vect_recog_bitfield_ref_pattern(), vect_recog_gcond_pattern(), verify_gimple_cond(), vn_phi_insert(), and vn_phi_lookup().

◆ gimple_cond_lhs() [2/2]

tree gimple_cond_lhs ( const gimple * gs)
inline

◆ gimple_cond_lhs_ptr()

tree * gimple_cond_lhs_ptr ( gcond * gs)
inline

◆ gimple_cond_make_false()

◆ gimple_cond_make_true()

◆ gimple_cond_rhs() [1/2]

tree gimple_cond_rhs ( const gcond * gs)
inline
Return the RHS operand of the predicate computed by conditional GS.   

References gimple_cond_rhs(), and gimple_statement_with_ops::op.

Referenced by crc_symbolic_execution::add_condition(), autofdo::afdo_propagate_circuit(), arith_overflow_check_p(), associate_equivalences_with_edges(), bound_difference(), gori_map::calculate_gori(), canonicalize_bool_cond(), strlen_pass::check_and_optimize_stmt(), check_forbidden_calls(), check_retval_uses(), checks_return_value_of_removable_allocation_p(), ipa_icf_gimple::func_checker::compare_gimple_cond(), comparison_combine(), compute_complex_ancestor_jump_func(), cond_on_phi_p(), cond_removal_in_builtin_zero_pattern(), crc_optimization::cond_true_is_checked_for_bit_one(), connect_loops(), copy_prop_visit_cond_stmt(), create_parallel_loop(), determine_value_range(), do_split_loop_on_cond(), do_warn_nonnull_compare(), do_while_loop_p(), dump_gimple_cond(), eliminate_unnecessary_stmts(), evaluate_control_stmt_using_entry_checks(), evaluate_stmt(), expand_complex_operations_1(), expand_gimple_cond(), expr_hash_elt::expr_hash_elt(), factor_out_conditional_operation(), infinite_recursion_diagnostic::fedge_uses_conjured_svalue_p(), find_conditions(), find_tail_calls(), simplify_using_ranges::fold_cond(), fold_stmt_1(), forward_propagate_into_gimple_cond(), get_pred_info_from_cond_edge(), get_upper_bound_based_on_builtin_expr_with_prob(), gimple_cond_false_canonical_p(), gimple_cond_false_p(), gimple_cond_rhs(), gimple_cond_rhs(), gimple_cond_true_canonical_p(), gimple_cond_true_p(), gimple_equal_p(), gimple_extract(), gimple_simplify_phiopt(), remove_unreachable::handle_early(), hoist_guard(), ifcombine_ifandif(), init_dont_simulate_again(), init_range_entry(), ipa_analyze_indirect_call_uses(), is_comparison_with_loop_invariant_p(), known_succ_p(), last_stmt_ptr_check(), simplify_using_ranges::legacy_fold_cond_overflow(), long_mul_check_low_plus_defer(), loop_niter_by_eval(), match_simplify_replacement(), match_single_bit_test(), maybe_optimize_guarding_check(), maybe_optimize_range_tests(), remove_unreachable::maybe_register(), maybe_set_nonzero_bits(), move_computations_worker(), number_of_iterations_cltz(), number_of_iterations_cltz_complement(), number_of_iterations_exit_assumptions(), number_of_iterations_popcount(), omp_sese_split_blocks(), op1_range(), operand_equal_for_value_replacement(), optimize_range_tests_var_bound(), optimize_spaceship(), dom_opt_dom_walker::optimize_stmt(), phi_result_unknown_predicate(), predicate_bbs(), predict_extra_loop_exits(), predict_loops(), process_bb(), recognize_bits_test(), recognize_single_bit_test(), record_edge_info(), reduce_vector_comparison_to_scalar_comparison(), fur_relation::register_relation(), remap_gimple_stmt(), remove_unreachable::remove(), replace_stmt_with_simplification(), rewrite_bittest(), set_cond_stmt_execution_predicate(), dom_opt_dom_walker::set_global_ranges_from_unreachable_edges(), should_duplicate_loop_header_p(), simplify_builtin_call(), simplify_using_ranges::simplify_cond_using_ranges_1(), jump_threader::simplify_control_stmt_condition(), simplify_using_initial_conditions(), spaceship_replacement(), split_at_bb_p(), dom_opt_dom_walker::test_for_singularity(), loop_distribution::transform_reduction_loop(), transform_to_exit_first_loop(), tree_estimate_loop_size(), tree_predict_by_opcode(), unswitch_predicate::unswitch_predicate(), use_in_zero_equality(), value_replacement(), vect_analyze_slp(), vect_mark_stmts_to_be_vectorized(), vect_recog_bitfield_ref_pattern(), vect_recog_gcond_pattern(), verify_gimple_cond(), vn_phi_insert(), and vn_phi_lookup().

◆ gimple_cond_rhs() [2/2]

tree gimple_cond_rhs ( const gimple * gs)
inline

◆ gimple_cond_rhs_ptr()

tree * gimple_cond_rhs_ptr ( gcond * gs)
inline

◆ gimple_cond_set_code()

◆ gimple_cond_set_condition()

void gimple_cond_set_condition ( gcond * stmt,
enum tree_code code,
tree lhs,
tree rhs )
inline

◆ gimple_cond_set_condition_from_tree()

void gimple_cond_set_condition_from_tree ( gcond * stmt,
tree cond )

◆ gimple_cond_set_false_label()

void gimple_cond_set_false_label ( gcond * gs,
tree label )
inline
Set LABEL to be the label used by conditional statement GS when its
predicate evaluates to false.   

References gimple_cond_set_false_label(), and gimple_statement_with_ops::op.

Referenced by adjust_assumption_stmt_r(), cleanup_dead_labels(), gimple_build_cond(), gimple_cond_set_false_label(), and make_cond_expr_edges().

◆ gimple_cond_set_lhs()

◆ gimple_cond_set_rhs()

◆ gimple_cond_set_true_label()

void gimple_cond_set_true_label ( gcond * gs,
tree label )
inline
Set LABEL to be the label used by conditional statement GS when its
predicate evaluates to true.   

References gimple_cond_set_true_label(), and gimple_statement_with_ops::op.

Referenced by adjust_assumption_stmt_r(), cleanup_dead_labels(), gimple_build_cond(), gimple_cond_set_true_label(), and make_cond_expr_edges().

◆ gimple_cond_true_canonical_p()

bool gimple_cond_true_canonical_p ( const gcond * gs)
inline
Check if conditional statement GS is in the caonical form of 'if (1 != 0)'.  

References boolean_false_node, boolean_true_node, gimple_cond_code(), gimple_cond_lhs(), gimple_cond_rhs(), and gimple_cond_true_canonical_p().

Referenced by gimple_cond_true_canonical_p(), and replace_stmt_with_simplification().

◆ gimple_cond_true_label()

◆ gimple_cond_true_p()

◆ gimple_copy()

gimple * gimple_copy ( gimple * stmt)
Return a deep copy of statement STMT.  All the operands from STMT
are reallocated and copied using unshare_expr.  The DEF, USE, VDEF
and VUSE operand arrays are set to empty in the new copy.  The new
copy isn't part of any sequence.   

References as_a(), cfun, g, gcc_unreachable, ggc_vec_alloc(), gimple_alloc(), gimple_assume_body(), gimple_assume_body_ptr(), gimple_assume_guard(), gimple_assume_set_guard(), gimple_bind_block(), gimple_bind_body(), gimple_bind_set_block(), gimple_bind_set_body(), gimple_bind_set_vars(), gimple_bind_vars(), gimple_catch_handler(), gimple_catch_set_handler(), gimple_catch_set_types(), gimple_catch_types(), gimple_copy(), gimple_debug_nonbind_marker_p(), gimple_eh_else_e_body(), gimple_eh_else_n_body(), gimple_eh_else_set_e_body(), gimple_eh_else_set_n_body(), gimple_eh_filter_failure(), gimple_eh_filter_set_failure(), gimple_eh_filter_set_types(), gimple_eh_filter_types(), gimple_has_mem_ops(), gimple_has_ops(), gimple_has_substatements(), gimple_init_singleton(), gimple_num_ops(), gimple_omp_atomic_load_lhs(), gimple_omp_atomic_load_rhs(), gimple_omp_atomic_load_set_lhs(), gimple_omp_atomic_load_set_rhs(), gimple_omp_atomic_store_set_val(), gimple_omp_atomic_store_val(), gimple_omp_body(), gimple_omp_critical_clauses(), gimple_omp_critical_name(), gimple_omp_critical_set_clauses(), gimple_omp_critical_set_name(), gimple_omp_dispatch_clauses(), gimple_omp_dispatch_set_clauses(), gimple_omp_for_clauses(), gimple_omp_for_collapse(), gimple_omp_for_cond(), gimple_omp_for_final(), gimple_omp_for_incr(), gimple_omp_for_index(), gimple_omp_for_initial(), gimple_omp_for_pre_body(), gimple_omp_for_set_clauses(), 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_for_set_pre_body(), gimple_omp_interop_clauses(), gimple_omp_interop_set_clauses(), gimple_omp_masked_clauses(), gimple_omp_masked_set_clauses(), gimple_omp_ordered_clauses(), gimple_omp_ordered_set_clauses(), gimple_omp_parallel_child_fn(), gimple_omp_parallel_clauses(), gimple_omp_parallel_data_arg(), gimple_omp_parallel_set_child_fn(), gimple_omp_parallel_set_clauses(), gimple_omp_parallel_set_data_arg(), gimple_omp_scan_clauses(), gimple_omp_scan_set_clauses(), gimple_omp_scope_clauses(), gimple_omp_scope_set_clauses(), gimple_omp_sections_clauses(), gimple_omp_sections_control(), gimple_omp_sections_set_clauses(), gimple_omp_sections_set_control(), gimple_omp_set_body(), gimple_omp_single_clauses(), gimple_omp_single_set_clauses(), gimple_omp_target_clauses(), gimple_omp_target_data_arg(), gimple_omp_target_set_clauses(), gimple_omp_target_set_data_arg(), gimple_omp_task_arg_align(), gimple_omp_task_arg_size(), gimple_omp_task_child_fn(), gimple_omp_task_clauses(), gimple_omp_task_copy_fn(), gimple_omp_task_data_arg(), gimple_omp_task_set_arg_align(), gimple_omp_task_set_arg_size(), gimple_omp_task_set_child_fn(), gimple_omp_task_set_clauses(), gimple_omp_task_set_copy_fn(), gimple_omp_task_set_data_arg(), gimple_omp_taskgroup_clauses(), gimple_omp_taskgroup_set_clauses(), gimple_omp_teams_clauses(), gimple_omp_teams_set_clauses(), gimple_op(), gimple_seq_copy(), gimple_set_modified(), gimple_set_op(), gimple_set_use_ops(), gimple_set_vdef(), gimple_set_vuse(), gimple_size(), gimple_transaction_body(), gimple_transaction_set_body(), gimple_try_cleanup(), gimple_try_eval(), gimple_try_set_cleanup(), gimple_try_set_eval(), gimple_vdef(), gimple_vuse(), gimple_wce_cleanup(), gimple_wce_set_cleanup(), i, gomp_for::iter, NULL, and unshare_expr().

Referenced by asan_expand_poison_ifn(), gimple_build_debug_inline_entry(), gimple_copy(), gimple_duplicate_bb(), gimple_duplicate_sese_tail(), gimple_ic(), gimple_seq_copy(), gimple_stringop_fixed_value(), hoist_defs_of_uses(), lower_omp_for_scan(), maybe_duplicate_comparison(), maybe_move_debug_stmts_to_successors(), propagate_threaded_block_debug_into(), remap_gimple_stmt(), jump_threader::simplify_control_stmt_condition(), and ssa_create_duplicates().

◆ gimple_could_trap_p()

◆ gimple_could_trap_p_1()

◆ gimple_debug_begin_stmt_p()

bool gimple_debug_begin_stmt_p ( const gimple * s)
inline

◆ gimple_debug_bind_get_value()

◆ gimple_debug_bind_get_value_ptr()

tree * gimple_debug_bind_get_value_ptr ( gimple * dbg)
inline

◆ gimple_debug_bind_get_var()

◆ gimple_debug_bind_has_value_p()

◆ gimple_debug_bind_p()

◆ gimple_debug_bind_reset_value()

◆ gimple_debug_bind_set_value()

void gimple_debug_bind_set_value ( gimple * dbg,
tree value )
inline

◆ gimple_debug_bind_set_var()

void gimple_debug_bind_set_var ( gimple * dbg,
tree var )
inline

◆ gimple_debug_inline_entry_p()

bool gimple_debug_inline_entry_p ( const gimple * s)
inline
Return true if S is a GIMPLE_DEBUG INLINE_ENTRY statement.   

References GIMPLE_DEBUG_INLINE_ENTRY, gimple_debug_inline_entry_p(), and is_gimple_debug().

Referenced by expand_gimple_basic_block(), gimple_debug_inline_entry_p(), and input_function().

◆ gimple_debug_nonbind_marker_p()

◆ gimple_debug_source_bind_get_value()

◆ gimple_debug_source_bind_get_value_ptr()

tree * gimple_debug_source_bind_get_value_ptr ( gimple * dbg)
inline
Return a pointer to the value bound to the variable in a
GIMPLE_DEBUG source bind statement.   

References gcc_gimple_checking_assert, GIMPLE_CHECK, gimple_debug_source_bind_get_value_ptr(), gimple_debug_source_bind_p(), and gimple_op_ptr().

Referenced by copy_debug_stmt(), and gimple_debug_source_bind_get_value_ptr().

◆ gimple_debug_source_bind_get_var()

◆ gimple_debug_source_bind_p()

◆ gimple_debug_source_bind_set_value()

void gimple_debug_source_bind_set_value ( gimple * dbg,
tree value )
inline
Set the value bound to the variable in a GIMPLE_DEBUG source bind
statement.   

References gcc_gimple_checking_assert, GIMPLE_CHECK, gimple_debug_source_bind_p(), gimple_debug_source_bind_set_value(), and gimple_set_op().

Referenced by gimple_build_debug_source_bind(), and gimple_debug_source_bind_set_value().

◆ gimple_debug_source_bind_set_var()

void gimple_debug_source_bind_set_var ( gimple * dbg,
tree var )
inline

◆ gimple_do_not_emit_location_p()

bool gimple_do_not_emit_location_p ( gimple * g)
inline
Return true if a location should not be emitted for this statement
by annotate_all_with_location.   

References g, GF_PLF_1, gimple_do_not_emit_location_p(), and gimple_plf().

Referenced by annotate_one_with_location(), and gimple_do_not_emit_location_p().

◆ gimple_eh_dispatch_region()

◆ gimple_eh_dispatch_set_region()

void gimple_eh_dispatch_set_region ( geh_dispatch * eh_dispatch_stmt,
int region )
inline
Set REGION to be the region number for GIMPLE_EH_DISPATCH
EH_DISPATCH_STMT.   

References gimple_eh_dispatch_set_region(), and gimple_statement_eh_ctrl::region.

Referenced by gimple_eh_dispatch_set_region(), input_gimple_stmt(), move_stmt_r(), and remap_gimple_stmt().

◆ gimple_eh_else_e_body()

◆ gimple_eh_else_e_body_ptr()

◆ gimple_eh_else_n_body()

◆ gimple_eh_else_n_body_ptr()

gimple_seq * gimple_eh_else_n_body_ptr ( geh_else * eh_else_stmt)
inline

◆ gimple_eh_else_set_e_body()

void gimple_eh_else_set_e_body ( geh_else * eh_else_stmt,
gimple_seq seq )
inline

◆ gimple_eh_else_set_n_body()

void gimple_eh_else_set_n_body ( geh_else * eh_else_stmt,
gimple_seq seq )
inline

◆ gimple_eh_filter_failure()

◆ gimple_eh_filter_failure_ptr()

gimple_seq * gimple_eh_filter_failure_ptr ( gimple * gs)
inline
Return a pointer to the sequence of statement to execute when
GIMPLE_EH_FILTER statement fails.   

References as_a(), geh_filter::failure, and gimple_eh_filter_failure_ptr().

Referenced by gimple_eh_filter_failure(), gimple_eh_filter_failure_ptr(), lower_eh_filter(), lower_omp_1(), lower_try_catch(), replace_goto_queue_1(), and walk_gimple_stmt().

◆ gimple_eh_filter_set_failure()

void gimple_eh_filter_set_failure ( geh_filter * eh_filter_stmt,
gimple_seq failure )
inline
Set FAILURE to be the sequence of statements to execute on failure
for GIMPLE_EH_FILTER EH_FILTER_STMT.   

References geh_filter::failure, and gimple_eh_filter_set_failure().

Referenced by gimple_build_eh_filter(), gimple_copy(), and gimple_eh_filter_set_failure().

◆ gimple_eh_filter_set_types()

void gimple_eh_filter_set_types ( geh_filter * eh_filter_stmt,
tree types )
inline
Set TYPES to be the set of types handled by GIMPLE_EH_FILTER
EH_FILTER_STMT.   

References gimple_eh_filter_set_types(), and geh_filter::types.

Referenced by gimple_build_eh_filter(), gimple_copy(), and gimple_eh_filter_set_types().

◆ gimple_eh_filter_types()

tree gimple_eh_filter_types ( const gimple * gs)
inline
Return the types handled by GIMPLE_EH_FILTER statement GS.   

References as_a(), gimple_eh_filter_types(), and geh_filter::types.

Referenced by dump_gimple_eh_filter(), gimple_copy(), gimple_eh_filter_types(), lower_eh_filter(), and remap_gimple_stmt().

◆ gimple_eh_filter_types_ptr()

tree * gimple_eh_filter_types_ptr ( gimple * gs)
inline
Return a pointer to the types handled by GIMPLE_EH_FILTER statement
GS.   

References as_a(), gimple_eh_filter_types_ptr(), and geh_filter::types.

Referenced by gimple_eh_filter_types_ptr(), and walk_gimple_op().

◆ gimple_eh_must_not_throw_fndecl()

tree gimple_eh_must_not_throw_fndecl ( const geh_mnt * eh_mnt_stmt)
inline
Get the function decl to be called by the MUST_NOT_THROW region.   

References geh_mnt::fndecl, and gimple_eh_must_not_throw_fndecl().

Referenced by dump_gimple_eh_must_not_throw(), gimple_eh_must_not_throw_fndecl(), lower_eh_must_not_throw(), and output_gimple_stmt().

◆ gimple_eh_must_not_throw_set_fndecl()

void gimple_eh_must_not_throw_set_fndecl ( geh_mnt * eh_mnt_stmt,
tree decl )
inline
Set the function decl to be called by GS to DECL.   

References geh_mnt::fndecl, and gimple_eh_must_not_throw_set_fndecl().

Referenced by gimple_build_eh_must_not_throw(), gimple_eh_must_not_throw_set_fndecl(), and input_gimple_stmt().

◆ gimple_expr_code()

enum tree_code gimple_expr_code ( const gimple * stmt)
inline
Return the tree code for the expression computed by STMT.  This is
only valid for GIMPLE_COND, GIMPLE_CALL and GIMPLE_ASSIGN.  For
GIMPLE_CALL, return CALL_EXPR as the expression code for
consistency.  This is useful when the caller needs to deal with the
three kinds of computation that GIMPLE supports.   

References dyn_cast(), gcc_gimple_checking_assert, gimple_assign_rhs_code(), gimple_cond_code(), and gimple_expr_code().

Referenced by gori_compute::compute_logical_operands(), gori_compute::compute_operand_range(), expand_complex_operations_1(), gimple_expr_code(), gimple_range_adjustment(), gori_stmt_info::gori_stmt_info(), init_dont_simulate_again(), is_gimple_logical_p(), omp_sese_split_blocks(), fold_using_range::relation_fold_and_or(), and complex_propagate::visit_stmt().

◆ gimple_filename()

const char * gimple_filename ( const gimple * stmt)
inline
Return the file name of the location of STMT.   

References gimple_filename(), gimple_location(), and LOCATION_FILE.

Referenced by branch_prob(), gimple_filename(), and inline_small_functions().

◆ gimple_get_alias_set()

alias_set_type gimple_get_alias_set ( tree t)
extern
Return the typed-based alias set for T, which may be an expression
or a type.  Return -1 if we don't do anything special.   

References char_type_node, get_alias_set(), gimple_get_alias_set(), gimple_signed_type(), signed_char_type_node, TREE_CODE, tree_to_uhwi(), lang_hooks_for_types::type_for_size, TYPE_P, TYPE_SIZE, TYPE_UNSIGNED, lang_hooks::types, and unsigned_char_type_node.

Referenced by gimple_build_debug_inline_entry(), and gimple_get_alias_set().

◆ gimple_get_lhs()

tree gimple_get_lhs ( const gimple * stmt)
Return the LHS of a statement that performs an assignment,
either a GIMPLE_ASSIGN or a GIMPLE_CALL.  Returns NULL_TREE
for a call to a function that returns no value, or for a
statement other than an assignment or a call.   

References gimple_assign_lhs(), gimple_call_lhs(), gimple_get_lhs(), gimple_phi_result(), and NULL_TREE.

Referenced by assume_query::assume_query(), attempt_builtin_powi(), back_propagate_equivalences(), substitute_and_fold_dom_walker::before_dom_children(), addsub_pattern::build(), complex_pattern::build_common(), assume_query::calculate_op(), assume_query::calculate_phi(), loop_cand::classify_simple_reduction(), ipa_icf_gimple::func_checker::compare_gimple_call(), gori_compute::compute_operand1_range(), gori_compute::compute_operand2_range(), cond_if_else_store_replacement(), cond_removal_in_builtin_zero_pattern(), convert_mult_to_fma(), convert_mult_to_fma_1(), create_expression_by_pieces(), discover_nonconstant_array_refs(), eliminate_dom_walker::eliminate_cleanup(), eliminate_redundant_comparison(), eliminate_redundant_computations(), eliminate_dom_walker::eliminate_stmt(), emit_cmp_and_jump_insns(), evaluate_stmt(), execute_fixup_cfg(), execute_update_addresses_taken(), expand_complex_operations_1(), find_assumption_locals_r(), find_func_clobbers(), fold_relations(), fold_using_range::fold_stmt(), forward_propagate_addr_expr(), vec_info::free_stmt_vec_info(), ranger_cache::get_global_range(), gimple_build_debug_inline_entry(), gimple_could_trap_p_1(), gimple_duplicate_bb(), gimple_equal_p(), gimple_get_lhs(), gimple_lower_bitint(), gimple_range_type(), gimple_regimplify_operands(), gimple_replace_ssa_lhs(), gimple_set_modified(), gimple_store_p(), gsi_replace(), ifcvt_local_dce(), initialize_ao_ref_for_dse(), input_gimple_stmt(), gimple_range_op_handler::lhs(), avail_exprs_stack::lookup_avail_expr(), lower_eh_constructs_2(), make_blocks_1(), make_new_ssa_for_def(), mark_aliased_reaching_defs_necessary_1(), mark_lhs_in_seq_for_dce(), maybe_remove_writeonly_store(), move_computations_worker(), move_stmt(), movement_possibility_1(), ref_always_stored::operator()(), optimize_mask_stores(), permute_vec_elements(), possible_vector_mask_operation_p(), pp_gimple_stmt_1(), predicate_rhs_code(), predicate_statements(), fold_using_range::range_of_address(), ranger_cache::range_of_def(), gimple_ranger::range_of_expr(), dom_ranger::range_of_stmt(), gimple_ranger::range_of_stmt(), range_query::range_of_stmt(), reassociate_bb(), relation_oracle::record(), jt_state::register_equivs_stmt(), gimple_ranger::register_inferred_ranges(), fur_relation::register_relation(), gimple_ranger::register_transitive_inferred_ranges(), remove_prop_source_from_use(), scc_copy_prop::replace_scc_by_value(), replace_stmt_with_simplification(), simd_clone_adjust(), simplify_builtin_memcpy_memset(), vect_optimize_slp_pass::start_choosing_layouts(), statement_sink_location(), stmt_kills_ref_p(), stmt_makes_single_store(), loop_distribution::transform_reduction_loop(), undistribute_bitref_for_vector(), undistribute_ops_list(), update_complex_components(), uses_consumed_by_stmt(), range_query::value_of_stmt(), substitute_and_fold_engine::value_of_stmt(), vect_analyze_slp_reduc_chain(), vect_build_slp_instance(), vect_build_slp_tree_1(), vect_build_slp_tree_3(), vect_convert_input(), vect_convert_output(), vect_create_epilog_for_reduction(), vect_create_vectorized_promotion_stmts(), vect_determine_min_output_precision(), vect_finish_replace_stmt(), vect_get_and_check_slp_defs(), vect_get_slp_scalar_def(), vect_get_vector_types_for_stmt(), vect_is_simple_use(), vect_mark_pattern_stmts(), vect_mark_stmts_to_be_vectorized(), vect_recog_bit_insert_pattern(), vect_recog_bitfield_ref_pattern(), vect_recog_dot_prod_pattern(), vect_recog_gather_scatter_pattern(), vect_recog_popcount_clz_ctz_ffs_pattern(), vect_recog_sad_pattern(), vect_recog_widen_op_pattern(), vect_recog_widen_sum_pattern(), vect_slp_check_for_roots(), vect_slp_convert_to_external(), vect_slp_function(), vect_slp_linearize_chain(), vect_split_statement(), vect_transform_loop(), vect_transform_reduction(), vect_widened_op_tree(), vectorizable_comparison_1(), vectorizable_condition(), vectorizable_conversion(), vectorizable_induction(), vectorizable_live_operation(), vectorizable_simd_clone_call(), vectorizable_store(), vectorize_fold_left_reduction(), vectorize_slp_instance_root_stmt(), visit_assignment(), and complex_propagate::visit_stmt().

◆ gimple_goto_dest()

◆ gimple_goto_set_dest()

void gimple_goto_set_dest ( ggoto * gs,
tree dest )
inline
Set DEST to be the destination of the unconditional jump GS.   

References gimple_goto_set_dest(), and gimple_statement_with_ops::op.

Referenced by adjust_assumption_stmt_r(), cleanup_dead_labels(), gimple_build_goto(), and gimple_goto_set_dest().

◆ gimple_has_lhs()

◆ gimple_has_location()

◆ gimple_has_mem_ops()

◆ gimple_has_ops()

bool gimple_has_ops ( const gimple * g)
inline

◆ gimple_has_side_effects()

◆ gimple_has_substatements()

bool gimple_has_substatements ( gimple * g)
inline
Return true if statement G has sub-statements.  This is only true for
High GIMPLE statements.   

References g, and gimple_has_substatements().

Referenced by gimple_copy(), gimple_has_substatements(), lower_coro_builtin(), lower_sequence_no_tm(), lower_sequence_tm(), make_tm_uninst(), remap_gimple_stmt(), and walk_gimple_stmt().

◆ gimple_has_volatile_ops()

◆ gimple_in_transaction()

bool gimple_in_transaction ( const gimple * stmt)
inline
Return true if STMT is in a transaction.   

References bb_in_transaction(), gimple_bb(), and gimple_in_transaction().

Referenced by gimple_in_transaction(), and movement_possibility_1().

◆ gimple_inexpensive_call_p()

◆ gimple_init()

void gimple_init ( gimple * g,
enum gimple_code code,
unsigned num_ops )
Initialize GIMPLE statement G with CODE and NUM_OPS.   

References g, gimple_init(), gimple_init_singleton(), gimple_set_code(), and gimple_set_num_ops().

Referenced by gimple_alloc(), gimple_init(), and maybe_fold_comparisons_from_match_pd().

◆ gimple_init_singleton()

void gimple_init_singleton ( gimple * g)
inline
Make statement G a singleton sequence.   

References g, gimple_init_singleton(), and NULL.

Referenced by gimple_assign_set_rhs_with_ops(), gimple_copy(), gimple_init(), gimple_init_singleton(), and make_phi_node().

◆ gimple_ior_addresses_taken()

bool gimple_ior_addresses_taken ( bitmap addresses_taken,
gimple * stmt )
extern
Set the bit for the uid of all decls that have their address taken
in STMT in the ADDRESSES_TAKEN bitmap.  Returns true if there
were any in this stmt.   

References gimple_ior_addresses_taken(), gimple_ior_addresses_taken_1(), NULL, and walk_stmt_load_store_addr_ops().

Referenced by execute_update_addresses_taken(), gimple_build_debug_inline_entry(), and gimple_ior_addresses_taken().

◆ gimple_label_label()

◆ gimple_label_set_label()

void gimple_label_set_label ( glabel * gs,
tree label )
inline
Set LABEL to be the LABEL_DECL node used by GIMPLE_LABEL statement
GS.   

References gimple_label_set_label(), and gimple_statement_with_ops::op.

Referenced by gimple_build_label(), and gimple_label_set_label().

◆ gimple_lineno()

int gimple_lineno ( const gimple * stmt)
inline
Return the line number of the location of STMT.   

References gimple_lineno(), gimple_location(), and LOCATION_LINE.

Referenced by branch_prob(), gimple_lineno(), and inline_small_functions().

◆ gimple_location()

location_t gimple_location ( const gimple * g)
inline
Return location information for statement G.   

References g, and gimple_location().

Referenced by add_field_for_reduction(), adjust_nested_loop_clauses(), asan_expand_check_ifn(), asan_expand_mark_ifn(), asan_expand_poison_ifn(), assign_discriminators(), assign_discriminators_to_bb(), assign_discriminators_to_stmt(), attempt_builtin_copysign(), attempt_builtin_powi(), branch_fixup(), branch_prob(), tree_switch_conversion::switch_conversion::build_arrays(), complex_pattern::build_common(), calls_builtin_apply_args_p(), can_strub_internally_p(), array_bounds_checker::check_array_bounds(), check_bounds_or_overlap(), check_oacc_kernel_gwv(), check_omp_nesting_restrictions(), loop_distribution::classify_partition(), collect_fallthrough_labels(), combine_cond_expr_cond(), compute_access_range(), compute_avail(), cond_if_else_store_replacement_1(), cond_store_replacement(), cond_store_replacement_limited(), convert_expand_mult_copysign(), convert_gimple_call(), convert_local_reference_stmt(), convert_mult_to_highpart(), convert_mult_to_widen(), convert_nonlocal_reference_stmt(), convert_plusminus_to_widen(), convert_tramp_reference_stmt(), copy_bb(), copy_prop_visit_cond_stmt(), create_mul_high_seq(), create_mul_low_seq(), create_omp_child_function(), create_phi_for_local_result(), create_task_copyfn(), decode_field_reference(), decompose_kernels_region_body(), diag_returned_locals(), diagnose_assume_labels(), diagnose_tm_1(), diagnose_tm_1_op(), do_warn_aggressive_loop_optimizations(), do_warn_nonnull_compare(), do_warn_unused_result(), dump_user_location_t::dump_user_location_t(), duplicate_loop_body_to_header_edge(), eliminate_tail_call(), eliminate_unnecessary_stmts(), tree_switch_conversion::switch_decision_tree::emit(), emit_warn_switch_unreachable(), execute_early_expand_coro_ifns(), execute_oacc_device_lower(), execute_omp_device_lower(), execute_update_addresses_taken(), expand_arith_overflow(), expand_asm_stmt(), expand_assign_tm(), expand_call_inline(), expand_call_stmt(), expand_call_tm(), expand_complex_addition(), expand_complex_asm(), expand_complex_comparison(), expand_complex_conjugate(), expand_complex_div_straight(), expand_complex_div_wide(), expand_complex_division(), expand_complex_move(), expand_complex_multiplication(), expand_complex_negation(), expand_complex_paren(), expand_DIVMOD(), expand_expr_real_gassign(), expand_FALLTHROUGH(), expand_FALLTHROUGH_r(), expand_gimple_basic_block(), expand_gimple_cond(), expand_gimple_stmt(), expand_gimple_stmt_1(), expand_ifn_va_arg_1(), expand_oacc_for(), expand_omp(), expand_omp_atomic_cas(), expand_omp_atomic_fetch_op(), expand_omp_atomic_load(), expand_omp_atomic_pipeline(), expand_omp_atomic_store(), expand_omp_for(), expand_omp_ordered_source_sink(), expand_omp_target(), expand_parallel_call(), expand_task_call(), expand_transaction(), expand_UBSAN_CHECK_ADD(), expand_UBSAN_CHECK_MUL(), expand_UBSAN_CHECK_SUB(), expand_vector_comparison(), expand_vector_condition(), expand_vector_conversion(), expand_vector_parallel(), expand_vector_piecewise(), expr_expected_value_1(), factor_out_conditional_load(), factor_out_conditional_operation(), factor_out_operators(), find_conditions(), find_implicit_erroneous_behavior(), find_loop_location(), find_tail_calls(), finish_taskreg_scan(), finish_update_gimple_call(), fold_builtin_alloca_with_align(), fold_call_stmt(), fold_gimple_assign(), forward_propagate_addr_expr_1(), frob_into_branch_around(), fuse_loops(), tree_switch_conversion::switch_conversion::gen_inbound_check(), gen_parallel_loop(), autofdo::autofdo_source_profile::get_callsite_total_count(), autofdo::autofdo_source_profile::get_count_info(), autofdo::get_inline_stack_in_node(), get_lineno(), get_location(), get_location(), autofdo::get_relative_location_for_stmt(), get_string_length(), get_ws_args_for(), gimple_assign_rhs_to_tree(), gimple_build_debug_bind(), gimple_build_debug_source_bind(), gimple_call_copy_skip_args(), gimple_call_set_fndecl(), gimple_can_merge_blocks_p(), gimple_expand_builtin_cabs(), gimple_expand_vec_cond_expr(), gimple_expand_vec_set_extract_expr(), gimple_filename(), gimple_fold_builtin_acc_on_device(), gimple_fold_builtin_clear_padding(), gimple_fold_builtin_fwrite(), gimple_fold_builtin_memory_chk(), gimple_fold_builtin_memory_op(), gimple_fold_builtin_memset(), gimple_fold_builtin_stdarg(), gimple_fold_builtin_stpcpy(), gimple_fold_builtin_strcat(), gimple_fold_builtin_strchr(), gimple_fold_builtin_strcpy(), gimple_fold_builtin_string_compare(), gimple_fold_builtin_strncat(), gimple_fold_builtin_strncpy(), gimple_fold_builtin_stxcpy_chk(), gimple_fold_call(), gimple_fold_partial_load_store(), gimple_fold_stmt_to_constant_1(), gimple_has_location(), gimple_lineno(), gimple_location(), gimple_location_safe(), gimple_lower_bitint(), gimple_nonartificial_location(), gimple_simplify_phiopt(), gimplify_build1(), gimplify_build2(), gimplify_build3(), gimplify_omp_workshare(), gsi_insert_finally_seq_after_call(), gsi_replace(), gsi_replace_with_seq_vops(), handle_abnormal_edges(), handle_builtin_alloca(), strlen_pass::handle_builtin_memcpy(), strlen_pass::handle_builtin_strcat(), strlen_pass::handle_builtin_strchr(), strlen_pass::handle_builtin_strcpy(), strlen_pass::handle_builtin_strlen(), handle_printf_call(), strlen_pass::handle_store(), honor_protect_cleanup_actions(), ifcombine_ifandif(), in_pragma_suppress_coverage_p(), access_ref::inform_access(), init_copyid_allocator(), init_range_entry(), init_tmp_var(), init_tmp_var_with_call(), initialize_reductions(), inline_small_functions(), insert_initializers(), insert_iv_increment(), instrument_bool_enum_load(), instrument_builtin(), instrument_builtin_call(), instrument_builtin_call(), instrument_expr(), instrument_func_exit(), instrument_mem_ref(), instrument_nonnull_arg(), instrument_nonnull_return(), instrument_object_size(), instrument_pointer_overflow(), instrument_si_overflow(), introduce_cast_before_cand(), ipa_tm_diagnose_tm_safe(), ipa_tm_diagnose_transaction(), ipa_tm_scan_irr_block(), is_addr_local(), long_mul_apply_extras(), long_mul_split_phi(), lower_assumption(), lower_builtin_setjmp(), lower_catch(), lower_eh_constructs_2(), lower_eh_dispatch(), lower_eh_filter(), lower_eh_must_not_throw(), lower_emutls_stmt(), lower_gimple_return(), lower_long_mul_high_chain(), lower_omp_1(), lower_omp_critical(), lower_omp_for(), lower_omp_master(), lower_omp_single_copy(), lower_omp_single_simple(), lower_omp_target(), lower_omp_taskreg(), lower_omp_teams(), lower_resx(), lower_try_finally_copy(), lower_try_finally_dup_block(), lower_try_finally_fallthru_label(), lower_try_finally_nofallthru(), lower_try_finally_onedest(), lower_try_finally_switch(), lower_vec_perm(), make_bit_field_load(), make_blocks_1(), make_cond_expr_edges(), make_edges_bb(), make_goto_expr_edges(), lazy_diagnostic_context_path::make_inner_path(), make_item_for_dump_gimple_expr(), make_item_for_dump_gimple_stmt(), make_region_loop_nest(), autofdo::function_instance::match(), match_long_mul_phi(), autofdo::match_with_target(), maybe_add_asan_poison_write(), maybe_error_musttail(), maybe_instrument_assignment(), maybe_instrument_call(), maybe_optimize_arith_overflow(), maybe_optimize_mod_cmp(), maybe_optimize_pow2p_mod_cmp(), maybe_optimize_ubsan_null_ifn(), maybe_record_in_goto_queue(), maybe_remove_forwarder_block(), maybe_warn_operand(), maybe_warn_pass_by_reference(), maybe_warn_pointless_strcmp(), maybe_warn_read_write_only(), merge_stmts_p(), ipa_param_body_adjustments::modify_assignment(), ipa_param_adjustments::modify_call(), ipa_param_body_adjustments::modify_call_stmt(), narrow_long_mul_halves(), narrow_long_mul_low_half(), new_oacc_loop(), new_oacc_loop_routine(), oacc_privatization_scan_decl_chain(), omp_extract_for_data(), omp_oacc_kernels_decompose_1(), optimize_range_tests_to_bit_test(), dom_opt_dom_walker::optimize_stmt(), optimize_strlen_comp(), optimize_vector_load(), output_gimple_stmt(), phiprop_insert_phi(), pp_gimple_stmt_1(), predicate_bbs(), reassociate_bb(), record_edge_info(), remove_exits_and_undefined_stmts(), autofdo::autofdo_source_profile::remove_icall_target(), replace_call_with_call_and_fold(), replace_conditional_candidate(), replace_goto_queue_1(), replace_goto_queue_cond_clause(), replace_loop_annotate(), replace_mult_candidate(), replace_one_candidate(), replace_profitable_candidates(), rewrite_add_phi_arguments(), rewrite_to_defined_unconditional(), rewrite_update_phi_arguments(), rhs_to_tree(), save_tmp_var(), scan_omp_1_stmt(), scan_omp_for(), scan_omp_parallel(), scan_omp_simd(), scan_omp_single(), scan_omp_target(), scan_omp_task(), scan_omp_teams(), set_location_for_edge(), shrink_wrap_len_call(), shrink_wrap_one_built_in_call_with_conds(), simplify_builtin_memchr(), simplify_builtin_memcmp(), simplify_count_zeroes(), simplify_using_ranges::simplify_internal_call_using_ranges(), simplify_phi_result_movdiv(), sra_modify_assign(), sra_modify_call_arg(), sra_modify_constructor_assign(), sra_modify_deferred_init(), sra_modify_expr(), stmt_uses_0_or_null_in_undefined_way(), suitable_for_tail_call_opt_p(), task_copyfn_remap_type(), ter_is_replaceable_p(), transform_kernels_loop_clauses(), loop_distribution::transform_reduction_loop(), tree_switch_conversion::switch_decision_tree::try_switch_expansion(), ubsan_expand_bounds_ifn(), ubsan_expand_null_ifn(), ubsan_expand_objsize_ifn(), ubsan_expand_ptr_ifn(), ubsan_expand_vptr_ifn(), ubsan_instrument_unreachable(), autofdo::autofdo_source_profile::update_inlined_ind_target(), update_range_test(), use_internal_fn(), vect_do_peeling(), vect_finish_stmt_generation_1(), vect_loop_versioning(), vect_recog_abd_pattern(), vect_recog_average_pattern(), vect_recog_build_binary_gimple_stmt(), vect_recog_cast_forwprop_pattern(), vect_recog_cond_store_pattern(), vect_recog_ctz_ffs_pattern(), vect_recog_divmod_pattern(), vect_recog_mulhs_pattern(), vect_recog_over_widening_pattern(), vect_recog_popcount_clz_ctz_ffs_pattern(), vect_recog_sat_trunc_pattern(), vect_recog_widen_abd_pattern(), vect_slp_bbs(), vect_transform_loop(), verify_gimple_in_cfg(), verify_strub(), visit_loops_in_gang_single_region(), walk_gimple_omp_for(), walk_gimple_stmt(), warn_implicit_fallthrough_r(), warn_switch_unreachable_and_auto_init_r(), warn_uninit(), and warn_uninit_phi_uses().

◆ gimple_location_ptr()

location_t * gimple_location_ptr ( gimple * g)
inline
Return address of the location information for statement G.   

References g, and gimple_location_ptr().

Referenced by gimple_location_ptr(), and input_gimple_stmt().

◆ gimple_location_safe()

location_t gimple_location_safe ( const gimple * g)
inline
Return location information for statement G if g is not NULL.
Otherwise, UNKNOWN_LOCATION is returned.   

References g, gimple_location(), gimple_location_safe(), and UNKNOWN_LOCATION.

Referenced by gimple_location_safe().

◆ gimple_modified_p()

bool gimple_modified_p ( const gimple * g)
inline
Return true if statement G has operands and the modified field has
been set.   

References bool, g, gimple_has_ops(), and gimple_modified_p().

Referenced by gimple_modified_p(), initialize_flags_in_bb(), dom_opt_dom_walker::optimize_stmt(), update_stmt_if_modified(), update_stmt_operands(), verify_imm_links(), and verify_ssa().

◆ gimple_move_vops()

◆ gimple_no_warning_p()

bool gimple_no_warning_p ( const gimple * stmt)
inline
Return true if no warnings should be emitted for statement STMT.   

References gimple_no_warning_p().

Referenced by gimple_no_warning_p(), and output_gimple_stmt().

◆ gimple_nonartificial_location()

location_t gimple_nonartificial_location ( const gimple * g)
inline

◆ gimple_nop_p()

◆ gimple_num_args()

◆ gimple_num_ops()

unsigned gimple_num_ops ( const gimple * gs)
inline
Return the number of operands for statement GS.   

References gimple_num_ops(), and gimple::num_ops.

Referenced by analyze_function_body(), gimple_range_op_handler::calc_op1(), check_call(), clear_unused_block_pointer(), ipa_icf_gimple::func_checker::compare_gimple_assign(), hybrid_jt_simplifier::compute_exit_dependencies(), dump_gimple_assign(), eliminated_by_inlining_prob(), crc_symbolic_execution::execute_assign_statement(), expand_complex_move(), expand_complex_operations_1(), expand_omp_target(), expand_omp_taskreg(), find_func_aliases(), find_tail_calls(), fold_stmt_1(), gimple_assign_rhs2(), gimple_assign_rhs2_ptr(), gimple_assign_rhs3(), gimple_assign_rhs3_ptr(), gimple_assign_set_rhs2(), gimple_assign_set_rhs3(), gimple_assign_set_rhs_with_ops(), gimple_call_arg(), gimple_call_arg_ptr(), gimple_call_num_args(), gimple_call_set_arg(), gimple_copy(), gimple_could_trap_p_1(), gimple_duplicate_bb(), gimple_fold_builtin_snprintf_chk(), gimple_fold_builtin_sprintf_chk(), gimple_lower_bitint(), gimple_num_args(), gimple_num_ops(), gimple_op(), gimple_op_ptr(), gimple_regimplify_operands(), gimple_set_op(), gimple_switch_label(), gimple_switch_num_labels(), gimple_switch_set_label(), ipa_icf::sem_function::hash_stmt(), init_dont_simulate_again(), init_vn_nary_op_from_stmt(), likely_value(), autofdo::function_instance::match(), op1_range(), vars_ssa_cache::operator()(), output_gimple_stmt(), operands_scanner::parse_ssa_operands(), fur_relation::register_relation(), remove_unused_locals(), replace_stmt_with_simplification(), replace_uses_by(), rewrite_to_defined_unconditional(), rewrite_use_nonlinear_expr(), stmt_could_throw_1_p(), vect_determine_mask_precision(), vect_determine_precisions_from_range(), vect_mark_stmts_to_be_vectorized(), vect_recog_over_widening_pattern(), vectorizable_lane_reducing(), vn_nary_length_from_stmt(), walk_gimple_op(), and walk_stmt_load_store_addr_ops().

◆ gimple_omp_atomic_load_lhs()

tree gimple_omp_atomic_load_lhs ( const gomp_atomic_load * load_stmt)
inline

◆ gimple_omp_atomic_load_lhs_ptr()

tree * gimple_omp_atomic_load_lhs_ptr ( gomp_atomic_load * load_stmt)
inline
Return a pointer to the LHS of an atomic load.   

References gimple_omp_atomic_load_lhs_ptr(), and gomp_atomic_load::lhs.

Referenced by gimple_omp_atomic_load_lhs_ptr(), and walk_gimple_op().

◆ gimple_omp_atomic_load_rhs()

tree gimple_omp_atomic_load_rhs ( const gomp_atomic_load * load_stmt)
inline

◆ gimple_omp_atomic_load_rhs_ptr()

tree * gimple_omp_atomic_load_rhs_ptr ( gomp_atomic_load * load_stmt)
inline

◆ gimple_omp_atomic_load_set_lhs()

void gimple_omp_atomic_load_set_lhs ( gomp_atomic_load * load_stmt,
tree lhs )
inline

◆ gimple_omp_atomic_load_set_rhs()

void gimple_omp_atomic_load_set_rhs ( gomp_atomic_load * load_stmt,
tree rhs )
inline

◆ gimple_omp_atomic_memory_order()

◆ gimple_omp_atomic_need_value_p()

bool gimple_omp_atomic_need_value_p ( const gimple * g)
inline

◆ gimple_omp_atomic_set_memory_order()

void gimple_omp_atomic_set_memory_order ( gimple * g,
enum omp_memory_order mo )
inline

◆ gimple_omp_atomic_set_need_value()

void gimple_omp_atomic_set_need_value ( gimple * g)
inline
Set the GF_OMP_ATOMIC_NEED_VALUE flag on G.   

References g, GF_OMP_ATOMIC_NEED_VALUE, GIMPLE_CHECK, and gimple_omp_atomic_set_need_value().

Referenced by gimple_omp_atomic_set_need_value(), and gimplify_omp_atomic().

◆ gimple_omp_atomic_set_weak()

void gimple_omp_atomic_set_weak ( gimple * g)
inline
Set the GF_OMP_ATOMIC_WEAK flag on G.   

References g, GF_OMP_ATOMIC_WEAK, GIMPLE_CHECK, and gimple_omp_atomic_set_weak().

Referenced by gimple_omp_atomic_set_weak(), and gimplify_omp_atomic().

◆ gimple_omp_atomic_store_set_val()

void gimple_omp_atomic_store_set_val ( gomp_atomic_store * store_stmt,
tree val )
inline

◆ gimple_omp_atomic_store_val()

tree gimple_omp_atomic_store_val ( const gomp_atomic_store * store_stmt)
inline

◆ gimple_omp_atomic_store_val_ptr()

tree * gimple_omp_atomic_store_val_ptr ( gomp_atomic_store * store_stmt)
inline
Return a pointer to the value being stored in an atomic store.   

References gimple_omp_atomic_store_val_ptr(), and gimple_statement_omp_atomic_store_layout::val.

Referenced by gimple_omp_atomic_store_val_ptr(), and walk_gimple_op().

◆ gimple_omp_atomic_weak_p()

bool gimple_omp_atomic_weak_p ( const gimple * g)
inline
Return true if OMP atomic load/store statement G has the
GF_OMP_ATOMIC_WEAK flag set.   

References g, GF_OMP_ATOMIC_WEAK, GIMPLE_CHECK, gimple_omp_atomic_weak_p(), and gimple_omp_subcode().

Referenced by dump_gimple_omp_atomic_load(), dump_gimple_omp_atomic_store(), expand_omp_atomic_cas(), and gimple_omp_atomic_weak_p().

◆ gimple_omp_body()

◆ gimple_omp_body_ptr()

◆ gimple_omp_continue_control_def()

◆ gimple_omp_continue_control_def_ptr()

tree * gimple_omp_continue_control_def_ptr ( gomp_continue * cont_stmt)
inline
The same as above, but return the address.   

References gomp_continue::control_def, and gimple_omp_continue_control_def_ptr().

Referenced by gimple_omp_continue_control_def_ptr(), and walk_gimple_op().

◆ gimple_omp_continue_control_use()

◆ gimple_omp_continue_control_use_ptr()

tree * gimple_omp_continue_control_use_ptr ( gomp_continue * cont_stmt)
inline
The same as above, but return the address.   

References gomp_continue::control_use, and gimple_omp_continue_control_use_ptr().

Referenced by gimple_omp_continue_control_use_ptr(), and walk_gimple_op().

◆ gimple_omp_continue_set_control_def()

void gimple_omp_continue_set_control_def ( gomp_continue * cont_stmt,
tree def )
inline
Set the definition of the control variable in a GIMPLE_OMP_CONTINUE.   

References gomp_continue::control_def, and gimple_omp_continue_set_control_def().

Referenced by gimple_build_omp_continue(), and gimple_omp_continue_set_control_def().

◆ gimple_omp_continue_set_control_use()

void gimple_omp_continue_set_control_use ( gomp_continue * cont_stmt,
tree use )
inline
Set the use of the control variable in a GIMPLE_OMP_CONTINUE.   

References gomp_continue::control_use, and gimple_omp_continue_set_control_use().

Referenced by gimple_build_omp_continue(), and gimple_omp_continue_set_control_use().

◆ gimple_omp_critical_clauses()

tree gimple_omp_critical_clauses ( const gomp_critical * crit_stmt)
inline
Return the clauses associated with OMP_CRITICAL statement CRIT_STMT.   

References gomp_critical::clauses, and gimple_omp_critical_clauses().

Referenced by dump_gimple_omp_critical(), gimple_copy(), gimple_omp_critical_clauses(), and remap_gimple_stmt().

◆ gimple_omp_critical_clauses_ptr()

tree * gimple_omp_critical_clauses_ptr ( gomp_critical * crit_stmt)
inline
Return a pointer to the clauses associated with OMP critical statement
CRIT_STMT.   

References gomp_critical::clauses, and gimple_omp_critical_clauses_ptr().

Referenced by gimple_omp_critical_clauses_ptr(), and walk_gimple_op().

◆ gimple_omp_critical_name()

tree gimple_omp_critical_name ( const gomp_critical * crit_stmt)
inline

◆ gimple_omp_critical_name_ptr()

tree * gimple_omp_critical_name_ptr ( gomp_critical * crit_stmt)
inline
Return a pointer to the name associated with OMP critical statement
CRIT_STMT.   

References gimple_omp_critical_name_ptr(), and gomp_critical::name.

Referenced by gimple_omp_critical_name_ptr(), and walk_gimple_op().

◆ gimple_omp_critical_set_clauses()

void gimple_omp_critical_set_clauses ( gomp_critical * crit_stmt,
tree clauses )
inline
Set CLAUSES to be the clauses associated with OMP critical statement
CRIT_STMT.   

References gomp_critical::clauses, and gimple_omp_critical_set_clauses().

Referenced by gimple_build_omp_critical(), gimple_copy(), and gimple_omp_critical_set_clauses().

◆ gimple_omp_critical_set_name()

void gimple_omp_critical_set_name ( gomp_critical * crit_stmt,
tree name )
inline
Set NAME to be the name associated with OMP critical statement
CRIT_STMT.   

References gimple_omp_critical_set_name(), and gomp_critical::name.

Referenced by gimple_build_omp_critical(), gimple_copy(), and gimple_omp_critical_set_name().

◆ gimple_omp_dispatch_clauses()

tree gimple_omp_dispatch_clauses ( const gimple * gs)
inline
Return the clauses associated with OMP_DISPATCH statement GS.   

References GIMPLE_CHECK, and gimple_omp_dispatch_clauses().

Referenced by dump_gimple_omp_dispatch(), gimple_copy(), gimple_omp_dispatch_clauses(), and remap_gimple_stmt().

◆ gimple_omp_dispatch_clauses_ptr()

tree * gimple_omp_dispatch_clauses_ptr ( gimple * gs)
inline
Return a pointer to the clauses associated with OMP dispatch statement
GS.   

References GIMPLE_CHECK, and gimple_omp_dispatch_clauses_ptr().

Referenced by gimple_omp_dispatch_clauses_ptr().

◆ gimple_omp_dispatch_set_clauses()

void gimple_omp_dispatch_set_clauses ( gimple * gs,
tree clauses )
inline
Set CLAUSES to be the clauses associated with OMP dispatch statement
GS.   

References GIMPLE_CHECK, and gimple_omp_dispatch_set_clauses().

Referenced by gimple_build_omp_dispatch(), gimple_copy(), and gimple_omp_dispatch_set_clauses().

◆ gimple_omp_for_clauses()

◆ gimple_omp_for_clauses_ptr()

tree * gimple_omp_for_clauses_ptr ( gimple * gs)
inline

◆ gimple_omp_for_collapse()

◆ gimple_omp_for_combined_into_p()

◆ gimple_omp_for_combined_p()

◆ gimple_omp_for_cond()

enum tree_code gimple_omp_for_cond ( const gimple * gs,
size_t i )
inline

◆ gimple_omp_for_final()

tree gimple_omp_for_final ( const gimple * gs,
size_t i )
inline

◆ gimple_omp_for_final_ptr()

tree * gimple_omp_for_final_ptr ( gimple * gs,
size_t i )
inline

◆ gimple_omp_for_incr()

tree gimple_omp_for_incr ( const gimple * gs,
size_t i )
inline

◆ gimple_omp_for_incr_ptr()

tree * gimple_omp_for_incr_ptr ( gimple * gs,
size_t i )
inline
Return a pointer to the increment value for the OMP_FOR statement GS.   

References as_a(), gcc_gimple_checking_assert, gimple_omp_for_incr_ptr(), i, gimple_omp_for_iter::incr, and gomp_for::iter.

Referenced by gimple_omp_for_incr_ptr(), scan_omp_for(), and walk_gimple_op().

◆ gimple_omp_for_index()

◆ gimple_omp_for_index_ptr()

tree * gimple_omp_for_index_ptr ( gimple * gs,
size_t i )
inline
Return a pointer to the index variable for the OMP_FOR statement GS.   

References as_a(), gcc_gimple_checking_assert, gimple_omp_for_index_ptr(), i, gimple_omp_for_iter::index, and gomp_for::iter.

Referenced by gimple_omp_for_index_ptr(), scan_omp_for(), walk_gimple_omp_for(), and walk_gimple_op().

◆ gimple_omp_for_initial()

tree gimple_omp_for_initial ( const gimple * gs,
size_t i )
inline

◆ gimple_omp_for_initial_ptr()

tree * gimple_omp_for_initial_ptr ( gimple * gs,
size_t i )
inline

◆ gimple_omp_for_kind()

◆ gimple_omp_for_pre_body()

gimple_seq gimple_omp_for_pre_body ( const gimple * gs)
inline

◆ gimple_omp_for_pre_body_ptr()

gimple_seq * gimple_omp_for_pre_body_ptr ( gimple * gs)
inline
Return a pointer to the sequence of statements to execute before the OMP_FOR
statement GS starts.   

References as_a(), gimple_omp_for_pre_body_ptr(), and gomp_for::pre_body.

Referenced by convert_gimple_call(), diagnose_sb_2(), gimple_omp_for_pre_body(), gimple_omp_for_pre_body_ptr(), lower_omp_for(), scan_omp_for(), walk_gimple_omp_for(), and walk_gimple_stmt().

◆ gimple_omp_for_set_clauses()

◆ gimple_omp_for_set_combined_into_p()

void gimple_omp_for_set_combined_into_p ( gomp_for * g,
bool combined_p )
inline
Set the GF_OMP_FOR_COMBINED_INTO field in the OMP_FOR statement G depending
on the boolean value of COMBINED_P.   

References g, GF_OMP_FOR_COMBINED_INTO, and gimple_omp_for_set_combined_into_p().

Referenced by gimple_omp_for_set_combined_into_p(), and gimplify_omp_for().

◆ gimple_omp_for_set_combined_p()

void gimple_omp_for_set_combined_p ( gomp_for * g,
bool combined_p )
inline
Set the GF_OMP_FOR_COMBINED field in the OMP_FOR statement G depending on
the boolean value of COMBINED_P.   

References g, GF_OMP_FOR_COMBINED, and gimple_omp_for_set_combined_p().

Referenced by gimple_omp_for_set_combined_p(), and gimplify_omp_for().

◆ gimple_omp_for_set_cond()

void gimple_omp_for_set_cond ( gimple * gs,
size_t i,
enum tree_code cond )
inline

◆ gimple_omp_for_set_final()

void gimple_omp_for_set_final ( gimple * gs,
size_t i,
tree final )
inline

◆ gimple_omp_for_set_incr()

void gimple_omp_for_set_incr ( gimple * gs,
size_t i,
tree incr )
inline

◆ gimple_omp_for_set_index()

void gimple_omp_for_set_index ( gimple * gs,
size_t i,
tree index )
inline

◆ gimple_omp_for_set_initial()

void gimple_omp_for_set_initial ( gimple * gs,
size_t i,
tree initial )
inline

◆ gimple_omp_for_set_kind()

void gimple_omp_for_set_kind ( gomp_for * g,
int kind )
inline
Set the kind of the OMP_FOR statement G.   

References g, GF_OMP_FOR_KIND_MASK, and gimple_omp_for_set_kind().

Referenced by gimple_build_omp_for(), and gimple_omp_for_set_kind().

◆ gimple_omp_for_set_pre_body()

void gimple_omp_for_set_pre_body ( gimple * gs,
gimple_seq pre_body )
inline
Set PRE_BODY to be the sequence of statements to execute before the
OMP_FOR statement GS starts.   

References as_a(), gimple_omp_for_set_pre_body(), and gomp_for::pre_body.

Referenced by gimple_build_omp_for(), gimple_copy(), gimple_omp_for_set_pre_body(), gimplify_omp_for(), lower_omp_for(), and walk_gimple_omp_for().

◆ gimple_omp_interop_clauses()

tree gimple_omp_interop_clauses ( const gimple * gs)
inline
Return the clauses associated with OMP_INTEROP statement GS.   

References GIMPLE_CHECK, and gimple_omp_interop_clauses().

Referenced by dump_gimple_omp_interop(), gimple_copy(), gimple_omp_interop_clauses(), and lower_omp_interop().

◆ gimple_omp_interop_clauses_ptr()

tree * gimple_omp_interop_clauses_ptr ( gimple * gs)
inline
Return a pointer to the clauses associated with OMP_INTEROP statement GS.   

References GIMPLE_CHECK, and gimple_omp_interop_clauses_ptr().

Referenced by gimple_omp_interop_clauses_ptr(), and lower_omp_interop().

◆ gimple_omp_interop_set_clauses()

void gimple_omp_interop_set_clauses ( gimple * gs,
tree clauses )
inline
Set CLAUSES to be the clauses associated with OMP interop statement
GS.   

References GIMPLE_CHECK, and gimple_omp_interop_set_clauses().

Referenced by gimple_build_omp_interop(), gimple_copy(), and gimple_omp_interop_set_clauses().

◆ gimple_omp_masked_clauses()

tree gimple_omp_masked_clauses ( const gimple * gs)
inline
Return the clauses associated with OMP_MASKED statement GS.   

References GIMPLE_CHECK, and gimple_omp_masked_clauses().

Referenced by dump_gimple_omp_masked(), gimple_copy(), gimple_omp_masked_clauses(), lower_omp_master(), remap_gimple_stmt(), and scan_omp_1_stmt().

◆ gimple_omp_masked_clauses_ptr()

tree * gimple_omp_masked_clauses_ptr ( gimple * gs)
inline
Return a pointer to the clauses associated with OMP masked statement
GS.   

References GIMPLE_CHECK, and gimple_omp_masked_clauses_ptr().

Referenced by gimple_omp_masked_clauses_ptr().

◆ gimple_omp_masked_set_clauses()

void gimple_omp_masked_set_clauses ( gimple * gs,
tree clauses )
inline
Set CLAUSES to be the clauses associated with OMP masked statement
GS.   

References GIMPLE_CHECK, and gimple_omp_masked_set_clauses().

Referenced by gimple_build_omp_masked(), gimple_copy(), and gimple_omp_masked_set_clauses().

◆ gimple_omp_ordered_clauses()

◆ gimple_omp_ordered_clauses_ptr()

tree * gimple_omp_ordered_clauses_ptr ( gomp_ordered * ord_stmt)
inline
Return a pointer to the clauses associated with OMP ordered statement
ORD_STMT.   

References gimple_statement_omp_single_layout::clauses, and gimple_omp_ordered_clauses_ptr().

Referenced by gimple_omp_ordered_clauses_ptr(), lower_omp_ordered_clauses(), and walk_gimple_op().

◆ gimple_omp_ordered_set_clauses()

void gimple_omp_ordered_set_clauses ( gomp_ordered * ord_stmt,
tree clauses )
inline
Set CLAUSES to be the clauses associated with OMP ordered statement
ORD_STMT.   

References gimple_statement_omp_single_layout::clauses, and gimple_omp_ordered_set_clauses().

Referenced by gimple_build_omp_ordered(), gimple_copy(), and gimple_omp_ordered_set_clauses().

◆ gimple_omp_ordered_standalone()

void gimple_omp_ordered_standalone ( gimple * g)
inline
Set the GF_OMP_ORDERED_STANDALONE flag on G.   

References g, GF_OMP_ORDERED_STANDALONE, GIMPLE_CHECK, and gimple_omp_ordered_standalone().

Referenced by gimple_omp_ordered_standalone(), and gimplify_expr().

◆ gimple_omp_ordered_standalone_p()

bool gimple_omp_ordered_standalone_p ( const gimple * g)
inline
Return true if OMP ordered construct is stand-alone
(G has the GF_OMP_ORDERED_STANDALONE flag set).   

References g, GF_OMP_ORDERED_STANDALONE, GIMPLE_CHECK, gimple_omp_ordered_standalone_p(), and gimple_omp_subcode().

Referenced by build_omp_regions_1(), check_omp_nesting_restrictions(), expand_omp(), gimple_omp_ordered_standalone_p(), lower_omp_ordered(), and omp_make_gimple_edges().

◆ gimple_omp_parallel_child_fn()

tree gimple_omp_parallel_child_fn ( const gomp_parallel * omp_parallel_stmt)
inline

◆ gimple_omp_parallel_child_fn_ptr()

tree * gimple_omp_parallel_child_fn_ptr ( gomp_parallel * omp_parallel_stmt)
inline
Return a pointer to the child function used to hold the body of
OMP_PARALLEL_STMT.   

References gimple_statement_omp_parallel_layout::child_fn, and gimple_omp_parallel_child_fn_ptr().

Referenced by gimple_omp_parallel_child_fn_ptr(), and walk_gimple_op().

◆ gimple_omp_parallel_clauses()

◆ gimple_omp_parallel_clauses_ptr()

tree * gimple_omp_parallel_clauses_ptr ( gomp_parallel * omp_parallel_stmt)
inline
Return a pointer to the clauses associated with OMP_PARALLEL_STMT.   

References gimple_statement_omp_parallel_layout::clauses, and gimple_omp_parallel_clauses_ptr().

Referenced by gimple_omp_parallel_clauses_ptr(), and walk_gimple_op().

◆ gimple_omp_parallel_combined_p()

bool gimple_omp_parallel_combined_p ( const gimple * g)
inline
Return true if OMP parallel statement G has the
GF_OMP_PARALLEL_COMBINED flag set.   

References g, GF_OMP_PARALLEL_COMBINED, GIMPLE_CHECK, gimple_omp_parallel_combined_p(), and gimple_omp_subcode().

Referenced by determine_parallel_type(), gimple_omp_parallel_combined_p(), lower_omp_taskreg(), and scan_omp_parallel().

◆ gimple_omp_parallel_data_arg()

tree gimple_omp_parallel_data_arg ( const gomp_parallel * omp_parallel_stmt)
inline
Return the artificial argument used to send variables and values
from the parent to the children threads in OMP_PARALLEL_STMT.   

References gimple_statement_omp_parallel_layout::data_arg, and gimple_omp_parallel_data_arg().

Referenced by dump_gimple_omp_parallel(), expand_parallel_call(), gimple_copy(), gimple_omp_parallel_data_arg(), and remap_gimple_stmt().

◆ gimple_omp_parallel_data_arg_ptr()

tree * gimple_omp_parallel_data_arg_ptr ( gomp_parallel * omp_parallel_stmt)
inline
Return a pointer to the data argument for OMP_PARALLEL_STMT.   

References gimple_statement_omp_parallel_layout::data_arg, and gimple_omp_parallel_data_arg_ptr().

Referenced by gimple_omp_parallel_data_arg_ptr(), and walk_gimple_op().

◆ gimple_omp_parallel_set_child_fn()

void gimple_omp_parallel_set_child_fn ( gomp_parallel * omp_parallel_stmt,
tree child_fn )
inline

◆ gimple_omp_parallel_set_clauses()

void gimple_omp_parallel_set_clauses ( gomp_parallel * omp_parallel_stmt,
tree clauses )
inline
Set CLAUSES to be the list of clauses associated with OMP_PARALLEL_STMT.   

References gimple_statement_omp_parallel_layout::clauses, and gimple_omp_parallel_set_clauses().

Referenced by gimple_build_omp_parallel(), gimple_copy(), gimple_omp_parallel_set_clauses(), and scan_omp_parallel().

◆ gimple_omp_parallel_set_combined_p()

void gimple_omp_parallel_set_combined_p ( gimple * g,
bool combined_p )
inline
Set the GF_OMP_PARALLEL_COMBINED field in G depending on the boolean
value of COMBINED_P.   

References g, GF_OMP_PARALLEL_COMBINED, GIMPLE_CHECK, and gimple_omp_parallel_set_combined_p().

Referenced by gimple_omp_parallel_set_combined_p(), and lower_omp_taskreg().

◆ gimple_omp_parallel_set_data_arg()

void gimple_omp_parallel_set_data_arg ( gomp_parallel * omp_parallel_stmt,
tree data_arg )
inline
Set DATA_ARG to be the data argument for OMP_PARALLEL_STMT.   

References gimple_statement_omp_parallel_layout::data_arg, and gimple_omp_parallel_set_data_arg().

Referenced by gimple_build_omp_parallel(), gimple_copy(), and gimple_omp_parallel_set_data_arg().

◆ gimple_omp_return_lhs()

◆ gimple_omp_return_lhs_ptr()

tree * gimple_omp_return_lhs_ptr ( gimple * g)
inline
Return a pointer to the LHS of OMP return.   

References as_a(), g, gimple_omp_return_lhs_ptr(), and gimple_statement_omp_atomic_store_layout::val.

Referenced by gimple_omp_return_lhs_ptr(), and walk_gimple_op().

◆ gimple_omp_return_nowait_p()

◆ gimple_omp_return_set_lhs()

void gimple_omp_return_set_lhs ( gimple * g,
tree lhs )
inline

◆ gimple_omp_return_set_nowait()

void gimple_omp_return_set_nowait ( gimple * s)
inline
Set the nowait flag on OMP_RETURN statement S.   

References GF_OMP_RETURN_NOWAIT, GIMPLE_CHECK, and gimple_omp_return_set_nowait().

Referenced by gimple_build_omp_return(), gimple_omp_return_set_nowait(), and remove_exit_barrier().

◆ gimple_omp_scan_clauses()

tree gimple_omp_scan_clauses ( const gomp_scan * scan_stmt)
inline

◆ gimple_omp_scan_clauses_ptr()

tree * gimple_omp_scan_clauses_ptr ( gomp_scan * scan_stmt)
inline
Return a pointer to the clauses associated with OMP scan statement
ORD_STMT.   

References gimple_statement_omp_single_layout::clauses, and gimple_omp_scan_clauses_ptr().

Referenced by gimple_omp_scan_clauses_ptr(), and walk_gimple_op().

◆ gimple_omp_scan_set_clauses()

void gimple_omp_scan_set_clauses ( gomp_scan * scan_stmt,
tree clauses )
inline
Set CLAUSES to be the clauses associated with OMP scan statement
ORD_STMT.   

References gimple_statement_omp_single_layout::clauses, and gimple_omp_scan_set_clauses().

Referenced by gimple_build_omp_scan(), gimple_copy(), and gimple_omp_scan_set_clauses().

◆ gimple_omp_scope_clauses()

tree gimple_omp_scope_clauses ( const gimple * gs)
inline

◆ gimple_omp_scope_clauses_ptr()

tree * gimple_omp_scope_clauses_ptr ( gimple * gs)
inline
Return a pointer to the clauses associated with OMP scope statement
GS.   

References GIMPLE_CHECK, and gimple_omp_scope_clauses_ptr().

Referenced by convert_local_reference_stmt(), convert_nonlocal_reference_stmt(), and gimple_omp_scope_clauses_ptr().

◆ gimple_omp_scope_set_clauses()

void gimple_omp_scope_set_clauses ( gimple * gs,
tree clauses )
inline
Set CLAUSES to be the clauses associated with OMP scope statement
GS.   

References GIMPLE_CHECK, and gimple_omp_scope_set_clauses().

Referenced by gimple_build_omp_scope(), gimple_copy(), gimple_omp_scope_set_clauses(), and lower_omp_scope().

◆ gimple_omp_section_last_p()

bool gimple_omp_section_last_p ( const gimple * g)
inline
Return true if OMP section statement G has the GF_OMP_SECTION_LAST
flag set.   

References g, GF_OMP_SECTION_LAST, GIMPLE_CHECK, gimple_omp_section_last_p(), and gimple_omp_subcode().

Referenced by expand_omp_sections(), and gimple_omp_section_last_p().

◆ gimple_omp_section_set_last()

void gimple_omp_section_set_last ( gimple * g)
inline
Set the GF_OMP_SECTION_LAST flag on G.   

References g, GF_OMP_SECTION_LAST, GIMPLE_CHECK, and gimple_omp_section_set_last().

Referenced by gimple_omp_section_set_last(), and lower_omp_sections().

◆ gimple_omp_sections_clauses()

◆ gimple_omp_sections_clauses_ptr()

tree * gimple_omp_sections_clauses_ptr ( gimple * gs)
inline

◆ gimple_omp_sections_control()

tree gimple_omp_sections_control ( const gimple * gs)
inline
Return the control variable associated with the GIMPLE_OMP_SECTIONS
in GS.   

References as_a(), gomp_sections::control, and gimple_omp_sections_control().

Referenced by dump_gimple_omp_sections(), expand_omp_sections(), gimple_copy(), and gimple_omp_sections_control().

◆ gimple_omp_sections_control_ptr()

tree * gimple_omp_sections_control_ptr ( gimple * gs)
inline
Return a pointer to the clauses associated with the GIMPLE_OMP_SECTIONS
GS.   

References as_a(), gomp_sections::control, and gimple_omp_sections_control_ptr().

Referenced by gimple_omp_sections_control_ptr(), and walk_gimple_op().

◆ gimple_omp_sections_set_clauses()

void gimple_omp_sections_set_clauses ( gimple * gs,
tree clauses )
inline
Set CLAUSES to be the set of clauses associated with OMP_SECTIONS
GS.   

References as_a(), gomp_sections::clauses, and gimple_omp_sections_set_clauses().

Referenced by gimple_build_omp_sections(), gimple_copy(), gimple_omp_sections_set_clauses(), and lower_omp_sections().

◆ gimple_omp_sections_set_control()

void gimple_omp_sections_set_control ( gimple * gs,
tree control )
inline
Set CONTROL to be the set of clauses associated with the
GIMPLE_OMP_SECTIONS in GS.   

References as_a(), gomp_sections::control, and gimple_omp_sections_set_control().

Referenced by gimple_copy(), gimple_omp_sections_set_control(), and lower_omp_sections().

◆ gimple_omp_set_body()

◆ gimple_omp_set_subcode()

void gimple_omp_set_subcode ( gimple * s,
unsigned int subcode )
inline
Set the subcode for OMP statement S to SUBCODE.   

References gcc_gimple_checking_assert, and gimple_omp_set_subcode().

Referenced by expand_omp_taskreg(), gimple_omp_set_subcode(), and gimplify_omp_parallel().

◆ gimple_omp_single_clauses()

tree gimple_omp_single_clauses ( const gimple * gs)
inline

◆ gimple_omp_single_clauses_ptr()

tree * gimple_omp_single_clauses_ptr ( gimple * gs)
inline

◆ gimple_omp_single_set_clauses()

void gimple_omp_single_set_clauses ( gomp_single * omp_single_stmt,
tree clauses )
inline
Set CLAUSES to be the clauses associated with OMP_SINGLE_STMT.   

References gimple_statement_omp_single_layout::clauses, and gimple_omp_single_set_clauses().

Referenced by gimple_build_omp_single(), gimple_copy(), and gimple_omp_single_set_clauses().

◆ gimple_omp_subcode()

◆ gimple_omp_target_child_fn()

tree gimple_omp_target_child_fn ( const gomp_target * omp_target_stmt)
inline
Return the child function used to hold the body of OMP_TARGET_STMT.   

References gimple_statement_omp_parallel_layout::child_fn, and gimple_omp_target_child_fn().

Referenced by adjust_context_and_scope(), dump_gimple_omp_target(), expand_omp_target(), and gimple_omp_target_child_fn().

◆ gimple_omp_target_child_fn_ptr()

tree * gimple_omp_target_child_fn_ptr ( gomp_target * omp_target_stmt)
inline
Return a pointer to the child function used to hold the body of
OMP_TARGET_STMT.   

References gimple_statement_omp_parallel_layout::child_fn, and gimple_omp_target_child_fn_ptr().

Referenced by gimple_omp_target_child_fn_ptr(), and walk_gimple_op().

◆ gimple_omp_target_clauses()

◆ gimple_omp_target_clauses_ptr()

tree * gimple_omp_target_clauses_ptr ( gimple * gs)
inline

◆ gimple_omp_target_data_arg()

tree gimple_omp_target_data_arg ( const gomp_target * omp_target_stmt)
inline
Return the artificial argument used to send variables and values
from the parent to the children threads in OMP_TARGET_STMT.   

References gimple_statement_omp_parallel_layout::data_arg, and gimple_omp_target_data_arg().

Referenced by dump_gimple_omp_target(), expand_omp_target(), gimple_copy(), and gimple_omp_target_data_arg().

◆ gimple_omp_target_data_arg_ptr()

tree * gimple_omp_target_data_arg_ptr ( gomp_target * omp_target_stmt)
inline
Return a pointer to the data argument for OMP_TARGET GS.   

References gimple_statement_omp_parallel_layout::data_arg, and gimple_omp_target_data_arg_ptr().

Referenced by gimple_omp_target_data_arg_ptr(), and walk_gimple_op().

◆ gimple_omp_target_iterator_loops()

gimple_seq gimple_omp_target_iterator_loops ( const gomp_target * omp_target_stmt)
inline
Return the Gimple sequence used to store loops for OpenMP iterators used
by OMP_TARGET_STMT.   

References gimple_omp_target_iterator_loops(), and gomp_target::iterator_loops.

Referenced by dump_gimple_omp_target(), gimple_omp_target_iterator_loops(), and lower_omp_target().

◆ gimple_omp_target_iterator_loops_ptr()

gimple_seq * gimple_omp_target_iterator_loops_ptr ( gimple * gs)
inline

◆ gimple_omp_target_kind()

◆ gimple_omp_target_set_child_fn()

void gimple_omp_target_set_child_fn ( gomp_target * omp_target_stmt,
tree child_fn )
inline
Set CHILD_FN to be the child function for OMP_TARGET_STMT.   

References gimple_statement_omp_parallel_layout::child_fn, and gimple_omp_target_set_child_fn().

Referenced by gimple_omp_target_set_child_fn(), and scan_omp_target().

◆ gimple_omp_target_set_clauses()

◆ gimple_omp_target_set_data_arg()

void gimple_omp_target_set_data_arg ( gomp_target * omp_target_stmt,
tree data_arg )
inline
Set DATA_ARG to be the data argument for OMP_TARGET_STMT.   

References gimple_statement_omp_parallel_layout::data_arg, and gimple_omp_target_set_data_arg().

Referenced by gimple_copy(), gimple_omp_target_set_data_arg(), and lower_omp_target().

◆ gimple_omp_target_set_iterator_loops()

void gimple_omp_target_set_iterator_loops ( gomp_target * omp_target_stmt,
gimple_seq iterator_loops )
inline
Set ITERATOR_LOOPS to be the Gimple sequence used to store loops
constructed for OpenMP iterators in OMP_TARGET_STMT.   

References gimple_omp_target_set_iterator_loops(), and gomp_target::iterator_loops.

Referenced by gimple_build_omp_target(), gimple_omp_target_set_iterator_loops(), and lower_omp_target().

◆ gimple_omp_target_set_kind()

void gimple_omp_target_set_kind ( gomp_target * g,
int kind )
inline
Set the kind of the OMP_TARGET G.   

References g, GF_OMP_TARGET_KIND_MASK, and gimple_omp_target_set_kind().

Referenced by gimple_build_omp_target(), and gimple_omp_target_set_kind().

◆ gimple_omp_task_arg_align()

tree gimple_omp_task_arg_align ( const gimple * gs)
inline
Return align of the data block in bytes in OMP_TASK GS.   

References gomp_task::arg_align, as_a(), and gimple_omp_task_arg_align().

Referenced by expand_task_call(), gimple_copy(), gimple_omp_task_arg_align(), and remap_gimple_stmt().

◆ gimple_omp_task_arg_align_ptr()

tree * gimple_omp_task_arg_align_ptr ( gimple * gs)
inline
Return a pointer to the data block align for OMP_TASK GS.   

References gomp_task::arg_align, as_a(), and gimple_omp_task_arg_align_ptr().

Referenced by gimple_omp_task_arg_align_ptr(), and walk_gimple_op().

◆ gimple_omp_task_arg_size()

tree gimple_omp_task_arg_size ( const gimple * gs)
inline
Return size of the data block in bytes in OMP_TASK GS.   

References gomp_task::arg_size, as_a(), and gimple_omp_task_arg_size().

Referenced by dump_gimple_omp_task(), expand_task_call(), gimple_copy(), gimple_omp_task_arg_size(), and remap_gimple_stmt().

◆ gimple_omp_task_arg_size_ptr()

tree * gimple_omp_task_arg_size_ptr ( gimple * gs)
inline
Return a pointer to the data block size for OMP_TASK GS.   

References gomp_task::arg_size, as_a(), and gimple_omp_task_arg_size_ptr().

Referenced by gimple_omp_task_arg_size_ptr(), and walk_gimple_op().

◆ gimple_omp_task_child_fn()

tree gimple_omp_task_child_fn ( const gimple * gs)
inline

◆ gimple_omp_task_child_fn_ptr()

tree * gimple_omp_task_child_fn_ptr ( gimple * gs)
inline
Return a pointer to the child function used to hold the body of
OMP_TASK GS.   

References as_a(), gimple_statement_omp_parallel_layout::child_fn, and gimple_omp_task_child_fn_ptr().

Referenced by gimple_omp_task_child_fn_ptr(), and walk_gimple_op().

◆ gimple_omp_task_clauses()

◆ gimple_omp_task_clauses_ptr()

tree * gimple_omp_task_clauses_ptr ( gimple * gs)
inline
Return a pointer to the clauses associated with OMP_TASK GS.   

References as_a(), gimple_statement_omp_parallel_layout::clauses, and gimple_omp_task_clauses_ptr().

Referenced by gimple_omp_task_clauses_ptr(), lower_omp_taskreg(), and walk_gimple_op().

◆ gimple_omp_task_copy_fn()

tree gimple_omp_task_copy_fn ( const gimple * gs)
inline

◆ gimple_omp_task_copy_fn_ptr()

tree * gimple_omp_task_copy_fn_ptr ( gimple * gs)
inline
Return a pointer to the copy function used to hold the body of
OMP_TASK GS.   

References as_a(), gomp_task::copy_fn, and gimple_omp_task_copy_fn_ptr().

Referenced by gimple_omp_task_copy_fn_ptr(), and walk_gimple_op().

◆ gimple_omp_task_data_arg()

tree gimple_omp_task_data_arg ( const gimple * gs)
inline
Return the artificial argument used to send variables and values
from the parent to the children threads in OMP_TASK GS.   

References as_a(), gimple_statement_omp_parallel_layout::data_arg, and gimple_omp_task_data_arg().

Referenced by dump_gimple_omp_task(), expand_task_call(), gimple_copy(), gimple_omp_task_data_arg(), and remap_gimple_stmt().

◆ gimple_omp_task_data_arg_ptr()

tree * gimple_omp_task_data_arg_ptr ( gimple * gs)
inline
Return a pointer to the data argument for OMP_TASK GS.   

References as_a(), gimple_statement_omp_parallel_layout::data_arg, and gimple_omp_task_data_arg_ptr().

Referenced by gimple_omp_task_data_arg_ptr(), and walk_gimple_op().

◆ gimple_omp_task_set_arg_align()

void gimple_omp_task_set_arg_align ( gimple * gs,
tree arg_align )
inline
Set ARG_SIZE to be the data block align for OMP_TASK GS.   

References gomp_task::arg_align, as_a(), and gimple_omp_task_set_arg_align().

Referenced by finish_taskreg_scan(), gimple_build_omp_task(), gimple_copy(), gimple_omp_task_set_arg_align(), and scan_omp_task().

◆ gimple_omp_task_set_arg_size()

void gimple_omp_task_set_arg_size ( gimple * gs,
tree arg_size )
inline
Set ARG_SIZE to be the data block size for OMP_TASK GS.   

References gomp_task::arg_size, as_a(), and gimple_omp_task_set_arg_size().

Referenced by finish_taskreg_scan(), gimple_build_omp_task(), gimple_copy(), gimple_omp_task_set_arg_size(), and scan_omp_task().

◆ gimple_omp_task_set_child_fn()

void gimple_omp_task_set_child_fn ( gimple * gs,
tree child_fn )
inline

◆ gimple_omp_task_set_clauses()

void gimple_omp_task_set_clauses ( gimple * gs,
tree clauses )
inline

◆ gimple_omp_task_set_copy_fn()

void gimple_omp_task_set_copy_fn ( gimple * gs,
tree copy_fn )
inline
Set CHILD_FN to be the copy function for OMP_TASK GS.   

References as_a(), copy_fn(), gomp_task::copy_fn, and gimple_omp_task_set_copy_fn().

Referenced by create_omp_child_function(), gimple_build_omp_task(), gimple_copy(), and gimple_omp_task_set_copy_fn().

◆ gimple_omp_task_set_data_arg()

void gimple_omp_task_set_data_arg ( gimple * gs,
tree data_arg )
inline
Set DATA_ARG to be the data argument for OMP_TASK GS.   

References as_a(), gimple_statement_omp_parallel_layout::data_arg, and gimple_omp_task_set_data_arg().

Referenced by gimple_build_omp_task(), gimple_copy(), and gimple_omp_task_set_data_arg().

◆ gimple_omp_task_set_taskloop_p()

void gimple_omp_task_set_taskloop_p ( gimple * g,
bool taskloop_p )
inline
Set the GF_OMP_TASK_TASKLOOP field in G depending on the boolean
value of TASKLOOP_P.   

References g, GF_OMP_TASK_TASKLOOP, GIMPLE_CHECK, and gimple_omp_task_set_taskloop_p().

Referenced by gimple_omp_task_set_taskloop_p(), and gimplify_omp_for().

◆ gimple_omp_task_set_taskwait_p()

void gimple_omp_task_set_taskwait_p ( gimple * g,
bool taskwait_p )
inline
Set the GF_OMP_TASK_TASKWAIT field in G depending on the boolean
value of TASKWAIT_P.   

References g, GF_OMP_TASK_TASKWAIT, GIMPLE_CHECK, and gimple_omp_task_set_taskwait_p().

Referenced by gimple_omp_task_set_taskwait_p(), and gimplify_omp_task().

◆ gimple_omp_task_taskloop_p()

◆ gimple_omp_task_taskwait_p()

bool gimple_omp_task_taskwait_p ( const gimple * g)
inline

◆ gimple_omp_taskgroup_clauses()

tree gimple_omp_taskgroup_clauses ( const gimple * gs)
inline
Return the clauses associated with OMP_TASKGROUP statement GS.   

References GIMPLE_CHECK, and gimple_omp_taskgroup_clauses().

Referenced by dump_gimple_omp_taskgroup(), gimple_copy(), gimple_omp_taskgroup_clauses(), lower_omp_taskgroup(), remap_gimple_stmt(), and scan_omp_1_stmt().

◆ gimple_omp_taskgroup_clauses_ptr()

tree * gimple_omp_taskgroup_clauses_ptr ( gimple * gs)
inline
Return a pointer to the clauses associated with OMP taskgroup statement
GS.   

References GIMPLE_CHECK, and gimple_omp_taskgroup_clauses_ptr().

Referenced by convert_local_reference_stmt(), convert_nonlocal_reference_stmt(), and gimple_omp_taskgroup_clauses_ptr().

◆ gimple_omp_taskgroup_set_clauses()

void gimple_omp_taskgroup_set_clauses ( gimple * gs,
tree clauses )
inline
Set CLAUSES to be the clauses associated with OMP taskgroup statement
GS.   

References GIMPLE_CHECK, and gimple_omp_taskgroup_set_clauses().

Referenced by gimple_build_omp_taskgroup(), gimple_copy(), and gimple_omp_taskgroup_set_clauses().

◆ gimple_omp_taskreg_child_fn()

tree gimple_omp_taskreg_child_fn ( const gimple * gs)
inline
Return the child function used to hold the body of OMP_TASK GS.   

References as_a(), gimple_statement_omp_parallel_layout::child_fn, and gimple_omp_taskreg_child_fn().

Referenced by adjust_context_and_scope(), expand_omp_taskreg(), and gimple_omp_taskreg_child_fn().

◆ gimple_omp_taskreg_child_fn_ptr()

tree * gimple_omp_taskreg_child_fn_ptr ( gimple * gs)
inline
Return a pointer to the child function used to hold the body of
OMP_TASK GS.   

References as_a(), gimple_statement_omp_parallel_layout::child_fn, and gimple_omp_taskreg_child_fn_ptr().

Referenced by gimple_omp_taskreg_child_fn_ptr().

◆ gimple_omp_taskreg_clauses()

◆ gimple_omp_taskreg_clauses_ptr()

tree * gimple_omp_taskreg_clauses_ptr ( gimple * gs)
inline

◆ gimple_omp_taskreg_data_arg()

tree gimple_omp_taskreg_data_arg ( const gimple * gs)
inline
Return the artificial argument used to send variables and values
from the parent to the children threads in OMP_TASK GS.   

References as_a(), gimple_statement_omp_parallel_layout::data_arg, and gimple_omp_taskreg_data_arg().

Referenced by expand_omp_taskreg(), and gimple_omp_taskreg_data_arg().

◆ gimple_omp_taskreg_data_arg_ptr()

tree * gimple_omp_taskreg_data_arg_ptr ( gimple * gs)
inline
Return a pointer to the data argument for OMP_TASK GS.   

References as_a(), gimple_statement_omp_parallel_layout::data_arg, and gimple_omp_taskreg_data_arg_ptr().

Referenced by gimple_omp_taskreg_data_arg_ptr().

◆ gimple_omp_taskreg_set_child_fn()

void gimple_omp_taskreg_set_child_fn ( gimple * gs,
tree child_fn )
inline
Set CHILD_FN to be the child function for OMP_TASK GS.   

References as_a(), gimple_statement_omp_parallel_layout::child_fn, and gimple_omp_taskreg_set_child_fn().

Referenced by gimple_omp_taskreg_set_child_fn().

◆ gimple_omp_taskreg_set_clauses()

void gimple_omp_taskreg_set_clauses ( gimple * gs,
tree clauses )
inline

◆ gimple_omp_taskreg_set_data_arg()

void gimple_omp_taskreg_set_data_arg ( gimple * gs,
tree data_arg )
inline
Set DATA_ARG to be the data argument for OMP_TASK GS.   

References as_a(), gimple_statement_omp_parallel_layout::data_arg, and gimple_omp_taskreg_set_data_arg().

Referenced by gimple_omp_taskreg_set_data_arg(), and lower_omp_taskreg().

◆ gimple_omp_teams_child_fn()

tree gimple_omp_teams_child_fn ( const gomp_teams * omp_teams_stmt)
inline
Return the child function used to hold the body of OMP_TEAMS_STMT.   

References gimple_statement_omp_parallel_layout::child_fn, and gimple_omp_teams_child_fn().

Referenced by expand_teams_call(), and gimple_omp_teams_child_fn().

◆ gimple_omp_teams_child_fn_ptr()

tree * gimple_omp_teams_child_fn_ptr ( gomp_teams * omp_teams_stmt)
inline
Return a pointer to the child function used to hold the body of
OMP_TEAMS_STMT.   

References gimple_statement_omp_parallel_layout::child_fn, and gimple_omp_teams_child_fn_ptr().

Referenced by gimple_omp_teams_child_fn_ptr().

◆ gimple_omp_teams_clauses()

tree gimple_omp_teams_clauses ( const gimple * gs)
inline

◆ gimple_omp_teams_clauses_ptr()

tree * gimple_omp_teams_clauses_ptr ( gimple * gs)
inline

◆ gimple_omp_teams_data_arg()

tree gimple_omp_teams_data_arg ( const gomp_teams * omp_teams_stmt)
inline
Return the artificial argument used to send variables and values
from the parent to the children threads in OMP_TEAMS_STMT.   

References gimple_statement_omp_parallel_layout::data_arg, and gimple_omp_teams_data_arg().

Referenced by expand_teams_call(), and gimple_omp_teams_data_arg().

◆ gimple_omp_teams_data_arg_ptr()

tree * gimple_omp_teams_data_arg_ptr ( gomp_teams * omp_teams_stmt)
inline
Return a pointer to the data argument for OMP_TEAMS_STMT.   

References gimple_statement_omp_parallel_layout::data_arg, and gimple_omp_teams_data_arg_ptr().

Referenced by gimple_omp_teams_data_arg_ptr().

◆ gimple_omp_teams_host()

◆ gimple_omp_teams_set_child_fn()

void gimple_omp_teams_set_child_fn ( gomp_teams * omp_teams_stmt,
tree child_fn )
inline
Set CHILD_FN to be the child function for OMP_TEAMS_STMT.   

References gimple_statement_omp_parallel_layout::child_fn, and gimple_omp_teams_set_child_fn().

Referenced by gimple_omp_teams_set_child_fn(), and scan_omp_teams().

◆ gimple_omp_teams_set_clauses()

void gimple_omp_teams_set_clauses ( gomp_teams * omp_teams_stmt,
tree clauses )
inline
Set CLAUSES to be the clauses associated with OMP_TEAMS_STMT.   

References gimple_statement_omp_parallel_layout::clauses, and gimple_omp_teams_set_clauses().

Referenced by gimple_build_omp_teams(), gimple_copy(), and gimple_omp_teams_set_clauses().

◆ gimple_omp_teams_set_data_arg()

void gimple_omp_teams_set_data_arg ( gomp_teams * omp_teams_stmt,
tree data_arg )
inline
Set DATA_ARG to be the data argument for OMP_TEAMS_STMT.   

References gimple_statement_omp_parallel_layout::data_arg, and gimple_omp_teams_set_data_arg().

Referenced by gimple_omp_teams_set_data_arg().

◆ gimple_omp_teams_set_host()

void gimple_omp_teams_set_host ( gomp_teams * omp_teams_stmt,
bool value )
inline
Set host flag of an OMP_TEAMS_STMT to VALUE.   

References GF_OMP_TEAMS_HOST, gimple_omp_teams_set_host(), and gimple::subcode.

Referenced by gimple_omp_teams_set_host(), and gimplify_omp_workshare().

◆ gimple_op()

◆ gimple_op_ptr()

◆ gimple_ops()

tree * gimple_ops ( gimple * gs)
inline
Return the array of operands for statement GS.   

References gcc_gimple_checking_assert, gimple_ops(), gimple_ops_offset_, and gimple_statement_structure().

Referenced by gimple_op(), gimple_op_ptr(), gimple_ops(), and gimple_set_op().

◆ gimple_or_expr_nonartificial_location()

◆ gimple_phi_arg() [1/4]

const phi_arg_d * gimple_phi_arg ( const gimple * gs,
unsigned index )
inline

References as_a(), and gimple_phi_arg().

◆ gimple_phi_arg() [2/4]

const phi_arg_d * gimple_phi_arg ( const gphi * gs,
unsigned index )
inline

◆ gimple_phi_arg() [3/4]

struct phi_arg_d * gimple_phi_arg ( gimple * gs,
unsigned index )
inline

References as_a(), and gimple_phi_arg().

◆ gimple_phi_arg() [4/4]

◆ gimple_phi_arg_def() [1/2]

tree gimple_phi_arg_def ( const gimple * gs,
size_t index )
inline

◆ gimple_phi_arg_def() [2/2]

tree gimple_phi_arg_def ( const gphi * gs,
size_t index )
inline
Return the tree operand for argument I of PHI node GS.   

References gimple_phi_arg(), and gimple_phi_arg_def().

Referenced by autofdo::afdo_propagate_circuit(), all_phi_incrs_profitable_1(), analyze_agg_content_value(), and_comparisons_1(), asan_expand_poison_ifn(), bb_phis_references_abnormal_uses(), strlen_pass::before_dom_children(), assume_query::calculate_phi(), can_skip_redundant_opnd(), tree_switch_conversion::switch_conversion::check_final_bb(), clean_up_loop_closed_phi(), cleanup_empty_eh_merge_phis(), clear_visited(), uninit_analysis::collect_phi_def_edges(), combine_blocks(), compute_uninit_opnds_pos(), cond_store_replacement(), cond_store_replacement_limited(), consider_split(), contains_phi_arg(), copy_phi_arg_into_existing_phi(), copy_phi_args(), strlen_pass::count_nonzero_bytes(), strlen_pass::count_nonzero_bytes_addr(), create_phi_basis_1(), degenerate_phi_p(), degenerate_phi_result(), do_invalidate(), access_ref::dump(), dump_gimple_phi(), execute_sm_if_changed(), expand_omp_for_static_chunk(), expand_omp_for_static_nochunk(), expr_hash_elt::expr_hash_elt(), factor_out_conditional_load(), factor_out_conditional_operation(), find_func_aliases(), find_implicit_erroneous_behavior(), find_vdef_in_loop(), tree_switch_conversion::switch_decision_tree::fix_phi_operands_for_edges(), get_range_strlen_phi(), access_ref::get_ref(), get_value_locus_in_path(), gimple_arg(), gimple_lower_bitint(), gimple_merge_blocks(), gimple_phi_arg_def(), gimple_phi_arg_def(), gimple_phi_integer_valued_real_p(), gimple_phi_nonnegative_p(), hoist_adjacent_loads(), ifcombine_replace_cond(), ipa_icf::sem_function::init(), insert_backedge_copies(), ipa_simd_modify_function_body(), is_addr_local(), is_degenerate_phi(), long_mul_op_fits_p(), long_mul_split_phi(), loop_has_phi_with_address_arg(), loop_iter_phi_semi_invariant_p(), make_forwarders_with_degenerate_phis(), malloc_candidate_p_1(), match_cond_with_binary_phi(), maybe_optimize_guarding_check(), maybe_optimize_range_tests(), path_range_query::maybe_register_phi_relation(), maybe_remove_forwarder_block(), move_early_exit_stmts(), ncd_with_phi(), predicate::normalize(), number_of_iterations_cltz(), number_of_iterations_cltz_complement(), number_of_iterations_popcount(), vars_ssa_cache::operator()(), optimize_va_list_gpr_fpr_size(), or_comparisons_1(), output_phi(), phi_add_costs_1(), phi_alternatives_equal(), phi_args_equal_on_edges(), phi_convertible_by_degenerating_args(), phi_dynamic_object_size(), phi_incr_cost_1(), phi_rank(), predicate_scalar_phi(), predict_extra_loop_exits(), gimple_ranger::prefill_stmt_dependencies(), phi_analyzer::process_phi(), scc_copy_prop::propagate(), propagate_with_phi(), uninit_analysis::prune_phi_opnds(), fold_using_range::range_of_phi(), record_equivalences_from_phis(), record_phi_increments_1(), tree_switch_conversion::switch_decision_tree::record_phi_operand_mapping(), remove_dead_phis(), substitute_and_fold_engine::replace_phi_args_in(), same_phi_alternatives_1(), same_succ_hash(), crc_optimization::set_defs(), shrink_wrap_one_built_in_call_with_conds(), simple_iv_increment_p(), simplify_phi_result_movdiv(), single_non_singleton_phi_for_edges(), sink_common_stores_to_bb(), slsr_process_phi(), sm_seq_valid_bb(), spaceship_replacement(), path_range_query::ssa_range_in_phi(), ssa_redirect_edge(), stmt_may_generate_copy(), stmt_semi_invariant_p_1(), suitable_cond_bb(), tree_lower_complex(), try_transform_to_exit_first_loop_alt(), unsplit_eh(), update_phi_components(), vect_determine_mask_precision(), vectorizable_induction(), verify_gimple_in_cfg(), verify_gimple_phi(), verify_live_on_entry(), verify_non_ssa_vars(), verify_ssaname_freelists(), visit_bb(), complex_propagate::visit_phi(), copy_prop::visit_phi(), walk_aliased_vdefs_1(), walk_regimplify_phi(), walk_ssa_copies(), walk_stmt_load_store_addr_ops(), and warn_uninitialized_phi().

◆ gimple_phi_arg_def_from_edge() [1/2]

tree gimple_phi_arg_def_from_edge ( const gimple * gs,
const_edge e )
inline

◆ gimple_phi_arg_def_from_edge() [2/2]

◆ gimple_phi_arg_def_ptr()

tree * gimple_phi_arg_def_ptr ( gphi * phi,
size_t index )
inline

◆ gimple_phi_arg_edge()

edge gimple_phi_arg_edge ( const gphi * phi,
size_t i )
inline
Return the edge associated with argument I of phi node PHI.   

References EDGE_PRED, gimple_bb(), gimple_phi_arg_edge(), and i.

Referenced by autofdo::afdo_propagate_circuit(), all_phi_incrs_profitable_1(), analyze_evolution_in_loop(), analyze_initial_condition(), apply_return_prediction(), asan_expand_poison_ifn(), backedge_phi_arg_p(), calculate_live_on_exit(), assume_query::calculate_phi(), tree_switch_conversion::switch_conversion::check_final_bb(), uninit_analysis::collect_phi_def_edges(), ipa_icf::sem_function::compare_phi_node(), path_range_query::compute_exit_dependencies(), path_range_query::compute_phi_relations(), consider_split(), create_coalesce_list_for_region(), dse_classify_store(), dump_gimple_phi(), emit_phi_nodes(), execute_sm_if_changed(), expr_expected_value_1(), find_bb_for_arg(), find_implicit_erroneous_behavior(), find_uninit_use(), tree_switch_conversion::switch_decision_tree::fix_phi_operands_for_edges(), scev_dfs::follow_ssa_edge_inner_loop_phi(), gen_phi_arg_condition(), get_continuation_for_phi(), get_reassociation_width(), gimple_lower_bitint(), gimple_phi_arg_edge(), insert_backedge_copies(), ipa_simd_modify_function_body(), uninit_analysis::is_use_guarded(), long_mul_split_phi(), loop_iter_phi_semi_invariant_p(), make_forwarders_with_degenerate_phis(), ipa_param_body_adjustments::mark_dead_statements(), mark_ssa_maybe_undefs(), ncd_with_phi(), nearest_common_dominator_of_uses(), output_phi(), phi_arg_edge_from_use(), phi_convertible_by_degenerating_args(), phi_dynamic_object_size(), predicate_scalar_phi(), predict_extra_loop_exits(), prepare_use_sites_for(), phi_analyzer::process_phi(), propagate_necessity(), propagate_value(), uninit_analysis::prune_phi_opnds(), fold_using_range::range_of_phi(), record_equivalences_from_phis(), tree_switch_conversion::switch_decision_tree::record_phi_operand_mapping(), substitute_and_fold_engine::replace_phi_args_in(), replace_uses_by(), set_var_live_on_entry(), simplify_phi_result_movdiv(), sink_common_stores_to_bb(), sm_seq_valid_bb(), stmt_semi_invariant_p_1(), vect_get_and_check_slp_defs(), vect_schedule_slp_node(), vectorizable_live_operation(), vectorizable_phi(), ccp_propagate::visit_phi(), copy_prop::visit_phi(), and walk_regimplify_phi().

◆ gimple_phi_arg_has_location()

bool gimple_phi_arg_has_location ( const gphi * phi,
size_t i )
inline

◆ gimple_phi_arg_location()

◆ gimple_phi_arg_location_from_edge()

◆ gimple_phi_arg_location_ptr()

location_t * gimple_phi_arg_location_ptr ( gphi * phi,
size_t i )
inline
Return address of source location of gimple argument I of phi node PHI.   

References gimple_phi_arg(), gimple_phi_arg_location_ptr(), and i.

Referenced by gimple_phi_arg_location_ptr(), and input_phi().

◆ gimple_phi_arg_set_location()

void gimple_phi_arg_set_location ( gphi * phi,
size_t i,
location_t loc )
inline

◆ gimple_phi_capacity()

unsigned gimple_phi_capacity ( const gimple * gs)
inline

◆ gimple_phi_num_args()

unsigned gimple_phi_num_args ( const gimple * gs)
inline
Return the number of arguments in GIMPLE_PHI GS.  This must always
be exactly the number of incoming edges for the basic block holding
GS.   

References as_a(), gimple_phi_num_args(), and gphi::nargs.

Referenced by add_phi_arg(), autofdo::afdo_propagate_circuit(), all_phi_incrs_profitable_1(), analyze_agg_content_value(), analyze_and_compute_bitop_with_inv_effect(), analyze_and_compute_bitwise_induction_effect(), analyze_evolution_in_loop(), analyze_initial_condition(), and_comparisons_1(), apply_return_prediction(), asan_expand_poison_ifn(), bb_phis_references_abnormal_uses(), strlen_pass::before_dom_children(), calculate_live_on_exit(), assume_query::calculate_phi(), can_skip_redundant_opnd(), tree_switch_conversion::switch_conversion::check_final_bb(), check_for_plus_in_loops_1(), clear_visited(), collect_dfa_stats(), collect_object_sizes_for(), uninit_analysis::collect_phi_def_edges(), ipa_icf::sem_function::compare_phi_node(), compute_complex_ancestor_jump_func(), path_range_query::compute_exit_dependencies(), compute_final_value_from_loop_phi_latch(), path_range_query::compute_phi_relations(), compute_uninit_opnds_pos(), consider_split(), contains_phi_arg(), strlen_pass::count_nonzero_bytes(), strlen_pass::count_nonzero_bytes_addr(), create_coalesce_list_for_region(), create_phi_basis_1(), degenerate_phi_p(), degenerate_phi_result(), determine_max_movement(), do_invalidate(), dse_classify_store(), access_ref::dump(), dump_gimple_phi(), emit_phi_nodes(), execute_sm_if_changed(), execute_update_addresses_taken(), expand_simple_operations(), expr_expected_value_1(), expr_hash_elt::expr_hash_elt(), factor_out_conditional_load(), factor_out_conditional_operation(), find_bb_for_arg(), find_func_aliases(), find_implicit_erroneous_behavior(), find_necessary_statements(), find_vdef_in_loop(), tree_switch_conversion::switch_decision_tree::fix_phi_operands_for_edges(), scev_dfs::follow_ssa_edge_in_condition_phi(), scev_dfs::follow_ssa_edge_inner_loop_phi(), get_continuation_for_phi(), crc_optimization::get_output_phi(), get_range_strlen(), get_range_strlen_phi(), access_ref::get_ref(), gimple_lower_bitint(), gimple_num_args(), gimple_phi_integer_valued_real_p(), gimple_phi_nonnegative_p(), gimple_phi_num_args(), hoist_adjacent_loads(), if_convertible_phi_p(), ifcombine_replace_cond(), ipa_icf::sem_function::init(), insert_backedge_copies(), interpret_condition_phi(), ipa_analyze_indirect_call_uses(), ipa_simd_modify_function_body(), is_addr_local(), is_degenerate_phi(), uninit_analysis::is_use_guarded(), long_mul_op_fits_p(), long_mul_split_phi(), loop_has_phi_with_address_arg(), loop_iter_phi_semi_invariant_p(), make_forwarders_with_degenerate_phis(), malloc_candidate_p_1(), match_cond_with_binary_phi(), match_saturation_add(), match_saturation_mul(), match_saturation_sub(), match_saturation_trunc(), match_spaceship(), move_computations_worker(), movement_possibility_1(), ncd_with_phi(), predicate::normalize(), number_of_iterations_cltz(), number_of_iterations_cltz_complement(), number_of_iterations_popcount(), op_iter_init_phiuse(), vars_ssa_cache::operator()(), optimize_pow_to_exp(), optimize_va_list_gpr_fpr_size(), or_comparisons_1(), output_phi(), parloops_is_simple_reduction(), phi_add_costs_1(), uninit_analysis::func_t::phi_arg_set(), phi_convertible_by_degenerating_args(), phi_dynamic_object_size(), phi_incr_cost_1(), phi_rank(), predicate_for_phi_result(), predicate_scalar_phi(), predict_extra_loop_exits(), gimple_ranger::prefill_stmt_dependencies(), phi_analyzer::process_phi(), scc_copy_prop::propagate(), propagate_necessity(), uninit_analysis::prune_phi_opnds(), fold_using_range::range_of_phi(), record_equivalences_from_phis(), record_phi_increments_1(), tree_switch_conversion::switch_decision_tree::record_phi_operand_mapping(), release_phi_node(), remove_phi_arg_num(), substitute_and_fold_engine::replace_phi_args_in(), resize_phi_node(), rewrite_trees(), rewrite_update_phi_arguments(), crc_optimization::set_defs(), simple_dce_from_worklist(), simple_iv_increment_p(), simplify_phi_result_movdiv(), sink_common_stores_to_bb(), slpeel_tree_duplicate_loop_to_edge_cfg(), slsr_process_phi(), sm_seq_valid_bb(), path_range_query::ssa_range_in_phi(), stmt_may_generate_copy(), stmt_semi_invariant_p_1(), thread_private_new_memory(), tree_lower_complex(), update_phi_components(), vect_bb_slp_scalar_cost(), vect_build_slp_tree_2(), vect_create_epilog_for_reduction(), vect_determine_mask_precision(), vect_is_nonlinear_iv_evolution(), vect_is_simple_reduction(), vectorizable_lc_phi(), vectorizable_live_operation_1(), vectorizable_phi(), verify_gimple_in_cfg(), verify_gimple_phi(), verify_live_on_entry(), verify_phi_args(), verify_ssaname_freelists(), visit_bb(), ccp_propagate::visit_phi(), complex_propagate::visit_phi(), copy_prop::visit_phi(), vn_phi_insert(), vn_phi_lookup(), walk_aliased_vdefs_1(), walk_gimple_op(), walk_regimplify_phi(), walk_ssa_copies(), walk_stmt_load_store_addr_ops(), warn_uninitialized_phi(), and zero_one_minusone().

◆ gimple_phi_result() [1/2]

tree gimple_phi_result ( const gimple * gs)
inline

References as_a(), and gimple_phi_result().

◆ gimple_phi_result() [2/2]

tree gimple_phi_result ( const gphi * gs)
inline
Return the SSA name created by GIMPLE_PHI GS.   

References gimple_phi_result(), and gphi::result.

Referenced by add_scope_conflicts_1(), scev_dfs::add_to_evolution_1(), and_comparisons_1(), assign_calc_vals_to_header_phis(), assign_known_vals_to_header_phis(), assign_vals_to_header_phis(), bb_has_non_vop_phi(), rewrite_dom_walker::before_dom_children(), rewrite_update_dom_walker::before_dom_children(), strlen_pass::before_dom_children(), substitute_and_fold_dom_walker::before_dom_children(), tree_switch_conversion::switch_conversion::build_arrays(), tree_switch_conversion::switch_conversion::build_constructors(), build_new_reduction(), calculate_live_on_exit(), can_handle_load(), can_skip_redundant_opnd(), ccp_initialize(), check_exit_phi(), tree_switch_conversion::switch_conversion::check_final_bb(), clean_up_loop_closed_phi(), cleanup_empty_eh_merge_phis(), combine_blocks(), ipa_icf::sem_function::compare_phi_node(), compute_avail(), path_range_query::compute_phi_relations(), path_range_query::compute_ranges_in_phis(), cond_if_else_store_replacement_1(), cond_store_replacement(), cond_store_replacement_limited(), consider_split(), constant_after_peeling(), copy_loop_before(), copy_phi_args(), create_coalesce_list_for_region(), degenerate_phi_result(), destroy_loop(), determine_reduction_stmt_1(), determine_value_range(), do_simple_agr_dse(), dse_classify_store(), dump_gimple_phi(), dump_phi_nodes(), edge_before_returns_twice_call(), eliminate_build(), eliminate_dom_walker::eliminate_cleanup(), eliminate_redundant_computations(), eliminate_unnecessary_stmts(), eliminate_useless_phis(), estimate_threading_killed_stmts(), crc_symbolic_execution::execute_bb_phi_statements(), execute_sm_if_changed(), expand_omp_for_generic(), expand_omp_for_static_chunk(), expr_hash_elt::expr_hash_elt(), factor_out_conditional_load(), factor_out_conditional_operation(), factor_out_operators(), find_basis_for_candidate(), find_deriving_biv_for_expr(), find_func_aliases(), find_implicit_erroneous_behavior(), pcom_worker::find_looparound_phi(), find_phi_def(), find_seed_stmts_for_distribution(), crc_optimization::find_shift_after_xor(), find_tail_calls(), find_uninit_use(), find_uses_to_rename_bb(), find_vdef_in_loop(), tree_switch_conversion::switch_conversion::fix_phi_nodes(), tree_switch_conversion::switch_decision_tree::fix_phi_operands_for_edges(), fuse_loops(), tree_switch_conversion::switch_conversion::gather_default_values(), generate_loops_for_partition(), virtual_operand_live::get_live_in(), get_live_virtual_operand_on_edge(), crc_optimization::get_output_phi(), get_range_strlen(), get_range_strlen_phi(), get_reassociation_width(), get_vop_from_header(), gimple_dump_bb_as_sarif_properties(), gimple_dump_bb_for_graph(), gimple_duplicate_bb(), gimple_get_lhs(), gimple_lower_bitint(), gimple_make_forwarder_block(), gimple_merge_blocks(), gimple_phi_result(), gimple_phi_result(), gimple_range_type(), gsi_next_nonvirtual_phi(), gsi_start_nonvirtual_phis(), hardcfr_sibcall_search_preds(), hoist_adjacent_loads(), hoist_guard(), ifcombine_replace_cond(), ifcvt_local_dce(), ipa_icf::sem_function::init(), init_copy_prop(), init_dont_simulate_again(), insert_backedge_copies(), insert_clobber_before_stack_restore(), pointer_analysis::intra_build_constraints(), pointer_analysis::ipa_build_constraints(), is_nonwrapping_integer_induction(), long_mul_split_phi(), avail_exprs_stack::lookup_avail_expr(), loop_iter_phi_semi_invariant_p(), lowest_cost_path(), lto_prepare_function_for_streaming(), make_forwarders_with_degenerate_phis(), ipa_param_body_adjustments::mark_dead_statements(), mark_ssa_maybe_undefs(), mark_virtual_phi_result_for_renaming(), match_long_mul_phi(), match_saturation_add(), match_saturation_mul(), match_saturation_sub(), match_saturation_trunc(), match_simplify_replacement(), match_spaceship(), path_range_query::maybe_register_phi_relation(), maybe_remove_forwarder_block(), ipa_param_body_adjustments::modify_cfun_body(), move_computations_worker(), move_early_exit_stmts(), movement_possibility_1(), op_iter_init_phidef(), op_iter_init_phiuse(), crc_optimization::optimize_crc_loop(), optimize_spaceship(), or_comparisons_1(), output_bb(), parloops_is_simple_reduction(), phi_incr_cost_1(), phi_rank(), predicate_all_scalar_phis(), predicate_for_phi_result(), predicate_scalar_phi(), prepare_block_for_update_1(), phi_analyzer::process_phi(), propagate_necessity(), uninit_analysis::prune_phi_opnds(), purge_all_uses(), _slp_tree::push_vec_def(), fold_using_range::range_of_phi(), relation_oracle::record(), record_equivalences_from_phis(), tree_switch_conversion::switch_decision_tree::record_phi_operand_mapping(), jump_threader::record_temporary_equivalences_from_phis(), reduc_stmt_res(), reduction_phi(), release_last_vdef(), remove_dead_phis(), remove_phi_node(), remove_unused_locals(), replace_block_by(), replace_phi_edge_with_variable(), replace_uncond_cands_and_profitable_phis(), reserve_phi_args_for_new_edge(), reset_flow_sensitive_info_in_bb(), returning_call_p(), rewrite_add_phi_arguments(), rewrite_trees(), rewrite_update_phi_arguments(), same_phi_alternatives_1(), same_succ_hash(), should_duplicate_loop_header_p(), shrink_wrap_one_built_in_call_with_conds(), simplify_phi_result_movdiv(), ssa_propagation_engine::simulate_stmt(), single_non_singleton_phi_for_edges(), single_phi_def(), sink_clobbers(), sink_common_stores_to_bb(), slpeel_tree_duplicate_loop_to_edge_cfg(), sm_seq_valid_bb(), spaceship_replacement(), split_function(), split_loop(), path_range_query::ssa_range_in_phi(), ssa_redirect_edge(), stmt_has_scalar_dependences_outside_loop(), stmt_may_generate_copy(), stmt_may_generate_copy(), loop_distribution::stmts_from_loop(), thread_private_new_memory(), total_savings(), unroll_jam_possible_p(), unsplit_eh(), update_phi_components(), value_replacement(), var_is_used_for_virtual_call_p(), vect_build_slp_tree_2(), vect_do_peeling(), vect_mark_stmts_to_be_vectorized(), vect_phi_first_order_recurrence_p(), vect_transform_cycle_phi(), vect_transform_lc_phi(), vect_update_ivs_after_vectorizer(), vectorizable_live_operation(), vectorizable_phi(), vectorizable_recurr(), vectorizable_reduction(), verify_gimple_in_cfg(), verify_gimple_phi(), verify_live_on_entry(), verify_non_ssa_vars(), verify_phi_args(), verify_ssa(), verify_ssaname_freelists(), verify_vssa(), visit_bb(), ccp_propagate::visit_phi(), complex_propagate::visit_phi(), copy_prop::visit_phi(), vn_phi_insert(), vn_phi_lookup(), vop_phi(), and warn_uninit_phi_uses().

◆ gimple_phi_result_ptr() [1/2]

tree * gimple_phi_result_ptr ( gimple * gs)
inline

References as_a(), and gimple_phi_result_ptr().

◆ gimple_phi_result_ptr() [2/2]

tree * gimple_phi_result_ptr ( gphi * gs)
inline

◆ gimple_phi_set_arg()

void gimple_phi_set_arg ( gphi * phi,
unsigned index,
struct phi_arg_d * phiarg )
inline
Set PHIARG to be the argument corresponding to incoming edge INDEX
for GIMPLE_PHI PHI.   

References gphi::args, gcc_gimple_checking_assert, and gimple_phi_set_arg().

Referenced by gimple_phi_set_arg().

◆ gimple_phi_set_result()

◆ gimple_plf()

unsigned int gimple_plf ( gimple * stmt,
enum plf_mask plf )
inline
Return the value of pass local flag PLF on statement STMT.

Please note that this 'plf' property of the gimple statement is
supposed to be undefined at pass boundaries.  This means that a
given pass should not assume it contains any useful value when the
pass starts and thus can set it to any value it sees fit.

You can learn more about the plf property by reading the comment of
the 'plf' data member of struct gimple_statement_structure.   

References gimple_plf().

Referenced by analyze_function_body(), do_rpo_vn_1(), eliminate_unnecessary_stmts(), find_deps_in_bb_for_stmt(), gimple_do_not_emit_location_p(), gimple_plf(), ifcvt_local_dce(), mark_all_reaching_defs_necessary_1(), mark_operand_necessary(), mark_stmt_necessary(), mark_stmt_necessary(), predicate_statements(), register_defs_p(), and remove_dead_phis().

◆ gimple_references_memory_p()

◆ gimple_resx_region()

int gimple_resx_region ( const gresx * resx_stmt)
inline

◆ gimple_resx_set_region()

void gimple_resx_set_region ( gresx * resx_stmt,
int region )
inline
Set REGION to be the region number for GIMPLE_RESX RESX_STMT.   

References gimple_resx_set_region(), and gimple_statement_eh_ctrl::region.

Referenced by gimple_resx_set_region(), input_gimple_stmt(), move_stmt_r(), and remap_gimple_stmt().

◆ gimple_return_retval()

◆ gimple_return_retval_ptr()

tree * gimple_return_retval_ptr ( greturn * gs)
inline

◆ gimple_return_set_retval()

◆ gimple_seq_add_seq()

void gimple_seq_add_seq ( gimple_seq * dst_p,
gimple_seq src )
Append sequence SRC to the end of sequence *DST_P.  If *DST_P is
NULL, a new sequence is allocated.   

References gimple_seq_add_seq(), gsi_insert_seq_after(), gsi_last(), GSI_NEW_STMT, NULL, and si.

Referenced by create_expression_by_pieces(), do_goto_redirection(), do_return_redirection(), emit_phi_nodes(), expand_ifn_va_arg_1(), finalize_nesting_tree_1(), flatten_binds(), frob_into_branch_around(), gimple_bind_add_seq(), gimple_build_debug_inline_entry(), gimple_seq_add_seq(), gimplify_cond_expr(), gimplify_expr(), gimplify_omp_workshare(), gimplify_switch_expr(), gimplify_target_expr(), gsi_insert_seq_on_edge(), honor_protect_cleanup_actions(), lower_catch(), lower_eh_filter(), lower_lastprivate_clauses(), lower_oacc_head_tail(), lower_oacc_reductions(), lower_omp_for(), lower_omp_for_lastprivate(), lower_omp_for_scan(), lower_omp_interop(), lower_omp_scan(), lower_omp_scope(), lower_omp_sections(), lower_omp_single(), lower_omp_single_copy(), lower_omp_single_simple(), lower_omp_target(), lower_omp_task_reductions(), lower_omp_taskreg(), lower_omp_teams(), lower_rec_input_clauses(), lower_reduction_clauses(), lower_try_finally(), lower_try_finally_copy(), lower_try_finally_nofallthru(), lower_try_finally_onedest(), lower_try_finally_switch(), optimize_double_finally(), remap_gimple_seq(), rewrite_use_nonlinear_expr(), vect_create_addr_base_for_vector_ref(), vect_create_cond_for_align_checks(), vect_gen_prolog_loop_niters(), vect_loop_versioning(), vect_prepare_for_masked_peels(), vect_set_loop_controls_directly(), vectorizable_induction(), vectorizable_live_operation_1(), and walk_gimple_omp_for().

◆ gimple_seq_add_seq_without_update()

◆ gimple_seq_add_stmt()

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

References gimple_seq_add_stmt(), gsi_insert_after(), gsi_last(), GSI_NEW_STMT, NULL, and si.

Referenced by add_phi_node_to_bb(), add_wait(), asan_expand_check_ifn(), rt_bb_visited::build_block_check(), build_mul_high_seq(), build_omp_iterators_loops(), rt_bb_visited::check(), create_iv(), create_mul_low_seq(), decompose_kernels_region_body(), default_goacc_reduction(), do_goto_redirection(), do_return_redirection(), duplicate_and_interleave(), tree_switch_conversion::jump_table_cluster::emit(), emit_post_landing_pad(), emit_resx(), final_value_replacement_loop(), finalize_nesting_tree_1(), finalize_task_copyfn(), flatten_binds(), frob_into_branch_around(), gen_emutls_addr(), generate_rawmemchr_builtin(), generate_strlen_builtin(), generate_strlen_builtin_1(), generate_strlen_builtin_using_rawmemchr(), gimple_bind_add_stmt(), gimple_build_debug_inline_entry(), gimple_seq_add_stmt(), gimple_seq_alloc_with_stmt(), gimple_seq_copy(), gimplify_body(), gimplify_case_label_expr(), gimplify_expr(), gimplify_function_tree(), gimplify_label_expr(), gimplify_omp_depend(), gimplify_omp_workshare(), gimplify_parameters(), gsi_insert_on_edge(), rt_bb_visited::insert_exit_check_on_edge(), insert_trap(), instrument_decisions(), long_mul_apply_extras(), lower_assumption(), lower_catch(), lower_cleanup(), lower_depend_clauses(), lower_eh_filter(), lower_emutls_1(), lower_function_body(), lower_lastprivate_clauses(), lower_long_mul_high_chain(), lower_oacc_head_mark(), lower_oacc_head_tail(), lower_oacc_loop_marker(), lower_oacc_reductions(), lower_omp_for(), lower_omp_for_scan(), lower_omp_interop(), lower_omp_scan(), lower_omp_scope(), lower_omp_sections(), lower_omp_single(), lower_omp_single_copy(), lower_omp_single_simple(), lower_omp_target(), lower_omp_task_reductions(), lower_omp_taskreg(), lower_omp_teams(), lower_private_allocate(), lower_rec_input_clauses(), lower_rec_simd_input_clauses(), lower_reduction_clauses(), lower_transaction(), lower_try_finally(), lower_try_finally_copy(), lower_try_finally_nofallthru(), lower_try_finally_onedest(), lower_try_finally_switch(), make_data_region_try_statement(), maybe_add_implicit_barrier_cancel(), oacc_dim_call(), reset_debug_binding(), rewrite_to_defined_unconditional(), rt_bb_visited::rt_bb_visited(), scan_omp_simd(), scan_omp_simd_scan(), set_component_ssa_name(), simplify_count_zeroes(), split_update_decision_counter(), task_reduction_read(), vect_adjust_loop_lens_control(), vect_create_cond_for_align_checks(), vect_create_constant_vectors(), vect_gen_len(), vect_gen_while(), vect_maybe_permute_loop_masks(), vect_set_loop_controls_directly(), vectorizable_load(), rt_bb_visited::vindex(), rt_bb_visited::visit(), rt_bb_visited::vset(), and worker_single_copy().

◆ gimple_seq_add_stmt_without_update()

void gimple_seq_add_stmt_without_update ( gimple_seq * seq_p,
gimple * gs )
extern
Link gimple statement GS to the end of the sequence *SEQ_P.  If
*SEQ_P is NULL, a new sequence is allocated.  This function is
similar to gimple_seq_add_stmt, but does not scan the operands.
During gimplification, we need to manipulate statement sequences
before the def/use vectors have been constructed.   

References gimple_seq_add_stmt_without_update(), gsi_insert_after_without_update(), gsi_last(), GSI_NEW_STMT, NULL, and si.

Referenced by append_inv_pattern_def_seq(), append_pattern_def_seq(), convert_nonlocal_omp_clauses(), create_expression_by_pieces(), finalize_eliminated_stores(), find_deps_in_bb_for_stmt(), gimple_build(), gimple_build(), gimple_build(), gimple_build(), gimple_build(), gimple_build(), gimple_build(), gimple_build_debug_inline_entry(), gimple_build_vector(), gimple_build_vector_from_val(), gimple_fold_builtin_bzero(), gimple_fold_builtin_fwrite(), gimple_fold_builtin_memchr(), gimple_fold_builtin_snprintf(), gimple_fold_builtin_sprintf(), gimple_fold_builtin_strcat(), gimple_fold_builtin_strchr(), gimple_fold_builtin_string_compare(), gimple_fold_builtin_strstr(), gimple_load_first_char(), gimple_seq_add_stmt_without_update(), gimplify_seq_add_stmt(), instrument_expr(), instrument_func_entry(), maybe_push_res_to_seq(), optimize_range_tests_cmp_bitwise(), optimize_range_tests_to_bit_test(), remap_gimple_stmt(), simd_clone_adjust(), loop_cand::undo_simple_reduction(), vect_create_partial_epilog(), vect_split_statement(), vect_update_ivs_after_vectorizer_for_early_breaks(), version_loop_by_alias_check(), and vn_nary_build_or_lookup_1().

◆ gimple_seq_alloc_with_stmt()

gimple_seq gimple_seq_alloc_with_stmt ( gimple * stmt)
inline

◆ gimple_seq_copy()

◆ gimple_seq_discard()

◆ gimple_seq_empty_p()

bool gimple_seq_empty_p ( gimple_seq s)
inline
Return true if GIMPLE sequence S is empty.   

References gimple_seq_empty_p(), and NULL.

Referenced by add_phi_args_after_copy_edge(), annotate_all_with_location(), compute_antic_aux(), compute_partial_antic_aux(), copy_bb(), create_expression_by_pieces(), do_hoist_insertion(), dump_gimple_omp_block(), dump_gimple_omp_critical(), dump_gimple_omp_dispatch(), dump_gimple_omp_for(), dump_gimple_omp_masked(), dump_gimple_omp_ordered(), dump_gimple_omp_scan(), dump_gimple_omp_scope(), dump_gimple_omp_sections(), dump_gimple_omp_single(), dump_gimple_omp_taskgroup(), dump_gimple_omp_teams(), empty_bb_or_one_feeding_into_p(), empty_body_p(), expand_omp_atomic_pipeline(), expand_phi_nodes(), expand_remove_edge(), force_gimple_operand_gsi_1(), gimple_execute_on_growing_pred(), gimple_execute_on_shrinking_pred(), gimple_find_edge_insert_loc(), gimple_push_condition(), gimple_regimplify_operands(), gimple_seq_empty_p(), gimplify_and_update_call_from_tree(), gimplify_body(), gimplify_expr(), gimplify_omp_for(), gsi_replace_with_seq(), gsi_safe_insert_seq_before(), insert_into_preds_of_block(), lower_emutls_function_body(), lower_omp_for(), lower_omp_for_lastprivate(), maybe_register_def(), maybe_remove_forwarder_block(), ipa_param_body_adjustments::modify_cfun_body(), no_side_effect_bb(), one_feeding_comparison_into_p(), phi_translate_set(), phiopt_early_allow(), remap_gimple_stmt(), replace_stmt_with_simplification(), single_block_loop_p(), sink_clobbers(), split_critical_edges(), take_address_of(), tree_optimize_tail_calls_1(), uncprop_into_successor_phis(), unsplit_eh(), value_replacement(), vect_analyze_loop_form(), vect_create_constant_vectors(), vect_recog_bit_insert_pattern(), vect_slp_region(), vect_transform_loop(), and walk_gimple_omp_for().

◆ gimple_seq_first()

◆ gimple_seq_first_nondebug_stmt()

gimple * gimple_seq_first_nondebug_stmt ( gimple_seq s)
inline
Return the first nondebug statement in GIMPLE sequence S.   

References gimple_seq_first(), gimple_seq_first_nondebug_stmt(), and is_gimple_debug().

Referenced by gimple_seq_first_nondebug_stmt(), and gimplify_body().

◆ gimple_seq_first_stmt()

◆ gimple_seq_first_stmt_as_a_bind()

gbind * gimple_seq_first_stmt_as_a_bind ( gimple_seq s)
inline
Return the first statement in GIMPLE sequence S as a gbind *,
verifying that it has code GIMPLE_BIND in a checked build.   

References as_a(), gimple_seq_first(), and gimple_seq_first_stmt_as_a_bind().

Referenced by finalize_nesting_tree_1(), gimple_seq_first_stmt_as_a_bind(), and lower_omp_target().

◆ gimple_seq_last()

◆ gimple_seq_last_nondebug_stmt()

gimple * gimple_seq_last_nondebug_stmt ( gimple_seq s)
inline
Return the last nondebug statement in GIMPLE sequence S.   

References gimple_seq_last(), gimple_seq_last_nondebug_stmt(), is_gimple_debug(), and NULL.

Referenced by gimple_seq_last_nondebug_stmt(), gimple_seq_may_fallthru(), and gimplify_body().

◆ gimple_seq_last_stmt()

◆ gimple_seq_set_first()

void gimple_seq_set_first ( gimple_seq * ps,
gimple_seq_node first )
inline

◆ gimple_seq_set_last()

void gimple_seq_set_last ( gimple_seq * ps,
gimple_seq_node last )
inline

◆ gimple_seq_set_location()

void gimple_seq_set_location ( gimple_seq seq,
location_t loc )
extern

◆ gimple_seq_singleton_p()

◆ gimple_set_bb()

◆ gimple_set_block()

◆ gimple_set_do_not_emit_location()

void gimple_set_do_not_emit_location ( gimple * g)
inline
Mark statement G so a location will not be emitted by
annotate_one_with_location.   

References g, GF_PLF_1, gimple_set_do_not_emit_location(), and gimple_set_plf().

Referenced by gimple_set_do_not_emit_location(), and gimplify_cond_expr().

◆ gimple_set_has_volatile_ops()

◆ gimple_set_lhs()

◆ gimple_set_location()

void gimple_set_location ( gimple * g,
location_t location )
inline
Forward declare.   
Set location information for statement G.   

References copy_warning(), g, gimple_set_location(), and UNKNOWN_LOCATION.

Referenced by add_wait(), annotate_one_with_location(), asan_expand_check_ifn(), asan_expand_mark_ifn(), asan_expand_poison_ifn(), asan_maybe_insert_dynamic_shadow_at_function_entry(), asan_store_shadow_bytes(), assign_discriminators(), assign_discriminators_to_bb(), assign_discriminators_to_stmt(), attempt_builtin_copysign(), attempt_builtin_powi(), branch_fixup(), build_and_insert_binop(), build_and_insert_call(), build_check_stmt(), complex_pattern::build_common(), build_mul_high_seq(), build_ref_for_offset(), build_shadow_mem_access(), build_tm_load(), build_tm_store(), clear_padding_emit_loop(), clear_padding_flush(), clear_padding_type(), clobber_subtree(), cond_store_replacement(), cond_store_replacement_limited(), convert_expand_mult_copysign(), copy_bb(), create_add_on_incoming_edge(), create_expression_by_pieces(), create_mul_low_seq(), create_parallel_loop(), decompose_kernels_region_body(), detach_value(), do_goto_redirection(), tree_switch_conversion::switch_decision_tree::do_jump_if_equal(), do_return_redirection(), tree_switch_conversion::jump_table_cluster::emit(), tree_switch_conversion::switch_decision_tree::emit_cmp_and_jump_insns(), execute_omp_device_lower(), execute_update_addresses_taken(), expand_assign_tm(), expand_call_inline(), expand_call_tm(), expand_complex_move(), expand_oacc_collapse_init(), expand_oacc_for(), expand_omp_atomic_cas(), expand_omp_atomic_load(), expand_omp_atomic_store(), expand_omp_ordered_sink(), expand_omp_ordered_source(), expand_omp_target(), expand_transaction(), final_value_replacement_loop(), finish_update_gimple_call(), frob_into_branch_around(), gen_emutls_addr(), generate_memcpy_builtin(), generate_memset_builtin(), generate_rawmemchr_builtin(), generate_strlen_builtin(), generate_strlen_builtin_using_rawmemchr(), generate_subtree_copies(), generate_subtree_deferred_init(), get_string_length(), gimple_build(), gimple_build(), gimple_build(), gimple_build(), gimple_build(), gimple_build(), gimple_build(), gimple_build_builtin_unreachable(), gimple_build_call_from_tree(), gimple_build_debug_begin_stmt(), gimple_build_debug_bind(), gimple_build_debug_inline_entry(), gimple_build_debug_source_bind(), gimple_build_vector(), gimple_build_vector_from_val(), gimple_call_copy_skip_args(), gimple_expand_builtin_cabs(), gimple_expand_vec_set_extract_expr(), gimple_fold_builtin_acc_on_device(), gimple_fold_builtin_clear_padding(), gimple_fold_builtin_memory_op(), gimple_fold_builtin_memset(), gimple_fold_builtin_stdarg(), gimple_fold_builtin_strcat(), gimple_fold_builtin_strchr(), gimple_fold_partial_load_store(), gimple_lower_bitint(), gimple_seq_set_location(), gimple_set_block(), gimple_set_location(), gimplify_bind_expr(), gimplify_call_expr(), gimplify_case_label_expr(), gimplify_cond_expr(), gimplify_expr(), gimplify_label_expr(), gimplify_modify_expr(), gimplify_omp_for(), gimplify_omp_workshare(), gimplify_switch_expr(), gsi_insert_finally_seq_after_call(), gsi_replace(), tree_switch_conversion::bit_test_cluster::hoist_edge_and_branch_if_true(), ifcombine_replace_cond(), init_subtree_with_zero(), init_tmp_var(), init_tmp_var_with_call(), insert_backedge_copies(), insert_check_and_trap(), insert_initializers(), instrument_bool_enum_load(), instrument_builtin(), instrument_expr(), instrument_func_entry(), instrument_func_exit(), instrument_mem_ref(), instrument_nonnull_arg(), instrument_nonnull_return(), instrument_object_size(), instrument_pointer_overflow(), instrument_si_overflow(), load_assign_lhs_subreplacements(), long_mul_apply_extras(), lower_assumption(), lower_builtin_setjmp(), lower_catch(), lower_eh_constructs_2(), lower_eh_dispatch(), lower_eh_filter(), lower_emutls_1(), lower_function_body(), lower_gimple_return(), lower_long_mul_high_chain(), lower_oacc_head_mark(), lower_oacc_head_tail(), lower_oacc_loop_marker(), lower_omp_teams(), lower_resx(), lower_try_finally_copy(), lower_try_finally_dup_block(), lower_try_finally_nofallthru(), lower_try_finally_onedest(), lower_try_finally_switch(), make_blocks(), make_blocks_1(), make_data_region_try_statement(), make_region_loop_nest(), make_region_seq(), maybe_add_asan_poison_write(), maybe_build_inner_data_region(), maybe_cast_to_ptrmode(), maybe_create_ssa_name(), maybe_instrument_call(), maybe_move_debug_stmts_to_successors(), ipa_param_adjustments::modify_call(), ipa_param_body_adjustments::modify_call_stmt(), narrow_long_mul_halves(), narrow_long_mul_low_half(), omp_oacc_kernels_decompose_1(), crc_optimization::optimize_crc_loop(), optimize_range_tests_to_bit_test(), optimize_tail_call(), optimize_vector_load(), phiprop_insert_phi(), powi_as_mults(), powi_as_mults_1(), reassociate_bb(), remap_gimple_stmt(), replace_call_with_call_and_fold(), replace_func_exit(), replace_goto_queue_1(), replace_mult_candidate(), replace_one_candidate(), save_tmp_var(), shrink_wrap_len_call(), simplify_count_zeroes(), simplify_using_ranges::simplify_internal_call_using_ranges(), sra_modify_expr(), ubsan_expand_bounds_ifn(), ubsan_expand_null_ifn(), ubsan_expand_objsize_ifn(), ubsan_expand_ptr_ifn(), ubsan_expand_vptr_ifn(), use_internal_fn(), vect_finish_stmt_generation_1(), vect_recog_abd_pattern(), vect_recog_average_pattern(), vect_recog_build_binary_gimple_stmt(), vect_recog_cast_forwprop_pattern(), vect_recog_cond_store_pattern(), vect_recog_ctz_ffs_pattern(), vect_recog_divmod_pattern(), vect_recog_mulhs_pattern(), vect_recog_over_widening_pattern(), vect_recog_popcount_clz_ctz_ffs_pattern(), vect_recog_sat_trunc_pattern(), vect_recog_widen_abd_pattern(), and walk_regimplify_phi().

◆ gimple_set_modified()

◆ gimple_set_no_warning()

void gimple_set_no_warning ( gimple * stmt,
bool no_warning )
inline
Set the no_warning flag of STMT to NO_WARNING.   

References gimple_set_no_warning(), and no_warning.

Referenced by gimple_set_no_warning().

◆ gimple_set_num_ops()

◆ gimple_set_op()

◆ gimple_set_plf()

void gimple_set_plf ( gimple * stmt,
enum plf_mask plf,
bool val_p )
inline
Set pass local flag PLF on statement STMT to VAL_P.

Please note that this PLF property of the gimple statement is
supposed to be undefined at pass boundaries.  This means that a
given pass should not assume it contains any useful value when the
pass starts and thus can set it to any value it sees fit.

You can learn more about the PLF property by reading the comment of
the 'plf' data member of struct gimple_statement_structure.   

References gimple_set_plf().

Referenced by eliminate_unnecessary_stmts(), find_deps_in_bb_for_stmt(), find_necessary_statements(), find_obviously_necessary_stmts(), gimple_set_do_not_emit_location(), gimple_set_plf(), if_convertible_gimple_assign_stmt_p(), if_convertible_stmt_p(), ifcvt_local_dce(), mark_operand_necessary(), mark_stmt_necessary(), mark_stmt_necessary(), remove_dead_phis(), set_register_defs(), and visit_phi().

◆ gimple_set_uid()

void gimple_set_uid ( gimple * g,
unsigned uid )
inline

◆ gimple_set_use_ops()

void gimple_set_use_ops ( gimple * g,
struct use_optype_d * use )
inline
Set USE to be the set of USE operands for statement G.   

References as_a(), g, gimple_set_use_ops(), and gimple_statement_with_ops_base::use_ops.

Referenced by operands_scanner::finalize_ssa_uses(), free_stmt_operands(), gimple_copy(), and gimple_set_use_ops().

◆ gimple_set_vdef()

◆ gimple_set_visited()

void gimple_set_visited ( gimple * stmt,
bool visited_p )
inline
Set the visited status on statement STMT to VISITED_P.

 Please note that this 'visited' property of the gimple statement is
 supposed to be undefined at pass boundaries.  This means that a
 given pass should not assume it contains any useful value when the
 pass starts and thus can set it to any value it sees fit.

 You can learn more about the visited property of the gimple
 statement by reading the comments of the 'visited' data member of
 struct gimple.

References gimple_set_visited().

Referenced by attempt_builtin_powi(), dom_opt_dom_walker::before_dom_children(), break_up_subtract_bb(), cond_if_else_store_replacement(), get_ops(), gimple_set_visited(), linearize_expr(), linearize_expr_tree(), maybe_optimize_range_tests(), negate_value(), optimize_range_tests_to_bit_test(), prop_set_simulate_again(), reassociate_bb(), rewrite_expr_tree(), rewrite_expr_tree_parallel(), set_rewrite_uses(), transform_add_to_multiply(), try_special_add_to_ops(), try_vectorize_loop_1(), undistribute_bitref_for_vector(), update_ops(), vect_bb_slp_scalar_cost(), vect_bb_vectorization_profitable_p(), vect_slp_analyze_instance_dependence(), and vect_slp_region().

◆ gimple_set_vuse()

◆ gimple_signed_type()

tree gimple_signed_type ( tree type)
extern

◆ gimple_size()

size_t gimple_size ( enum gimple_code code,
unsigned num_ops )
Return the number of bytes needed to hold a GIMPLE statement with
code CODE.   

References gimple_size(), gss_for_code(), and gsstruct_code_size.

Referenced by gimple_alloc(), gimple_assign_set_rhs_with_ops(), gimple_copy(), gimple_size(), and maybe_fold_comparisons_from_match_pd().

◆ gimple_statement_structure()

enum gimple_statement_structure_enum gimple_statement_structure ( gimple * gs)
inline
Return which GSS code is used by GS.   

References gimple_statement_structure(), and gss_for_code().

Referenced by gimple_ops(), gimple_statement_structure(), and walk_gimple_op().

◆ gimple_stmt_max_uid()

unsigned int gimple_stmt_max_uid ( struct function * fn)
inline
Get the number of the next statement uid to be allocated.   

References gimple_stmt_max_uid(), and function::last_stmt_uid.

Referenced by gimple_stmt_max_uid(), input_function(), and ssa_prop_init().

◆ gimple_store_p()

◆ gimple_switch_default_label()

◆ gimple_switch_index()

tree gimple_switch_index ( const gswitch * gs)
inline
Return the index variable used by the switch statement GS.   

References gimple_switch_index(), and gimple_statement_with_ops::op.

Referenced by associate_equivalences_with_edges(), gimple_outgoing_range::calc_switch_ranges(), gori_map::calculate_gori(), ccp_fold(), clean_up_after_unswitching(), cleanup_control_expr_graph(), tree_switch_conversion::switch_conversion::collect(), ipa_icf_gimple::func_checker::compare_gimple_switch(), gori_compute::compute_operand_range_switch(), convert_single_case_switch(), dump_gimple_switch(), eliminate_redundant_computations(), eliminate_dom_walker::eliminate_stmt(), evaluate_control_stmt_using_entry_checks(), evaluate_stmt(), tree_switch_conversion::switch_conversion::exp_index_transform(), expand_case(), expr_hash_elt::expr_hash_elt(), infinite_recursion_diagnostic::fedge_uses_conjured_svalue_p(), find_case_label_range(), find_tail_calls(), back_threader::find_taken_edge_switch(), find_taken_edge_switch_expr(), find_unswitching_predicates_for_bb(), gimple_lower_bitint(), gimple_switch_index(), ipa_icf::sem_function::hash_stmt(), predicate::init_from_control_deps(), tree_switch_conversion::switch_conversion::is_exp_index_transform_viable(), may_propagate_copy_into_stmt(), dom_opt_dom_walker::optimize_stmt(), predicate_bbs(), process_bb(), record_edge_info(), set_switch_stmt_execution_predicate(), hybrid_jt_simplifier::simplify(), jump_threader::simplify_control_stmt_condition(), simplify_gimple_switch(), simplify_using_ranges::simplify_switch_using_ranges(), gimple_outgoing_range::switch_edge_range(), tree_estimate_loop_size(), tree_predict_by_opcode(), tree_switch_conversion::switch_decision_tree::try_switch_expansion(), and verify_gimple_switch().

◆ gimple_switch_index_ptr()

tree * gimple_switch_index_ptr ( gswitch * gs)
inline

◆ gimple_switch_label()

tree gimple_switch_label ( const gswitch * gs,
unsigned index )
inline
Return the label numbered INDEX.  The default label is 0, followed by any
labels in a switch statement.   

References gcc_gimple_checking_assert, gimple_num_ops(), gimple_switch_label(), and gimple_statement_with_ops::op.

Referenced by tree_switch_conversion::switch_decision_tree::analyze_switch_statement(), associate_equivalences_with_edges(), tree_switch_conversion::switch_conversion::build_constructors(), gimple_outgoing_range::calc_switch_ranges(), clean_up_after_unswitching(), cleanup_dead_labels(), simplify_using_ranges::cleanup_edges_and_switches(), tree_switch_conversion::switch_conversion::collect(), ipa_icf_gimple::func_checker::compare_gimple_switch(), tree_switch_conversion::switch_decision_tree::compute_cases_per_edge(), control_flow_regions::compute_regions(), convert_single_case_switch(), diagnose_sb_2(), dump_gimple_switch(), evaluate_control_stmt_using_entry_checks(), tree_switch_conversion::switch_conversion::exp_index_transform(), tree_switch_conversion::switch_conversion::expand(), expand_case(), find_case_label_for_value(), find_case_label_index(), find_case_label_range(), find_case_label_range(), find_unswitching_predicates_for_bb(), generate_loops_for_partition(), get_cases_for_edge(), gimple_redirect_edge_and_branch(), gimple_switch_default_label(), gimple_switch_label(), gimple_switch_label_bb(), gimple_verify_flow_info(), group_case_labels_stmt(), if_convertible_switch_p(), tree_switch_conversion::switch_conversion::is_exp_index_transform_viable(), predicate_bbs(), record_edge_info(), set_switch_stmt_execution_predicate(), simplify_gimple_switch(), simplify_gimple_switch_label_vec(), simplify_using_ranges::simplify_switch_using_ranges(), gimple_outgoing_range::switch_edge_range(), and verify_gimple_switch().

◆ gimple_switch_num_labels()

unsigned gimple_switch_num_labels ( const gswitch * gs)
inline
Return the number of labels associated with the switch statement GS.   

References gcc_gimple_checking_assert, GIMPLE_CHECK, gimple_num_ops(), and gimple_switch_num_labels().

Referenced by tree_switch_conversion::switch_decision_tree::analyze_switch_statement(), associate_equivalences_with_edges(), tree_switch_conversion::switch_conversion::build_constructors(), gimple_outgoing_range::calc_switch_ranges(), tree_switch_conversion::switch_conversion::check_final_bb(), clean_up_after_unswitching(), cleanup_dead_labels(), tree_switch_conversion::switch_conversion::collect(), ipa_icf_gimple::func_checker::compare_gimple_switch(), tree_switch_conversion::switch_decision_tree::compute_cases_per_edge(), control_flow_regions::compute_regions(), convert_single_case_switch(), diagnose_sb_2(), dump_gimple_switch(), estimate_num_insns(), evaluate_control_stmt_using_entry_checks(), tree_switch_conversion::switch_conversion::exp_index_transform(), tree_switch_conversion::switch_conversion::expand(), expand_case(), expand_gimple_stmt_1(), find_case_label_for_value(), find_case_label_index(), find_case_label_range(), find_taken_edge_switch_expr(), find_unswitching_predicates_for_bb(), get_cases_for_edge(), gimple_lower_bitint(), gimple_redirect_edge_and_branch(), gimple_switch_num_labels(), gimple_verify_flow_info(), group_case_labels_stmt(), if_convertible_switch_p(), tree_switch_conversion::switch_conversion::is_exp_index_transform_viable(), make_gimple_switch_edges(), predicate_bbs(), record_edge_info(), set_switch_stmt_execution_predicate(), simplify_gimple_switch(), simplify_gimple_switch_label_vec(), simplify_using_ranges::simplify_switch_using_ranges(), gimple_outgoing_range::switch_edge_range(), tree_switch_conversion::switch_decision_tree::try_switch_expansion(), and verify_gimple_switch().

◆ gimple_switch_set_default_label()

void gimple_switch_set_default_label ( gswitch * gs,
tree label )
inline

◆ gimple_switch_set_index()

◆ gimple_switch_set_label()

◆ gimple_switch_set_num_labels()

void gimple_switch_set_num_labels ( gswitch * g,
unsigned nlabels )
inline

◆ gimple_transaction_body()

gimple_seq gimple_transaction_body ( const gtransaction * transaction_stmt)
inline

◆ gimple_transaction_body_ptr()

gimple_seq * gimple_transaction_body_ptr ( gtransaction * transaction_stmt)
inline
Return a pointer to the body for the GIMPLE_TRANSACTION statement
TRANSACTION_STMT.   

References gtransaction::body, and gimple_transaction_body_ptr().

Referenced by gimple_transaction_body_ptr(), lower_omp_1(), lower_stmt(), lower_transaction(), and walk_gimple_stmt().

◆ gimple_transaction_label_norm()

tree gimple_transaction_label_norm ( const gtransaction * transaction_stmt)
inline

◆ gimple_transaction_label_norm_ptr()

tree * gimple_transaction_label_norm_ptr ( gtransaction * transaction_stmt)
inline

◆ gimple_transaction_label_over()

◆ gimple_transaction_label_over_ptr()

tree * gimple_transaction_label_over_ptr ( gtransaction * transaction_stmt)
inline

◆ gimple_transaction_label_uninst()

◆ gimple_transaction_label_uninst_ptr()

tree * gimple_transaction_label_uninst_ptr ( gtransaction * transaction_stmt)
inline

◆ gimple_transaction_set_body()

void gimple_transaction_set_body ( gtransaction * transaction_stmt,
gimple_seq body )
inline
Set BODY to be the body for the GIMPLE_TRANSACTION statement
TRANSACTION_STMT.   

References gtransaction::body, and gimple_transaction_set_body().

Referenced by gimple_build_transaction(), gimple_copy(), gimple_transaction_set_body(), and lower_transaction().

◆ gimple_transaction_set_label_norm()

void gimple_transaction_set_label_norm ( gtransaction * transaction_stmt,
tree label )
inline

◆ gimple_transaction_set_label_over()

◆ gimple_transaction_set_label_uninst()

◆ gimple_transaction_set_subcode()

void gimple_transaction_set_subcode ( gtransaction * transaction_stmt,
unsigned int subcode )
inline

◆ gimple_transaction_subcode()

◆ gimple_try_catch_is_cleanup()

bool gimple_try_catch_is_cleanup ( const gimple * gs)
inline

◆ gimple_try_cleanup()

◆ gimple_try_cleanup_ptr()

gimple_seq * gimple_try_cleanup_ptr ( gimple * gs)
inline
Return a pointer to the sequence of statements used as the cleanup body for
GIMPLE_TRY GS.   

References as_a(), gtry::cleanup, and gimple_try_cleanup_ptr().

Referenced by gimple_try_catch_may_fallthru(), gimple_try_cleanup(), gimple_try_cleanup_ptr(), lower_cleanup(), lower_omp_1(), lower_stmt(), lower_try_catch(), replace_goto_queue_1(), and walk_gimple_stmt().

◆ gimple_try_eval()

◆ gimple_try_eval_ptr()

◆ gimple_try_kind()

◆ gimple_try_set_catch_is_cleanup()

void gimple_try_set_catch_is_cleanup ( gtry * g,
bool catch_is_cleanup )
inline

◆ gimple_try_set_cleanup()

void gimple_try_set_cleanup ( gtry * try_stmt,
gimple_seq cleanup )
inline
Set CLEANUP to be the sequence of statements to use as the cleanup
body for GIMPLE_TRY TRY_STMT.   

References gtry::cleanup, and gimple_try_set_cleanup().

Referenced by gimple_build_try(), gimple_copy(), gimple_try_set_cleanup(), honor_protect_cleanup_actions(), lower_catch(), lower_eh_filter(), lower_try_finally(), and optimize_double_finally().

◆ gimple_try_set_eval()

void gimple_try_set_eval ( gtry * try_stmt,
gimple_seq eval )
inline
Set EVAL to be the sequence of statements to use as the body for
GIMPLE_TRY TRY_STMT.   

References gtry::eval, and gimple_try_set_eval().

Referenced by gimple_build_try(), gimple_copy(), gimple_try_set_eval(), and optimize_double_finally().

◆ gimple_try_set_kind()

void gimple_try_set_kind ( gtry * gs,
enum gimple_try_flags kind )
inline
Set the kind of try block represented by GIMPLE_TRY GS.   

References gcc_gimple_checking_assert, GIMPLE_TRY_CATCH, GIMPLE_TRY_FINALLY, gimple_try_kind(), gimple_try_set_kind(), and gimple::subcode.

Referenced by gimple_try_set_kind(), and optimize_double_finally().

◆ gimple_uid()

unsigned gimple_uid ( const gimple * g)
inline
Return the UID of statement.

Please note that this UID property is supposed to be undefined at
pass boundaries.  This means that a given pass should not assume it
contains any useful value when the pass starts and thus can set it
to any value it sees fit.   

References g, and gimple_uid().

Referenced by add_ssa_edge(), attempt_builtin_powi(), build_and_add_sum(), can_blend_vec_perm_simplify_seqs_p(), can_remove_asan_check(), cond_if_else_store_replacement(), convert_to_divmod(), copy_bb(), dr_align_group_sort_cmp(), dr_group_sort_cmp(), expand_call_inline(), generate_loops_for_partition(), get_later_stmt(), get_predicates_for_bb(), gimple_duplicate_bb(), gimple_uid(), bst_traits::hash(), if_convertible_loop_p_1(), ifcvt_memrefs_wont_trap(), input_function(), insert_backedge_copies(), insert_stmt_after(), insert_stmt_before_use(), linearize_expr(), vec_info::lookup_stmt(), loop_combined_static_and_iv_p(), loop_invariant_op_p(), loop_static_op_p(), lto_output_edge(), lto_output_ref(), make_new_ssa_for_def(), maybe_optimize_range_tests(), negate_value(), optimize_range_tests_var_bound(), pcom_stmt_dominates_stmt_p(), rdg_vertex_for_stmt(), reassoc_remove_stmt(), reassoc_stmt_dominates_stmt_p(), reassociate_bb(), reduction_phi(), reorder_operands(), vec_info::replace_stmt(), vec_info::resync_stmt_addr(), rewrite_expr_tree(), set_autoinc_for_original_candidates(), vec_info::set_vinfo_for_stmt(), ssa_propagation_engine::simulate_stmt(), stmt_after_inc_pos(), trivially_conflicts_p(), pcom_worker::try_combine_chains(), undistribute_bitref_for_vector(), update_epilogue_loop_vinfo(), update_ops(), update_range_test(), vect_analyze_data_ref_accesses(), vect_cse_gather_part_starts(), vect_cse_slp_node_parts(), vect_schedule_slp_node(), vect_stmt_dominates_stmt_p(), vectorizable_recurr(), and vllp_cmp().

◆ gimple_unsigned_type()

tree gimple_unsigned_type ( tree type)
extern
Return an unsigned type the same as TYPE in other respects.   

References gimple_signed_or_unsigned_type(), and gimple_unsigned_type().

Referenced by gimple_build_debug_inline_entry(), and gimple_unsigned_type().

◆ gimple_use_ops()

struct use_optype_d * gimple_use_ops ( const gimple * g)
inline

◆ gimple_vdef()

tree gimple_vdef ( const gimple * g)
inline
Return the single VDEF operand of the statement G.   

References dyn_cast(), g, gimple_vdef(), NULL_TREE, and gimple_statement_with_memory_ops_base::vdef.

Referenced by bb_no_side_effects_p(), bb_prevents_fusion_p(), nontrapping_dom_walker::before_dom_children(), can_shrink_wrap_len_p(), can_use_internal_fn(), strlen_pass::check_and_optimize_stmt(), collect_dfa_stats(), combine_blocks(), compute_avail(), create_call_for_reduction_1(), destroy_loop(), discover_nonconstant_array_refs(), do_not_sink(), do_simple_agr_dse(), dse_classify_store(), dse_optimize_redundant_stores(), dump_gimple_mem_ops(), eliminate_redundant_computations(), eliminate_dom_walker::eliminate_stmt(), empty_bb_without_guard_p(), execute_oacc_device_lower(), expand_call_inline(), expand_ifn_va_arg_1(), expand_omp_atomic_mutex(), expand_omp_atomic_store(), operands_scanner::finalize_ssa_defs(), find_func_clobbers(), find_replaceable_in_bb(), find_seed_stmts_for_distribution(), gather_mem_refs_stmt(), virtual_operand_live::get_live_out(), get_live_virtual_operand_on_edge(), gimple_call_copy_skip_args(), gimple_copy(), gimple_fold_builtin_bcopy(), gimple_fold_builtin_bzero(), gimple_fold_builtin_fprintf(), gimple_fold_builtin_fputs(), gimple_fold_builtin_fwrite(), gimple_fold_builtin_memory_chk(), gimple_fold_builtin_memory_op(), gimple_fold_builtin_memset(), gimple_fold_builtin_printf(), gimple_fold_builtin_realloc(), gimple_fold_builtin_snprintf(), gimple_fold_builtin_snprintf_chk(), gimple_fold_builtin_sprintf(), gimple_fold_builtin_sprintf_chk(), gimple_fold_builtin_stdarg(), gimple_fold_builtin_stpcpy(), gimple_fold_builtin_strcat(), gimple_fold_builtin_strcat_chk(), gimple_fold_builtin_strcpy(), gimple_fold_builtin_strncat(), gimple_fold_builtin_strncat_chk(), gimple_fold_builtin_strncpy(), gimple_fold_builtin_stxcpy_chk(), gimple_fold_builtin_stxncpy_chk(), gimple_ic(), gimple_move_vops(), gimple_stringop_fixed_value(), gimple_vdef(), gsi_replace_with_seq_vops(), hoist_memory_references(), if_convertible_gimple_assign_stmt_p(), ifcvt_can_hoist(), ifcvt_local_dce(), insert_clobber_before_stack_restore(), invariant_in_sese_p_rec(), mark_stmt_if_obviously_necessary(), maybe_warn_operand(), tree_loop_interchange::move_code_to_inner_loop(), move_computations_worker(), movement_possibility_1(), oacc_entry_exit_ok_1(), oacc_entry_exit_single_gang(), op_iter_next_tree(), optimize_aggr_zeroprop(), optimize_agr_copyprop(), optimize_atomic_compare_exchange_p(), optimize_mask_stores(), predicate_statements(), prepare_block_for_update_1(), propagate_with_phi(), purge_all_uses(), record_equivalences_from_stmt(), ref_conflicts_with_region(), release_last_vdef(), pcom_worker::remove_stmt(), replace_call_with_value(), replace_refs(), rewrite_stmt(), sanopt_optimize_walker(), simple_mem_ref_in_stmt(), simplify_builtin_memcpy_memset(), sink_clobbers(), sink_code_in_bb(), sink_common_stores_to_bb(), slsr_process_ref(), sm_seq_valid_bb(), split_function(), ssa_is_replaceable_p(), statement_sink_location(), stmt_local_def(), stmt_makes_single_store(), stmt_may_clobber_global_p(), surely_varying_stmt_p(), trailing_store_in_bb(), loop_cand::undo_simple_reduction(), unlink_stmt_vdef(), valid_builtin_call(), value_dies_in_block_x(), vect_analyze_early_break_dependences(), vect_finish_stmt_generation(), vect_slp_analyze_load_dependences(), vect_stmt_relevant_p(), vectorizable_simd_clone_call(), operands_scanner::verify_ssa_operands(), verify_vssa(), visit_reference_op_call(), visit_reference_op_store(), visit_stmt(), and warn_uninitialized_vars().

◆ gimple_vdef_ptr()

tree * gimple_vdef_ptr ( gimple * g)
inline
Return the single VDEF operand of the statement G.   

References dyn_cast(), g, gimple_vdef_ptr(), NULL, and gimple_statement_with_memory_ops_base::vdef.

Referenced by gimple_vdef_ptr(), and op_iter_next_def().

◆ gimple_visited_p()

bool gimple_visited_p ( gimple * stmt)
inline
Return the visited status for statement STMT.

Please note that this 'visited' property of the gimple statement is
supposed to be undefined at pass boundaries.  This means that a
given pass should not assume it contains any useful value when the
pass starts and thus can set it to any value it sees fit.

You can learn more about the visited property of the gimple
statement by reading the comments of the 'visited' data member of
struct gimple.   

References gimple_visited_p().

Referenced by dom_opt_dom_walker::before_dom_children(), cond_if_else_store_replacement(), gimple_visited_p(), prop_simulate_again_p(), reassociate_bb(), remove_visited_stmt_chain(), rewrite_uses_p(), suitable_cond_bb(), vect_slp_analyze_load_dependences(), vect_slp_analyze_store_dependences(), and vect_slp_region().

◆ gimple_vuse()

tree gimple_vuse ( const gimple * g)
inline
Return the single VUSE operand of the statement G.   

References dyn_cast(), g, gimple_vuse(), NULL_TREE, and gimple_statement_with_memory_ops_base::vuse.

Referenced by strlen_pass::adjust_last_stmt(), find_candidates_dom_walker::before_dom_children(), can_handle_load(), loop_cand::can_interchange_p(), cfun_returns(), collect_dfa_stats(), combine_blocks(), compute_avail(), cond_store_replacement(), cond_store_replacement_limited(), strlen_pass::count_nonzero_bytes(), strlen_pass::count_nonzero_bytes_addr(), create_call_for_reduction_1(), detect_type_change_from_memory_writes(), determine_known_aggregate_parts(), determine_max_movement(), do_invalidate(), do_not_sink(), do_simple_agr_dse(), dump_gimple_mem_ops(), eliminate_dom_walker::eliminate_stmt(), empty_bb_or_one_feeding_into_p(), execute_oacc_device_lower(), execute_update_addresses_taken(), expand_omp_atomic_load(), expand_omp_atomic_mutex(), expand_omp_atomic_store(), expr_hash_elt::expr_hash_elt(), factor_out_conditional_load(), operands_scanner::finalize_ssa_uses(), find_func_clobbers(), pcom_worker::find_looparound_phi(), find_replaceable_in_bb(), find_single_drs(), find_uses_to_rename_stmt(), find_vdef_in_loop(), fold_strstr_to_strncmp(), fold_truth_andor_for_ifcombine(), remove_unreachable::fully_replaceable(), gather_mem_refs_stmt(), gather_memory_references(), ipa_polymorphic_call_context::get_dynamic_type(), virtual_operand_live::get_live_out(), get_live_virtual_operand_on_edge(), get_references_in_stmt(), get_string_length(), gimple_call_copy_skip_args(), gimple_copy(), gimple_expand_vec_set_extract_expr(), gimple_fold_builtin_bcmp(), gimple_fold_builtin_memory_op(), gimple_fold_builtin_strchr(), gimple_fold_builtin_string_compare(), gimple_fold_builtin_strstr(), gimple_move_vops(), gimple_references_memory_p(), gimple_vuse(), gsi_advance_bw_nondebug_nonlocal(), gsi_replace_with_seq_vops(), if_convertible_gimple_assign_stmt_p(), ifc_temp_var(), ifcvt_can_hoist(), insert_clobber_before_stack_restore(), invariant_in_sese_p_rec(), local_mem_dependence(), avail_exprs_stack::lookup_avail_expr(), make_bit_field_load(), mark_aliased_reaching_defs_necessary(), mark_all_reaching_defs_necessary(), maybe_skip_until(), maybe_warn_operand(), ipa_param_adjustments::modify_call(), tree_loop_interchange::move_code_to_inner_loop(), move_computations_worker(), move_early_exit_stmts(), oacc_entry_exit_ok_1(), oacc_entry_exit_single_gang(), one_feeding_comparison_into_p(), op_iter_init(), optimize_atomic_compare_exchange_p(), optimize_mask_stores(), dom_opt_dom_walker::optimize_stmt(), optimize_vector_load(), param_change_prob(), parm_preserved_before_stmt_p(), parm_ref_data_pass_through_p(), parm_ref_data_preserved_p(), predicate_load_or_store(), prepare_block_for_update_1(), process_replaceable(), propagate_necessity(), propagate_with_phi(), ref_conflicts_with_region(), same_value_p(), should_duplicate_loop_header_p(), simple_mem_ref_in_stmt(), simplify_builtin_memcpy_memset(), sink_clobbers(), sink_code_in_bb(), sm_seq_valid_bb(), split_function(), ssa_vuse_operand(), statement_sink_location(), stmt_local_def(), stmt_may_generate_copy(), stmt_semi_invariant_p_1(), trailing_store_in_bb(), unlink_stmt_vdef(), unmodified_parm_1(), valid_builtin_call(), value_dies_in_block_x(), vect_analyze_early_break_dependences(), vect_build_slp_tree_2(), vect_finish_stmt_generation(), vect_recog_cond_store_pattern(), vect_setup_realignment(), vect_slp_analyze_store_dependences(), vectorizable_call(), vectorizable_load(), vectorizable_simd_clone_call(), operands_scanner::verify_ssa_operands(), verify_vssa(), visit_nary_op(), visit_reference_op_call(), visit_reference_op_load(), visit_reference_op_store(), visit_stmt(), vn_reference_lookup_3(), vn_reference_lookup_call(), walk_aliased_vdefs_1(), and walk_non_aliased_vuses().

◆ gimple_vuse_ptr()

tree * gimple_vuse_ptr ( gimple * g)
inline
Return the single VUSE operand of the statement G.   

References dyn_cast(), g, gimple_vuse_ptr(), NULL, and gimple_statement_with_memory_ops_base::vuse.

Referenced by operands_scanner::finalize_ssa_uses(), and gimple_vuse_ptr().

◆ gimple_wce_cleanup()

gimple_seq gimple_wce_cleanup ( gimple * gs)
inline
Return the cleanup sequence for cleanup statement GS.   

References gimple_wce_cleanup(), and gimple_wce_cleanup_ptr().

Referenced by gimple_copy(), gimple_wce_cleanup(), gimplify_cleanup_point_expr(), and remap_gimple_stmt().

◆ gimple_wce_cleanup_eh_only()

bool gimple_wce_cleanup_eh_only ( const gimple * gs)
inline
Return the CLEANUP_EH_ONLY flag for a WCE tuple.   

References GIMPLE_CHECK, gimple_wce_cleanup_eh_only(), and gimple::subcode.

Referenced by gimple_wce_cleanup_eh_only(), and gimplify_cleanup_point_expr().

◆ gimple_wce_cleanup_ptr()

gimple_seq * gimple_wce_cleanup_ptr ( gimple * gs)
inline
Return a pointer to the cleanup sequence for cleanup statement GS.   

References as_a(), gimple_statement_wce::cleanup, and gimple_wce_cleanup_ptr().

Referenced by gimple_wce_cleanup(), gimple_wce_cleanup_ptr(), and walk_gimple_stmt().

◆ gimple_wce_set_cleanup()

void gimple_wce_set_cleanup ( gimple * gs,
gimple_seq cleanup )
inline
Set CLEANUP to be the cleanup sequence for GS.   

References as_a(), gimple_statement_wce::cleanup, and gimple_wce_set_cleanup().

Referenced by gimple_build_wce(), gimple_copy(), and gimple_wce_set_cleanup().

◆ gimple_wce_set_cleanup_eh_only()

void gimple_wce_set_cleanup_eh_only ( gimple * gs,
bool eh_only_p )
inline
Set the CLEANUP_EH_ONLY flag for a WCE tuple.   

References GIMPLE_CHECK, gimple_wce_set_cleanup_eh_only(), and gimple::subcode.

Referenced by gimple_push_cleanup(), and gimple_wce_set_cleanup_eh_only().

◆ gss_for_code()

enum gimple_statement_structure_enum gss_for_code ( enum gimple_code code)
inline
Return the GSS code used by a GIMPLE code.   

References gcc_gimple_checking_assert, gss_for_code(), and gss_for_code_.

Referenced by gimple_size(), gimple_statement_structure(), and gss_for_code().

◆ inc_gimple_stmt_max_uid()

unsigned int inc_gimple_stmt_max_uid ( struct function * fn)
inline

◆ infer_nonnull_range()

bool infer_nonnull_range ( gimple * stmt,
tree op )
extern
Return true if OP can be inferred to be non-NULL after STMT executes,
either by using a pointer dereference or attributes.   

References infer_nonnull_range(), infer_nonnull_range_by_attribute(), and infer_nonnull_range_by_dereference().

Referenced by gimple_build_debug_inline_entry(), and infer_nonnull_range().

◆ infer_nonnull_range_by_attribute()

bool infer_nonnull_range_by_attribute ( gimple * stmt,
tree op,
tree * op2,
tree * op3 )
extern
Return true if OP can be inferred to be a non-NULL after STMT
executes by using attributes.  If OP2 and OP3 are non-NULL and
nonnull_if_nonzero is the only attribute implying OP being non-NULL
and the corresponding argument(s) aren't non-zero INTEGER_CST, set *OP2
and *OP3 to the corresponding arguments and return true (in that case
returning true doesn't mean OP can be unconditionally inferred to be
non-NULL, but conditionally).   

References current_function_decl, dyn_cast(), gimple_call_arg(), gimple_call_fntype(), gimple_call_internal_p(), gimple_call_num_args(), gimple_return_retval(), i, infer_nonnull_range_by_attribute(), integer_nonzerop(), integer_zerop(), INTEGRAL_TYPE_P, is_gimple_call(), lookup_attribute(), NULL_TREE, operand_equal_p(), POINTER_TYPE_P, TREE_CHAIN, tree_expr_nonzero_p(), TREE_INT_CST_LOW, TREE_TYPE, TREE_VALUE, and TYPE_ATTRIBUTES.

Referenced by gimple_build_debug_inline_entry(), gimple_call_nonnull_arg(), infer_nonnull_range(), infer_nonnull_range_by_attribute(), instrument_nonnull_arg(), instrument_nonnull_return(), stmt_uses_0_or_null_in_undefined_way(), and stmt_uses_name_in_undefined_way().

◆ infer_nonnull_range_by_dereference()

bool infer_nonnull_range_by_dereference ( gimple * stmt,
tree op )
extern

◆ is_gimple_assign()

bool is_gimple_assign ( const gimple * gs)
inline
Return true if GS is a GIMPLE_ASSIGN.   

References is_gimple_assign().

Referenced by adjust_imagpart_expr(), strlen_pass::adjust_last_stmt(), adjust_realpart_expr(), aff_combination_expand(), all_uses_feed_or_dominated_by_stmt(), analyze_agg_content_value(), analyze_and_compute_bitop_with_inv_effect(), analyze_function_body(), and_var_with_comparison(), and_var_with_comparison_1(), ao_ref_init_from_ptr_and_range(), arith_overflow_check_p(), avoid_deep_ter_for_debug(), find_candidates_dom_walker::before_dom_children(), branch_fixup(), break_up_subtract_bb(), build_bitint_stmt_ssa_conflicts(), build_ssa_conflict_graph(), can_combine_bbs_with_short_circuit(), can_propagate_from(), ccmp_candidate_p(), ccmp_tree_comparison_p(), check_all_va_list_escapes(), strlen_pass::check_and_optimize_stmt(), check_defs(), check_for_plus_in_loops(), check_scan_store(), compatible_complex_nodes_p(), compute_invariantness(), constant_byte_string(), constant_pointer_difference(), convert_mult_to_fma(), convert_mult_to_fma_1(), convert_plusminus_to_widen(), convert_to_divmod(), decompose_param_expr(), defcodefor_name(), edge_info::derive_equivalences(), do_warn_nonnull_compare(), dse_classify_store(), dse_optimize_redundant_stores(), dse_optimize_stmt(), eliminate_dom_walker::eliminate_cleanup(), eliminate_redundant_comparison(), eliminate_redundant_computations(), eliminate_dom_walker::eliminate_stmt(), emit_cmp_and_jump_insns(), empty_bb_or_one_feeding_into_p(), execute_cse_reciprocals_1(), execute_early_expand_coro_ifns(), crc_optimization::exists_shift_for_opp_xor_shift(), expand_call_inline(), expand_call_stmt(), expand_case(), expand_complex_move(), expand_complex_operations_1(), expand_debug_expr(), expand_expr_real_1(), expand_expr_real_2(), expand_gimple_basic_block(), expand_mul_overflow(), expand_omp_atomic_cas(), expand_omp_atomic_fetch_op(), expand_vec_cond_mask_optab_fn(), expr_coherent_p(), expr_expected_value_1(), extract_mem_content(), final_range_test_p(), find_equal_ptrs(), find_foldable_builtin_expect(), find_func_aliases(), find_interesting_uses_op(), find_interesting_uses_stmt(), pcom_worker::find_looparound_phi(), find_replaceable_in_bb(), crc_optimization::find_shift_after_xor(), find_tail_calls(), fold_stmt_1(), fold_strstr_to_strncmp(), scev_dfs::follow_ssa_edge_expr(), forward_propagate_addr_expr(), gather_mem_refs_stmt(), get_attr_nonstring_decl(), get_bit_field_ref_def(), get_compare_parts(), get_computation_aff_1(), get_def_for_expr(), get_def_for_expr_class(), get_default_value(), get_known_nonzero_bits(), get_min_precision(), get_name_for_bit_test(), get_nonzero_bits(), get_prop_source_stmt(), get_range_pos_neg(), get_rank(), get_reassociation_width(), access_ref::get_ref(), get_single_immediate_use(), get_stridx(), get_unary_op(), get_val_for(), gimple_assign_cast_p(), gimple_assign_rhs_could_trap_p(), gimple_assign_single_p(), gimple_assign_unary_nop_p(), gimple_divmod_fixed_value(), gimple_has_lhs(), gimple_lower_bitint(), gimple_mod_pow2(), gimple_mod_subtract(), gimple_needing_rewrite_undefined(), gimple_regimplify_operands(), strlen_pass::handle_builtin_memcpy(), handle_ssa_name(), strlen_pass::handle_store(), ifcvt_can_predicate(), infer_loop_bounds_from_array(), infer_loop_bounds_from_pointer_arith(), access_ref::inform_access(), init_range_entry(), input_gimple_stmt(), insert_backedge_copies(), insert_debug_temp_for_var_def(), insert_predicates_for_cond(), insert_stmt_before_use(), insert_trap(), instrument_gimple(), instrument_object_size(), interpret_rhs_expr(), ipa_analyze_indirect_call_uses(), ipa_compute_jump_functions_for_edge(), is_addr_local(), is_cond_scalar_reduction(), is_division_by(), is_divmod_with_given_divisor(), is_gimple_assign(), is_gimple_logical_p(), is_reassociable_op(), is_self_write(), is_strlen_related_p(), is_widening_mult_rhs_p(), legal_cast_p(), long_mul_check_low_plus_defer(), long_mul_high_half_uses(), long_mul_is_lshift_def(), long_mul_linearize_chain(), long_mul_op_fits_p(), long_mul_split_operand(), crc_optimization::loop_may_calculate_crc(), lower_long_mul_high_chain(), lower_vec_perm(), ipa_param_body_adjustments::mark_dead_statements(), match_arith_overflow(), match_long_mul(), match_long_mul_phi(), match_simplify_replacement(), match_uaddc_usubc(), may_propagate_copy_into_stmt(), maybe_diag_stxncpy_trunc(), maybe_duplicate_comparison(), maybe_optimize_arith_overflow(), maybe_optimize_mod_cmp(), maybe_optimize_range_tests(), maybe_set_nonzero_bits(), maybe_set_strlen_range(), maybe_trim_partially_dead_store(), maybe_warn_operand(), strlen_pass::maybe_warn_overflow(), movement_possibility_1(), name_for_ref(), narrow_long_mul_operands(), negate_value(), no_side_effect_bb(), noncall_stmt_may_be_vtbl_ptr_store(), number_of_iterations_cltz(), number_of_iterations_cltz_complement(), number_of_iterations_popcount(), omp_sese_find_par(), omp_sese_split_blocks(), operand_equal_for_value_replacement(), sm_set_flag_if_changed::operator()(), optimize_aggr_zeroprop_1(), optimize_bitfield_assignment_op(), optimize_pow_to_exp(), optimize_range_tests_var_bound(), dom_opt_dom_walker::optimize_stmt(), optimize_successive_divisions_p(), optimize_va_list_gpr_fpr_size(), optimize_vector_constructor(), optimize_vector_load(), or_var_with_comparison(), or_var_with_comparison_1(), output_gimple_stmt(), overflow_comparison_p_1(), parloops_is_simple_reduction(), parloops_valid_reduction_input_p(), parse_predicate(), phiopt_early_allow(), phiprop_insert_phi(), predicate_rhs_code(), predicate_statements(), ipa_param_body_adjustments::prepare_debug_expressions(), propagate_bias_p(), propagate_tree_value_into_stmt(), propagate_with_phi(), purge_all_uses(), rank_ops_for_fma(), reassociate_bb(), recognize_bits_test(), recognize_single_bit_test(), record_equivalences_from_stmt(), ref_maybe_used_by_stmt_p(), remap_gimple_stmt(), remove_name_from_operation(), remove_prop_source_from_use(), remove_visited_stmt_chain(), reorder_operands(), replace_ref_with(), replace_stmt_with_simplification(), repropagate_negates(), rewrite_use_nonlinear_expr(), rhs_is_fed_for_value_replacement(), same_bool_comparison_p(), same_succ_hash(), scan_operand_equal_p(), should_break_up_subtract(), simplify_using_ranges::simplify(), avail_exprs_stack::simplify_binary_operation(), simplify_builtin_call(), simplify_using_ranges::simplify_casted_compare(), simplify_conversion_using_ranges(), simplify_permutation(), sink_common_stores_to_bb(), skip_a_safe_conversion_op(), spaceship_replacement(), 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_may_be_vtbl_ptr_store(), strip_conversion(), dom_opt_dom_walker::test_for_singularity(), thread_private_new_memory(), try_special_add_to_ops(), try_transform_to_exit_first_loop_alt(), uaddc_is_cplxpart(), uaddc_ne0(), unadjusted_ptr_and_unit_offset(), undistribute_bitref_for_vector(), undistribute_ops_list(), unexpandable_long_mul_p(), uses_consumed_by_stmt(), va_list_counter_bump(), value_replacement(), valueized_wider_op(), var_is_used_for_virtual_call_p(), vect_analyze_slp_reduc_chain(), vect_build_slp_tree_2(), vect_check_gather_scatter(), vect_compute_single_scalar_iteration_cost(), vect_find_stmt_data_reference(), vect_finish_stmt_generation(), vect_get_operand_map(), vect_is_nonlinear_iv_evolution(), vect_is_simple_reduction(), vect_match_expression_p(), vect_recog_bitfield_ref_pattern(), vect_recog_bool_pattern(), vect_recog_divmod_pattern(), vect_recog_mask_conversion_pattern(), vect_recog_mod_var_pattern(), vect_recog_mult_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_simd_lane_linear(), vect_slp_check_for_roots(), vect_slp_linearize_chain(), vect_transform_slp_perm_load_1(), vect_widened_op_tree(), vector_element(), vectorizable_conversion(), copy_prop::visit_stmt(), vn_reference_lookup_3(), vn_reference_maybe_forwprop_address(), vuse_semi_invariant_p(), walk_stmt_load_store_addr_ops(), warn_uninit(), zero_one_minusone(), and zero_one_operation().

◆ is_gimple_call()

bool is_gimple_call ( const gimple * gs)
inline
Return true if GS is a GIMPLE_CALL.   

References is_gimple_call().

Referenced by _loop_vec_info::_loop_vec_info(), adjust_imagpart_expr(), adjust_pointer_diff_expr(), adjust_simduid_builtins(), alloc_object_size(), analyze_function_body(), arith_overflow_arg_kind(), bb_no_side_effects_p(), nontrapping_dom_walker::before_dom_children(), substitute_and_fold_dom_walker::before_dom_children(), branch_prob(), build_and_add_sum(), build_bitint_stmt_ssa_conflicts(), call_object_size(), cgraph_update_edges_for_call_stmt_node(), strlen_pass::check_and_optimize_stmt(), check_defs(), array_bounds_checker::check_mem_ref(), check_omp_nesting_restrictions(), check_stmt_for_type_change(), cleanup_call_ctrl_altering_flag(), cleanup_control_flow_bb(), compatible_complex_nodes_p(), compute_avail(), cond_removal_in_builtin_zero_pattern(), convert_mult_to_fma_1(), copy_edges_for_bb(), symbol_table::create_edge(), determine_unlikely_bbs(), dse_optimize_redundant_stores(), dse_optimize_stmt(), edge_before_returns_twice_call(), eliminate_dom_walker::eliminate_cleanup(), eliminate_redundant_computations(), eliminate_dom_walker::eliminate_stmt(), eliminate_tail_call(), eliminate_unnecessary_stmts(), emit_cmp_and_jump_insns(), empty_bb_or_one_feeding_into_p(), same_succ::equal(), estimate_bb_frequencies(), evaluate_stmt(), execute_early_expand_coro_ifns(), execute_fixup_cfg(), execute_oacc_device_lower(), execute_omp_device_lower(), execute_omp_oacc_neuter_broadcast(), expand_call_inline(), expand_complex_move(), expr_expected_value_1(), find_func_aliases(), find_replaceable_in_bb(), find_tail_calls(), fold_marked_statements(), gather_memory_references(), gen_shrink_wrap_conditions(), get_default_value(), get_string_length(), gimple_alloca_call_p(), gimple_block_ends_with_call_p(), gimple_call_alloc_size(), gimple_call_builtin_p(), gimple_call_builtin_p(), gimple_call_builtin_p(), gimple_call_internal_p(), gimple_can_duplicate_bb_p(), gimple_expand_calls_inline(), gimple_has_side_effects(), gimple_lower_bitint(), gimple_maybe_alloca_call_p(), gimple_regimplify_operands(), gimplify_and_update_call_from_tree(), gsi_replace_with_seq_vops(), gsi_safe_insert_before(), gsi_safe_insert_seq_before(), strlen_pass::handle_assign(), strlen_pass::handle_builtin_memset(), handle_ssa_name(), strlen_pass::handle_store(), hardcfr_scan_block(), has_stmt_been_instrumented_p(), if_convertible_simdclone_stmt_p(), imm_dom_path_with_freeing_call(), infer_loop_bounds_from_array(), infer_nonnull_range_by_attribute(), access_ref::inform_access(), initialize_ao_ref_for_dse(), input_function(), instrument_expr(), instrument_gimple(), ipa_analyze_controlled_uses(), ipa_analyze_stmt_uses(), ipa_tm_decrement_clone_counts(), ipa_tm_diagnose_transaction(), ipa_tm_scan_calls_block(), ipa_tm_transform_calls_1(), is_gimple_call(), is_strlen_related_p(), likely_value(), loop_body_includes_call(), make_blocks_1(), make_edges(), ipa_param_body_adjustments::mark_dead_statements(), match_uaddc_usubc(), may_propagate_copy(), may_propagate_copy_into_stmt(), maybe_invalidate(), maybe_warn_operand(), strlen_pass::maybe_warn_overflow(), merge_stmts_p(), move_block_to_fn(), movement_possibility_1(), note_simd_array_uses(), oacc_loop_discover_walk(), optimize_agr_copyprop(), optimize_omp_library_calls(), optimize_stack_restore(), dom_opt_dom_walker::optimize_stmt(), optimize_va_list_gpr_fpr_size(), output_gimple_stmt(), parloops_valid_reduction_input_p(), predicate_statements(), predict_loops(), propagate_necessity(), propagate_op_to_single_use(), propagate_tree_value_into_stmt(), jump_threader::record_temporary_equivalences_from_stmts_at_dest(), redirect_all_calls(), ref_maybe_used_by_stmt_p(), same_handler_p(), same_succ_hash(), sanopt_optimize_walker(), scan_omp_1_stmt(), simplify_using_ranges::simplify(), simplify_builtin_memcpy_memset(), pcom_worker::split_data_refs_to_components(), stack_protect_return_slot_p(), vect_optimize_slp_pass::start_choosing_layouts(), statement_sink_location(), stmt_can_make_abnormal_goto(), stmt_can_terminate_bb_p(), stmt_cost(), stmt_is_power_of_op(), stmt_kills_ref_p(), stmt_local_def(), stmt_may_be_vtbl_ptr_store(), stmt_may_clobber_ref_p_1(), strip_predict_hints(), surely_varying_stmt_p(), thread_private_new_memory(), transform_statements(), tree_bb_level_predictions(), tree_estimate_probability_bb(), tree_optimize_tail_calls_1(), try_special_add_to_ops(), unlikely_executed_stmt_p(), update_call_edge_frequencies(), update_gimple_call(), var_is_used_for_virtual_call_p(), vect_analyze_slp(), vect_build_slp_tree_2(), vect_compute_single_scalar_iteration_cost(), vect_find_stmt_data_reference(), vect_finish_stmt_generation(), vect_get_datarefs_in_loop(), vect_get_vector_types_for_stmt(), vect_is_simple_reduction(), vect_recog_ctz_ffs_pattern(), vect_recog_mask_conversion_pattern(), vect_recog_popcount_clz_ctz_ffs_pattern(), vect_recog_pow_pattern(), vect_widened_op_tree(), vectorizable_conversion(), verify_bb_vtables(), cgraph_node::verify_node(), vn_reference_lookup_3(), and warn_dealloc_offset().

◆ is_gimple_debug()

bool is_gimple_debug ( const gimple * gs)
inline
Return true if GS is a GIMPLE_DEBUG statement.   

References is_gimple_debug().

Referenced by _bb_vec_info::_bb_vec_info(), _loop_vec_info::_loop_vec_info(), back_threader_profitability::account_bb(), add_scope_conflicts_1(), operands_scanner::add_virtual_operand(), adjust_debug_stmts_now(), all_immediate_uses_same_place(), all_uses_feed_or_dominated_by_stmt(), loop_cand::analyze_iloop_reduction_var(), loop_cand::analyze_oloop_reduction_var(), asan_expand_poison_ifn(), assign_discriminators_to_bb(), bb_no_side_effects_p(), check_array_bounds_dom_walker::before_dom_children(), substitute_and_fold_dom_walker::before_dom_children(), build_ssa_conflict_graph(), loop_cand::can_interchange_p(), check_all_va_list_escapes(), check_loop_closed_ssa_def(), check_reduction_path(), check_retval_uses(), check_scan_store(), check_stmt(), cleanup_empty_eh(), clear_unused_block_pointer(), clobber_only_eh_bb_p(), collect_fallthrough_labels(), compute_added_num_insns(), compute_avail(), compute_live_vars_1(), cond_only_block_p(), convert_mult_to_fma(), convert_mult_to_fma_1(), copy_edges_for_bb(), count_stmts_and_phis_in_block(), create_coalesce_list_for_region(), debug_seed_ranger(), decide_copy_try_finally(), discover_nonconstant_array_refs(), dse_optimize_call(), dump_enumerated_decls(), dump_gimple_bb_header(), eliminate_local_variables(), eliminate_dom_walker::eliminate_stmt(), eliminate_unnecessary_stmts(), empty_bb_without_guard_p(), empty_body_p(), empty_eh_cleanup(), execute_update_addresses_taken(), expand_FALLTHROUGH_r(), expand_gimple_basic_block(), expand_omp_atomic_fetch_op(), find_givs_in_bb(), find_interesting_uses(), find_replaceable_in_bb(), find_return_bb(), crc_optimization::find_shift_after_xor(), find_tail_calls(), find_uninit_use(), find_uses_to_rename_stmt(), first_stmt(), forward_propagate_addr_expr(), remove_unreachable::fully_replaceable(), generate_loops_for_partition(), operands_scanner::get_expr_operands(), gimple_can_merge_blocks_p(), gimple_debug_begin_stmt_p(), gimple_debug_bind_p(), gimple_debug_inline_entry_p(), gimple_debug_nonbind_marker_p(), gimple_debug_source_bind_p(), gimple_empty_block_p(), gimple_find_edge_insert_loc(), gimple_has_side_effects(), gimple_lower_bitint(), gimple_seq_first_nondebug_stmt(), gimple_seq_last_nondebug_stmt(), gimple_seq_unreachable_p(), gimple_verify_flow_info(), gsi_last_nondebug_bb(), gsi_next_nondebug(), gsi_prev_nondebug(), gsi_start_nondebug(), gsi_start_nondebug_after_labels_bb(), gsi_start_nondebug_bb(), hardcfr_scan_block(), has_single_use(), has_zero_uses(), ifcvt_local_dce(), infinite_empty_loop_p(), input_function(), insert_backedge_copies(), insert_init_stmt(), insert_iv_increment(), ipa_analyze_controlled_uses(), ipa_analyze_params_uses_in_bb(), ipa_simd_modify_stmt_ops(), is_cond_scalar_reduction(), is_factor_profitable(), is_gimple_debug(), last_nondebug_stmt(), last_stmt_in_scope(), long_mul_high_half_uses(), lower_emutls_1(), lower_omp_ordered_clauses(), make_blocks(), make_blocks_1(), make_edges(), make_new_ssa_for_def(), ipa_param_body_adjustments::mark_dead_statements(), mark_def_sites(), mark_stmt_necessary(), mark_use_interesting(), match_arith_overflow(), match_uaddc_usubc(), maybe_dead_abnormal_edge_p(), maybe_diag_stxncpy_trunc(), maybe_duplicate_comparison(), maybe_move_debug_stmts_to_successors(), maybe_optimize_arith_overflow(), maybe_optimize_guarding_check(), maybe_optimize_range_tests(), maybe_remove_forwarder_block(), move_debug_stmts_from_forwarder(), nearest_common_dominator_of_uses(), no_side_effect_bb(), note_simd_array_uses(), num_imm_uses(), oacc_entry_exit_ok_1(), optimize_clobbers(), optimize_mask_stores(), optimize_recip_sqrt(), optimize_va_list_gpr_fpr_size(), optimize_vector_load(), output_gimple_stmt(), parloops_is_simple_reduction(), propagate_threaded_block_debug_into(), gimple_ranger::range_of_expr(), reassoc_remove_stmt(), jump_threader::record_temporary_equivalences_from_stmts_at_dest(), redirection_block_p(), release_defs_bitset(), remap_gimple_stmt(), remove_unreachable::remove_and_update_globals(), remove_unused_locals(), reorder_operands(), ipa_param_body_adjustments::reset_debug_stmts(), rewrite_stmt(), rewrite_update_stmt(), same_succ_hash(), separate_decls_in_region(), sese_build_liveouts_bb(), sese_reset_debug_liveouts(), sese_trivially_empty_bb_p(), set_location_for_edge(), set_var_live_on_entry(), should_duplicate_loop_header_p(), simd_clone_adjust(), simple_dce_from_worklist(), simplify_builtin_call(), single_imm_use(), single_imm_use_1(), pcom_worker::single_nonlooparound_use(), single_use(), single_use_in_loop(), sink_clobbers(), spaceship_replacement(), split_function(), ssa_create_duplicates(), ssa_name_any_use_dominates_bb_p(), ssa_name_has_uses_outside_loop_p(), statement_sink_location(), stmt_loc_used_by_debug_info(), stmt_local_def(), stmt_starts_bb_p(), loop_distribution::stmts_from_loop(), trivially_conflicts_p(), unroll_jam_possible_p(), unsplit_eh(), update_debug_stmts(), update_epilogue_loop_vinfo(), use_in_zero_equality(), used_outside_loop_p(), uses_consumed_by_stmt(), uses_in_bb(), value_replacement(), vect_analyze_early_break_dependences(), vect_analyze_slp_reduc_chain(), vect_bb_slp_mark_live_stmts(), vect_bb_slp_scalar_cost(), vect_create_epilog_for_reduction(), vect_determine_min_output_precision_1(), vect_get_datarefs_in_loop(), vect_is_simple_reduction(), vect_mark_stmts_to_be_vectorized(), vect_phi_first_order_recurrence_p(), vect_slp_bbs(), vect_stmt_relevant_p(), vectorizable_induction(), vectorizable_live_operation(), vectorizable_scan_store(), verify_non_ssa_vars(), visit_bb(), and warn_uninitialized_vars().

◆ is_gimple_omp()

◆ is_gimple_omp_oacc()

◆ is_gimple_omp_offloaded()

◆ is_gimple_resx()

bool is_gimple_resx ( const gimple * gs)
inline
Return true if GS is a GIMPLE_RESX.   

References is_gimple_resx().

Referenced by cleanup_empty_eh(), empty_eh_cleanup(), and is_gimple_resx().

◆ maybe_remove_unused_call_args()

void maybe_remove_unused_call_args ( struct function * fn,
gimple * stmt )
extern
See if STMT now calls function that takes no parameters and if so, drop
call arguments.  This is used when devirtualization machinery redirects
to __builtin_unreachable or __cxa_pure_virtual.   

References gimple_call_fndecl(), gimple_call_num_args(), gimple_set_num_ops(), maybe_remove_unused_call_args(), TREE_TYPE, TREE_VALUE, TYPE_ARG_TYPES, update_stmt_fn(), and void_type_node.

Referenced by eliminate_dom_walker::eliminate_stmt(), expand_call_inline(), gimple_build_debug_inline_entry(), gimple_fold_call(), maybe_remove_unused_call_args(), and cgraph_edge::redirect_call_stmt_to_callee().

◆ nonbarrier_call_p()

bool nonbarrier_call_p ( gimple * call)
extern
Return true when CALL is a call stmt that definitely need not
be considered to be a memory barrier.   

References ECF_CONST, ECF_PURE, gimple_call_flags(), and nonbarrier_call_p().

Referenced by nontrapping_dom_walker::before_dom_children(), gimple_build_debug_inline_entry(), and nonbarrier_call_p().

◆ nonfreeing_call_p()

◆ phi_nodes()

◆ phi_nodes_ptr()

gimple_seq * phi_nodes_ptr ( basic_block bb)
inline

◆ preprocess_case_label_vec_for_gimple()

void preprocess_case_label_vec_for_gimple ( vec< tree > & labels,
tree index_type,
tree * default_casep )
extern
Prepare a vector of case labels to be used in a GIMPLE_SWITCH statement.

LABELS is a vector that contains all case labels to look at.

INDEX_TYPE is the type of the switch index expression.  Case labels
in LABELS are discarded if their values are not in the value range
covered by INDEX_TYPE.  The remaining case label values are folded
to INDEX_TYPE.

If a default case exists in LABELS, it is removed from LABELS and
returned in DEFAULT_CASEP.  If no default case exists, but the
case labels already cover the whole range of INDEX_TYPE, a default
case is returned pointing to one of the existing case labels.
Otherwise DEFAULT_CASEP is set to NULL_TREE.

DEFAULT_CASEP may be NULL, in which case the above comment doesn't
apply and no action is taken regardless of whether a default case is
found or not.   

References build_case_label(), CASE_HIGH, CASE_LABEL, CASE_LOW, fold_convert, gcc_assert, gcc_checking_assert, wi::gtu_p(), i, NULL_TREE, preprocess_case_label_vec_for_gimple(), sort_case_labels(), wi::to_wide(), TREE_CODE, tree_int_cst_compare(), tree_int_cst_equal(), TYPE_MAX_VALUE, and TYPE_MIN_VALUE.

Referenced by gimple_build_debug_inline_entry(), gimplify_switch_expr(), preprocess_case_label_vec_for_gimple(), and simplify_gimple_switch_label_vec().

◆ set_bb_seq()

◆ set_gimple_stmt_max_uid()

void set_gimple_stmt_max_uid ( struct function * fn,
unsigned int maxid )
inline

◆ sort_case_labels()

void sort_case_labels ( vec< tree > & label_vec)
extern

◆ stmt_can_terminate_bb_p()

◆ suppress_warning()

void suppress_warning ( gimple * stmt,
opt_code opt,
bool supp )
extern
Set the disposition for a warning (or all warnings by default)
at a location to enabled by default.   
Enable, or by default disable, a warning for the statement STMT.
The wildcard OPT of -1 controls all warnings.   

References get_location(), no_warning, RESERVED_LOCATION_P, set_no_warning_bit(), suppress_warning(), and suppress_warning_at().

Referenced by c_strlen(), check_access(), array_bounds_checker::check_addr_expr(), array_bounds_checker::check_array_bounds(), array_bounds_checker::check_array_ref(), check_bounds_or_overlap(), check_global_declaration(), array_bounds_checker::check_mem_ref(), clear_padding_flush(), cond_store_replacement(), cond_store_replacement_limited(), create_access_replacement(), create_one_component_var(), declare_return_variable(), do_mpfr_remquo(), execute_sm(), execute_update_addresses_taken(), expand_call_inline(), expand_omp_for_generic(), expand_omp_taskloop_for_outer(), find_tail_calls(), fold_builtin_frexp(), fold_builtin_modf(), fold_builtin_varargs(), fold_unary_loc(), generate_subtree_copies(), gimple_build_debug_inline_entry(), gimple_fold_builtin_stpcpy(), gimple_fold_builtin_strcpy(), gimple_fold_builtin_strncat(), gimple_lower_bitint(), gimple_push_cleanup(), gimplify_modify_expr(), gimplify_modify_expr_complex_part(), gimplify_return_expr(), strlen_pass::handle_builtin_strcat(), strlen_pass::handle_builtin_strcpy(), strlen_pass::handle_builtin_stxncpy_strncat(), handle_printf_call(), lower_lastprivate_clauses(), lower_omp_target(), lower_rec_input_clauses(), lower_send_clauses(), maybe_warn_for_bound(), maybe_warn_nonstring_arg(), strlen_pass::maybe_warn_overflow(), maybe_warn_read_write_only(), set_no_uninit_warning(), suitable_for_tail_call_opt_p(), suppress_warning(), suppress_warning(), vectorizable_operation(), warn_for_access(), warn_string_no_nul(), and warn_uninit().

◆ warning_suppressed_p()

Variable Documentation

◆ currently_expanding_gimple_stmt

gimple* currently_expanding_gimple_stmt
extern

◆ gimple_alloc_counts

uint64_t gimple_alloc_counts[]
extern
Gimple stats.   

Referenced by allocate_phi_node(), dump_gimple_statistics(), and gimple_alloc().

◆ gimple_alloc_sizes

uint64_t gimple_alloc_sizes[]
extern

◆ gimple_code_name

const char* const gimple_code_name[]
extern

◆ gimple_ops_offset_

size_t const gimple_ops_offset_[]
extern
Offset in bytes to the location of the operand vector.
Zero if there is no operand vector for this tuple structure.   

Referenced by gimple_ops().

◆ gimple_rhs_class_table

const unsigned char gimple_rhs_class_table[]
extern

Referenced by get_gimple_rhs_class().

◆ gss_for_code_

enum gimple_statement_structure_enum const gss_for_code_[]
extern
Map GIMPLE codes to GSS codes.   

Referenced by gss_for_code().