#include "tree-ssa-alias.h"
#include "gimple-expr.h"
#include "gimple.def"
#include "gsstruct.def"

Include dependency graph for gimple.h:

Data Structures
struct	remove_pointer< T >

struct	remove_pointer< T * >

struct	gimple

struct	gimple_statement_with_ops_base

struct	gimple_statement_with_ops

struct	gimple_statement_with_memory_ops_base

struct	gimple_statement_with_memory_ops

struct	gcall

struct	gimple_statement_omp

struct	gbind

struct	gcatch

struct	geh_filter

struct	geh_else

struct	geh_mnt

struct	gphi

struct	gimple_statement_eh_ctrl

struct	gresx

struct	geh_dispatch

struct	gtry

struct	gimple_statement_wce

struct	gasm

struct	gomp_critical

struct	gimple_omp_for_iter

struct	gomp_for

struct	gimple_statement_omp_parallel_layout

struct	gimple_statement_omp_taskreg

struct	gomp_parallel

struct	gomp_target

struct	gomp_task

struct	gomp_sections

struct	gomp_continue

struct	gimple_statement_omp_single_layout

struct	gomp_single

struct	gomp_teams

struct	gomp_ordered

struct	gomp_scan

struct	gomp_atomic_load

struct	gimple_statement_omp_atomic_store_layout

struct	gomp_atomic_store

struct	gimple_statement_omp_return

struct	gimple_statement_assume

struct	gtransaction

struct	gcond

struct	gdebug

struct	ggoto

struct	glabel

struct	gswitch

struct	gassign

struct	greturn

struct	gimple_temp_hash_elt

Macros
#define	DEFGSCODE(SYM, STRING, STRUCT)

#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 /* error_mark_node @endverbatim */

#define	CASE_GIMPLE_OMP

Typedefs
typedef gimple *	gimple_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 >
T	GIMPLE_CHECK2 (gimple *gs)

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

size_t	gimple_size (enum gimple_code code, unsigned num_ops=0)

void	gimple_init (gimple *g, enum gimple_code code, unsigned num_ops)

gimple *	gimple_alloc (enum gimple_code, unsigned CXX_MEM_STAT_INFO)

greturn *	gimple_build_return (tree)

void	gimple_call_reset_alias_info (gcall *)

gcall *	gimple_build_call_vec (tree, const vec< tree > &)

gcall *	gimple_build_call (tree, unsigned,...)

gcall *	gimple_build_call_valist (tree, unsigned, va_list)

gcall *	gimple_build_call_internal (enum internal_fn, unsigned,...)

gcall *	gimple_build_call_internal_vec (enum internal_fn, const vec< tree > &)

gcall *	gimple_build_call_from_tree (tree, tree)

gassign *	gimple_build_assign (tree, tree CXX_MEM_STAT_INFO)

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

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

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

gcond *	gimple_build_cond (enum tree_code, tree, tree, tree, tree)

gcond *	gimple_build_cond_from_tree (tree, tree, tree)

void	gimple_cond_set_condition_from_tree (gcond *, tree)

glabel *	gimple_build_label (tree label)

ggoto *	gimple_build_goto (tree dest)

gimple *	gimple_build_nop (void)

gbind *	gimple_build_bind (tree, gimple_seq, tree)

gasm *	gimple_build_asm_vec (const char , vec< tree, va_gc > , vec< tree, va_gc > , vec< tree, va_gc > , vec< tree, va_gc > *)

gcatch *	gimple_build_catch (tree, gimple_seq)

geh_filter *	gimple_build_eh_filter (tree, gimple_seq)

geh_mnt *	gimple_build_eh_must_not_throw (tree)

geh_else *	gimple_build_eh_else (gimple_seq, gimple_seq)

gtry *	gimple_build_try (gimple_seq, gimple_seq, enum gimple_try_flags)

gimple *	gimple_build_wce (gimple_seq)

gresx *	gimple_build_resx (int)

gswitch *	gimple_build_switch_nlabels (unsigned, tree, tree)

gswitch *	gimple_build_switch (tree, tree, const vec< tree > &)

geh_dispatch *	gimple_build_eh_dispatch (int)

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

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

gdebug *	gimple_build_debug_begin_stmt (tree, location_t CXX_MEM_STAT_INFO)

gdebug *	gimple_build_debug_inline_entry (tree, location_t CXX_MEM_STAT_INFO)

gomp_critical *	gimple_build_omp_critical (gimple_seq, tree, tree)

gomp_for *	gimple_build_omp_for (gimple_seq, int, tree, size_t, gimple_seq)

gomp_parallel *	gimple_build_omp_parallel (gimple_seq, tree, tree, tree)

gomp_task *	gimple_build_omp_task (gimple_seq, tree, tree, tree, tree, tree, tree)

gimple *	gimple_build_omp_section (gimple_seq)

gimple *	gimple_build_omp_structured_block (gimple_seq)

gimple *	gimple_build_omp_scope (gimple_seq, tree)

gimple *	gimple_build_omp_master (gimple_seq)

gimple *	gimple_build_omp_masked (gimple_seq, tree)

gimple *	gimple_build_omp_taskgroup (gimple_seq, tree)

gomp_continue *	gimple_build_omp_continue (tree, tree)

gomp_ordered *	gimple_build_omp_ordered (gimple_seq, tree)

gimple *	gimple_build_omp_return (bool)

gomp_scan *	gimple_build_omp_scan (gimple_seq, tree)

gomp_sections *	gimple_build_omp_sections (gimple_seq, tree)

gimple *	gimple_build_omp_sections_switch (void)

gomp_single *	gimple_build_omp_single (gimple_seq, tree)

gomp_target *	gimple_build_omp_target (gimple_seq, int, tree)

gomp_teams *	gimple_build_omp_teams (gimple_seq, tree)

gomp_atomic_load *	gimple_build_omp_atomic_load (tree, tree, enum omp_memory_order)

gomp_atomic_store *	gimple_build_omp_atomic_store (tree, enum omp_memory_order)

gimple *	gimple_build_assume (tree, gimple_seq)

gtransaction *	gimple_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)

gimple *	gimple_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)

gcall *	gimple_call_copy_skip_args (gcall *, bitmap)

bool	gimple_compare_field_offset (tree, tree)

tree	gimple_unsigned_type (tree)

tree	gimple_signed_type (tree)

alias_set_type	gimple_get_alias_set (tree)

bool	gimple_ior_addresses_taken (bitmap, gimple *)

bool	gimple_builtin_call_types_compatible_p (const gimple *, tree)

combined_fn	gimple_call_combined_fn (const gimple *)

bool	gimple_call_operator_delete_p (const gcall *)

bool	gimple_call_builtin_p (const gimple *)

bool	gimple_call_builtin_p (const gimple *, enum built_in_class)

bool	gimple_call_builtin_p (const gimple *, enum built_in_function)

bool	gimple_asm_clobbers_memory_p (const gasm *)

void	dump_decl_set (FILE *, bitmap)

bool	nonfreeing_call_p (gimple *)

bool	nonbarrier_call_p (gimple *)

bool	infer_nonnull_range (gimple *, tree)

bool	infer_nonnull_range_by_dereference (gimple *, tree)

bool	infer_nonnull_range_by_attribute (gimple *, tree)

void	sort_case_labels (vec< tree > &)

void	preprocess_case_label_vec_for_gimple (vec< tree > &, tree, tree *)

void	gimple_seq_set_location (gimple_seq, location_t)

void	gimple_seq_discard (gimple_seq)

void	maybe_remove_unused_call_args (struct function , gimple )

bool	gimple_inexpensive_call_p (gcall *)

bool	stmt_can_terminate_bb_p (gimple *)

location_t	gimple_or_expr_nonartificial_location (gimple *, tree)

gcall *	gimple_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)

gimple *	gimple_seq_first_stmt (gimple_seq s)

gbind *	gimple_seq_first_stmt_as_a_bind (gimple_seq s)

gimple_seq_node	gimple_seq_last (gimple_seq s)

gimple *	gimple_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_seq *	bb_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_d *	gimple_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)

tree *	gimple_vuse_ptr (gimple *g)

tree *	gimple_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)

tree *	gimple_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)

tree *	gimple_ops (gimple *gs)

tree	gimple_op (const gimple *gs, unsigned i)

tree *	gimple_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)

tree *	gimple_assign_lhs_ptr (gassign *gs)

tree *	gimple_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)

tree *	gimple_assign_rhs1_ptr (gassign *gs)

tree *	gimple_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)

tree *	gimple_assign_rhs2_ptr (gassign *gs)

tree *	gimple_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)

tree *	gimple_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)

tree *	gimple_call_lhs_ptr (gcall *gs)

tree *	gimple_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)

tree *	gimple_call_fn_ptr (gcall *gs)

tree *	gimple_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)

tree *	gimple_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)

tree *	gimple_call_arg_ptr (gcall *gs, unsigned index)

tree *	gimple_call_arg_ptr (gimple *gs, unsigned index)

void	gimple_call_set_arg (gcall *gs, unsigned index, tree arg)

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

void	gimple_call_set_tail (gcall *s, bool tail_p)

bool	gimple_call_tail_p (const gcall *s)

void	gimple_call_set_must_tail (gcall *s, bool must_tail_p)

bool	gimple_call_must_tail_p (const gcall *s)

void	gimple_call_set_return_slot_opt (gcall *s, bool return_slot_opt_p)

bool	gimple_call_return_slot_opt_p (const gcall *s)

void	gimple_call_set_from_thunk (gcall *s, bool from_thunk_p)

bool	gimple_call_from_thunk_p (gcall *s)

void	gimple_call_set_from_new_or_delete (gcall *s, bool from_new_or_delete_p)

bool	gimple_call_from_new_or_delete (const gcall *s)

void	gimple_call_set_va_arg_pack (gcall *s, bool pass_arg_pack_p)

bool	gimple_call_va_arg_pack_p (const gcall *s)

bool	gimple_call_noreturn_p (const gcall *s)

bool	gimple_call_noreturn_p (const gimple *s)

void	gimple_call_set_nothrow (gcall *s, bool nothrow_p)

bool	gimple_call_nothrow_p (gcall *s)

static void	gimple_call_set_expected_throw (gcall *s, bool expected_throw_p)

static bool	gimple_call_expected_throw_p (gcall *s)

void	gimple_call_set_alloca_for_var (gcall *s, bool for_var)

bool	gimple_call_alloca_for_var_p (gcall *s)

bool	gimple_call_alloca_for_var_p (gimple *s)

void	gimple_call_set_by_descriptor (gcall *s, bool by_descriptor_p)

bool	gimple_call_by_descriptor_p (gcall *s)

void	gimple_call_copy_flags (gcall dest_call, gcall orig_call)

struct pt_solution *	gimple_call_use_set (gcall *call_stmt)

const pt_solution *	gimple_call_use_set (const gcall *call_stmt)

struct pt_solution *	gimple_call_clobber_set (gcall *call_stmt)

const pt_solution *	gimple_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)

tree *	gimple_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)

tree *	gimple_cond_rhs_ptr (gcond *gs)

void	gimple_cond_set_rhs (gcond *gs, tree rhs)

tree	gimple_cond_true_label (const gcond *gs)

void	gimple_cond_set_true_label (gcond *gs, tree label)

void	gimple_cond_set_false_label (gcond *gs, tree label)

tree	gimple_cond_false_label (const gcond *gs)

void	gimple_cond_make_false (gcond *gs)

void	gimple_cond_make_true (gcond *gs)

bool	gimple_cond_true_p (const gcond *gs)

bool	gimple_cond_false_p (const gcond *gs)

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

enum tree_code	gimple_expr_code (const gimple *stmt)

tree	gimple_label_label (const glabel *gs)

void	gimple_label_set_label (glabel *gs, tree label)

tree	gimple_goto_dest (const gimple *gs)

void	gimple_goto_set_dest (ggoto *gs, tree dest)

tree	gimple_bind_vars (const gbind *bind_stmt)

void	gimple_bind_set_vars (gbind *bind_stmt, tree vars)

void	gimple_bind_append_vars (gbind *bind_stmt, tree vars)

gimple_seq *	gimple_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)

tree *	gimple_catch_types_ptr (gcatch *catch_stmt)

gimple_seq *	gimple_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)

tree *	gimple_eh_filter_types_ptr (gimple *gs)

gimple_seq *	gimple_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_seq *	gimple_eh_else_n_body_ptr (geh_else *eh_else_stmt)

gimple_seq	gimple_eh_else_n_body (const geh_else *eh_else_stmt)

gimple_seq *	gimple_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_seq *	gimple_try_eval_ptr (gimple *gs)

gimple_seq	gimple_try_eval (const gimple *gs)

gimple_seq *	gimple_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_seq *	gimple_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)

tree *	gimple_phi_result_ptr (gphi *gs)

tree *	gimple_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_seq *	phi_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)

tree *	gimple_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)

tree *	gimple_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)

tree *	gimple_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)

gimple *	gimple_seq_first_nondebug_stmt (gimple_seq s)

gimple *	gimple_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)

tree *	gimple_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)

tree *	gimple_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_seq *	gimple_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)

tree *	gimple_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)

tree *	gimple_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)

tree *	gimple_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)

tree *	gimple_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)

tree *	gimple_omp_taskgroup_clauses_ptr (gimple *gs)

void	gimple_omp_taskgroup_set_clauses (gimple *gs, tree clauses)

tree	gimple_omp_masked_clauses (const gimple *gs)

tree *	gimple_omp_masked_clauses_ptr (gimple *gs)

void	gimple_omp_masked_set_clauses (gimple *gs, tree clauses)

tree	gimple_omp_scope_clauses (const gimple *gs)

tree *	gimple_omp_scope_clauses_ptr (gimple *gs)

void	gimple_omp_scope_set_clauses (gimple *gs, tree clauses)

int	gimple_omp_for_kind (const gimple *g)

void	gimple_omp_for_set_kind (gomp_for *g, int kind)

bool	gimple_omp_for_combined_p (const gimple *g)

void	gimple_omp_for_set_combined_p (gomp_for *g, bool combined_p)

bool	gimple_omp_for_combined_into_p (const gimple *g)

void	gimple_omp_for_set_combined_into_p (gomp_for *g, bool combined_p)

tree	gimple_omp_for_clauses (const gimple *gs)

tree *	gimple_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)

tree *	gimple_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)

tree *	gimple_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)

tree *	gimple_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)

tree *	gimple_omp_for_incr_ptr (gimple *gs, size_t i)

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

gimple_seq *	gimple_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)

tree *	gimple_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)

tree *	gimple_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)

tree *	gimple_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)

tree *	gimple_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)

tree *	gimple_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)

tree *	gimple_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)

tree *	gimple_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)

tree *	gimple_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)

tree *	gimple_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)

tree *	gimple_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)

tree *	gimple_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)

tree *	gimple_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)

tree *	gimple_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)

tree *	gimple_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)

tree *	gimple_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)

tree *	gimple_omp_target_data_arg_ptr (gomp_target *omp_target_stmt)

void	gimple_omp_target_set_data_arg (gomp_target *omp_target_stmt, tree data_arg)

tree	gimple_omp_teams_clauses (const gimple *gs)

tree *	gimple_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)

tree *	gimple_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)

tree *	gimple_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)

tree *	gimple_omp_sections_clauses_ptr (gimple *gs)

void	gimple_omp_sections_set_clauses (gimple *gs, tree clauses)

tree	gimple_omp_sections_control (const gimple *gs)

tree *	gimple_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)

tree *	gimple_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)

tree *	gimple_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)

tree *	gimple_omp_atomic_load_rhs_ptr (gomp_atomic_load *load_stmt)

tree	gimple_omp_continue_control_def (const gomp_continue *cont_stmt)

tree *	gimple_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)

tree *	gimple_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)

tree *	gimple_assume_guard_ptr (gimple *gs)

gimple_seq *	gimple_assume_body_ptr (gimple *gs)

gimple_seq	gimple_assume_body (const gimple *gs)

gimple_seq *	gimple_transaction_body_ptr (gtransaction *transaction_stmt)

gimple_seq	gimple_transaction_body (const gtransaction *transaction_stmt)

tree	gimple_transaction_label_norm (const gtransaction *transaction_stmt)

tree *	gimple_transaction_label_norm_ptr (gtransaction *transaction_stmt)

tree	gimple_transaction_label_uninst (const gtransaction *transaction_stmt)

tree *	gimple_transaction_label_uninst_ptr (gtransaction *transaction_stmt)

tree	gimple_transaction_label_over (const gtransaction *transaction_stmt)

tree *	gimple_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)

tree *	gimple_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_ []

gimple *	currently_expanding_gimple_stmt

uint64_t	gimple_alloc_counts []

uint64_t	gimple_alloc_sizes []

Macro Definition Documentation

◆ CASE_GIMPLE_OMP

#define CASE_GIMPLE_OMP

Value:

    case GIMPLE_OMP_PARALLEL:                   \
    case GIMPLE_OMP_TASK:                       \
    case GIMPLE_OMP_FOR:                        \
    case GIMPLE_OMP_SECTIONS:                   \
    case GIMPLE_OMP_SECTIONS_SWITCH:            \
    case GIMPLE_OMP_SINGLE:                     \
    case GIMPLE_OMP_TARGET:                     \
    case GIMPLE_OMP_TEAMS:                      \
    case GIMPLE_OMP_SCOPE:                      \
    case GIMPLE_OMP_SECTION:                    \
    case GIMPLE_OMP_STRUCTURED_BLOCK:           \
    case GIMPLE_OMP_MASTER:                     \
    case GIMPLE_OMP_MASKED:                     \
    case GIMPLE_OMP_TASKGROUP:                  \
    case GIMPLE_OMP_ORDERED:                    \
    case GIMPLE_OMP_CRITICAL:                   \
    case GIMPLE_OMP_SCAN:                       \
    case GIMPLE_OMP_RETURN:                     \
    case GIMPLE_OMP_ATOMIC_LOAD:                \
    case GIMPLE_OMP_ATOMIC_STORE:               \
    case GIMPLE_OMP_CONTINUE

Returns true when the gimple statement STMT is any of the OMP types.

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

◆ DEFGSCODE

#define DEFGSCODE	(	SYM,
		STRING,
		STRUCT )

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_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_for_combined_into_p(), gimple_omp_for_combined_p(), gimple_omp_for_kind(), gimple_omp_masked_clauses(), gimple_omp_masked_clauses_ptr(), gimple_omp_masked_set_clauses(), gimple_omp_ordered_standalone(), gimple_omp_ordered_standalone_p(), gimple_omp_parallel_combined_p(), gimple_omp_parallel_set_combined_p(), gimple_omp_return_nowait_p(), gimple_omp_return_set_nowait(), gimple_omp_scope_clauses(), gimple_omp_scope_clauses_ptr(), gimple_omp_scope_set_clauses(), gimple_omp_section_last_p(), gimple_omp_section_set_last(), gimple_omp_target_kind(), gimple_omp_task_set_taskloop_p(), gimple_omp_task_set_taskwait_p(), gimple_omp_task_taskloop_p(), gimple_omp_task_taskwait_p(), gimple_omp_taskgroup_clauses(), gimple_omp_taskgroup_clauses_ptr(), gimple_omp_taskgroup_set_clauses(), gimple_predict_outcome(), gimple_predict_predictor(), gimple_predict_set_outcome(), gimple_predict_set_predictor(), gimple_switch_num_labels(), gimple_switch_set_num_labels(), gimple_try_kind(), gimple_wce_cleanup_eh_only(), and gimple_wce_set_cleanup_eh_only().

◆ GIMPLE_DEBUG_BIND_NOVALUE

#define GIMPLE_DEBUG_BIND_NOVALUE NULL_TREE /* error_mark_node @endverbatim */

The second operand of a GIMPLE_DEBUG_BIND, when the value was
optimized away.

Referenced by gimple_debug_bind_has_value_p(), and gimple_debug_bind_reset_value().

◆ GTMA_DECLARATION_MASK

#define GTMA_DECLARATION_MASK (GTMA_IS_OUTER | GTMA_IS_RELAXED)

Referenced by generate_tm_state(), and lower_transaction().

◆ GTMA_DOES_GO_IRREVOCABLE

#define GTMA_DOES_GO_IRREVOCABLE (1u << 6)

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

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

◆ GTMA_HAS_NO_INSTRUMENTATION

#define GTMA_HAS_NO_INSTRUMENTATION (1u << 7)

The transaction contains no instrumentation code whatsover, most
likely because it is guaranteed to go irrevocable upon entry.

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

◆ GTMA_HAVE_ABORT

#define GTMA_HAVE_ABORT (1u << 2)

The transaction is seen to not have an abort.

Referenced by dump_gimple_transaction(), examine_call_tm(), expand_call_tm(), expand_transaction(), lower_transaction(), make_edges_bb(), and propagate_tm_flags_out().

◆ 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

#define GTMA_HAVE_STORE (1u << 4)

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

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

Referenced by diagnose_tm_1(), dump_gimple_transaction(), gimplify_transaction(), and ipa_tm_diagnose_transaction().

◆ GTMA_MAY_ENTER_IRREVOCABLE

#define GTMA_MAY_ENTER_IRREVOCABLE (1u << 5)

The transaction MAY enter serial irrevocable mode in its dynamic scope.

Referenced by dump_gimple_transaction(), execute_tm_mark(), expand_call_tm(), expand_transaction(), generate_tm_state(), ipa_tm_insert_gettmclone_call(), ipa_tm_insert_irr_call(), ipa_tm_transform_transaction(), lower_sequence_tm(), and propagate_tm_flags_out().

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

typedef gimple* gimple_seq_node

Gimple IR definitions.

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

This file is part of GCC.

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

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

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

Enumeration Type Documentation

◆ gf_mask

enum gf_mask

Specific flags for individual GIMPLE statements.  These flags are
always stored in gimple.subcode and they may only be
defined for statement codes that do not use subcodes.

Values for the masks can overlap as long as the overlapping values
are never used in the same statement class.

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

Keep this list sorted.

Enumerator
GF_ASM_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 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

enum gimple_code

Enumerator

DEFGSCODE

This file contains the definitions of the GIMPLE IR tuples used in GCC.

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

This file is part of GCC.

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

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

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

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 exected
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-2024 Free Software Foundation, Inc.
   Contributed by Aldy Hernandez <aldyh@redhat.com>

This file is part of GCC.

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

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

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

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 exected
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

enum 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

enum 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

enum 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-2024 Free Software Foundation, Inc.
   Contributed by Aldy Hernandez <aldyh@redhat.com>

This file is part of GCC.

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

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

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

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

enum gimple_try_flags

Kind of GIMPLE_TRY statements.

Enumerator
GIMPLE_TRY_CATCH
GIMPLE_TRY_FINALLY
GIMPLE_TRY_KIND
GIMPLE_TRY_CATCH_IS_CLEANUP

◆ plf_mask

enum plf_mask

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

Enumerator
GF_PLF_1
GF_PLF_2

Function Documentation

◆ annotate_all_with_location()

void annotate_all_with_location	(	gimple_seq	stmt_p,
		location_t	location )

extern

Set the location for all the statements in a sequence STMT_P to LOCATION.

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

Referenced by finalize_nesting_tree_1(), gimple_simplify_phiopt(), gimplify_expr(), gsi_insert_finally_seq_after_call(), gsi_replace_with_seq_vops(), and walk_gimple_omp_for().

◆ annotate_all_with_location_after()

void annotate_all_with_location_after	(	gimple_seq	seq,
		gimple_stmt_iterator	gsi,
		location_t	location )

extern

Set LOCATION for all the statements after iterator GSI in sequence
SEQ.  If GSI is pointing to the end of the sequence, start with the
first statement in SEQ.

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

Referenced by gimplify_expr().

◆ bb_seq()

gimple_seq bb_seq ( const_basic_block bb )

inline

Returns the sequence of statements in BB.

References basic_block_def::flags, basic_block_def::basic_block_il_dependent::gimple, basic_block_def::il, NULL, and gimple_bb_info::seq.

Referenced by adjust_return_value(), assert_unreachable_fallthru_edge_p(), combine_blocks(), compute_added_num_insns(), expand_case(), expand_gimple_basic_block(), gimple_merge_blocks(), group_case_labels_stmt(), inline_forbidden_p(), input_function(), remove_unreachable::maybe_register(), remove_bb(), reorder_operands(), ssa_create_duplicates(), try_transform_to_exit_first_loop_alt(), value_replacement(), and verify_bb_vtables().

◆ bb_seq_addr()

gimple_seq * bb_seq_addr ( basic_block bb )

inline

References basic_block_def::flags, basic_block_def::basic_block_il_dependent::gimple, basic_block_def::il, NULL, and gimple_bb_info::seq.

Referenced by gsi_end_bb(), gsi_last_bb(), and gsi_start_bb().

◆ copy_warning() [1/3]

void copy_warning	(	gimple *	to,
		const gimple *	from )

extern

Copy the warning disposition mapping from one statement to another.

References copy_warning().

Referenced by gimple_set_location().

◆ copy_warning() [2/3]

void copy_warning	(	gimple *	to,
		const_tree	from )

extern

Copy the warning disposition mapping from an expression to a statement.

References copy_warning().

◆ copy_warning() [3/3]

void copy_warning	(	tree	to,
		const gimple *	from )

extern

Copy the warning disposition mapping from a statement to an expression.

References copy_warning().

◆ dump_decl_set()

void dump_decl_set	(	FILE *	file,
		bitmap	set )

extern

Dump bitmap SET (assumed to contain VAR_DECLs) to FILE.

References EXECUTE_IF_SET_IN_BITMAP, and i.

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

◆ dump_gimple_statistics()

void dump_gimple_statistics ( void )

extern

Print debugging information for gimple stmts generated.

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

Referenced by dump_memory_report().

◆ empty_body_p()

bool empty_body_p ( gimple_seq body )

Return true if BODY contains nothing but empty statements.

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

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

◆ get_gimple_rhs_class()

enum gimple_rhs_class get_gimple_rhs_class ( enum tree_code code )

inline

Determine if expression CODE is one of the valid expressions that can
be used on the RHS of GIMPLE assignments.

References gimple_rhs_class_table.

Referenced by aff_combination_expand(), check_all_va_list_escapes(), compute_invariantness(), defcodefor_name(), difference_cannot_overflow_p(), estimate_num_insns(), estimate_operator_cost(), evaluate_stmt(), expand_expr_real_2(), expand_expr_real_gassign(), expand_simple_operations(), expand_vector_operations_1(), expr_expected_value_1(), expr_hash_elt::expr_hash_elt(), extract_ops_from_tree(), find_deriving_biv_for_expr(), find_interesting_uses_stmt(), pcom_worker::find_use_stmt(), fold_gimple_assign(), scev_dfs::follow_ssa_edge_expr(), pointer_equiv_analyzer::get_equiv_expr(), get_gimple_rhs_num_ops(), gimple_assign_integer_valued_real_p(), gimple_assign_nonnegative_warnv_p(), gimple_assign_rhs_class(), gimple_assign_rhs_code(), gimple_could_trap_p_1(), gimple_fold_stmt_to_constant_1(), inline_read_section(), interpret_expr(), interpret_rhs_expr(), is_gimple_reg_rhs(), is_gimple_reg_rhs_or_call(), optimize_va_list_gpr_fpr_size(), parloops_is_simple_reduction(), process_assignment(), reassociate_bb(), rhs_to_tree(), split_constant_offset(), update_known_bitmask(), va_list_counter_bump(), valid_gimple_rhs_p(), vect_check_gather_scatter(), and vn_get_stmt_kind().

◆ get_gimple_rhs_num_ops()

unsigned get_gimple_rhs_num_ops ( enum tree_code code )

Return the number of operands needed on the RHS of a GIMPLE
assignment for an expression with tree code CODE.

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

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

◆ get_lineno()

int get_lineno ( const gimple * stmt )

inline

Return the line number for EXPR, or return -1 if we have no line
number information for it.

References gimple_location(), LOCATION_LINE, and UNKNOWN_LOCATION.

Referenced by dump_gimple_bb_header().

◆ gimple_alloc()

gimple * gimple_alloc	(	enum	gimple_code,
		unsigned	CXX_MEM_STAT_INFO )

◆ gimple_alloc_kind()

enum gimple_alloc_kind gimple_alloc_kind ( enum gimple_code code )

inline

Return the allocation kind for a given stmt CODE.

References gimple_alloc_kind_assign, gimple_alloc_kind_cond, gimple_alloc_kind_phi, and gimple_alloc_kind_rest.

◆ gimple_arg()

tree gimple_arg	(	const gimple *	gs,
		unsigned int	i )

inline

GS must be an assignment, a call, or a PHI.
If it's an assignment, return rhs operand I.
If it's a call, return function argument I.
If it's a PHI, return the value of PHI argument I.

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

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

◆ gimple_arg_ptr()

tree * gimple_arg_ptr	(	gimple *	gs,
		unsigned int	i )

inline

Return a pointer to gimple_arg (GS, I).

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

◆ gimple_asm_basic_p()

bool gimple_asm_basic_p ( const gasm * asm_stmt )

inline

Return true if asm ASM_STMT is a basic asm rather than an extended asm.

References GF_ASM_BASIC, and gimple::subcode.

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

◆ gimple_asm_clobber_op()

tree gimple_asm_clobber_op	(	const gasm *	asm_stmt,
		unsigned	index )

inline

Return clobber operand INDEX of GIMPLE_ASM ASM_STMT.

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

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

◆ gimple_asm_clobbers_memory_p()

bool gimple_asm_clobbers_memory_p ( const gasm * stmt )

extern

Return true if STMT clobbers memory.  STMT is required to be a
GIMPLE_ASM.

References gimple_asm_basic_p(), gimple_asm_clobber_op(), gimple_asm_nclobbers(), gimple_asm_string(), i, TREE_STRING_POINTER, and TREE_VALUE.

Referenced by check_stmt(), operands_scanner::get_asm_stmt_operands(), imm_dom_path_with_freeing_call(), and sanopt_optimize_walker().

◆ gimple_asm_inline_p()

bool gimple_asm_inline_p ( const gasm * asm_stmt )

inline

Return true if ASM_STMT is marked inline.

References GF_ASM_INLINE, and gimple::subcode.

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

◆ gimple_asm_input_op()

tree gimple_asm_input_op	(	const gasm *	asm_stmt,
		unsigned	index )

inline

Return input operand INDEX of GIMPLE_ASM ASM_STMT.

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

Referenced by ipa_icf_gimple::func_checker::compare_gimple_asm(), create_coalesce_list_for_region(), dump_gimple_asm(), execute_update_addresses_taken(), expand_asm_stmt(), find_func_aliases(), fold_stmt_1(), operands_scanner::get_asm_stmt_operands(), gimple_regimplify_operands(), ipa_param_body_adjustments::modify_gimple_stmt(), propagate_necessity(), scan_function(), sra_modify_function_body(), walk_gimple_asm(), and walk_stmt_load_store_addr_ops().

◆ gimple_asm_label_op()

tree gimple_asm_label_op	(	const gasm *	asm_stmt,
		unsigned	index )

inline

Return label operand INDEX of GIMPLE_ASM ASM_STMT.

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

Referenced by cleanup_dead_labels(), dump_gimple_asm(), expand_asm_stmt(), gimple_redirect_edge_and_branch(), make_gimple_asm_edges(), and walk_gimple_asm().

◆ gimple_asm_nclobbers()

unsigned gimple_asm_nclobbers ( const gasm * asm_stmt )

inline

Return the number of clobber operands for GIMPLE_ASM ASM_STMT.

References gasm::nc.

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

◆ gimple_asm_ninputs()

unsigned gimple_asm_ninputs ( const gasm * asm_stmt )

inline

Return the number of input operands for GIMPLE_ASM ASM_STMT.

References gasm::ni.

Referenced by ipa_icf_gimple::func_checker::compare_gimple_asm(), create_coalesce_list_for_region(), dump_gimple_asm(), execute_update_addresses_taken(), expand_asm_stmt(), find_func_aliases(), fold_stmt_1(), operands_scanner::get_asm_stmt_operands(), gimple_regimplify_operands(), ipa_param_body_adjustments::modify_gimple_stmt(), output_gimple_stmt(), propagate_necessity(), scan_function(), sra_modify_function_body(), walk_gimple_asm(), and walk_stmt_load_store_addr_ops().

◆ gimple_asm_nlabels()

unsigned gimple_asm_nlabels ( const gasm * asm_stmt )

inline

Return the number of label operands for GIMPLE_ASM ASM_STMT.

References gasm::nl.

Referenced by can_reassociate_op_p(), cleanup_dead_labels(), ipa_icf_gimple::func_checker::compare_gimple_asm(), dump_gimple_asm(), expand_asm_stmt(), expand_complex_asm(), gimple_redirect_edge_and_branch(), insert_stmt_after(), is_ctrl_altering_stmt(), make_gimple_asm_edges(), output_gimple_stmt(), and walk_gimple_asm().

◆ gimple_asm_noutputs()

unsigned gimple_asm_noutputs ( const gasm * asm_stmt )

inline

Return the number of output operands for GIMPLE_ASM ASM_STMT.

References gasm::no.

Referenced by ipa_icf_gimple::func_checker::compare_gimple_asm(), create_coalesce_list_for_region(), dump_gimple_asm(), execute_update_addresses_taken(), expand_asm_stmt(), expand_complex_asm(), find_func_aliases(), fold_stmt_1(), operands_scanner::get_asm_stmt_operands(), gimple_regimplify_operands(), input_gimple_stmt(), ipa_param_body_adjustments::modify_gimple_stmt(), op_iter_init(), output_gimple_stmt(), scan_function(), sra_modify_function_body(), walk_gimple_asm(), and walk_stmt_load_store_addr_ops().

◆ gimple_asm_output_op()

tree gimple_asm_output_op	(	const gasm *	asm_stmt,
		unsigned	index )

inline

Return output operand INDEX of GIMPLE_ASM ASM_STMT.

References gcc_gimple_checking_assert, and gasm::op.

Referenced by ipa_icf_gimple::func_checker::compare_gimple_asm(), create_coalesce_list_for_region(), dump_gimple_asm(), execute_update_addresses_taken(), expand_asm_stmt(), expand_complex_asm(), find_func_aliases(), fold_stmt_1(), operands_scanner::get_asm_stmt_operands(), gimple_regimplify_operands(), input_gimple_stmt(), ipa_param_body_adjustments::modify_gimple_stmt(), scan_function(), sra_modify_function_body(), walk_gimple_asm(), and walk_stmt_load_store_addr_ops().

◆ 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, and gimple::subcode.

Referenced by 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, gasm::ni, gasm::no, gasm::op, and TREE_CODE.

Referenced by gimple_build_asm_vec().

◆ gimple_asm_set_inline()

void gimple_asm_set_inline	(	gasm *	asm_stmt,
		bool	inline_p )

inline

If INLINE_P is true, mark asm statement ASM_STMT as inline.

References GF_ASM_INLINE, and gimple::subcode.

Referenced by gimplify_asm_expr().

◆ gimple_asm_set_input_op()

void gimple_asm_set_input_op	(	gasm *	asm_stmt,
		unsigned	index,
		tree	in_op )

inline

Set IN_OP to be input operand INDEX in GIMPLE_ASM ASM_STMT.

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

Referenced by gimple_build_asm_vec().

◆ gimple_asm_set_label_op()

void gimple_asm_set_label_op	(	gasm *	asm_stmt,
		unsigned	index,
		tree	label_op )

inline

Set LABEL_OP to be label operand INDEX in GIMPLE_ASM ASM_STMT.

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

Referenced by gimple_build_asm_vec().

◆ gimple_asm_set_output_op()

void gimple_asm_set_output_op	(	gasm *	asm_stmt,
		unsigned	index,
		tree	out_op )

inline

Set OUT_OP to be output operand INDEX in GIMPLE_ASM ASM_STMT.

References gcc_gimple_checking_assert, gasm::op, and TREE_CODE.

Referenced by gimple_build_asm_vec().

◆ gimple_asm_set_volatile()

void gimple_asm_set_volatile	(	gasm *	asm_stmt,
		bool	volatile_p )

inline

If VOLATILE_P is true, mark asm statement ASM_STMT as volatile.

References GF_ASM_VOLATILE, and gimple::subcode.

Referenced by gimplify_asm_expr().

◆ gimple_asm_string()

const char * gimple_asm_string ( const gasm * asm_stmt )

inline

Return the string representing the assembly instruction in
GIMPLE_ASM ASM_STMT.

References gasm::string.

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

◆ gimple_asm_volatile_p()

bool gimple_asm_volatile_p ( const gasm * asm_stmt )

inline

Return true if ASM_STMT is marked volatile.

References GF_ASM_VOLATILE, and gimple::subcode.

Referenced by check_stmt(), ipa_icf_gimple::func_checker::compare_gimple_asm(), dump_gimple_asm(), expand_asm_stmt(), get_references_in_stmt(), gimple_could_trap_p_1(), gimple_has_side_effects(), imm_dom_path_with_freeing_call(), jump_threader::record_temporary_equivalences_from_stmts_at_dest(), sanopt_optimize_walker(), stmt_can_terminate_bb_p(), stmt_could_throw_p(), and stmt_may_terminate_function_p().

◆ gimple_assign_cast_p()

bool gimple_assign_cast_p ( const gimple * s )

inline

Return true if S is a type-cast assignment.

References CONVERT_EXPR_CODE_P, gimple_assign_rhs_code(), is_gimple_assign(), and sc.

Referenced by arith_cast_equal_p(), arith_overflow_check_p(), check_all_va_list_escapes(), strlen_pass::check_and_optimize_stmt(), execute_cse_conv_1(), expand_expr_force_mode(), factor_out_conditional_operation(), final_range_test_p(), gimple_lower_bitint(), instrument_object_size(), match_arith_overflow(), match_uaddc_usubc(), maybe_optimize_guarding_check(), maybe_optimize_range_tests(), maybe_set_nonzero_bits(), minmax_replacement(), ipa_param_adjustments::modify_call(), optimize_atomic_op_fetch_cmp_0(), optimize_range_tests_var_bound(), process_assignment(), scan_operand_equal_p(), simplify_builtin_call(), simplify_gimple_switch(), spaceship_replacement(), uaddc_cast(), va_list_counter_bump(), vect_get_smallest_scalar_type(), vect_recog_rotate_pattern(), vect_recog_vector_vector_shift_pattern(), and zero_one_minusone().

◆ gimple_assign_copy_p()

bool gimple_assign_copy_p ( gimple * gs )

Return true if GS is a copy assignment.

References gimple_assign_single_p(), gimple_op(), and is_gimple_val().

Referenced by build_ssa_conflict_graph(), exist_non_indexing_operands_for_use_p(), pcom_worker::find_use_stmt(), ipa_param_body_adjustments::prepare_debug_expressions(), replace_ref_with(), and visit_stmt().

◆ gimple_assign_lhs() [1/2]

tree gimple_assign_lhs ( const gassign * gs )

inline

Return the LHS of assignment statement GS.

References gimple_statement_with_memory_ops::op.

◆ gimple_assign_lhs() [2/2]

tree gimple_assign_lhs ( const gimple * gs )

inline

References gimple_assign_lhs(), and GIMPLE_CHECK2().

◆ gimple_assign_lhs_ptr() [1/2]

tree * gimple_assign_lhs_ptr ( gassign * gs )

inline

Return a pointer to the LHS of assignment statement GS.

References gimple_statement_with_memory_ops::op.

Referenced by find_interesting_uses_stmt(), fold_stmt_1(), forward_propagate_addr_expr_1(), gimple_assign_lhs_ptr(), ipa_param_body_adjustments::modify_assignment(), sm_set_flag_if_changed::operator()(), propagate_with_phi(), replace_refs(), simple_mem_ref_in_stmt(), and sra_modify_assign().

◆ gimple_assign_lhs_ptr() [2/2]

tree * gimple_assign_lhs_ptr ( gimple * gs )

inline

References gimple_assign_lhs_ptr(), and GIMPLE_CHECK2().

◆ gimple_assign_load_p()

bool gimple_assign_load_p ( const gimple * gs )

Return true if GS is an assignment that loads from its rhs1.

References DECL_P, gimple_assign_rhs1(), gimple_assign_single_p(), handled_component_p(), TREE_CODE, and TREE_OPERAND.

Referenced by ipcp_modif_dom_walker::before_dom_children(), check_scan_store(), loop_cand::classify_simple_reduction(), eliminate_dom_walker::eliminate_stmt(), estimate_num_insns(), ipa_polymorphic_call_context::get_dynamic_type(), get_mem_ref_of_assignment(), gimple_lower_bitint(), strlen_pass::handle_integral_assign(), has_stmt_been_instrumented_p(), ifcvt_can_use_mask_load_store(), ifcvt_local_dce(), instrument_gimple(), load_from_unmodified_param_or_agg(), load_or_store_of_ptr_parameter(), maybe_instrument_assignment(), oacc_entry_exit_ok_1(), strub_from_body_p(), walk_ssa_copies(), warn_uninitialized_vars(), and will_be_nonconstant_predicate().

◆ gimple_assign_nontemporal_move_p()

bool gimple_assign_nontemporal_move_p ( const gassign * gs )

inline

Returns true if GS is a nontemporal move.

References gimple::nontemporal_move.

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

◆ gimple_assign_rhs1() [1/2]

tree gimple_assign_rhs1 ( const gassign * gs )

inline

Return the first operand on the RHS of assignment statement GS.

References gimple_statement_with_memory_ops::op.

◆ gimple_assign_rhs1() [2/2]

tree gimple_assign_rhs1 ( const gimple * gs )

inline

References gimple_assign_rhs1(), and GIMPLE_CHECK2().

◆ gimple_assign_rhs1_ptr() [1/2]

tree * gimple_assign_rhs1_ptr ( gassign * gs )

inline

Return a pointer to the first operand on the RHS of assignment
statement GS.

References gimple_statement_with_memory_ops::op.

Referenced by loop_cand::analyze_iloop_reduction_var(), check_reduction_path(), execute_update_addresses_taken(), extract_cond_operands(), find_interesting_uses_stmt(), fold_stmt_1(), forward_propagate_addr_expr_1(), gimple_assign_rhs1_ptr(), gimple_regimplify_operands(), hardcfr_scan_block(), linearize_expr_tree(), maybe_duplicate_comparison(), maybe_warn_operand(), ipa_param_body_adjustments::modify_assignment(), parloops_is_simple_reduction(), parloops_is_slp_reduction(), reorder_operands(), replace_refs(), repropagate_negates(), simple_mem_ref_in_stmt(), sra_modify_assign(), vect_is_simple_reduction(), and warn_uninitialized_vars().

◆ gimple_assign_rhs1_ptr() [2/2]

tree * gimple_assign_rhs1_ptr ( gimple * gs )

inline

References gimple_assign_rhs1_ptr(), and GIMPLE_CHECK2().

◆ gimple_assign_rhs2() [1/2]

tree gimple_assign_rhs2 ( const gassign * gs )

inline

Return the second operand on the RHS of assignment statement GS.
If GS does not have two operands, NULL is returned instead.

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

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

◆ gimple_assign_rhs2() [2/2]

tree gimple_assign_rhs2 ( const gimple * gs )

inline

References gimple_assign_rhs2(), and GIMPLE_CHECK2().

◆ gimple_assign_rhs2_ptr() [1/2]

tree * gimple_assign_rhs2_ptr ( gassign * gs )

inline

Return a pointer to the second operand on the RHS of assignment
statement GS.

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

Referenced by extract_cond_operands(), gimple_assign_rhs2_ptr(), linearize_expr_tree(), optimize_vec_cond_expr(), parloops_is_simple_reduction(), parloops_is_slp_reduction(), reorder_operands(), repropagate_negates(), and vect_determine_min_output_precision_1().

◆ gimple_assign_rhs2_ptr() [2/2]

tree * gimple_assign_rhs2_ptr ( gimple * gs )

inline

References gimple_assign_rhs2_ptr(), and GIMPLE_CHECK2().

◆ gimple_assign_rhs3() [1/2]

tree gimple_assign_rhs3 ( const gassign * gs )

inline

Return the third operand on the RHS of assignment statement GS.
If GS does not have two operands, NULL is returned instead.

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

Referenced by can_interpret_as_conditional_op_p(), check_redundant_cond_expr(), cond_expr_object_size(), defcodefor_name(), dump_gimple_assign(), dump_ternary_rhs(), expand_expr_real_gassign(), expand_omp_atomic_cas(), expand_vector_comparison(), expand_vector_condition(), expand_vector_scalar_condition(), expr_hash_elt::expr_hash_elt(), find_func_aliases(), fold_gimple_assign(), get_range_strlen(), gimple_assign_rhs3(), gimple_assign_rhs_to_tree(), gimple_expand_vec_cond_expr(), gimple_extract(), gimple_fold_stmt_to_constant_1(), gimple_lower_bitint(), gimple_range_ssa_names(), is_addr_local(), lower_vec_perm(), maybe_optimize_guarding_check(), ovce_extract_ops(), parloops_is_simple_reduction(), fold_using_range::range_of_cond_expr(), rhs_to_tree(), simplify_bitfield_ref(), simplify_permutation(), thread_private_new_memory(), vect_recog_bit_insert_pattern(), vect_recog_bool_pattern(), vect_recog_mask_conversion_pattern(), vect_recog_mixed_size_cond_pattern(), vect_slp_check_for_roots(), vect_slp_is_lane_insert(), and verify_gimple_assign_ternary().

◆ gimple_assign_rhs3() [2/2]

tree gimple_assign_rhs3 ( const gimple * gs )

inline

References gimple_assign_rhs3(), and GIMPLE_CHECK2().

◆ gimple_assign_rhs3_ptr()

tree * gimple_assign_rhs3_ptr ( gimple * gs )

inline

Return a pointer to the third operand on the RHS of assignment
statement GS.

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

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

◆ gimple_assign_rhs_class()

enum gimple_rhs_class gimple_assign_rhs_class ( const gimple * gs )

inline

Return the gimple rhs class of the code of the expression computed on
the rhs of assignment statement GS.
This will never return GIMPLE_INVALID_RHS.

References get_gimple_rhs_class(), and gimple_assign_rhs_code().

Referenced by analyze_agg_content_value(), arith_overflow_check_p(), chain_of_csts_start(), check_scan_store(), compute_complex_assign_jump_func(), constant_after_peeling(), decompose_param_expr(), dump_gimple_assign(), eliminate_dom_walker::eliminate_avail(), eliminated_by_inlining_prob(), expand_gimple_stmt_1(), fold_stmt_1(), get_val_for(), gimple_assign_rhs_to_tree(), gimple_assign_single_p(), gimple_extract(), insert_init_stmt(), instantiate_scev_name(), match_arith_overflow(), simplify_builtin_call(), spaceship_replacement(), tree_estimate_loop_size(), value_replacement(), verify_gimple_assign(), and walk_gimple_op().

◆ gimple_assign_rhs_code() [1/2]

enum tree_code gimple_assign_rhs_code ( const gassign * gs )

inline

Return the code of the expression computed on the rhs of assignment
statement GS.  In case that the RHS is a single object, returns the
tree code of the object.

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

◆ gimple_assign_rhs_code() [2/2]

enum tree_code gimple_assign_rhs_code ( const gimple * gs )

inline

References gimple_assign_rhs_code(), and GIMPLE_CHECK2().

◆ gimple_assign_rhs_could_trap_p()

bool gimple_assign_rhs_could_trap_p ( gimple * s )

Return true if RHS of a GIMPLE_ASSIGN S can trap.

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

Referenced by no_side_effect_bb().

◆ gimple_assign_set_lhs() [1/2]

void gimple_assign_set_lhs	(	gassign *	gs,
		tree	lhs )

inline

Set LHS to be the LHS operand of assignment statement GS.

References gimple_statement_with_memory_ops::op, SSA_NAME_DEF_STMT, and TREE_CODE.

Referenced by create_new_def_for(), execute_update_addresses_taken(), expand_complex_move(), gen_conditions_for_pow_int_base(), gen_one_condition(), gimple_assign_set_lhs(), gimple_assign_set_rhs_with_ops(), gimple_build_assign_1(), gimple_fold_builtin_memory_op(), gimple_load_first_char(), gimple_set_lhs(), instrument_bool_enum_load(), ipa_tm_insert_gettmclone_call(), lower_emutls_1(), maybe_duplicate_comparison(), maybe_fold_comparisons_from_match_pd(), maybe_trim_complex_store(), maybe_trim_constructor_store(), ipa_param_adjustments::modify_call(), read_vector_array(), rewrite_to_defined_overflow(), sra_modify_assign(), tm_log_emit_saves(), vect_create_epilog_for_reduction(), vect_create_half_widening_stmts(), vect_expand_fold_left(), vect_setup_realignment(), vectorizable_assignment(), vectorizable_conversion(), vectorizable_load(), vectorizable_operation(), and vectorizable_shift().

◆ gimple_assign_set_lhs() [2/2]

void gimple_assign_set_lhs	(	gimple *	gs,
		tree	lhs )

inline

References gimple_assign_set_lhs(), and GIMPLE_CHECK2().

◆ gimple_assign_set_nontemporal_move()

void gimple_assign_set_nontemporal_move	(	gimple *	gs,
		bool	nontemporal )

inline

Sets nontemporal move flag of GS to NONTEMPORAL.

References GIMPLE_CHECK, and gimple::nontemporal_move.

Referenced by mark_nontemporal_store().

◆ gimple_assign_set_rhs1() [1/2]

void gimple_assign_set_rhs1	(	gassign *	gs,
		tree	rhs )

inline

Set RHS to be the first operand on the RHS of assignment statement GS.

References gimple_statement_with_memory_ops::op.

Referenced by convert_mult_to_widen(), expand_complex_move(), expand_omp_taskreg(), fold_stmt_1(), fold_strstr_to_strncmp(), forward_propagate_addr_expr_1(), gimple_assign_set_rhs1(), gimple_assign_set_rhs_with_ops(), gimple_build_assign_1(), gimple_lower_bitint(), initialize_root_vars_store_elim_2(), insert_init_stmt(), insert_trap(), instrument_si_overflow(), linearize_expr(), match_arith_overflow(), match_single_bit_test(), maybe_duplicate_comparison(), maybe_fold_comparisons_from_match_pd(), maybe_set_vectorized_backedge_value(), maybe_trim_complex_store(), maybe_trim_constructor_store(), ipa_param_body_adjustments::modify_assignment(), optimize_atomic_op_fetch_cmp_0(), optimize_vec_cond_expr(), predicate_statements(), propagate_with_phi(), rewrite_expr_tree(), rewrite_expr_tree_parallel(), simplify_using_ranges::simplify_abs_using_ranges(), simplify_bitfield_ref(), simplify_builtin_call(), 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_float_conversion_using_ranges(), simplify_permutation(), sink_common_stores_to_bb(), spaceship_replacement(), split_function(), undistribute_bitref_for_vector(), loop_cand::undo_simple_reduction(), vect_schedule_scc(), and vect_split_statement().

◆ gimple_assign_set_rhs1() [2/2]

void gimple_assign_set_rhs1	(	gimple *	gs,
		tree	rhs )

inline

References gimple_assign_set_rhs1(), and GIMPLE_CHECK2().

◆ gimple_assign_set_rhs2() [1/2]

void gimple_assign_set_rhs2	(	gassign *	gs,
		tree	rhs )

inline

Set RHS to be the second operand on the RHS of assignment statement GS.

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

Referenced by convert_mult_to_widen(), expand_vector_operations_1(), fold_stmt_1(), fold_strstr_to_strncmp(), gimple_assign_set_rhs2(), gimple_assign_set_rhs_with_ops(), gimple_build_assign_1(), gimple_lower_bitint(), linearize_expr(), match_arith_overflow(), match_single_bit_test(), maybe_fold_comparisons_from_match_pd(), maybe_set_vectorized_backedge_value(), replace_reciprocal_squares(), rewrite_expr_tree(), rewrite_expr_tree_parallel(), simplify_builtin_call(), simplify_using_ranges::simplify_compare_assign_using_ranges_1(), simplify_using_ranges::simplify_div_or_mod_using_ranges(), spaceship_replacement(), dom_opt_dom_walker::test_for_singularity(), undistribute_bitref_for_vector(), and vect_schedule_scc().

◆ gimple_assign_set_rhs2() [2/2]

void gimple_assign_set_rhs2	(	gimple *	gs,
		tree	rhs )

inline

References gimple_assign_set_rhs2(), and GIMPLE_CHECK2().

◆ gimple_assign_set_rhs3() [1/2]

void gimple_assign_set_rhs3	(	gassign *	gs,
		tree	rhs )

inline

Set RHS to be the third operand on the RHS of assignment statement GS.

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

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

◆ gimple_assign_set_rhs3() [2/2]

void gimple_assign_set_rhs3	(	gimple *	gs,
		tree	rhs )

inline

References gimple_assign_set_rhs3(), and GIMPLE_CHECK2().

◆ gimple_assign_set_rhs_code()

void gimple_assign_set_rhs_code	(	gimple *	s,
		enum tree_code	code )

inline

Set CODE to be the code for the expression computed on the RHS of
assignment S.

References GIMPLE_CHECK, and gimple::subcode.

Referenced by convert_mult_to_widen(), fold_stmt_1(), forward_propagate_addr_expr_1(), insert_init_stmt(), insert_trap(), match_arith_overflow(), match_single_bit_test(), maybe_fold_comparisons_from_match_pd(), replace_reciprocal(), replace_reciprocal_squares(), rewrite_to_defined_overflow(), simplify_using_ranges::simplify_abs_using_ranges(), simplify_using_ranges::simplify_compare_assign_using_ranges_1(), simplify_using_ranges::simplify_div_or_mod_using_ranges(), simplify_permutation(), spaceship_replacement(), dom_opt_dom_walker::test_for_singularity(), and zero_one_operation().

◆ gimple_assign_set_rhs_from_tree()

void gimple_assign_set_rhs_from_tree	(	gimple_stmt_iterator *	gsi,
		tree	expr )

Modify the RHS of the assignment pointed-to by GSI using the
operands in the expression tree EXPR.

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

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

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

References extract_ops_from_tree(), and gimple_assign_set_rhs_with_ops().

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

◆ gimple_assign_set_rhs_with_ops() [1/3]

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

Set the RHS of assignment statement pointed-to by GSI to CODE with
operands OP1, OP2 and OP3.

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

References get_gimple_rhs_num_ops(), gimple_alloc(), gimple_assign_lhs(), gimple_assign_set_lhs(), gimple_assign_set_rhs1(), gimple_assign_set_rhs2(), gimple_assign_set_rhs3(), gimple_init_singleton(), gimple_num_ops(), gimple_set_num_ops(), gimple_set_subcode(), gimple_size(), gsi_replace(), and gsi_stmt().

Referenced by break_up_subtract(), convert_plusminus_to_widen(), execute_update_addresses_taken(), fold_stmt_1(), forward_propagate_addr_expr_1(), gimple_assign_set_rhs_from_tree(), gimple_assign_set_rhs_with_ops(), gimple_assign_set_rhs_with_ops(), strlen_pass::handle_pointer_plus(), instrument_bool_enum_load(), match_arith_overflow(), optimize_atomic_bit_test_and(), optimize_atomic_op_fetch_cmp_0(), pcom_worker::reassociate_to_the_same_stmt(), replace_mult_candidate(), replace_one_candidate(), replace_rhs_if_not_dup(), replace_stmt_with_simplification(), repropagate_negates(), simplify_using_ranges::simplify(), simplify_using_ranges::simplify_bit_ops_using_ranges(), simplify_builtin_call(), simplify_using_ranges::simplify_truth_ops_using_ranges(), simplify_vector_constructor(), spaceship_replacement(), transform_stmt_to_multiply(), and update_complex_assignment().

◆ gimple_assign_set_rhs_with_ops() [2/3]

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

inline

A wrapper around 3 operand gimple_assign_set_rhs_with_ops, for callers
which expect to see only one operands.

References gimple_assign_set_rhs_with_ops(), and NULL.

◆ gimple_assign_set_rhs_with_ops() [3/3]

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

inline

A wrapper around 3 operand gimple_assign_set_rhs_with_ops, for callers
which expect to see only two operands.

References gimple_assign_set_rhs_with_ops(), and NULL.

◆ gimple_assign_single_p()

bool gimple_assign_single_p ( const gimple * gs )

inline

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

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

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

◆ gimple_assign_ssa_name_copy_p()

bool gimple_assign_ssa_name_copy_p ( gimple * gs )

Return true if GS is a SSA_NAME copy assignment.

References gimple_assign_lhs(), gimple_assign_rhs1(), gimple_assign_single_p(), and TREE_CODE.

Referenced by create_coalesce_list_for_region(), find_uninit_use(), get_val_for(), insert_clobber_before_stack_restore(), instrument_object_size(), loop_iter_phi_semi_invariant_p(), propagate_with_phi(), recognize_single_bit_test(), pcom_worker::remove_stmt(), and simple_iv_increment_p().

◆ gimple_assign_unary_nop_p()

bool gimple_assign_unary_nop_p ( gimple * gs )

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

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

References CONVERT_EXPR_CODE_P, error_mark_node, gimple_assign_lhs(), gimple_assign_rhs1(), gimple_assign_rhs_code(), is_gimple_assign(), TREE_TYPE, and TYPE_MODE.

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

◆ gimple_assume_body()

gimple_seq gimple_assume_body ( const gimple * gs )

inline

Return the GIMPLE sequence contained in the GIMPLE_ASSUME statement GS.

References as_a(), and gimple_statement_assume::body.

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

◆ gimple_assume_body_ptr()

gimple_seq * gimple_assume_body_ptr ( gimple * gs )

inline

Return the address of the GIMPLE sequence contained in the GIMPLE_ASSUME
statement GS.

References as_a(), and gimple_statement_assume::body.

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

◆ gimple_assume_guard()

tree gimple_assume_guard ( const gimple * gs )

inline

Return the guard associated with the GIMPLE_ASSUME statement GS.

References as_a(), and gimple_statement_assume::guard.

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

◆ gimple_assume_guard_ptr()

tree * gimple_assume_guard_ptr ( gimple * gs )

inline

References as_a(), and gimple_statement_assume::guard.

Referenced by walk_gimple_op().

◆ gimple_assume_set_guard()

void gimple_assume_set_guard	(	gimple *	gs,
		tree	guard )

inline

Set the guard associated with the GIMPLE_ASSUME statement GS.

References as_a(), and gimple_statement_assume::guard.

Referenced by gimple_build_assume(), and gimple_copy().

◆ gimple_bb()

basic_block gimple_bb ( const gimple * g )

inline

Return the basic block holding statement G.

References g.

◆ gimple_bind_add_seq()

void gimple_bind_add_seq	(	gbind *	bind_stmt,
		gimple_seq	seq )

inline

Append a sequence of statements to the end of a GIMPLE_BIND's body.

References gbind::body, and gimple_seq_add_seq().

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

◆ gimple_bind_add_stmt()

void gimple_bind_add_stmt	(	gbind *	bind_stmt,
		gimple *	stmt )

inline

Append a statement to the end of a GIMPLE_BIND's body.

References gbind::body, and gimple_seq_add_stmt().

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

◆ gimple_bind_append_vars()

void gimple_bind_append_vars	(	gbind *	bind_stmt,
		tree	vars )

inline

Append VARS to the set of variables declared in the GIMPLE_BIND
statement GS.

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

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

◆ gimple_bind_block()

tree gimple_bind_block ( const gbind * bind_stmt )

inline

Return the TREE_BLOCK node associated with GIMPLE_BIND statement
GS.  This is analogous to the BIND_EXPR_BLOCK field in trees.

References gbind::block.

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

◆ gimple_bind_body()

gimple_seq gimple_bind_body ( const gbind * gs )

inline

Return the GIMPLE sequence contained in the GIMPLE_BIND statement GS.

References gimple_bind_body_ptr().

Referenced by collect_fallthrough_labels(), copy_gimple_bind(), decompose_kernels_region_body(), do_warn_unused_result(), dump_gimple_bind(), empty_stmt_p(), estimate_num_insns(), finalize_nesting_tree_1(), flatten_binds(), gimple_copy(), gimple_stmt_may_fallthru(), gimplify_bind_expr(), gimplify_body(), last_stmt_in_scope(), lower_gimple_bind(), lower_omp_critical(), lower_omp_target(), lower_omp_taskreg(), top_level_omp_for_in_stmt(), and verify_gimple_in_seq_2().

◆ gimple_bind_body_ptr()

gimple_seq * gimple_bind_body_ptr ( gbind * bind_stmt )

inline

References gbind::body.

Referenced by gimple_bind_body(), lower_gimple_bind(), lower_omp_1(), lower_omp_taskgroup(), and walk_gimple_stmt().

◆ gimple_bind_set_block()

void gimple_bind_set_block	(	gbind *	bind_stmt,
		tree	block )

inline

Set BLOCK to be the TREE_BLOCK node associated with GIMPLE_BIND
statement GS.

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

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

◆ gimple_bind_set_body()

void gimple_bind_set_body	(	gbind *	bind_stmt,
		gimple_seq	seq )

inline

Set SEQ to be the GIMPLE sequence contained in the GIMPLE_BIND
statement GS.

References gbind::body.

Referenced by finalize_nesting_tree_1(), flatten_binds(), gimple_build_bind(), gimple_copy(), gimplify_bind_expr(), gimplify_body(), lower_omp_critical(), lower_omp_for(), lower_omp_scope(), lower_omp_sections(), lower_omp_single(), lower_omp_teams(), and scan_omp_simd().

◆ gimple_bind_set_vars()

void gimple_bind_set_vars	(	gbind *	bind_stmt,
		tree	vars )

inline

Set VARS to be the set of variables declared in the GIMPLE_BIND
statement GS.

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

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

◆ gimple_bind_vars()

tree gimple_bind_vars ( const gbind * bind_stmt )

inline

Return the variables declared in the GIMPLE_BIND statement GS.

References gbind::vars.

Referenced by convert_local_reference_stmt(), convert_nonlocal_reference_stmt(), copy_gimple_bind(), declare_vars(), decompose_kernels_region_body(), dump_gimple_bind(), find_assumption_locals_r(), flatten_binds(), gimple_copy(), lower_gimple_bind(), lower_omp_1(), lower_omp_critical(), lower_omp_for(), lower_omp_ordered(), lower_omp_sections(), lower_omp_target(), lower_omp_taskreg(), maybe_remove_omp_member_access_dummy_vars(), replace_locals_stmt(), and scan_omp_1_stmt().

◆ gimple_block()

tree gimple_block ( const gimple * g )

inline

Return the lexical scope block holding statement G.

References g, and LOCATION_BLOCK.

Referenced by clear_unused_block_pointer(), copy_debug_stmt(), decl_maybe_in_construction_p(), dump_gimple_debug(), expand_call_inline(), expand_omp_target(), expand_omp_taskreg(), finish_update_gimple_call(), fold_builtin_alloca_with_align(), autofdo::get_relative_location_for_stmt(), gimple_assign_rhs_to_tree(), gimple_nonartificial_location(), input_function(), lower_eh_constructs_2(), lower_try_finally_dup_block(), lower_try_finally_onedest(), make_blocks_1(), ipa_param_adjustments::modify_call(), move_stmt_r(), noncall_stmt_may_be_vtbl_ptr_store(), param_type_may_change_p(), remap_gimple_stmt(), remove_exit_barrier(), remove_unused_locals(), and set_location_for_edge().

◆ gimple_build_asm_vec()

gasm * gimple_build_asm_vec	(	const char *	string,
		vec< tree, va_gc > *	inputs,
		vec< tree, va_gc > *	outputs,
		vec< tree, va_gc > *	clobbers,
		vec< tree, va_gc > *	labels )

Build a GIMPLE_ASM statement.

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

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

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

◆ gimple_build_assign() [1/4]

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

◆ gimple_build_assign() [2/4]

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

◆ gimple_build_assign() [3/4]

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

◆ gimple_build_assign() [4/4]

gassign * gimple_build_assign	(	tree	,
		tree	CXX_MEM_STAT_INFO )

◆ gimple_build_assume()

gimple * gimple_build_assume	(	tree	guard,
		gimple_seq	body )

Build a GIMPLE_ASSUME statement.

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

Referenced by gimplify_call_expr(), and remap_gimple_stmt().

◆ gimple_build_bind()

gbind * gimple_build_bind	(	tree	vars,
		gimple_seq	body,
		tree	block )

Build a GIMPLE_BIND statement.
VARS are the variables in BODY.
BLOCK is the containing block.

References as_a(), gimple_alloc(), gimple_bind_set_block(), gimple_bind_set_body(), and gimple_bind_set_vars().

Referenced by convert_nonlocal_omp_clauses(), copy_gimple_bind(), decompose_kernels_region_body(), finalize_task_copyfn(), gimplify_bind_expr(), gimplify_body(), gimplify_function_tree(), gimplify_omp_for(), gimplify_switch_expr(), lower_assumption(), lower_omp_critical(), lower_omp_for(), lower_omp_master(), lower_omp_ordered(), lower_omp_scope(), lower_omp_sections(), lower_omp_single(), lower_omp_target(), lower_omp_taskgroup(), lower_omp_taskreg(), lower_omp_teams(), make_region_loop_nest(), make_region_seq(), maybe_build_inner_data_region(), scan_omp_simd(), and scan_omp_target().

◆ gimple_build_builtin_unreachable()

gcall * gimple_build_builtin_unreachable ( location_t loc )

Build a gcall to __builtin_unreachable as rewritten by
-fsanitize=unreachable.

References g, gimple_build_call(), gimple_call_set_ctrl_altering(), gimple_set_location(), NULL_TREE, and sanitize_unreachable_fn().

Referenced by execute_fixup_cfg(), gimple_fold_call(), remove_exits_and_undefined_stmts(), ubsan_instrument_unreachable(), and unloop_loops().

◆ gimple_build_call()

gcall * gimple_build_call	(	tree	fn,
		unsigned	nargs,
			... )

Build a GIMPLE_CALL statement to function FN.  NARGS is the number of
arguments.  The ... are the arguments.

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

◆ gimple_build_call_from_tree()

gcall * gimple_build_call_from_tree	(	tree	t,
		tree	fnptrtype )

Build a GIMPLE_CALL statement from CALL_EXPR T.  Note that T is
assumed to be in GIMPLE form already.  Minimal checking is done of
this fact.

Referenced by gimplify_call_expr(), and gimplify_modify_expr().

◆ gimple_build_call_internal()

gcall * gimple_build_call_internal	(	enum internal_fn	fn,
		unsigned	nargs,
			... )

Build a GIMPLE_CALL statement to internal function FN.  NARGS is
the number of arguments.  The ... are the arguments.

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

◆ gimple_build_call_internal_vec()

gcall * gimple_build_call_internal_vec	(	enum internal_fn	fn,
		const vec< tree > &	args )

Build a GIMPLE_CALL statement to internal function FN with the arguments
specified in vector ARGS.

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

Referenced by complex_pattern::build(), create_expression_by_pieces(), expand_call_inline(), gimple_call_copy_skip_args(), gimplify_call_expr(), gimplify_modify_expr(), lower_assumption(), lower_oacc_head_mark(), lower_oacc_private_marker(), lower_rec_input_clauses(), predicate_rhs_code(), predicate_statements(), use_internal_fn(), vect_recog_mask_conversion_pattern(), vectorizable_call(), and vectorizable_operation().

◆ gimple_build_call_valist()

gcall * gimple_build_call_valist	(	tree	fn,
		unsigned	nargs,
		va_list	ap )

Build a GIMPLE_CALL statement to function FN.  NARGS is the number of
arguments.  AP contains the arguments.

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

Referenced by update_gimple_call().

◆ gimple_build_call_vec()

gcall * gimple_build_call_vec	(	tree	fn,
		const vec< tree > &	args )

Build a GIMPLE_CALL statement to function FN with the arguments
specified in vector ARGS.

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

Referenced by copy_bb(), create_expression_by_pieces(), expand_omp_ordered_sink(), expand_omp_target(), expand_thunk(), gimple_call_copy_skip_args(), gimplify_and_update_call_from_tree(), ipa_param_adjustments::modify_call(), ipa_param_body_adjustments::modify_call_stmt(), split_function(), vectorizable_call(), and vectorizable_simd_clone_call().

◆ gimple_build_catch()

gcatch * gimple_build_catch	(	tree	types,
		gimple_seq	handler )

Build a GIMPLE_CATCH statement.

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

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

Referenced by gimplify_expr(), and remap_gimple_stmt().

◆ gimple_build_cond()

gcond * gimple_build_cond	(	enum tree_code	pred_code,
		tree	lhs,
		tree	rhs,
		tree	t_label,
		tree	f_label )

Build a GIMPLE_COND statement.

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

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

Referenced by asan_expand_check_ifn(), branch_fixup(), build_instrumentation_call(), rt_bb_visited::check(), clear_padding_emit_loop(), connect_loops(), convert_single_case_switch(), create_empty_loop_on_edge(), tree_switch_conversion::switch_decision_tree::do_jump_if_equal(), do_split_loop_on_cond(), dom_opt_dom_walker::dom_opt_dom_walker(), tree_switch_conversion::jump_table_cluster::emit(), tree_switch_conversion::switch_decision_tree::emit_cmp_and_jump_insns(), execute_sm_if_changed(), 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(), gimple_build_cond_empty(), gimple_build_cond_from_tree(), gimple_divmod_fixed_value(), gimple_gen_ic_func_profiler(), gimple_gen_time_profiler(), gimple_ic(), gimple_lower_bitint(), gimple_mod_pow2(), gimple_mod_subtract(), gimple_stringop_fixed_value(), gimplify_cond_expr(), gimplify_init_ctor_eval_range(), gimplify_omp_loop_xform(), hoist_guard(), insert_check_and_trap(), rt_bb_visited::insert_exit_check_on_edge(), instrument_bool_enum_load(), instrument_builtin(), instrument_nonnull_arg(), instrument_nonnull_return(), jump_threader::jump_threader(), lower_builtin_posix_memalign(), lower_eh_dispatch(), lower_lastprivate_clauses(), lower_omp_1(), lower_omp_for_scan(), lower_omp_ordered(), lower_omp_single_simple(), lower_omp_task_reductions(), lower_omp_teams(), lower_rec_input_clauses(), lower_reduction_clauses(), maybe_add_implicit_barrier_cancel(), move_sese_in_condition(), oacc_entry_exit_single_gang(), omp_sese_split_blocks(), optimize_atomic_bit_test_and(), optimize_mask_stores(), scan_omp_simd(), simd_clone_adjust(), tree_transform_and_unroll_loop(), ubsan_expand_bounds_ifn(), ubsan_expand_null_ifn(), ubsan_expand_objsize_ifn(), ubsan_expand_ptr_ifn(), ubsan_expand_vptr_ifn(), use_internal_fn(), vect_loop_versioning(), vect_recog_bitfield_ref_pattern(), vect_recog_gcond_pattern(), vect_set_loop_condition_normal(), vect_set_loop_condition_partial_vectors(), vect_set_loop_condition_partial_vectors_avx512(), worker_single_copy(), and worker_single_simple().

◆ gimple_build_cond_from_tree()

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

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

References gimple_build_cond(), and gimple_cond_get_ops_from_tree().

Referenced by create_empty_if_region_on_edge(), gen_one_condition(), gimple_lv_add_condition_to_bb(), tree_switch_conversion::bit_test_cluster::hoist_edge_and_branch_if_true(), lower_omp_target(), set_ifsese_condition(), and slpeel_add_loop_guard().

◆ gimple_build_debug_begin_stmt()

gdebug * gimple_build_debug_begin_stmt	(	tree	,
		location_t	CXX_MEM_STAT_INFO )

◆ gimple_build_debug_bind()

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

◆ gimple_build_debug_inline_entry()

gdebug * gimple_build_debug_inline_entry	(	tree	,
		location_t	CXX_MEM_STAT_INFO )

◆ gimple_build_debug_source_bind()

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

◆ gimple_build_eh_dispatch()

geh_dispatch * gimple_build_eh_dispatch ( int region )

Build a GIMPLE_EH_DISPATCH statement.

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

Referenced by lower_catch(), and lower_eh_filter().

◆ gimple_build_eh_else()

geh_else * gimple_build_eh_else	(	gimple_seq	n_body,
		gimple_seq	e_body )

Build a GIMPLE_EH_ELSE statement.

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

Referenced by gimplify_expr(), and lower_transaction().

◆ gimple_build_eh_filter()

geh_filter * gimple_build_eh_filter	(	tree	types,
		gimple_seq	failure )

Build a GIMPLE_EH_FILTER statement.

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

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

Referenced by gimplify_expr(), and remap_gimple_stmt().

◆ gimple_build_eh_must_not_throw()

geh_mnt * gimple_build_eh_must_not_throw ( tree decl )

Build a GIMPLE_EH_MUST_NOT_THROW statement.

References as_a(), ECF_NORETURN, flags_from_decl_or_type(), gcc_assert, gimple_alloc(), gimple_eh_must_not_throw_set_fndecl(), and TREE_CODE.

Referenced by honor_protect_cleanup_actions(), and maybe_catch_exception().

◆ gimple_build_goto()

ggoto * gimple_build_goto ( tree dest )

Build a GIMPLE_GOTO statement to label DEST.

References as_a(), gimple_build_with_ops, and gimple_goto_set_dest().

Referenced by clear_padding_emit_loop(), convert_nl_goto_receiver(), do_goto_redirection(), do_return_redirection(), frob_into_branch_around(), gimplify_cond_expr(), gimplify_expr(), gimplify_init_ctor_eval_range(), gimplify_loop_expr(), gimplify_omp_loop_xform(), handle_abnormal_edges(), lower_builtin_setjmp(), lower_catch(), lower_coro_builtin(), lower_gimple_return(), lower_omp_for_scan(), lower_omp_target(), lower_omp_task_reductions(), lower_omp_teams(), lower_rec_input_clauses(), lower_transaction(), lower_try_finally_copy(), lower_try_finally_nofallthru(), lower_try_finally_switch(), and scan_omp_simd().

◆ gimple_build_label()

glabel * gimple_build_label ( tree label )

Build a GIMPLE_LABEL statement for LABEL.

References as_a(), gimple_build_with_ops, and gimple_label_set_label().

Referenced by build_instrumentation_call(), clear_padding_emit_loop(), convert_nl_goto_receiver(), emit_post_landing_pad(), frob_into_branch_around(), tree_switch_conversion::switch_conversion::gen_inbound_check(), gimple_block_label(), gimplify_case_label_expr(), gimplify_cond_expr(), gimplify_init_ctor_eval_range(), gimplify_label_expr(), gimplify_loop_expr(), gimplify_omp_loop_xform(), gimplify_switch_expr(), handle_abnormal_edges(), label_to_block(), lower_assumption(), lower_builtin_posix_memalign(), lower_builtin_setjmp(), lower_catch(), lower_cleanup(), lower_eh_filter(), lower_function_body(), lower_lastprivate_clauses(), lower_omp_1(), lower_omp_for(), lower_omp_for_scan(), lower_omp_master(), lower_omp_ordered(), lower_omp_sections(), 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_transaction(), lower_try_finally(), lower_try_finally_copy(), lower_try_finally_nofallthru(), lower_try_finally_onedest(), lower_try_finally_switch(), maybe_add_implicit_barrier_cancel(), replace_goto_queue_cond_clause(), and scan_omp_simd().

◆ gimple_build_nop()

gimple * gimple_build_nop ( void )

Build a GIMPLE_NOP statement.

References gimple_alloc().

Referenced by asan_expand_poison_ifn(), convert_local_reference_stmt(), convert_nonlocal_reference_stmt(), copy_phis_for_bb(), decompose_kernels_region_body(), diagnose_sb_0(), eliminate_local_variables_stmt(), eliminate_tail_call(), execute_omp_device_lower(), expand_call_inline(), expand_complex_div_wide(), expand_complex_multiplication(), expand_oacc_for(), expand_omp_for_init_vars(), expand_vector_conversion(), fixup_noreturn_call(), get_or_create_ssa_default_def(), get_representative_for(), gimple_flow_call_edges_add(), gimple_fold_builtin_clear_padding(), gimple_fold_builtin_memchr(), gimple_fold_builtin_memory_op(), gimple_fold_call(), gimple_lower_bitint(), gimplify_and_update_call_from_tree(), gimplify_body(), gimplify_modify_expr(), gimplify_omp_ordered(), input_ssa_names(), lower_omp_1(), lower_omp_ordered_clauses(), lower_omp_scan(), move_sese_region_to_fn(), omp_sese_split_blocks(), cgraph_edge::redirect_call_stmt_to_callee(), remap_ssa_name(), replace_call_with_value(), rewrite_stmt(), scan_omp_1_stmt(), scan_omp_parallel(), scan_omp_task(), simplify_builtin_call(), tree_function_versioning(), vect_do_peeling(), vect_get_loop_len(), vect_get_loop_mask(), vect_remove_slp_scalar_calls(), and vectorizable_simd_clone_call().

◆ gimple_build_omp_atomic_load()

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

Build a GIMPLE_OMP_ATOMIC_LOAD statement.

References as_a(), gimple_alloc(), gimple_omp_atomic_load_set_lhs(), gimple_omp_atomic_load_set_rhs(), and gimple_omp_atomic_set_memory_order().

Referenced by create_call_for_reduction_1(), and gimplify_omp_atomic().

◆ gimple_build_omp_atomic_store()

gomp_atomic_store * gimple_build_omp_atomic_store	(	tree	val,
		enum omp_memory_order	mo )

Build a GIMPLE_OMP_ATOMIC_STORE statement.

VAL is the value we are storing.

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

Referenced by create_call_for_reduction_1(), and gimplify_omp_atomic().

◆ gimple_build_omp_continue()

gomp_continue * gimple_build_omp_continue	(	tree	control_def,

Data Structures

Macros

Typedefs

Enumerations

Functions

Variables

Macro Definition Documentation

◆ CASE_GIMPLE_OMP

◆ DEFGSCODE

◆ DEFGSSTRUCT

◆ gcc_gimple_checking_assert

◆ GIMPLE_CHECK

◆ GIMPLE_DEBUG_BIND_NOVALUE

◆ GTMA_DECLARATION_MASK

◆ GTMA_DOES_GO_IRREVOCABLE

◆ GTMA_HAS_NO_INSTRUMENTATION

◆ GTMA_HAVE_ABORT

◆ GTMA_HAVE_LOAD

◆ GTMA_HAVE_STORE

◆ GTMA_IS_OUTER

◆ GTMA_IS_RELAXED

◆ GTMA_MAY_ENTER_IRREVOCABLE

Typedef Documentation

◆ elt_t

◆ gimple_seq_node

Enumeration Type Documentation

◆ gf_mask

◆ gimple_alloc_kind

◆ gimple_code

◆ gimple_debug_subcode

◆ gimple_rhs_class

◆ gimple_statement_structure_enum

◆ gimple_try_flags

◆ plf_mask

Function Documentation

◆ annotate_all_with_location()

◆ annotate_all_with_location_after()

◆ bb_seq()

◆ bb_seq_addr()

◆ copy_warning() [1/3]

◆ copy_warning() [2/3]

◆ copy_warning() [3/3]

◆ dump_decl_set()

◆ dump_gimple_statistics()

◆ empty_body_p()

◆ get_gimple_rhs_class()

◆ get_gimple_rhs_num_ops()

◆ get_lineno()

◆ gimple_alloc()

◆ gimple_alloc_kind()

◆ gimple_arg()

◆ gimple_arg_ptr()

◆ gimple_asm_basic_p()

◆ gimple_asm_clobber_op()

◆ gimple_asm_clobbers_memory_p()

◆ gimple_asm_inline_p()

◆ gimple_asm_input_op()

◆ gimple_asm_label_op()

◆ gimple_asm_nclobbers()

◆ gimple_asm_ninputs()

◆ gimple_asm_nlabels()

◆ gimple_asm_noutputs()

◆ gimple_asm_output_op()

◆ gimple_asm_set_basic()

◆ gimple_asm_set_clobber_op()

◆ gimple_asm_set_inline()

◆ gimple_asm_set_input_op()

◆ gimple_asm_set_label_op()

◆ gimple_asm_set_output_op()

◆ gimple_asm_set_volatile()

◆ gimple_asm_string()

◆ gimple_asm_volatile_p()

◆ gimple_assign_cast_p()

◆ gimple_assign_copy_p()

◆ gimple_assign_lhs() [1/2]

◆ gimple_assign_lhs() [2/2]

◆ gimple_assign_lhs_ptr() [1/2]

◆ gimple_assign_lhs_ptr() [2/2]

◆ gimple_assign_load_p()

◆ gimple_assign_nontemporal_move_p()