GCC Middle and Back End API Reference
Data Structures | Macros | Typedefs | Enumerations | Functions | Variables
gimple.h File Reference
#include "tree-ssa-alias.h"
#include "gimple-expr.h"
#include "gimple.def"
#include "gsstruct.def"
Include dependency graph for gimple.h:

Go to the source code of this file.

Data Structures

struct  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_dispatch (gimple_seq, tree)
 
gimple * gimple_build_omp_interop (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, tree *=NULL)
 
void sort_case_labels (vec< tree > &)
 
void preprocess_case_label_vec_for_gimple (vec< tree > &, tree, tree *)
 
void gimple_seq_set_location (gimple_seq, location_t)
 
void gimple_seq_discard (gimple_seq)
 
void maybe_remove_unused_call_args (struct function *, gimple *)
 
bool gimple_inexpensive_call_p (gcall *)
 
bool stmt_can_terminate_bb_p (gimple *)
 
location_t gimple_or_expr_nonartificial_location (gimple *, tree)
 
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 (const gcall *s)
 
static void gimple_call_set_expected_throw (gcall *s, bool expected_throw_p)
 
static bool gimple_call_expected_throw_p (gcall *s)
 
void gimple_call_set_alloca_for_var (gcall *s, bool for_var)
 
bool gimple_call_alloca_for_var_p (gcall *s)
 
bool gimple_call_alloca_for_var_p (gimple *s)
 
void gimple_call_set_by_descriptor (gcall *s, bool by_descriptor_p)
 
bool gimple_call_by_descriptor_p (gcall *s)
 
void gimple_call_copy_flags (gcall *dest_call, gcall *orig_call)
 
struct pt_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_true_canonical_p (const gcond *gs)
 
bool gimple_cond_false_p (const gcond *gs)
 
bool gimple_cond_false_canonical_p (const gcond *gs)
 
void gimple_cond_set_condition (gcond *stmt, enum tree_code code, tree lhs, tree rhs)
 
enum tree_code gimple_expr_code (const gimple *stmt)
 
tree gimple_label_label (const glabel *gs)
 
void gimple_label_set_label (glabel *gs, tree label)
 
tree gimple_goto_dest (const gimple *gs)
 
void gimple_goto_set_dest (ggoto *gs, tree dest)
 
tree gimple_bind_vars (const gbind *bind_stmt)
 
void gimple_bind_set_vars (gbind *bind_stmt, tree vars)
 
void gimple_bind_append_vars (gbind *bind_stmt, tree vars)
 
gimple_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)
 
tree gimple_omp_dispatch_clauses (const gimple *gs)
 
tree * gimple_omp_dispatch_clauses_ptr (gimple *gs)
 
void gimple_omp_dispatch_set_clauses (gimple *gs, tree clauses)
 
tree gimple_omp_interop_clauses (const gimple *gs)
 
tree * gimple_omp_interop_clauses_ptr (gimple *gs)
 
void gimple_omp_interop_set_clauses (gimple *gs, tree clauses)
 
int gimple_omp_for_kind (const gimple *g)
 
void gimple_omp_for_set_kind (gomp_for *g, int kind)
 
bool gimple_omp_for_combined_p (const gimple *g)
 
void gimple_omp_for_set_combined_p (gomp_for *g, bool combined_p)
 
bool gimple_omp_for_combined_into_p (const gimple *g)
 
void gimple_omp_for_set_combined_into_p (gomp_for *g, bool combined_p)
 
tree gimple_omp_for_clauses (const gimple *gs)
 
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_DISPATCH: \
case GIMPLE_OMP_INTEROP: \
case GIMPLE_OMP_SECTION: \
case GIMPLE_OMP_STRUCTURED_BLOCK: \
case GIMPLE_OMP_MASTER: \
case GIMPLE_OMP_MASKED: \
case GIMPLE_OMP_TASKGROUP: \
case GIMPLE_OMP_ORDERED: \
case GIMPLE_OMP_CRITICAL: \
case GIMPLE_OMP_SCAN: \
case GIMPLE_OMP_RETURN: \
case GIMPLE_OMP_ATOMIC_LOAD: \
case GIMPLE_OMP_ATOMIC_STORE: \
case GIMPLE_OMP_CONTINUE
Returns true when the gimple statement STMT is any of the OMP types.

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

◆ DEFGSCODE

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

◆ DEFGSSTRUCT

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

◆ gcc_gimple_checking_assert

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

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

◆ GIMPLE_CHECK

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

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

◆ GIMPLE_DEBUG_BIND_NOVALUE

#define GIMPLE_DEBUG_BIND_NOVALUE   NULL_TREE /* 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 dump_gimple_transaction(), 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-2025 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-2025 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-2025 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-2025 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 )

References 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_bitint_stmt_ssa_conflicts(), build_ssa_conflict_graph(), exist_non_indexing_operands_for_use_p(), pcom_worker::find_use_stmt(), gimple_lower_bitint(), 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.

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

◆ 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(), decode_field_reference(), eliminate_dom_walker::eliminate_stmt(), estimate_num_insns(), fold_stmt_1(), ipa_polymorphic_call_context::get_dynamic_type(), get_mem_ref_of_assignment(), gimple_convert_def_p(), 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(), make_bit_field_load(), 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.

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

◆ gimple_assign_rhs1() [2/2]

tree gimple_assign_rhs1 ( const gimple * gs)
inline

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 strlen_pass::adjust_last_stmt(), adjust_pointer_diff_expr(), aff_combination_expand(), analyze_agg_content_value(), analyze_and_compute_bitop_with_inv_effect(), and_var_with_comparison_1(), ao_ref_init_from_ptr_and_range(), arith_overflow_check_p(), bb_no_side_effects_p(), find_candidates_dom_walker::before_dom_children(), blend_vec_perm_simplify_seqs(), branch_fixup(), break_up_subtract(), break_up_subtract_bb(), addsub_pattern::build(), crc_optimization::can_be_crc_shift(), can_interpret_as_conditional_op_p(), ccmp_candidate_p(), check_all_va_list_escapes(), check_for_plus_in_loops(), check_for_plus_in_loops_1(), check_redundant_cond_expr(), check_retval_uses(), check_scan_store(), 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(), crc_symbolic_execution::execute_assign_statement(), execute_cse_reciprocals_1(), crc_optimization::exists_shift_for_opp_xor_shift(), expand_ccmp_expr_1(), expand_complex_move(), expand_complex_operations_1(), expand_cond_expr_using_cmove(), expand_expr_real_1(), expand_expr_real_2(), expand_expr_real_gassign(), expand_gimple_cond(), expand_omp_atomic_cas(), expand_omp_atomic_fetch_op(), expand_simple_operations(), expand_single_bit_test(), expand_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_known_nonzero_bits(), get_nonzero_bits(), get_ops(), get_pred_info_from_cmp(), get_range_strlen(), get_reassociation_width(), access_ref::get_ref(), get_stridx(), get_val_for(), gimple_assign_integer_valued_real_p(), gimple_assign_nonnegative_warnv_p(), gimple_assign_rhs2(), gimple_assign_rhs_to_tree(), gimple_binop_def_p(), gimple_bitwise_inverted_equal_p(), gimple_could_trap_p_1(), gimple_divmod_fixed_value(), gimple_divmod_fixed_value_transform(), gimple_divmod_values_to_profile(), gimple_expand_vec_cond_expr(), gimple_extract(), gimple_fold_stmt_to_constant_1(), gimple_lower_bitint(), gimple_mod_pow2(), gimple_mod_pow2_value_transform(), gimple_mod_subtract(), gimple_range_ssa_names(), strlen_pass::handle_builtin_memcpy(), strlen_pass::handle_integral_assign(), handle_min_max_size(), strlen_pass::handle_pointer_plus(), handle_ssa_name(), infer_loop_bounds_from_pointer_arith(), access_ref::inform_access(), init_dont_simulate_again(), init_range_entry(), insert_backedge_copies(), insert_predicates_for_cond(), insert_stmt_before_use(), instantiate_scev_name(), instrument_object_size(), instrument_si_overflow(), interpret_gimple_assign(), interpret_rhs_expr(), ipa_analyze_indirect_call_uses(), is_addr_local(), is_cond_scalar_reduction(), is_division_by(), is_division_by_square(), is_divmod_with_given_divisor(), is_lshift_by_1(), is_mult_by(), is_reassociable_op(), is_rshift_by_1(), is_strlen_related_p(), is_widening_mult_p(), is_widening_mult_rhs_p(), linearize_expr(), linearize_expr_tree(), 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(), recognise_vec_perm_simplify_seq(), recognize_bits_test(), recognize_single_bit_test(), record_equivalences_from_stmt(), record_increment(), fur_relation::register_relation(), remove_name_from_operation(), replace_mult_candidate(), replace_one_candidate(), repropagate_negates(), rewrite_bittest(), rewrite_expr_tree(), rewrite_reciprocal(), rewrite_use_nonlinear_expr(), rhs_is_fed_for_value_replacement(), rhs_to_tree(), same_bool_comparison_p(), scan_operand_equal_p(), crc_optimization::set_defs(), should_break_up_subtract(), should_duplicate_loop_header_p(), simplify_using_ranges::simplify(), simplify_1a(), predicate::simplify_4(), avail_exprs_stack::simplify_binary_operation(), simplify_using_ranges::simplify_bit_ops_using_ranges(), simplify_builtin_call(), simplify_using_ranges::simplify_compare_assign_using_ranges_1(), simplify_using_ranges::simplify_div_or_mod_using_ranges(), simplify_using_ranges::simplify_min_or_max_using_ranges(), simplify_permutation(), simplify_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_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(), crc_optimization::xor_calculates_crc(), 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 calc_perm_vec_perm_simplify_seqs(), 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_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(), recognise_vec_perm_simplify_seq(), rhs_to_tree(), simplify_permutation(), thread_private_new_memory(), vect_recog_bit_insert_pattern(), vect_recog_bool_pattern(), vect_recog_mask_conversion_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.

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

◆ gimple_assign_rhs_code() [2/2]

enum tree_code gimple_assign_rhs_code ( const gimple * gs)
inline

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_unconditional(), 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 blend_vec_perm_simplify_seqs(), 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_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(), rewrite_to_defined_unconditional(), simplify_using_ranges::simplify_abs_using_ranges(), 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 blend_vec_perm_simplify_seqs(), 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(), 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 blend_vec_perm_simplify_seqs(), gimple_assign_set_rhs3(), gimple_assign_set_rhs_with_ops(), gimple_build_assign_1(), lower_vec_perm(), and narrow_vec_perm_simplify_seq().

◆ 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_unconditional(), 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_to_memset(), 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_vptr_store(), load_from_unmodified_param(), lower_sequence_tm(), mark_all_reaching_defs_necessary_1(), may_propagate_copy_into_stmt(), maybe_get_single_definition(), maybe_instrument_assignment(), maybe_remove_writeonly_store(), ipa_param_body_adjustments::modify_assignment(), movement_possibility_1(), vars_ssa_cache::operator()(), optimize_memcpy_to_memset(), 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.

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

◆ gimple_bind_add_seq()

void gimple_bind_add_seq ( gbind * bind_stmt,
gimple_seq seq )
inline 
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_dispatch(), lower_omp_for(), lower_omp_interop(), 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_dispatch(), lower_omp_for(), lower_omp_interop(), 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 )

References CXX_MEM_STAT_INFO.

◆ gimple_build_assign() [2/4]

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

References CXX_MEM_STAT_INFO.

◆ gimple_build_assign() [3/4]

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

References CXX_MEM_STAT_INFO.

◆ gimple_build_assign() [4/4]

gassign * gimple_build_assign ( tree ,
tree CXX_MEM_STAT_INFO )

References 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_dispatch(), gimplify_omp_for(), gimplify_switch_expr(), lower_assumption(), lower_omp_critical(), lower_omp_dispatch(), lower_omp_for(), lower_omp_interop(), 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.

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

◆ gimple_build_call_from_tree()

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.

References ALLOCA_FUNCTION_CODE_P, BUILT_IN_NORMAL, CALL_ALLOCA_FOR_VAR_P, CALL_EXPR_ARG, CALL_EXPR_BY_DESCRIPTOR, CALL_EXPR_FN, CALL_EXPR_IFN, CALL_EXPR_MUST_TAIL_CALL, call_expr_nargs, CALL_EXPR_RETURN_SLOT_OPT, CALL_EXPR_STATIC_CHAIN, CALL_EXPR_TAILCALL, CALL_EXPR_VA_ARG_PACK, CALL_FROM_NEW_OR_DELETE_P, CALL_FROM_THUNK_P, copy_warning(), DECL_FUNCTION_CODE(), DECL_IS_OPERATOR_DELETE_P, DECL_IS_OPERATOR_NEW_P, ECF_XTHROW, EXPR_LOCATION, flags_from_decl_or_type(), fndecl_built_in_p(), gcc_assert, get_callee_fndecl(), gimple_build_call_1(), gimple_build_call_internal_1(), gimple_call_set_alloca_for_var(), gimple_call_set_arg(), gimple_call_set_by_descriptor(), gimple_call_set_chain(), gimple_call_set_expected_throw(), gimple_call_set_fntype(), gimple_call_set_from_new_or_delete(), gimple_call_set_from_thunk(), gimple_call_set_must_tail(), gimple_call_set_nocf_check(), gimple_call_set_nothrow(), gimple_call_set_return_slot_opt(), gimple_call_set_tail(), gimple_call_set_va_arg_pack(), gimple_set_block(), gimple_set_location(), i, lookup_attribute(), NULL_TREE, POINTER_TYPE_P, TREE_BLOCK, TREE_CODE, TREE_NOTHROW, TREE_TYPE, and TYPE_ATTRIBUTES.

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.

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

◆ 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(), expand_omp_metadirective(), gen_one_condition(), gimple_lv_add_condition_to_bb(), gimplify_omp_dispatch(), 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 )

References CXX_MEM_STAT_INFO.

◆ gimple_build_debug_bind()

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

References CXX_MEM_STAT_INFO.

◆ gimple_build_debug_inline_entry()

gdebug * gimple_build_debug_inline_entry ( tree ,
location_t CXX_MEM_STAT_INFO )

References all_warnings, copy_warning(), CXX_MEM_STAT_INFO, and NULL.

◆ gimple_build_debug_source_bind()

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

References 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(), expand_omp_metadirective(), frob_into_branch_around(), gimplify_cond_expr(), gimplify_expr(), gimplify_init_ctor_eval_range(), gimplify_loop_expr(), gimplify_omp_dispatch(), 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(), expand_omp_metadirective(), 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_dispatch(), 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,
tree control_use ) 
Build a GIMPLE_OMP_CONTINUE statement.

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

References as_a(), gimple_alloc(), gimple_omp_continue_set_control_def(), and gimple_omp_continue_set_control_use().

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

◆ gimple_build_omp_critical()

gomp_critical * gimple_build_omp_critical ( gimple_seq body,
tree name,
tree clauses ) 
Build a GIMPLE_OMP_CRITICAL statement.

BODY is the sequence of statements for which only one thread can execute.
NAME is optional identifier for this critical block.
CLAUSES are clauses for this critical block.

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

Referenced by gimplify_expr(), and remap_gimple_stmt().

◆ gimple_build_omp_dispatch()

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

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

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

Referenced by gimplify_omp_dispatch(), and remap_gimple_stmt().

◆ gimple_build_omp_for()

gomp_for * gimple_build_omp_for ( gimple_seq body,
int kind,
tree clauses,
size_t collapse,
gimple_seq pre_body ) 
Build a GIMPLE_OMP_FOR statement.

BODY is sequence of statements inside the for loop.
KIND is the `for' variant.
CLAUSES are any of the construct's clauses.
COLLAPSE is the collapse count.
PRE_BODY is the sequence of statements that are loop invariant.

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

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

◆ gimple_build_omp_interop()

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

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

References gimple_alloc(), and gimple_omp_interop_set_clauses().

Referenced by gimplify_omp_interop().

◆ gimple_build_omp_masked()

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

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

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

Referenced by gimplify_expr(), and remap_gimple_stmt().

◆ gimple_build_omp_master()

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

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

References gimple_alloc(), and gimple_omp_set_body().

Referenced by gimplify_expr(), and remap_gimple_stmt().

◆ gimple_build_omp_ordered()

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

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

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

Referenced by gimplify_omp_ordered(), and remap_gimple_stmt().

◆ gimple_build_omp_parallel()

gomp_parallel * gimple_build_omp_parallel ( gimple_seq body,
tree clauses,
tree child_fn,
tree data_arg ) 
Build a GIMPLE_OMP_PARALLEL statement.

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

References as_a(), gimple_alloc(), gimple_omp_parallel_set_child_fn(), gimple_omp_parallel_set_clauses(), gimple_omp_parallel_set_data_arg(), and gimple_omp_set_body().

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

◆ gimple_build_omp_return()

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

References gimple_alloc(), and gimple_omp_return_set_nowait().

Referenced by create_parallel_loop(), lower_omp_critical(), lower_omp_for(), lower_omp_for_scan(), lower_omp_master(), lower_omp_ordered(), lower_omp_scope(), lower_omp_sections(), lower_omp_single(), lower_omp_target(), lower_omp_taskreg(), and lower_omp_teams().

◆ gimple_build_omp_scan()

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

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

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

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

◆ gimple_build_omp_scope()

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

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

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

Referenced by gimplify_omp_workshare(), and remap_gimple_stmt().

◆ gimple_build_omp_section()

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

BODY is the sequence of statements in the section.

References gimple_alloc(), and gimple_omp_set_body().

Referenced by gimplify_expr(), and remap_gimple_stmt().

◆ gimple_build_omp_sections()

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

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

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

Referenced by gimplify_omp_workshare(), and remap_gimple_stmt().

◆ gimple_build_omp_sections_switch()

gimple * gimple_build_omp_sections_switch ( void ) 
Build a GIMPLE_OMP_SECTIONS_SWITCH.

References gimple_alloc().

Referenced by lower_omp_sections().

◆ gimple_build_omp_single()

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

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

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

Referenced by gimplify_omp_workshare(), and remap_gimple_stmt().

◆ gimple_build_omp_structured_block()

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

BODY is the structured block sequence.

References gimple_alloc(), and gimple_omp_set_body().

Referenced by gimplify_expr(), and remap_gimple_stmt().

◆ gimple_build_omp_target()

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

BODY is the sequence of statements that will be executed.
KIND is the kind of the region.
CLAUSES are any of the construct's clauses.

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

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

◆ gimple_build_omp_task()

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

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

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

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

◆ gimple_build_omp_taskgroup()

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

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

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

Referenced by gimplify_expr(), and remap_gimple_stmt().

◆ gimple_build_omp_teams()

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

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

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

Referenced by gimplify_omp_workshare(), and remap_gimple_stmt().

◆ gimple_build_resx()

gresx * gimple_build_resx ( int region) 
Build a GIMPLE_RESX statement.

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

Referenced by emit_resx(), and gsi_insert_finally_seq_after_call().

◆ gimple_build_return()

greturn * gimple_build_return ( tree retval) 
Build a GIMPLE_RETURN statement returning RETVAL.

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

Referenced by expand_omp_target(), expand_omp_taskreg(), expand_thunk(), gimplify_return_expr(), lower_assumption(), lower_function_body(), simd_clone_adjust(), and split_function().

◆ gimple_build_switch()

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

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

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

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

◆ gimple_build_switch_nlabels()

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

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

Referenced by gimple_build_switch().

◆ gimple_build_transaction()

gtransaction * gimple_build_transaction ( gimple_seq body) 
Build a GIMPLE_TRANSACTION statement.

References as_a(), gimple_alloc(), gimple_transaction_set_body(), gimple_transaction_set_label_norm(), gimple_transaction_set_label_over(), and gimple_transaction_set_label_uninst().

Referenced by gimplify_transaction(), and remap_gimple_stmt().

◆ gimple_build_try()

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

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

References as_a(), gcc_assert, gimple_alloc(), gimple_set_subcode(), GIMPLE_TRY_CATCH, GIMPLE_TRY_FINALLY, gimple_try_set_cleanup(), and gimple_try_set_eval().

Referenced by finalize_nesting_tree_1(), gimplify_bind_expr(), gimplify_body(), gimplify_cleanup_point_expr(), gimplify_expr(), gimplify_function_tree(), gimplify_omp_workshare(), honor_protect_cleanup_actions(), lower_transaction(), make_data_region_try_statement(), maybe_build_inner_data_region(), maybe_catch_exception(), and remap_gimple_stmt().

◆ gimple_build_wce()

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

CLEANUP is the cleanup expression.

References gimple_alloc(), and gimple_wce_set_cleanup().

Referenced by gimple_push_cleanup(), and remap_gimple_stmt().

◆ gimple_builtin_call_types_compatible_p()

bool gimple_builtin_call_types_compatible_p ( const gimple * stmt,
tree fndecl )
extern 
Return true when STMTs arguments and return value match those of FNDECL,
a decl of a builtin function.

References BUILT_IN_NORMAL, builtin_decl_explicit(), DECL_BUILT_IN_CLASS, DECL_FUNCTION_CODE(), gcc_checking_assert, gimple_call_arg(), gimple_call_lhs(), gimple_call_num_args(), i, NOT_BUILT_IN, TREE_CHAIN, TREE_TYPE, TREE_VALUE, TYPE_ARG_TYPES, useless_type_conversion_p(), and VOID_TYPE_P.

Referenced by gimple_call_builtin_p(), gimple_call_builtin_p(), gimple_call_builtin_p(), gimple_call_combined_fn(), gimple_extract(), gimple_fold_stmt_to_constant_1(), and lower_stmt().

◆ gimple_call_alloca_for_var_p() [1/2]

bool gimple_call_alloca_for_var_p ( gcall * s)
inline 
Return true of S is a call to builtin_alloca emitted for VLA objects.

References GF_CALL_ALLOCA_FOR_VAR, and gimple::subcode.

Referenced by ipa_icf_gimple::func_checker::compare_gimple_call(), pass_walloca::execute(), expand_call_inline(), expand_call_stmt(), gimple_fold_builtin_memory_op(), and inline_forbidden_p_stmt().

◆ gimple_call_alloca_for_var_p() [2/2]

bool gimple_call_alloca_for_var_p ( gimple * s)
inline

References GF_CALL_ALLOCA_FOR_VAR, GIMPLE_CHECK2(), and gimple::subcode.

◆ gimple_call_arg() [1/2]

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

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

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

◆ gimple_call_arg() [2/2]

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

References gimple_call_arg(), and GIMPLE_CHECK2().

◆ gimple_call_arg_flags()

int gimple_call_arg_flags ( const gcall * stmt,
unsigned arg ) 
Detects argument flags for argument number ARG on call STMT.

References attr_fnspec::arg_eaf_flags(), modref_summary::arg_flags, symtab_node::binds_to_current_def_p(), dbg_cnt(), cgraph_node::get(), get_modref_function_summary(), gimple_call_fndecl(), gimple_call_fnspec(), interposable_eaf_flags(), attr_fnspec::known_p(), and NULL.

Referenced by handle_rhs_call(), maybe_warn_pass_by_reference(), ref_maybe_used_by_call_p_1(), scan_function(), and sra_modify_function_body().

◆ gimple_call_arg_ptr() [1/2]

tree * gimple_call_arg_ptr ( gcall * gs,
unsigned index )
inline 
Return a pointer to the argument at position INDEX for call
statement GS.

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

Referenced by check_reduction_path(), convert_tramp_reference_stmt(), copy_bb(), decrement_count(), execute_update_addresses_taken(), fold_call_stmt(), fold_stmt_1(), get_alias_ptr_type_for_ptr_address(), get_mem_type_for_internal_fn(), gimple_arg_ptr(), gimple_call_arg_ptr(), increment_start_addr(), maybe_trim_memstar_call(), ipa_param_body_adjustments::modify_call_stmt(), oacc_loop_xform_head_tail(), ompdevlow_adjust_simt_enter(), sra_modify_function_body(), vect_is_simple_reduction(), and walk_gimple_op().

◆ gimple_call_arg_ptr() [2/2]

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

References gimple_call_arg_ptr(), and GIMPLE_CHECK2().

◆ gimple_call_builtin_p() [1/3]

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

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

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

◆ gimple_call_builtin_p() [2/3]

bool gimple_call_builtin_p ( const gimple * stmt,
enum built_in_class klass )
extern 
Return true when STMT is builtins call to CLASS.

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

◆ gimple_call_builtin_p() [3/3]

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

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

◆ gimple_call_by_descriptor_p()

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

References GF_CALL_BY_DESCRIPTOR, and gimple::subcode.

Referenced by expand_call_stmt().

◆ gimple_call_chain() [1/2]

tree gimple_call_chain ( const gcall * gs)
inline 
Return the static chain for call statement GS.

References gcall::op.

Referenced by ipa_icf_gimple::func_checker::compare_gimple_call(), convert_gimple_call(), copy_reference_ops_from_call(), dump_gimple_call(), expand_call_stmt(), find_func_aliases_for_call(), modref_access_node::get_call_arg(), gimple_call_chain(), gimple_call_copy_skip_args(), gimple_equal_p(), gimple_fold_call(), handle_rhs_call(), initialize_inlined_parameters(), ipa_param_adjustments::modify_call(), ipa_param_body_adjustments::modify_call_stmt(), cgraph_edge::redirect_call_stmt_to_callee(), same_handler_p(), same_succ_hash(), scan_function(), sra_modify_function_body(), vect_build_slp_tree_1(), verify_gimple_call(), and walk_stmt_load_store_addr_ops().

◆ gimple_call_chain() [2/2]

tree gimple_call_chain ( const gimple * gs)
inline

References gimple_call_chain(), and GIMPLE_CHECK2().

◆ gimple_call_chain_ptr()

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

References gcall::op.

Referenced by sra_modify_function_body(), and walk_gimple_op().

◆ gimple_call_clobber_set() [1/2]

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

References gcall::call_clobbered.

◆ gimple_call_clobber_set() [2/2]

struct pt_solution * gimple_call_clobber_set ( gcall * call_stmt)
inline 
Return a pointer to the points-to solution for the set of call-used
variables of the call CALL_STMT.

References gcall::call_clobbered.

Referenced by call_may_clobber_ref_p_1(), compute_points_to_sets(), dump_gimple_call(), ipa_icf::sem_item_optimizer::fixup_points_to_sets(), gimple_call_reset_alias_info(), and ipa_pta_execute().

◆ gimple_call_combined_fn()

combined_fn gimple_call_combined_fn ( const gimple * stmt)
extern 
If CALL is a call to a combined_fn (i.e. an internal function or
a normal built-in function), return its code, otherwise return
CFN_LAST.

References as_combined_fn(), BUILT_IN_NORMAL, DECL_FUNCTION_CODE(), dyn_cast(), fndecl_built_in_p(), gimple_builtin_call_types_compatible_p(), gimple_call_fndecl(), gimple_call_internal_fn(), and gimple_call_internal_p().

Referenced by acceptable_pow_call(), attempt_builtin_copysign(), compatible_calls_p(), cond_removal_in_builtin_zero_pattern(), decrement_power(), empty_bb_or_one_feeding_into_p(), execute_cse_sincos_1(), expand_complex_operations_1(), fold_stmt_1(), gimple_call_integer_valued_real_p(), gimple_call_nonnegative_warnv_p(), if_convertible_stmt_p(), init_dont_simulate_again(), internal_fn_reciprocal(), is_copysign_call_with_1(), match_single_bit_test(), gimple_range_op_handler::maybe_builtin_call(), optimize_recip_sqrt(), replace_stmt_with_simplification(), vect_optimize_slp_pass::start_choosing_layouts(), stmt_is_power_of_op(), vect_build_slp_tree_1(), vect_recog_ctz_ffs_pattern(), vect_recog_popcount_clz_ctz_ffs_pattern(), vect_recog_pow_pattern(), vect_widened_op_tree(), and vectorizable_call().

◆ gimple_call_copy_flags()

void gimple_call_copy_flags ( gcall * dest_call,
gcall * orig_call )
inline 
Copy all the GF_CALL_* flags from ORIG_CALL to DEST_CALL.

References gimple::subcode.

Referenced by copy_bb(), gimple_call_copy_skip_args(), ipa_param_adjustments::modify_call(), and ipa_param_body_adjustments::modify_call_stmt().

◆ gimple_call_copy_skip_args()

gcall * gimple_call_copy_skip_args ( gcall * stmt,
bitmap args_to_skip ) 
Build a GIMPLE_CALL identical to STMT but skipping the arguments in
the positions marked by the set ARGS_TO_SKIP.

References bitmap_bit_p, gimple_build_call_internal_vec(), gimple_build_call_vec(), gimple_call_arg(), gimple_call_chain(), gimple_call_copy_flags(), gimple_call_fn(), gimple_call_internal_fn(), gimple_call_internal_p(), gimple_call_lhs(), gimple_call_num_args(), gimple_call_set_chain(), gimple_call_set_lhs(), gimple_has_location(), gimple_location(), gimple_set_location(), gimple_set_modified(), gimple_set_vdef(), gimple_set_vuse(), gimple_vdef(), gimple_vuse(), and i.

◆ gimple_call_ctrl_altering_p() [1/2]

bool gimple_call_ctrl_altering_p ( const gcall * gs)
inline 
Return true if call GS calls an func whose GF_CALL_CTRL_ALTERING
flag is set. Such call could not be a stmt in the middle of a bb.

References GF_CALL_CTRL_ALTERING, and gimple::subcode.

Referenced by cleanup_call_ctrl_altering_flag(), ipa_icf_gimple::func_checker::compare_gimple_call(), dse_optimize_call(), fixup_noreturn_call(), gimple_call_ctrl_altering_p(), if_convertible_bb_p(), is_ctrl_altering_stmt(), mark_stmt_if_obviously_necessary(), and verify_gimple_call().

◆ gimple_call_ctrl_altering_p() [2/2]

bool gimple_call_ctrl_altering_p ( const gimple * gs)
inline

References gimple_call_ctrl_altering_p(), and GIMPLE_CHECK2().

◆ gimple_call_expected_throw_p()

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

References ECF_XTHROW, and gimple_call_flags().

Referenced by always_throwing_noreturn_call_p().

◆ gimple_call_flags()

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

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

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

◆ gimple_call_fn() [1/2]

tree gimple_call_fn ( const gcall * gs)
inline 
Return the tree node representing the function called by call
statement GS.

References gcall::op.

Referenced by inchash::add_hashable_expr(), autofdo::afdo_indirect_call(), autofdo::afdo_vpt_for_early_inline(), ipa_icf_gimple::func_checker::compare_gimple_call(), compatible_calls_p(), copy_bb(), copy_reference_ops_from_call(), cgraph_node::create_indirect_edge(), diagnose_tm_1(), distinctify_node_type(), dump_gimple_call(), dump_ic_profile(), dump_transformation(), dynamic_object_sizes_execute_one(), effective_strub_mode_for_call(), eliminate_dom_walker::eliminate_stmt(), execute_omp_device_lower(), expand_call_stmt(), expand_call_tm(), ipa_polymorphic_call_context::get_dynamic_type(), get_fi_for_callee(), gimple_call_copy_skip_args(), gimple_call_fn(), gimple_call_fndecl(), gimple_call_same_target_p(), gimple_extract(), gimple_fold_call(), gimple_fold_stmt_to_constant_1(), gimple_ic(), gimple_indirect_call_to_profile(), autofdo::has_indirect_call(), access_ref::inform_access(), ipa_analyze_call_uses(), ipa_analyze_controlled_uses(), ipa_tm_insert_gettmclone_call(), ipa_tm_scan_irr_block(), ipa_param_body_adjustments::modify_call_stmt(), optimize_atomic_bit_test_and(), optimize_atomic_op_fetch_cmp_0(), possible_polymorphic_call_target_p(), predicate_statements(), expr_hash_elt::print(), same_succ_hash(), strub_call_fntype_override_p(), tm_memopt_transform_stmt(), tree_estimate_probability_bb(), var_is_used_for_virtual_call_p(), verify_bb_vtables(), verify_gimple_call(), visit_reference_op_call(), and visit_stmt().

◆ gimple_call_fn() [2/2]

tree gimple_call_fn ( const gimple * gs)
inline

References gimple_call_fn(), and GIMPLE_CHECK2().

◆ gimple_call_fn_ptr() [1/2]

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

References gcall::op.

Referenced by gimple_call_fn_ptr(), and walk_gimple_op().

◆ gimple_call_fn_ptr() [2/2]

tree * gimple_call_fn_ptr ( gimple * gs)
inline

References gimple_call_fn_ptr(), and GIMPLE_CHECK2().

◆ gimple_call_fndecl() [1/2]

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

References gimple_call_addr_fndecl(), and gimple_call_fn().

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

◆ gimple_call_fndecl() [2/2]

tree gimple_call_fndecl ( const gimple * gs)
inline

References gimple_call_fndecl(), and GIMPLE_CHECK2().

◆ gimple_call_fntype() [1/2]

tree gimple_call_fntype ( const gcall * gs)
inline 
Return the function type of the function called by GS.

References gcall::fntype, gimple_call_internal_p(), NULL_TREE, and gcall::u.

Referenced by alloc_object_size(), strlen_pass::check_and_optimize_call(), ipa_icf_gimple::func_checker::compare_gimple_call(), compatible_calls_p(), copy_bb(), copy_reference_ops_from_call(), do_warn_unused_result(), dse_optimize_stmt(), effective_strub_mode_for_call(), evaluate_stmt(), expand_call_stmt(), expand_expr_real_1(), find_func_aliases_for_call(), find_tail_calls(), fixup_noreturn_call(), ccp_folder::fold_stmt(), gimple_call_alloc_size(), gimple_call_flags(), gimple_call_fnspec(), gimple_call_fntype(), gimple_call_nonnull_result_p(), gimple_call_return_type(), gimple_fold_call(), gimple_infer_range::gimple_infer_range(), gimple_range_type(), has_stmt_been_instrumented_p(), infer_nonnull_range_by_attribute(), ipa_get_callee_param_type(), ipa_tm_insert_gettmclone_call(), maybe_instrument_call(), maybe_warn_pass_by_reference(), output_gimple_stmt(), cgraph_edge::redirect_call_stmt_to_callee(), stack_protect_return_slot_p(), surely_varying_stmt_p(), tree_profiling(), unlikely_executed_stmt_p(), vect_recog_rotate_pattern(), verify_gimple_call(), and warn_dealloc_offset().

◆ gimple_call_fntype() [2/2]

tree gimple_call_fntype ( const gimple * gs)
inline

References gimple_call_fntype(), and GIMPLE_CHECK2().

◆ gimple_call_from_new_or_delete()

bool gimple_call_from_new_or_delete ( const gcall * s)
inline 
Return true if GIMPLE_CALL S is a call to operator new or delete from
from a new or delete expression.

References GF_CALL_FROM_NEW_OR_DELETE, and gimple::subcode.

Referenced by ipa_icf_gimple::func_checker::compare_gimple_call(), eliminate_unnecessary_stmts(), find_func_aliases_for_call(), gimple_call_fnspec(), is_removable_allocation_p(), mark_all_reaching_defs_necessary_1(), and propagate_necessity().

◆ gimple_call_from_thunk_p()

bool gimple_call_from_thunk_p ( gcall * s)
inline 
Return true if GIMPLE_CALL S is a jump from a thunk.

References GF_CALL_FROM_THUNK, and gimple::subcode.

Referenced by ipa_icf_gimple::func_checker::compare_gimple_call(), expand_call_stmt(), and remap_gimple_stmt().

◆ gimple_call_internal_fn() [1/2]

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

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

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

◆ gimple_call_internal_fn() [2/2]

enum internal_fn gimple_call_internal_fn ( const gimple * gs)
inline

References gimple_call_internal_fn(), and GIMPLE_CHECK2().

◆ gimple_call_internal_p() [1/3]

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

References GF_CALL_INTERNAL, and gimple::subcode.

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

◆ gimple_call_internal_p() [2/3]

bool gimple_call_internal_p ( const gimple * gs)
inline

References gimple_call_internal_p(), and GIMPLE_CHECK2().

◆ gimple_call_internal_p() [3/3]

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

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

◆ gimple_call_internal_unique_p() [1/2]

bool gimple_call_internal_unique_p ( const gcall * gs)
inline 
Return true, if this internal gimple call is unique.

References gimple_call_internal_fn().

Referenced by cleanup_call_ctrl_altering_flag(), gimple_call_initialize_ctrl_altering(), gimple_call_internal_unique_p(), gimple_call_same_target_p(), gimple_can_duplicate_bb_p(), and jump_threader::record_temporary_equivalences_from_stmts_at_dest().

◆ gimple_call_internal_unique_p() [2/2]

bool gimple_call_internal_unique_p ( const gimple * gs)
inline

References gimple_call_internal_unique_p(), and GIMPLE_CHECK2().

◆ gimple_call_lhs() [1/2]

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

References gcall::op.

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

◆ gimple_call_lhs() [2/2]

tree gimple_call_lhs ( const gimple * gs)
inline

References gimple_call_lhs(), and GIMPLE_CHECK2().

◆ gimple_call_lhs_ptr() [1/2]

tree * gimple_call_lhs_ptr ( gcall * gs)
inline 
Return a pointer to the LHS of call statement GS.

References gcall::op.

Referenced by fold_stmt_1(), gimple_call_lhs_ptr(), ipa_param_body_adjustments::modify_call_stmt(), sra_modify_function_body(), and walk_gimple_op().

◆ gimple_call_lhs_ptr() [2/2]

tree * gimple_call_lhs_ptr ( gimple * gs)
inline

References gimple_call_lhs_ptr(), and GIMPLE_CHECK2().

◆ gimple_call_must_tail_p()

bool gimple_call_must_tail_p ( const gcall * s)
inline 
Return true if call statement has been marked as requiring
tail call optimization.

References GF_CALL_MUST_TAIL_CALL, and gimple::subcode.

Referenced by branch_prob(), ipa_icf_gimple::func_checker::compare_gimple_call(), dump_gimple_call(), expand_call_stmt(), find_tail_calls(), hardcfr_sibcall_search_block(), may_propagate_copy(), maybe_error_musttail(), notice_special_calls(), remap_gimple_stmt(), returning_call_p(), suitable_for_tail_call_opt_p(), and tree_optimize_tail_calls_1().

◆ gimple_call_nocf_check_p()

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

References GF_CALL_NOCF_CHECK, and gimple::subcode.

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

◆ gimple_call_nonnull_arg()

tree gimple_call_nonnull_arg ( gcall * call) 
If CALL returns a non-null result in an argument, return that arg.

References ERF_RETURN_ARG_MASK, ERF_RETURNS_ARG, gimple_call_arg(), gimple_call_fndecl(), gimple_call_num_args(), gimple_call_return_flags(), infer_nonnull_range_by_attribute(), NULL_TREE, and SSA_VAR_P.

Referenced by fold_using_range::range_of_call().

◆ gimple_call_nonnull_result_p()

bool gimple_call_nonnull_result_p ( gcall * call) 
Return true if call STMT is known to return a non-zero result.

References DECL_IS_OPERATOR_NEW_P, gimple_alloca_call_p(), gimple_call_fndecl(), gimple_call_fntype(), lookup_attribute(), TREE_CODE, TREE_NOTHROW, TREE_TYPE, and TYPE_ATTRIBUTES.

Referenced by fold_using_range::range_of_call().

◆ gimple_call_noreturn_p() [1/2]

bool gimple_call_noreturn_p ( const gcall * s)
inline 
Return true if S is a noreturn call.

References ECF_NORETURN, and gimple_call_flags().

Referenced by always_throwing_noreturn_call_p(), substitute_and_fold_dom_walker::before_dom_children(), cleanup_control_flow_bb(), eliminate_dom_walker::eliminate_stmt(), eliminate_tail_call(), execute_fixup_cfg(), expand_call_inline(), find_tail_calls(), gimple_call_noreturn_p(), gimple_fold_call(), gimple_stmt_may_fallthru(), gimplify_modify_expr(), gsi_insert_finally_seq_after_call(), hardcfr_sibcall_search_block(), make_edges_bb(), maybe_instrument_call(), dom_opt_dom_walker::optimize_stmt(), cgraph_edge::redirect_call_stmt_to_callee(), returning_call_p(), tree_bb_level_predictions(), tree_optimize_tail_calls_1(), vect_build_slp_tree_1(), and verify_gimple_call().

◆ gimple_call_noreturn_p() [2/2]

bool gimple_call_noreturn_p ( const gimple * s)
inline

References gimple_call_noreturn_p(), and GIMPLE_CHECK2().

◆ gimple_call_nothrow_p()

bool gimple_call_nothrow_p ( const gcall * s)
inline 
Return true if S is a nothrow call.

References ECF_NOTHROW, and gimple_call_flags().

Referenced by expand_call_stmt(), fold_builtin_atomic_compare_exchange(), gsi_insert_finally_seq_after_call(), ipa_tm_insert_gettmclone_call(), optimize_atomic_bit_test_and(), optimize_atomic_op_fetch_cmp_0(), stmt_could_throw_p(), and use_internal_fn().

◆ gimple_call_num_args() [1/2]

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

References gimple_num_ops().

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

◆ gimple_call_num_args() [2/2]

unsigned gimple_call_num_args ( const gimple * gs)
inline

References gimple_call_num_args(), and GIMPLE_CHECK2().

◆ gimple_call_operator_delete_p()

bool gimple_call_operator_delete_p ( const gcall * stmt)
extern 
Return true when STMT is operator a replaceable delete call.

References DECL_IS_OPERATOR_DELETE_P, gimple_call_fndecl(), and NULL_TREE.

Referenced by eliminate_unnecessary_stmts(), and propagate_necessity().

◆ gimple_call_reset_alias_info()

void gimple_call_reset_alias_info ( gcall * s) 
Reset alias information on call S.

References ECF_CONST, ECF_NOVOPS, ECF_PURE, gimple_call_clobber_set(), gimple_call_flags(), gimple_call_use_set(), and pt_solution_reset().

Referenced by gimple_build_call_1(), gimple_build_call_internal_1(), input_gimple_stmt(), and remap_gimple_stmt().

◆ gimple_call_retslot_flags()

int gimple_call_retslot_flags ( const gcall * stmt) 
Detects argument flags for return slot on call STMT.

References symtab_node::binds_to_current_def_p(), dbg_cnt(), cgraph_node::get(), get_modref_function_summary(), gimple_call_fndecl(), implicit_retslot_eaf_flags, interposable_eaf_flags(), NULL, and modref_summary::retslot_flags.

Referenced by handle_rhs_call().

◆ gimple_call_return_flags()

int gimple_call_return_flags ( const gcall * stmt) 
Detects return flags for the call STMT.

References ECF_MALLOC, ERF_NOALIAS, ERF_RETURNS_ARG, gimple_call_flags(), gimple_call_fnspec(), attr_fnspec::returns_arg(), and attr_fnspec::returns_noalias_p().

Referenced by decompose_param_expr(), evaluate_stmt(), find_func_aliases_for_builtin_call(), find_func_aliases_for_call(), find_tail_calls(), gimple_call_nonnull_arg(), pass_through_call(), and visit_stmt().

◆ gimple_call_return_slot_opt_p()

bool gimple_call_return_slot_opt_p ( const gcall * s)
inline 
Return true if S is marked for return slot optimization.

References GF_CALL_RETURN_SLOT_OPT, and gimple::subcode.

Referenced by ipa_icf_gimple::func_checker::compare_gimple_call(), dse_optimize_stmt(), dump_gimple_call(), expand_call_inline(), expand_call_stmt(), expand_call_tm(), handle_rhs_call(), and walk_stmt_load_store_addr_ops().

◆ gimple_call_return_type()

tree gimple_call_return_type ( const gcall * gs)
inline 
Return the type returned by call statement GS.

References gimple_call_fntype(), gimple_call_lhs(), NULL_TREE, and TREE_TYPE.

Referenced by dynamic_object_sizes_execute_one(), expand_call_stmt(), gimple_fold_builtin(), gimple_fold_stmt_to_constant_1(), init_tmp_var_with_call(), and vect_setup_realignment().

◆ gimple_call_same_target_p()

bool gimple_call_same_target_p ( const gimple * c1,
const gimple * c2 ) 
Return true if calls C1 and C2 are known to go to the same function.

References as_a(), gimple_call_fn(), gimple_call_fndecl(), gimple_call_internal_fn(), gimple_call_internal_p(), and gimple_call_internal_unique_p().

Referenced by same_succ::equal(), gimple_equal_p(), hashable_expr_equal_p(), and same_handler_p().

◆ gimple_call_set_alloca_for_var()

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

References GF_CALL_ALLOCA_FOR_VAR, and gimple::subcode.

Referenced by gimple_build_call_from_tree(), and gimplify_modify_expr_to_memcpy().

◆ gimple_call_set_arg() [1/2]

void gimple_call_set_arg ( gcall * gs,
unsigned index,
tree arg )
inline 
Set ARG to be the argument at position INDEX for call statement GS.

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

Referenced by strlen_pass::adjust_last_stmt(), decrement_power(), execute_omp_device_lower(), execute_update_addresses_taken(), expand_call_inline(), ccp_folder::fold_stmt(), fold_stmt_1(), get_string_length(), gimple_build_call(), gimple_build_call_from_tree(), gimple_build_call_internal(), gimple_build_call_internal_vec(), gimple_build_call_valist(), gimple_build_call_vec(), gimple_call_set_arg(), gimple_fold_builtin_memory_op(), gimple_fold_builtin_snprintf_chk(), gimple_fold_builtin_sprintf_chk(), gimple_stringop_fixed_value(), lower_builtin_posix_memalign(), lower_eh_constructs_2(), lower_oacc_head_tail(), lower_omp_target(), maybe_trim_memstar_call(), move_sese_region_to_fn(), move_stmt_r(), oacc_loop_process(), optimize_memcpy_to_memset(), remap_gimple_stmt(), replace_stmt_with_simplification(), simplify_builtin_call(), sra_modify_deferred_init(), version_loop_by_alias_check(), version_loop_for_if_conversion(), and vn_reference_lookup_3().

◆ gimple_call_set_arg() [2/2]

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

References gimple_call_set_arg(), and GIMPLE_CHECK2().

◆ gimple_call_set_by_descriptor()

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

References GF_CALL_BY_DESCRIPTOR, and gimple::subcode.

Referenced by gimple_build_call_from_tree().

◆ gimple_call_set_chain()

void gimple_call_set_chain ( gcall * call_stmt,
tree chain )
inline 
Set CHAIN to be the static chain for call statement CALL_STMT.

References gcall::op.

Referenced by convert_gimple_call(), create_expression_by_pieces(), expand_thunk(), gimple_build_call_from_tree(), gimple_call_copy_skip_args(), gimple_fold_call(), ipa_param_adjustments::modify_call(), ipa_param_body_adjustments::modify_call_stmt(), and cgraph_edge::redirect_call_stmt_to_callee().

◆ gimple_call_set_ctrl_altering() [1/2]

void gimple_call_set_ctrl_altering ( gcall * s,
bool ctrl_altering_p )
inline 
If CTRL_ALTERING_P is true, mark GIMPLE_CALL S to be a stmt
that could alter control flow.

References GF_CALL_CTRL_ALTERING, and gimple::subcode.

Referenced by cleanup_call_ctrl_altering_flag(), cleanup_control_flow_bb(), copy_edges_for_bb(), execute_fixup_cfg(), expand_thunk(), fixup_noreturn_call(), gimple_build_builtin_unreachable(), gimple_call_initialize_ctrl_altering(), gimple_call_set_ctrl_altering(), gimple_fold_call(), handle_abnormal_edges(), insert_check_and_trap(), and lower_resx().

◆ gimple_call_set_ctrl_altering() [2/2]

void gimple_call_set_ctrl_altering ( gimple * s,
bool ctrl_altering_p )
inline

References gimple_call_set_ctrl_altering(), and GIMPLE_CHECK2().

◆ gimple_call_set_expected_throw()

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

References GF_CALL_XTHROW, and gimple::subcode.

Referenced by gimple_build_call_from_tree().

◆ gimple_call_set_fn()

void gimple_call_set_fn ( gcall * gs,
tree fn )
inline 
Set FN to be the function called by call statement GS.

References gcc_gimple_checking_assert, gimple_call_internal_p(), and gcall::op.

Referenced by execute_omp_device_lower(), gimple_fold_call(), ipa_tm_insert_gettmclone_call(), lower_coro_builtin(), and tm_memopt_transform_stmt().

◆ gimple_call_set_fndecl() [1/2]

void gimple_call_set_fndecl ( gcall * gs,
tree decl )
inline 
Set FNDECL to be the function called by call statement GS.

References build1_loc(), build_pointer_type(), gcc_gimple_checking_assert, gimple_call_internal_p(), gimple_location(), gcall::op, and TREE_TYPE.

Referenced by eliminate_dom_walker::eliminate_stmt(), expand_call_inline(), expand_call_tm(), get_string_length(), gimple_call_set_fndecl(), gimple_fold_builtin_memory_op(), gimple_fold_builtin_snprintf_chk(), gimple_fold_builtin_sprintf_chk(), gimple_fold_builtin_stpcpy(), gimple_fold_call(), gimple_ic(), strlen_pass::handle_builtin_memcmp(), instrument_builtin_call(), ipa_tm_transform_calls_redirect(), lower_omp_1(), object_sizes_execute(), optimize_memcpy_to_memset(), optimize_omp_library_calls(), cgraph_edge::redirect_call_stmt_to_callee(), simplify_builtin_call(), and update_call_expr().

◆ gimple_call_set_fndecl() [2/2]

void gimple_call_set_fndecl ( gimple * gs,
tree decl )
inline

References gimple_call_set_fndecl(), and GIMPLE_CHECK2().

◆ gimple_call_set_fntype()

void gimple_call_set_fntype ( gcall * call_stmt,
tree fntype )
inline 
Set the type of the function called by CALL_STMT to FNTYPE.

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

Referenced by copy_bb(), create_expression_by_pieces(), distinctify_node_type(), eliminate_dom_walker::eliminate_stmt(), gimple_build_call_1(), gimple_build_call_from_tree(), gimple_fold_builtin_bcopy(), gimple_fold_builtin_snprintf_chk(), gimple_fold_builtin_sprintf_chk(), gimple_fold_call(), input_gimple_stmt(), lower_omp_1(), optimize_memcpy_to_memset(), cgraph_edge::redirect_call_stmt_to_callee(), simplify_builtin_call(), tree_profiling(), and vect_recog_rotate_pattern().

◆ gimple_call_set_from_new_or_delete()

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

References GF_CALL_FROM_NEW_OR_DELETE, and gimple::subcode.

Referenced by gimple_build_call_from_tree().

◆ gimple_call_set_from_thunk()

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

References GF_CALL_FROM_THUNK, and gimple::subcode.

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

◆ gimple_call_set_internal_fn()

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

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

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

◆ gimple_call_set_lhs() [1/2]

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

References gcall::op, SSA_NAME_DEF_STMT, and TREE_CODE.

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

◆ gimple_call_set_lhs() [2/2]

void gimple_call_set_lhs ( gimple * gs,
tree lhs )
inline

References gimple_call_set_lhs(), and GIMPLE_CHECK2().

◆ gimple_call_set_must_tail()

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

References GF_CALL_MUST_TAIL_CALL, and gimple::subcode.

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

◆ gimple_call_set_nocf_check()

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

References GF_CALL_NOCF_CHECK, and gimple::subcode.

Referenced by gimple_build_call_from_tree().

◆ gimple_call_set_nothrow()

void gimple_call_set_nothrow ( gcall * s,
bool nothrow_p )
inline 
If NOTHROW_P is true, GIMPLE_CALL S is a call that is known to not throw
even if the called function can throw in other cases.

References GF_CALL_NOTHROW, and gimple::subcode.

Referenced by addsub_pattern::build(), complex_pattern::build(), convert_mult_to_fma_1(), convert_to_divmod(), expand_complex_libcall(), fold_builtin_atomic_compare_exchange(), gimple_build_call_from_tree(), gimplify_call_expr(), gimplify_modify_expr(), ipa_tm_insert_gettmclone_call(), optimize_atomic_bit_test_and(), optimize_atomic_op_fetch_cmp_0(), predicate_load_or_store(), predicate_rhs_code(), use_internal_fn(), vect_recog_build_binary_gimple_stmt(), vect_recog_gather_scatter_pattern(), vect_recog_mask_conversion_pattern(), vect_recog_pow_pattern(), vect_recog_sat_sub_pattern_transform(), vect_recog_sat_trunc_pattern(), vect_transform_reduction(), vectorizable_call(), vectorizable_load(), vectorizable_operation(), and vectorizable_store().

◆ gimple_call_set_return_slot_opt()

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

References GF_CALL_RETURN_SLOT_OPT, and gimple::subcode.

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

◆ gimple_call_set_tail()

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

References GF_CALL_TAILCALL, and gimple::subcode.

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

◆ gimple_call_set_va_arg_pack()

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

References GF_CALL_VA_ARG_PACK, and gimple::subcode.

Referenced by copy_bb(), and gimple_build_call_from_tree().

◆ gimple_call_static_chain_flags()

int gimple_call_static_chain_flags ( const gcall * stmt) 
Detects argument flags for static chain on call STMT.

References symtab_node::binds_to_current_def_p(), dbg_cnt(), gcc_checking_assert, cgraph_node::get(), get_modref_function_summary(), gimple_call_fndecl(), NULL, and modref_summary::static_chain_flags.

Referenced by handle_rhs_call(), and sra_modify_function_body().

◆ gimple_call_tail_p()

bool gimple_call_tail_p ( const gcall * s)
inline 
Return true if GIMPLE_CALL S is marked as a tail call.

References GF_CALL_TAILCALL, and gimple::subcode.

Referenced by ipa_icf_gimple::func_checker::compare_gimple_call(), dump_gimple_call(), expand_call_stmt(), expand_gimple_basic_block(), hardcfr_sibcall_search_block(), remap_gimple_stmt(), returning_call_p(), ssa_is_replaceable_p(), and vect_build_slp_tree_1().

◆ gimple_call_use_set() [1/2]

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

References gcall::call_used.

◆ gimple_call_use_set() [2/2]

struct pt_solution * gimple_call_use_set ( gcall * call_stmt)
inline 
Return a pointer to the points-to solution for the set of call-used
variables of the call CALL_STMT.

References gcall::call_used.

Referenced by compute_points_to_sets(), dump_gimple_call(), ipa_icf::sem_item_optimizer::fixup_points_to_sets(), gimple_call_reset_alias_info(), ipa_pta_execute(), and ref_maybe_used_by_call_p_1().

◆ gimple_call_va_arg_pack_p()

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

References GF_CALL_VA_ARG_PACK, and gimple::subcode.

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

◆ gimple_catch_handler()

gimple_seq gimple_catch_handler ( const gcatch * catch_stmt)
inline 
Return the GIMPLE sequence representing the body of the handler of
GIMPLE_CATCH statement CATCH_STMT.

References gimple_catch_handler_ptr().

Referenced by collect_finally_tree(), do_warn_unused_result(), dump_gimple_catch(), estimate_num_insns(), gimple_copy(), gimple_try_catch_may_fallthru(), lower_catch(), refactor_eh_r(), remap_gimple_stmt(), and verify_gimple_in_seq_2().

◆ gimple_catch_handler_ptr()

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

References gcatch::handler.

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

◆ gimple_catch_set_handler()

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

References gcatch::handler.

Referenced by gimple_build_catch(), and gimple_copy().

◆ gimple_catch_set_types()

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

References gcatch::types.

Referenced by gimple_build_catch(), and gimple_copy().

◆ gimple_catch_types()

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

References gcatch::types.

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

◆ gimple_catch_types_ptr()

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

References gcatch::types.

Referenced by walk_gimple_op().

◆ GIMPLE_CHECK2() [1/2]

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

References as_a().

◆ GIMPLE_CHECK2() [2/2]

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

References as_a().

Referenced by gimple_assign_lhs(), gimple_assign_lhs_ptr(), gimple_assign_rhs1(), gimple_assign_rhs1_ptr(), gimple_assign_rhs2(), gimple_assign_rhs2_ptr(), gimple_assign_rhs3(), gimple_assign_rhs3_ptr(), gimple_assign_rhs_code(), gimple_assign_set_lhs(), gimple_assign_set_rhs1(), gimple_assign_set_rhs2(), gimple_assign_set_rhs3(), gimple_call_alloca_for_var_p(), gimple_call_arg(), gimple_call_arg_ptr(), gimple_call_chain(), gimple_call_ctrl_altering_p(), gimple_call_fn(), gimple_call_fn_ptr(), gimple_call_fndecl(), gimple_call_fntype(), gimple_call_internal_fn(), gimple_call_internal_p(), gimple_call_internal_unique_p(), gimple_call_lhs(), gimple_call_lhs_ptr(), gimple_call_noreturn_p(), gimple_call_num_args(), gimple_call_set_arg(), gimple_call_set_ctrl_altering(), gimple_call_set_fndecl(), gimple_call_set_lhs(), gimple_cond_code(), gimple_cond_lhs(), and gimple_cond_rhs().

◆ gimple_clobber_p() [1/2]

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

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

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

◆ gimple_clobber_p() [2/2]

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

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

◆ gimple_code()

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

References g.

◆ gimple_compare_field_offset()

bool gimple_compare_field_offset ( tree f1,
tree f2 )
extern 
Return true if the field decls F1 and F2 are at the same offset.

This is intended to be used on GIMPLE types only.

References DECL_ALIGN, DECL_FIELD_BIT_OFFSET, DECL_FIELD_OFFSET, DECL_OFFSET_ALIGN, DECL_SIZE, f1, f2, operand_equal_p(), TREE_CODE, tree_fits_shwi_p(), tree_int_cst_equal(), and TREE_INT_CST_LOW.

Referenced by gimple_canonical_types_compatible_p(), and odr_types_equivalent_p().

◆ gimple_cond_code() [1/2]

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

References gimple::subcode.

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

◆ gimple_cond_code() [2/2]

enum tree_code gimple_cond_code ( const gimple * gs)
inline

References GIMPLE_CHECK2(), and gimple_cond_code().

◆ gimple_cond_false_canonical_p()

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

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

Referenced by replace_stmt_with_simplification().

◆ gimple_cond_false_label()

tree gimple_cond_false_label ( const gcond * gs)
inline 
Return the label used by conditional statement GS when its
predicate evaluates to false.

References gimple_statement_with_ops::op.

Referenced by adjust_assumption_stmt_r(), cleanup_dead_labels(), collect_fallthrough_labels(), control_flow_regions::compute_regions(), diagnose_sb_2(), dump_gimple_cond(), make_cond_expr_edges(), maybe_record_in_goto_queue(), omp_sese_split_blocks(), and verify_gimple_cond().

◆ gimple_cond_false_p()

bool gimple_cond_false_p ( const gcond * gs)
inline 
Check if conditional statement GS is of the form 'if (1 != 1)',
'if (0 != 0)', 'if (1 == 0)' or 'if (0 == 1)'

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

Referenced by eliminate_dom_walker::eliminate_stmt(), evaluate_bbs(), find_loop_guard(), find_taken_edge_cond_expr(), find_unswitching_predicates_for_bb(), dom_opt_dom_walker::fold_cond(), and fold_loop_internal_call().

◆ gimple_cond_lhs() [1/2]

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

References gimple_statement_with_ops::op.

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

◆ gimple_cond_lhs() [2/2]

tree gimple_cond_lhs ( const gimple * gs)
inline

References GIMPLE_CHECK2(), and gimple_cond_lhs().

◆ gimple_cond_lhs_ptr()

tree * gimple_cond_lhs_ptr ( gcond * gs)
inline 
Return the pointer to the LHS of the predicate computed by conditional
statement GS.

References gimple_statement_with_ops::op.

Referenced by expand_omp_build_cond(), expand_omp_simd(), extract_cond_operands(), extract_omp_for_update_vars(), gimple_regimplify_operands(), insert_backedge_copies(), and lower_omp_1().

◆ gimple_cond_make_false()

void gimple_cond_make_false ( gcond * gs)
inline 
Set the conditional COND_STMT to be of the form 'if (0 != 0)'.

References boolean_false_node, gimple_cond_set_lhs(), gimple_cond_set_rhs(), and gimple::subcode.

Referenced by substitute_and_fold_dom_walker::before_dom_children(), do_split_loop_on_cond(), eliminate_dom_walker::eliminate_stmt(), execute_early_expand_coro_ifns(), simplify_using_ranges::fold_cond(), ccp_folder::fold_stmt(), generate_loops_for_partition(), remove_unreachable::handle_early(), hoist_guard(), maybe_optimize_guarding_check(), maybe_optimize_range_tests(), crc_optimization::optimize_crc_loop(), dom_opt_dom_walker::optimize_stmt(), optimize_unreachable(), remove_unreachable::remove(), remove_unreachable::remove_and_update_globals(), remove_exits_and_undefined_stmts(), remove_redundant_iv_tests(), replace_phi_edge_with_variable(), replace_stmt_with_simplification(), split_loop(), try_unroll_loop_completely(), and update_profile_after_ch().

◆ gimple_cond_make_true()

void gimple_cond_make_true ( gcond * gs)
inline 
Set the conditional COND_STMT to be of the form 'if (1 != 0)'.

References boolean_false_node, boolean_true_node, gimple_cond_set_lhs(), gimple_cond_set_rhs(), and gimple::subcode.

Referenced by substitute_and_fold_dom_walker::before_dom_children(), do_split_loop_on_cond(), eliminate_dom_walker::eliminate_stmt(), execute_early_expand_coro_ifns(), simplify_using_ranges::fold_cond(), ccp_folder::fold_stmt(), gen_parallel_loop(), generate_loops_for_partition(), remove_unreachable::handle_early(), hoist_guard(), maybe_optimize_guarding_check(), maybe_optimize_range_tests(), dom_opt_dom_walker::optimize_stmt(), optimize_unreachable(), remove_unreachable::remove(), remove_unreachable::remove_and_update_globals(), remove_exits_and_undefined_stmts(), remove_redundant_iv_tests(), replace_phi_edge_with_variable(), replace_stmt_with_simplification(), split_loop(), try_unroll_loop_completely(), and update_profile_after_ch().

◆ gimple_cond_rhs() [1/2]

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

References gimple_statement_with_ops::op.

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

◆ gimple_cond_rhs() [2/2]

tree gimple_cond_rhs ( const gimple * gs)
inline

References GIMPLE_CHECK2(), and gimple_cond_rhs().

◆ gimple_cond_rhs_ptr()

tree * gimple_cond_rhs_ptr ( gcond * gs)
inline 
Return the pointer to the RHS operand of the predicate computed by
conditional GS.

References gimple_statement_with_ops::op.

Referenced by expand_omp_build_cond(), expand_omp_simd(), extract_cond_operands(), extract_omp_for_update_vars(), gimple_regimplify_operands(), insert_backedge_copies(), and lower_omp_1().

◆ gimple_cond_set_code()

void gimple_cond_set_code ( gcond * gs,
enum tree_code code )
inline 
Set CODE to be the predicate code for the conditional statement GS.

References gimple::subcode.

Referenced by canonicalize_loop_ivs(), create_canonical_iv(), expand_complex_comparison(), fold_stmt_1(), forward_propagate_into_gimple_cond(), gimple_cond_set_condition(), match_arith_overflow(), match_single_bit_test(), maybe_optimize_range_tests(), optimize_atomic_op_fetch_cmp_0(), optimize_range_tests_var_bound(), optimize_spaceship(), propagate_tree_value_into_stmt(), remap_gimple_stmt(), rewrite_use_compare(), simplify_using_ranges::simplify_cond_using_ranges_1(), jump_threader::simplify_control_stmt_condition_1(), spaceship_replacement(), dom_opt_dom_walker::test_for_singularity(), and tree_transform_and_unroll_loop().

◆ gimple_cond_set_condition()

void gimple_cond_set_condition ( gcond * stmt,
enum tree_code code,
tree lhs,
tree rhs )
inline 
Set the code, LHS and RHS of GIMPLE_COND STMT from CODE, LHS and RHS.

References gimple_cond_set_code(), gimple_cond_set_lhs(), and gimple_cond_set_rhs().

Referenced by gimple_cond_set_condition_from_tree(), patch_loop_exit(), replace_stmt_with_simplification(), split_at_bb_p(), and vectorizable_early_exit().

◆ gimple_cond_set_condition_from_tree()

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

References gimple_cond_get_ops_from_tree(), and gimple_cond_set_condition().

Referenced by forward_propagate_into_gimple_cond(), ifcombine_replace_cond(), simplify_loop_version(), and vect_loop_versioning().

◆ gimple_cond_set_false_label()

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

References gimple_statement_with_ops::op.

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

◆ gimple_cond_set_lhs()

void gimple_cond_set_lhs ( gcond * gs,
tree lhs )
inline 
Set LHS to be the LHS operand of the predicate computed by
conditional statement GS.

References gimple_statement_with_ops::op.

Referenced by canonicalize_loop_ivs(), create_canonical_iv(), create_empty_loop_on_edge(), create_parallel_loop(), eliminate_unnecessary_stmts(), expand_complex_comparison(), fold_stmt_1(), fold_strstr_to_strncmp(), gimple_build_cond(), gimple_cond_make_false(), gimple_cond_make_true(), gimple_cond_set_condition(), match_arith_overflow(), match_single_bit_test(), maybe_optimize_range_tests(), optimize_atomic_op_fetch_cmp_0(), optimize_range_tests_var_bound(), optimize_spaceship(), dom_opt_dom_walker::optimize_stmt(), propagate_tree_value_into_stmt(), reduce_vector_comparison_to_scalar_comparison(), remap_gimple_stmt(), rewrite_use_compare(), simplify_builtin_call(), simplify_using_ranges::simplify_cond_using_ranges_1(), jump_threader::simplify_control_stmt_condition_1(), spaceship_replacement(), dom_opt_dom_walker::test_for_singularity(), transform_to_exit_first_loop(), and tree_transform_and_unroll_loop().

◆ gimple_cond_set_rhs()

void gimple_cond_set_rhs ( gcond * gs,
tree rhs )
inline 
Set RHS to be the RHS operand of the predicate computed by
conditional statement GS.

References gimple_statement_with_ops::op.

Referenced by canonicalize_loop_ivs(), create_canonical_iv(), expand_complex_comparison(), fold_stmt_1(), fold_strstr_to_strncmp(), forward_propagate_into_gimple_cond(), gimple_build_cond(), gimple_cond_make_false(), gimple_cond_make_true(), gimple_cond_set_condition(), match_arith_overflow(), match_single_bit_test(), maybe_optimize_range_tests(), optimize_atomic_op_fetch_cmp_0(), optimize_range_tests_var_bound(), optimize_spaceship(), propagate_tree_value_into_stmt(), reduce_vector_comparison_to_scalar_comparison(), remap_gimple_stmt(), rewrite_bittest(), rewrite_use_compare(), simplify_builtin_call(), simplify_using_ranges::simplify_cond_using_ranges_1(), jump_threader::simplify_control_stmt_condition_1(), spaceship_replacement(), dom_opt_dom_walker::test_for_singularity(), transform_to_exit_first_loop_alt(), and tree_transform_and_unroll_loop().

◆ gimple_cond_set_true_label()

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

References gimple_statement_with_ops::op.

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

◆ gimple_cond_true_canonical_p()

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

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

Referenced by replace_stmt_with_simplification().

◆ gimple_cond_true_label()

tree gimple_cond_true_label ( const gcond * gs)
inline 
Return the label used by conditional statement GS when its
predicate evaluates to true.

References gimple_statement_with_ops::op.

Referenced by adjust_assumption_stmt_r(), cleanup_dead_labels(), control_flow_regions::compute_regions(), diagnose_sb_2(), dump_gimple_cond(), make_cond_expr_edges(), maybe_record_in_goto_queue(), omp_sese_split_blocks(), and verify_gimple_cond().

◆ gimple_cond_true_p()

bool gimple_cond_true_p ( const gcond * gs)
inline 
Check if conditional statement GS is of the form 'if (1 == 1)',
'if (0 == 0)', 'if (1 != 0)' or 'if (0 != 1)'

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

Referenced by eliminate_dom_walker::eliminate_stmt(), evaluate_bbs(), find_loop_guard(), find_taken_edge_cond_expr(), find_unswitching_predicates_for_bb(), dom_opt_dom_walker::fold_cond(), and fold_loop_internal_call().

◆ gimple_copy()

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

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

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

◆ gimple_could_trap_p()

bool gimple_could_trap_p ( const gimple * s) 
Return true if statement S can trap.

References gimple_could_trap_p_1().

Referenced by bb_no_side_effects_p(), empty_bb_or_one_feeding_into_p(), find_replaceable_in_bb(), if_convertible_gimple_assign_stmt_p(), ifcvt_can_hoist(), movement_possibility_1(), oacc_entry_exit_ok_1(), poor_ifcvt_pred(), remap_gimple_stmt(), stmt_may_terminate_function_p(), vect_build_slp_tree_1(), vect_schedule_slp_node(), and vectorizable_operation().

◆ gimple_could_trap_p_1()

bool gimple_could_trap_p_1 ( const gimple * s,
bool include_mem,
bool include_stores ) 
Helper for gimple_could_trap_p and gimple_assign_rhs_could_trap_p.
Return true if S can trap.  When INCLUDE_MEM is true, check whether
the memory operations could trap.  When INCLUDE_STORES is true and
S is a GIMPLE_ASSIGN, the LHS of the assignment is also checked.

References as_a(), DECL_P, DECL_WEAK, FLOAT_TYPE_P, get_gimple_rhs_class(), gimple_asm_volatile_p(), gimple_assign_lhs(), gimple_assign_rhs1(), gimple_assign_rhs2(), gimple_assign_rhs_code(), GIMPLE_BINARY_RHS, gimple_call_fndecl(), gimple_call_internal_p(), gimple_cond_code(), gimple_cond_lhs(), gimple_num_ops(), gimple_op(), i, INTEGRAL_TYPE_P, is_gimple_assign(), NULL_TREE, operation_could_trap_p(), tcc_comparison, TREE_CODE_CLASS, tree_could_trap_p(), TREE_TYPE, and TYPE_OVERFLOW_TRAPS.

Referenced by gimple_assign_rhs_could_trap_p(), gimple_could_trap_p(), if_convertible_gimple_assign_stmt_p(), and stmt_local_def().

◆ gimple_debug_begin_stmt_p()

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

References GIMPLE_DEBUG_BEGIN_STMT, is_gimple_debug(), and gimple::subcode.

Referenced by eliminate_unnecessary_stmts(), expand_gimple_basic_block(), and lower_try_catch().

◆ gimple_debug_bind_get_value()

tree gimple_debug_bind_get_value ( const gimple * dbg)
inline 
Return the value bound to the variable in a GIMPLE_DEBUG bind
statement.

References gcc_gimple_checking_assert, GIMPLE_CHECK, gimple_debug_bind_p(), and gimple_op().

Referenced by destroy_loop(), dump_gimple_debug(), expand_gimple_basic_block(), fold_stmt_1(), insert_debug_temp_for_var_def(), maybe_move_debug_stmts_to_successors(), maybe_optimize_arith_overflow(), remap_gimple_stmt(), remove_unused_ivs(), and remove_unused_locals().

◆ gimple_debug_bind_get_value_ptr()

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

References gcc_gimple_checking_assert, GIMPLE_CHECK, gimple_debug_bind_p(), and gimple_op_ptr().

Referenced by copy_debug_stmt(), eliminate_local_variables_stmt(), execute_update_addresses_taken(), fold_stmt_1(), and operands_scanner::parse_ssa_operands().

◆ gimple_debug_bind_get_var()

tree gimple_debug_bind_get_var ( const gimple * dbg)
inline 
Return the variable bound in a GIMPLE_DEBUG bind statement.

References gcc_gimple_checking_assert, GIMPLE_CHECK, gimple_debug_bind_p(), and gimple_op().

Referenced by copy_debug_stmt(), dump_gimple_debug(), eliminate_unnecessary_stmts(), expand_gimple_basic_block(), gimple_duplicate_bb(), ipa_simd_modify_function_body(), mark_stmt_if_obviously_necessary(), maybe_move_debug_stmts_to_successors(), propagate_threaded_block_debug_into(), remap_gimple_stmt(), remove_unused_locals(), and separate_decls_in_region_debug().

◆ gimple_debug_bind_has_value_p()

bool gimple_debug_bind_has_value_p ( gimple * dbg)
inline 
Return true if the GIMPLE_DEBUG bind statement is bound to a
value.

References gcc_gimple_checking_assert, GIMPLE_CHECK, GIMPLE_DEBUG_BIND_NOVALUE, gimple_debug_bind_p(), and gimple_op().

Referenced by copy_debug_stmt(), execute_update_addresses_taken(), expand_gimple_basic_block(), mark_stmt_if_obviously_necessary(), operands_scanner::parse_ssa_operands(), and verify_ssa().

◆ gimple_debug_bind_p()

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

References GIMPLE_DEBUG_BIND, is_gimple_debug(), and gimple::subcode.

Referenced by adjust_debug_stmts_now(), cleanup_empty_eh_merge_phis(), copy_debug_stmt(), destroy_loop(), eliminate_local_variables(), eliminate_local_variables_stmt(), eliminate_unnecessary_stmts(), execute_update_addresses_taken(), expand_gimple_basic_block(), fold_stmt_1(), operands_scanner::get_expr_operands(), 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_duplicate_bb(), insert_debug_temp_for_var_def(), ipa_simd_modify_function_body(), ipa_param_body_adjustments::mark_dead_statements(), mark_stmt_if_obviously_necessary(), maybe_move_debug_stmts_to_successors(), maybe_optimize_arith_overflow(), move_debug_stmts_from_forwarder(), optimize_vector_load(), operands_scanner::parse_ssa_operands(), propagate_threaded_block_debug_into(), purge_all_uses(), remap_gimple_stmt(), remove_conditions_and_labels(), remove_unused_ivs(), remove_unused_locals(), reset_debug_uses(), separate_decls_in_region_debug(), try_create_reduction_list(), update_debug_stmt(), vect_do_peeling(), and verify_ssa().

◆ gimple_debug_bind_reset_value()

void gimple_debug_bind_reset_value ( gimple * dbg)
inline 
Remove the value bound to the variable in a GIMPLE_DEBUG bind
statement.

References gcc_gimple_checking_assert, GIMPLE_CHECK, GIMPLE_DEBUG_BIND_NOVALUE, gimple_debug_bind_p(), and gimple_set_op().

Referenced by adjust_debug_stmts_now(), copy_debug_stmt(), destroy_loop(), eliminate_local_variables_stmt(), execute_update_addresses_taken(), gimple_merge_blocks(), insert_debug_temp_for_var_def(), lower_emutls_1(), maybe_move_debug_stmts_to_successors(), maybe_optimize_arith_overflow(), move_debug_stmts_from_forwarder(), optimize_atomic_bit_test_and(), optimize_vector_load(), purge_all_uses(), remove_conditions_and_labels(), ipa_param_body_adjustments::reset_debug_stmts(), reset_debug_uses(), rewrite_debug_stmt_uses(), rewrite_update_stmt(), separate_decls_in_region_debug(), sese_reset_debug_liveouts(), simplify_builtin_call(), split_function(), tree_unswitch_outer_loop(), update_debug_stmt(), and vect_do_peeling().

◆ gimple_debug_bind_set_value()

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

References gcc_gimple_checking_assert, GIMPLE_CHECK, gimple_debug_bind_p(), and gimple_set_op().

Referenced by copy_debug_stmt(), fold_stmt_1(), and gimple_build_debug_bind().

◆ gimple_debug_bind_set_var()

void gimple_debug_bind_set_var ( gimple * dbg,
tree var )
inline 
Set the variable bound in a GIMPLE_DEBUG bind statement.

References gcc_gimple_checking_assert, GIMPLE_CHECK, gimple_debug_bind_p(), and gimple_set_op().

Referenced by copy_debug_stmt(), gimple_build_debug_bind(), and separate_decls_in_region_debug().

◆ gimple_debug_inline_entry_p()

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

References GIMPLE_DEBUG_INLINE_ENTRY, is_gimple_debug(), and gimple::subcode.

Referenced by expand_gimple_basic_block(), and input_function().

◆ gimple_debug_nonbind_marker_p()

bool gimple_debug_nonbind_marker_p ( const gimple * s)
inline 
Return true if S is a GIMPLE_DEBUG non-binding marker statement.

References GIMPLE_DEBUG_BEGIN_STMT, GIMPLE_DEBUG_INLINE_ENTRY, is_gimple_debug(), and gimple::subcode.

Referenced by clear_unused_block_pointer(), copy_debug_stmt(), expand_gimple_basic_block(), gimple_copy(), gsi_remove(), input_function(), lower_stmt(), make_blocks(), mark_stmt_if_obviously_necessary(), maybe_move_debug_stmts_to_successors(), propagate_threaded_block_debug_into(), and remap_gimple_stmt().

◆ gimple_debug_source_bind_get_value()

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

References gcc_gimple_checking_assert, GIMPLE_CHECK, gimple_debug_source_bind_p(), and gimple_op().

Referenced by copy_debug_stmt(), dump_gimple_debug(), expand_gimple_basic_block(), maybe_move_debug_stmts_to_successors(), remap_gimple_stmt(), and rewrite_debug_stmt_uses().

◆ gimple_debug_source_bind_get_value_ptr()

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

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

Referenced by copy_debug_stmt().

◆ gimple_debug_source_bind_get_var()

tree gimple_debug_source_bind_get_var ( const gimple * dbg)
inline 
Return the variable bound in a GIMPLE_DEBUG source bind statement.

References gcc_gimple_checking_assert, GIMPLE_CHECK, gimple_debug_source_bind_p(), and gimple_op().

Referenced by copy_debug_stmt(), dump_gimple_debug(), expand_gimple_basic_block(), ipa_simd_modify_function_body(), maybe_move_debug_stmts_to_successors(), propagate_threaded_block_debug_into(), remap_gimple_stmt(), rewrite_debug_stmt_uses(), and separate_decls_in_region_debug().

◆ gimple_debug_source_bind_p()

bool gimple_debug_source_bind_p ( const gimple * s)
inline 
Return true if S is a GIMPLE_DEBUG SOURCE BIND statement.

References GIMPLE_DEBUG_SOURCE_BIND, is_gimple_debug(), and gimple::subcode.

Referenced by copy_debug_stmt(), expand_gimple_basic_block(), 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(), ipa_simd_modify_function_body(), maybe_move_debug_stmts_to_successors(), propagate_threaded_block_debug_into(), remap_gimple_stmt(), rewrite_debug_stmt_uses(), and separate_decls_in_region_debug().

◆ gimple_debug_source_bind_set_value()

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

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

Referenced by gimple_build_debug_source_bind().

◆ gimple_debug_source_bind_set_var()

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

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

Referenced by copy_debug_stmt(), gimple_build_debug_source_bind(), and separate_decls_in_region_debug().

◆ gimple_do_not_emit_location_p()

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

References g, GF_PLF_1, and gimple_plf().

Referenced by annotate_one_with_location().

◆ gimple_eh_dispatch_region()

int gimple_eh_dispatch_region ( const geh_dispatch * eh_dispatch_stmt)
inline 
Return the region number for GIMPLE_EH_DISPATCH EH_DISPATCH_STMT.

References gimple_statement_eh_ctrl::region.

Referenced by ipa_icf_gimple::func_checker::compare_bb(), dump_gimple_eh_dispatch(), lower_eh_dispatch(), make_eh_dispatch_edges(), mark_reachable_handlers(), move_stmt_r(), output_gimple_stmt(), redirect_eh_dispatch_edge(), remap_gimple_stmt(), and verify_eh_dispatch_edge().

◆ gimple_eh_dispatch_set_region()

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

References gimple_statement_eh_ctrl::region.

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

◆ gimple_eh_else_e_body()

gimple_seq gimple_eh_else_e_body ( const geh_else * eh_else_stmt)
inline

References gimple_eh_else_e_body_ptr().

Referenced by collect_finally_tree(), dump_gimple_eh_else(), dump_gimple_try(), gimple_copy(), gimple_stmt_may_fallthru(), honor_protect_cleanup_actions(), lower_try_finally_copy(), lower_try_finally_nofallthru(), lower_try_finally_onedest(), lower_try_finally_switch(), refactor_eh_r(), and verify_gimple_in_seq_2().

◆ gimple_eh_else_e_body_ptr()

gimple_seq * gimple_eh_else_e_body_ptr ( geh_else * eh_else_stmt)
inline

References geh_else::e_body.

Referenced by gimple_eh_else_e_body(), lower_stmt(), replace_goto_queue_1(), and walk_gimple_stmt().

◆ gimple_eh_else_n_body()

gimple_seq gimple_eh_else_n_body ( const geh_else * eh_else_stmt)
inline

References gimple_eh_else_n_body_ptr().

Referenced by collect_finally_tree(), decide_copy_try_finally(), dump_gimple_eh_else(), dump_gimple_try(), gimple_copy(), gimple_stmt_may_fallthru(), honor_protect_cleanup_actions(), lower_try_finally_copy(), lower_try_finally_nofallthru(), lower_try_finally_onedest(), lower_try_finally_switch(), refactor_eh_r(), and verify_gimple_in_seq_2().

◆ gimple_eh_else_n_body_ptr()

gimple_seq * gimple_eh_else_n_body_ptr ( geh_else * eh_else_stmt)
inline 
GIMPLE_EH_ELSE accessors.

References geh_else::n_body.

Referenced by gimple_eh_else_n_body(), lower_stmt(), replace_goto_queue_1(), and walk_gimple_stmt().

◆ gimple_eh_else_set_e_body()

void gimple_eh_else_set_e_body ( geh_else * eh_else_stmt,
gimple_seq seq )
inline

References geh_else::e_body.

Referenced by gimple_build_eh_else(), and gimple_copy().

◆ gimple_eh_else_set_n_body()

void gimple_eh_else_set_n_body ( geh_else * eh_else_stmt,
gimple_seq seq )
inline

References geh_else::n_body.

Referenced by gimple_build_eh_else(), and gimple_copy().

◆ gimple_eh_filter_failure()

gimple_seq gimple_eh_filter_failure ( const gimple * gs)
inline 
Return the sequence of statement to execute when GIMPLE_EH_FILTER
statement fails.

References gimple_eh_filter_failure_ptr().

Referenced by collect_finally_tree(), do_warn_unused_result(), dump_gimple_eh_filter(), estimate_num_insns(), gimple_copy(), gimple_try_catch_may_fallthru(), lower_eh_filter(), refactor_eh_r(), remap_gimple_stmt(), and verify_gimple_in_seq_2().

◆ gimple_eh_filter_failure_ptr()

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

References as_a(), and geh_filter::failure.

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

◆ gimple_eh_filter_set_failure()

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

References failure, and geh_filter::failure.

Referenced by gimple_build_eh_filter(), and gimple_copy().

◆ gimple_eh_filter_set_types()

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

References geh_filter::types.

Referenced by gimple_build_eh_filter(), and gimple_copy().

◆ gimple_eh_filter_types()

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

References as_a(), and geh_filter::types.

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

◆ gimple_eh_filter_types_ptr()

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

References as_a(), and geh_filter::types.

Referenced by walk_gimple_op().

◆ gimple_eh_must_not_throw_fndecl()

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

References geh_mnt::fndecl.

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

◆ gimple_eh_must_not_throw_set_fndecl()

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

References geh_mnt::fndecl.

Referenced by gimple_build_eh_must_not_throw(), and input_gimple_stmt().

◆ gimple_expr_code()

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

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

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

◆ gimple_filename()

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

References gimple_location(), and LOCATION_FILE.

Referenced by branch_prob(), and inline_small_functions().

◆ gimple_get_alias_set()

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

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

◆ gimple_get_lhs()

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

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

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

◆ gimple_goto_dest()

tree gimple_goto_dest ( const gimple * gs)
inline 
Return the destination of the unconditional jump GS.

References GIMPLE_CHECK, and gimple_op().

Referenced by adjust_assumption_stmt_r(), cleanup_control_flow_bb(), cleanup_dead_labels(), collect_fallthrough_labels(), ipa_icf_gimple::func_checker::compare_gimple_goto(), control_flow_regions::compute_regions(), computed_goto_p(), convert_nl_goto_reference(), convert_nonlocal_reference_stmt(), diagnose_sb_2(), dump_gimple_goto(), emit_warn_switch_unreachable(), expand_FALLTHROUGH_r(), expand_gimple_stmt_1(), expr_hash_elt::expr_hash_elt(), handle_abnormal_edges(), inline_forbidden_p_stmt(), make_goto_expr_edges(), maybe_record_in_goto_queue(), dom_opt_dom_walker::optimize_stmt(), process_bb(), replace_goto_queue_cond_clause(), simple_goto_p(), jump_threader::simplify_control_stmt_condition(), verify_gimple_goto(), and walk_stmt_load_store_addr_ops().

◆ gimple_goto_set_dest()

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

References gimple_statement_with_ops::op.

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

◆ gimple_has_lhs()

bool gimple_has_lhs ( const gimple * stmt)
inline 
Returns true if this is a GIMPLE_ASSIGN or a GIMPLE_CALL with a
non-NULL lhs.

References dyn_cast(), gimple_call_lhs(), is_gimple_assign(), and NULL_TREE.

Referenced by find_func_clobbers(), gsi_replace(), likely_value(), lower_eh_constructs_2(), make_blocks_1(), mark_aliased_reaching_defs_necessary_1(), move_computations_worker(), pp_gimple_stmt_1(), replace_stmt_with_simplification(), statement_sink_location(), and stmt_kills_ref_p().

◆ gimple_has_location()

bool gimple_has_location ( const gimple * g)
inline 
Return true if G contains location information.

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

Referenced by annotate_one_with_location(), check_array_bounds_dom_walker::before_dom_children(), branch_prob(), collect_fallthrough_labels(), expand_FALLTHROUGH_r(), expand_gimple_stmt(), expand_gimple_stmt_1(), expand_omp(), fold_call_stmt(), gimple_assign_rhs_to_tree(), gimple_call_copy_skip_args(), gsi_insert_finally_seq_after_call(), gsi_replace_with_seq_vops(), lower_gimple_return(), lower_omp_1(), ipa_param_adjustments::modify_call(), ipa_param_body_adjustments::modify_call_stmt(), pp_gimple_stmt_1(), scan_omp_1_stmt(), set_location_for_edge(), tree_forwarder_block_p(), walk_gimple_stmt(), warn_implicit_fallthrough_r(), warn_uninit(), and warn_uninitialized_vars().

◆ gimple_has_mem_ops()

bool gimple_has_mem_ops ( const gimple * g)
inline 
Return true if GIMPLE statement G has memory operands.

References g.

Referenced by free_stmt_operands(), gimple_copy(), gimple_has_volatile_ops(), gimple_references_memory_p(), gimple_set_has_volatile_ops(), gsi_replace_with_seq_vops(), make_bit_field_load(), pp_gimple_stmt_1(), remap_gimple_stmt(), is_a_helper< const T * >::test(), is_a_helper< const T * >::test(), and vect_finish_stmt_generation().

◆ gimple_has_ops()

bool gimple_has_ops ( const gimple * g)
inline 
Return true if GIMPLE statement G has register or memory operands.

References g.

Referenced by gimple_copy(), gimple_modified_p(), gimple_op(), gimple_op_ptr(), gimple_set_modified(), gimple_set_op(), is_a_helper< const T * >::test(), is_a_helper< const T * >::test(), update_stmt(), and update_stmt_fn().

◆ gimple_has_side_effects()

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

- It is a GIMPLE_CALL not marked with ECF_PURE or ECF_CONST.
- Any of its operands are marked TREE_THIS_VOLATILE or TREE_SIDE_EFFECTS.

References as_a(), ECF_CONST, ECF_LOOPING_CONST_OR_PURE, ECF_PURE, gimple_asm_volatile_p(), gimple_call_flags(), gimple_has_volatile_ops(), is_gimple_call(), and is_gimple_debug().

Referenced by bb_no_side_effects_p(), bb_prevents_fusion_p(), substitute_and_fold_dom_walker::before_dom_children(), call_can_make_abnormal_goto(), loop_cand::can_interchange_p(), compute_avail(), dse_optimize_stmt(), empty_bb_or_one_feeding_into_p(), empty_bb_without_guard_p(), estimate_threading_killed_stmts(), expand_call_stmt(), expand_complex_move(), find_necessary_statements(), find_seed_stmts_for_distribution(), if_convertible_gimple_assign_stmt_p(), ifcvt_can_hoist(), loop_edge_to_cancel(), mark_stmt_if_obviously_necessary(), gori_compute::may_recompute_p(), maybe_lower_iteration_bound(), maybe_remove_writeonly_store(), movement_possibility_1(), n_of_executions_at_most(), no_side_effect_bb(), nonpure_call_p(), oacc_entry_exit_ok_1(), dom_opt_dom_walker::optimize_stmt(), remove_prop_source_from_use(), simple_dce_from_worklist(), statement_sink_location(), stmt_local_def(), stmt_semi_invariant_p_1(), tree_estimate_loop_size(), and tree_estimate_probability_bb().

◆ gimple_has_substatements()

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

References g.

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

◆ gimple_has_volatile_ops()

bool gimple_has_volatile_ops ( const gimple * stmt)
inline 
Return true if statement STMT contains volatile operands.

References gimple_has_mem_ops().

Referenced by auto_simd_check_stmt(), nontrapping_dom_walker::before_dom_children(), build_accesses_from_assign(), can_propagate_from(), check_stmt(), loop_distribution::classify_partition(), cond_if_else_store_replacement_1(), cond_store_replacement(), determine_reduction_stmt_1(), dse_optimize_stmt(), dump_gimple_assign(), dump_gimple_call(), eliminate_dom_walker::eliminate_stmt(), find_interesting_uses_address(), find_replaceable_in_bb(), find_tail_calls(), gimple_has_side_effects(), gimple_lower_bitint(), strlen_pass::handle_integral_assign(), hoist_adjacent_loads(), if_convertible_gimple_assign_stmt_p(), ifcvt_can_predicate(), ifcvt_local_dce(), is_cond_scalar_reduction(), likely_value(), movement_possibility_1(), optimize_mask_stores(), optimize_memcpy_to_memset(), output_gimple_stmt(), propagate_with_phi(), record_equivalences_from_stmt(), sra_modify_assign(), ssa_is_replaceable_p(), stmt_may_generate_copy(), surely_varying_stmt_p(), vect_analyze_stmt(), vect_build_slp_tree_1(), vect_find_stmt_data_reference(), operands_scanner::verify_ssa_operands(), visit_nary_op(), and visit_stmt().

◆ gimple_in_transaction()

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

References bb_in_transaction(), and gimple_bb().

Referenced by movement_possibility_1().

◆ gimple_inexpensive_call_p()

bool gimple_inexpensive_call_p ( gcall * stmt)
extern 
Return false if STMT will likely expand to real function call.

References gimple_call_fndecl(), gimple_call_internal_p(), and is_inexpensive_builtin().

Referenced by loop_cand::can_interchange_p(), should_duplicate_loop_header_p(), tree_estimate_loop_size(), and tree_estimate_probability_bb().

◆ gimple_init()

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

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

Referenced by gimple_alloc(), and maybe_fold_comparisons_from_match_pd().

◆ gimple_init_singleton()

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

References g, and NULL.

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

◆ gimple_ior_addresses_taken()

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

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

Referenced by execute_update_addresses_taken().

◆ gimple_label_label()

tree gimple_label_label ( const glabel * gs)
inline 
Return the LABEL_DECL node used by GIMPLE_LABEL statement GS.

References gimple_statement_with_ops::op.

Referenced by adjust_assumption_stmt_r(), can_strub_internally_p(), check_stmt(), cleanup_dead_labels(), cleanup_empty_eh_unsplit(), collect_fallthrough_labels(), collect_finally_tree(), ipa_icf_gimple::func_checker::compare_gimple_label(), control_flow_regions::compute_regions(), convert_nl_goto_receiver(), diagnose_sb_1(), dump_gimple_label(), expand_FALLTHROUGH_r(), expand_gimple_stmt_1(), find_assumption_locals_r(), find_duplicate(), get_loop_body_in_if_conv_order(), gimple_block_label(), gimple_can_merge_blocks_p(), gimple_merge_blocks(), gimple_set_bb(), gimple_verify_flow_info(), gimplify_switch_expr(), group_case_labels_stmt(), label_rtx_for_bb(), make_edges(), mark_local_labels_stmt(), maybe_dead_abnormal_edge_p(), move_block_to_fn(), move_stmt_r(), optimize_unreachable(), ipa_icf_gimple::func_checker::parse_labels(), remove_bb(), remove_forwarder_block(), remove_forwarder_block_with_phi(), replace_block_by(), should_warn_for_implicit_fallthrough(), single_block_loop_p(), stmt_starts_bb_p(), tree_forwarder_block_p(), unsplit_eh(), verify_gimple_label(), verify_non_ssa_vars(), and warn_implicit_fallthrough_r().

◆ gimple_label_set_label()

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

References gimple_statement_with_ops::op.

Referenced by gimple_build_label().

◆ gimple_lineno()

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

References gimple_location(), and LOCATION_LINE.

Referenced by branch_prob(), and inline_small_functions().

◆ gimple_location()

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

References g.

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

◆ gimple_location_ptr()

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

References g.

Referenced by input_gimple_stmt().

◆ gimple_location_safe()

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

References g, gimple_location(), and UNKNOWN_LOCATION.

◆ gimple_modified_p()

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

References bool, g, and gimple_has_ops().

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

◆ gimple_move_vops()

void gimple_move_vops ( gimple * new_stmt,
gimple * old_stmt ) 
Move OLD_STMT's vuse and vdef operands to NEW_STMT, on the assumption
that OLD_STMT is about to be removed.

References gimple_set_vdef(), gimple_set_vuse(), gimple_vdef(), gimple_vuse(), SSA_NAME_DEF_STMT, and TREE_CODE.

Referenced by adjust_simduid_builtins(), finish_update_gimple_call(), fold_builtin_atomic_compare_exchange(), gimple_expand_vec_set_extract_expr(), gimple_fold_builtin_memory_op(), gimple_fold_builtin_memset(), gimple_fold_builtin_stpcpy(), gimple_fold_call(), gimple_fold_partial_load(), gimple_fold_partial_store(), lower_bitfield(), ipa_param_adjustments::modify_call(), optimize_atomic_bit_test_and(), optimize_atomic_op_fetch_cmp_0(), predicate_load_or_store(), replace_call_with_call_and_fold(), use_internal_fn(), and vectorizable_load().

◆ gimple_no_warning_p()

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

Referenced by output_gimple_stmt().

◆ gimple_nonartificial_location()

location_t gimple_nonartificial_location ( const gimple * g)
inline 
Return non-artificial location information for statement G.

References block_nonartificial_location(), g, gimple_block(), gimple_location(), and NULL.

Referenced by pass_walloca::execute(), and gimple_or_expr_nonartificial_location().

◆ gimple_nop_p()

bool gimple_nop_p ( const gimple * g)
inline 
Returns TRUE if statement G is a GIMPLE_NOP.

References g.

Referenced by build_and_add_sum(), builtin_unreachable_bb_p(), check_reduction_path(), compute_avail(), copy_bb(), eliminate_dom_walker::eliminate_stmt(), eliminate_unnecessary_stmts(), find_ssa_names_to_propagate(), scev_dfs::follow_ssa_edge_expr(), force_move_till_op(), get_base_decl(), get_default_value(), get_representative_for(), handle_ssa_name(), hoist_defs_of_uses(), access_ref::inform_access(), insert_backedge_copies(), is_inv_store_elimination_chain(), mark_all_reaching_defs_necessary_1(), mark_operand_necessary(), mark_operand_necessary(), maybe_skip_until(), neuter_worker_single(), omp_sese_find_par(), prune_clobbered_mems(), redirection_block_p(), ssa_propagation_engine::simulate_stmt(), ssa_undefined_value_p(), translate_vuse_through_block(), valueize_op_1(), verify_live_on_entry(), verify_ssa(), verify_ssa_name(), verify_use(), walk_aliased_vdefs_1(), walk_non_aliased_vuses(), and worker_single_copy().

◆ gimple_num_args()

unsigned gimple_num_args ( const gimple * gs)
inline 
Return the number of arguments that can be accessed by gimple_arg.

References as_a(), dyn_cast(), gimple_call_num_args(), gimple_num_ops(), and gimple_phi_num_args().

Referenced by compatible_complex_nodes_p(), gimple_equal_p(), ifcvt_can_hoist(), vect_build_slp_tree_2(), and vect_get_and_check_slp_defs().

◆ gimple_num_ops()

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

References gimple::num_ops.

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

◆ gimple_omp_atomic_load_lhs()

tree gimple_omp_atomic_load_lhs ( const gomp_atomic_load * load_stmt)
inline 
Get the LHS of an atomic load.

References gomp_atomic_load::lhs.

Referenced by dump_gimple_omp_atomic_load(), and expand_omp_atomic().

◆ gimple_omp_atomic_load_lhs_ptr()

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

References gomp_atomic_load::lhs.

Referenced by walk_gimple_op().

◆ gimple_omp_atomic_load_rhs()

tree gimple_omp_atomic_load_rhs ( const gomp_atomic_load * load_stmt)
inline 
Get the RHS of an atomic load.

References gomp_atomic_load::rhs.

Referenced by dump_gimple_omp_atomic_load(), and expand_omp_atomic().

◆ gimple_omp_atomic_load_rhs_ptr()

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

References gomp_atomic_load::rhs.

Referenced by gimple_regimplify_operands(), lower_omp_1(), and walk_gimple_op().

◆ gimple_omp_atomic_load_set_lhs()

void gimple_omp_atomic_load_set_lhs ( gomp_atomic_load * load_stmt,
tree lhs )
inline 
Set the LHS of an atomic load.

References gomp_atomic_load::lhs.

Referenced by gimple_build_omp_atomic_load().

◆ gimple_omp_atomic_load_set_rhs()

void gimple_omp_atomic_load_set_rhs ( gomp_atomic_load * load_stmt,
tree rhs )
inline 
Set the RHS of an atomic load.

References gomp_atomic_load::rhs.

Referenced by gimple_build_omp_atomic_load().

◆ gimple_omp_atomic_memory_order()

enum omp_memory_order gimple_omp_atomic_memory_order ( const gimple * g)
inline 
Return the memory order of the OMP atomic load/store statement G.

References g, GF_OMP_ATOMIC_MEMORY_ORDER, GIMPLE_CHECK, and gimple_omp_subcode().

Referenced by dump_gimple_omp_atomic_load(), dump_gimple_omp_atomic_store(), expand_omp_atomic_cas(), expand_omp_atomic_fetch_op(), expand_omp_atomic_load(), expand_omp_atomic_pipeline(), and expand_omp_atomic_store().

◆ gimple_omp_atomic_need_value_p()

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

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

Referenced by dump_gimple_omp_atomic_load(), dump_gimple_omp_atomic_store(), expand_omp_atomic_cas(), expand_omp_atomic_fetch_op(), and expand_omp_atomic_store().

◆ gimple_omp_atomic_set_memory_order()

void gimple_omp_atomic_set_memory_order ( gimple * g,
enum omp_memory_order mo )
inline 
Set the memory order on G.

References g, GF_OMP_ATOMIC_MEMORY_ORDER, and GIMPLE_CHECK.

Referenced by gimple_build_omp_atomic_load(), and gimple_build_omp_atomic_store().

◆ gimple_omp_atomic_set_need_value()

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

References g, GF_OMP_ATOMIC_NEED_VALUE, and GIMPLE_CHECK.

Referenced by gimplify_omp_atomic().

◆ gimple_omp_atomic_set_weak()

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

References g, GF_OMP_ATOMIC_WEAK, and GIMPLE_CHECK.

Referenced by gimplify_omp_atomic().

◆ gimple_omp_atomic_store_set_val()

void gimple_omp_atomic_store_set_val ( gomp_atomic_store * store_stmt,
tree val )
inline 
Set the value being stored in an atomic store.

References gimple_statement_omp_atomic_store_layout::val.

Referenced by gimple_build_omp_atomic_store().

◆ gimple_omp_atomic_store_val()

tree gimple_omp_atomic_store_val ( const gomp_atomic_store * store_stmt)
inline 
Return the value being stored in an atomic store.

References gimple_statement_omp_atomic_store_layout::val.

Referenced by dump_gimple_omp_atomic_store(), and expand_omp_atomic().

◆ gimple_omp_atomic_store_val_ptr()

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

References gimple_statement_omp_atomic_store_layout::val.

Referenced by walk_gimple_op().

◆ gimple_omp_atomic_weak_p()

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

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

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

◆ gimple_omp_body()

gimple_seq gimple_omp_body ( const gimple * gs)
inline 
Return the body for the OMP statement GS.

References gimple_omp_body_ptr().

Referenced by add_taskreg_looptemp_clauses(), convert_local_reference_stmt(), convert_nonlocal_reference_stmt(), convert_tramp_reference_stmt(), decompose_kernels_region_body(), diagnose_sb_1(), dump_gimple_omp_block(), dump_gimple_omp_critical(), dump_gimple_omp_dispatch(), dump_gimple_omp_for(), dump_gimple_omp_masked(), dump_gimple_omp_ordered(), dump_gimple_omp_parallel(), dump_gimple_omp_scan(), dump_gimple_omp_scope(), dump_gimple_omp_sections(), dump_gimple_omp_single(), dump_gimple_omp_target(), dump_gimple_omp_task(), dump_gimple_omp_taskgroup(), dump_gimple_omp_teams(), estimate_num_insns(), gimple_copy(), lower_omp_1(), lower_omp_critical(), lower_omp_directive(), lower_omp_dispatch(), lower_omp_for(), lower_omp_for_scan(), lower_omp_master(), lower_omp_ordered(), lower_omp_scan(), lower_omp_scope(), lower_omp_sections(), lower_omp_single_copy(), lower_omp_single_simple(), lower_omp_target(), lower_omp_taskgroup(), lower_omp_taskreg(), lower_omp_teams(), remap_gimple_stmt(), scan_omp_parallel(), scan_omp_simd_scan(), scan_omp_task(), and transform_kernels_loop_clauses().

◆ gimple_omp_body_ptr()

gimple_seq * gimple_omp_body_ptr ( gimple * gs)
inline 
Return a pointer to the body for the OMP statement GS.

Referenced by convert_gimple_call(), convert_local_reference_stmt(), convert_nonlocal_reference_stmt(), convert_tramp_reference_stmt(), diagnose_sb_2(), gimple_omp_body(), lower_omp_1(), lower_omp_critical(), lower_omp_directive(), lower_omp_dispatch(), lower_omp_for(), lower_omp_for_scan(), lower_omp_master(), lower_omp_ordered(), lower_omp_scan(), lower_omp_scope(), lower_omp_sections(), lower_omp_single(), lower_omp_taskgroup(), lower_omp_teams(), lower_rec_input_clauses(), move_stmt_r(), scan_omp_1_stmt(), scan_omp_for(), scan_omp_parallel(), scan_omp_sections(), scan_omp_simd_scan(), scan_omp_single(), scan_omp_target(), scan_omp_task(), scan_omp_teams(), and walk_gimple_stmt().

◆ gimple_omp_continue_control_def()

tree gimple_omp_continue_control_def ( const gomp_continue * cont_stmt)
inline 
Get the definition of the control variable in a GIMPLE_OMP_CONTINUE.

References gomp_continue::control_def.

Referenced by dump_gimple_omp_continue(), expand_oacc_for(), expand_omp_for_generic(), expand_omp_for_static_chunk(), expand_omp_for_static_nochunk(), expand_omp_sections(), and expand_omp_taskloop_for_inner().

◆ gimple_omp_continue_control_def_ptr()

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

References gomp_continue::control_def.

Referenced by walk_gimple_op().

◆ gimple_omp_continue_control_use()

tree gimple_omp_continue_control_use ( const gomp_continue * cont_stmt)
inline 
Get the use of the control variable in a GIMPLE_OMP_CONTINUE.

References gomp_continue::control_use.

Referenced by dump_gimple_omp_continue(), expand_oacc_for(), expand_omp_for_generic(), expand_omp_for_static_chunk(), expand_omp_for_static_nochunk(), expand_omp_sections(), and expand_omp_taskloop_for_inner().

◆ gimple_omp_continue_control_use_ptr()

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

References gomp_continue::control_use.

Referenced by walk_gimple_op().

◆ gimple_omp_continue_set_control_def()

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

References gomp_continue::control_def.

Referenced by gimple_build_omp_continue().

◆ gimple_omp_continue_set_control_use()

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

References gomp_continue::control_use.

Referenced by gimple_build_omp_continue().

◆ gimple_omp_critical_clauses()

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

References gomp_critical::clauses.

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

◆ gimple_omp_critical_clauses_ptr()

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

References gomp_critical::clauses.

Referenced by walk_gimple_op().

◆ gimple_omp_critical_name()

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

References gomp_critical::name.

Referenced by check_omp_nesting_restrictions(), dump_gimple_omp_critical(), gimple_copy(), lower_omp_critical(), and remap_gimple_stmt().

◆ gimple_omp_critical_name_ptr()

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

References gomp_critical::name.

Referenced by walk_gimple_op().

◆ gimple_omp_critical_set_clauses()

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

References gomp_critical::clauses.

Referenced by gimple_build_omp_critical(), and gimple_copy().

◆ gimple_omp_critical_set_name()

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

References gomp_critical::name.

Referenced by gimple_build_omp_critical(), and gimple_copy().

◆ gimple_omp_dispatch_clauses()

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

References GIMPLE_CHECK.

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

◆ gimple_omp_dispatch_clauses_ptr()

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

References GIMPLE_CHECK.

◆ gimple_omp_dispatch_set_clauses()

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

References GIMPLE_CHECK.

Referenced by gimple_build_omp_dispatch(), and gimple_copy().

◆ gimple_omp_for_clauses()

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

References as_a(), and gomp_for::clauses.

Referenced by add_taskreg_looptemp_clauses(), adjust_nested_loop_clauses(), adjust_region_code_walk_stmt_fn(), check_oacc_kernel_gwv(), check_omp_nesting_restrictions(), determine_parallel_type(), dump_gimple_omp_for(), expand_omp_for_generic(), expand_omp_for_init_counts(), expand_omp_for_init_vars(), expand_omp_for_static_chunk(), expand_omp_for_static_nochunk(), expand_omp_simd(), expand_omp_taskloop_for_inner(), expand_task_call(), gimple_copy(), gimplify_omp_for(), lower_oacc_reductions(), lower_omp_1(), lower_omp_for(), lower_omp_for_lastprivate(), lower_omp_for_scan(), lower_omp_scan(), lower_omp_task_reductions(), lower_rec_input_clauses(), lower_rec_simd_input_clauses(), omp_extract_for_data(), remap_gimple_stmt(), scan_omp_1_stmt(), scan_omp_for(), scan_omp_simd(), transform_kernels_loop_clauses(), and visit_loops_in_gang_single_region().

◆ gimple_omp_for_clauses_ptr()

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

References as_a(), and gomp_for::clauses.

Referenced by convert_local_reference_stmt(), convert_nonlocal_reference_stmt(), gimplify_omp_for(), lower_omp_for(), and walk_gimple_op().

◆ gimple_omp_for_collapse()

size_t gimple_omp_for_collapse ( const gimple * gs)
inline 
Get the collapse count of the OMP_FOR statement GS.

References as_a(), and gomp_for::collapse.

Referenced by dump_gimple_omp_for(), expand_omp_for(), gimple_copy(), gimplify_omp_for(), lower_omp_for(), lower_omp_ordered_clauses(), lower_rec_input_clauses(), remap_gimple_stmt(), scan_omp_1_stmt(), scan_omp_for(), walk_gimple_omp_for(), and walk_gimple_op().

◆ gimple_omp_for_combined_into_p()

bool gimple_omp_for_combined_into_p ( const gimple * g)
inline 
Return true if the OMP_FOR statement G has the
GF_OMP_FOR_COMBINED_INTO flag set.

References g, GF_OMP_FOR_COMBINED_INTO, GIMPLE_CHECK, and gimple_omp_subcode().

Referenced by check_omp_nesting_restrictions(), expand_oacc_for(), expand_omp_for(), expand_omp_for_generic(), expand_omp_for_init_counts(), expand_omp_for_static_chunk(), expand_omp_for_static_nochunk(), expand_omp_simd(), get_ws_args_for(), lower_omp_for(), lower_omp_for_lastprivate(), lower_omp_scan(), lower_rec_input_clauses(), omp_find_combined_for(), omp_find_scan(), and scan_omp_1_stmt().

◆ gimple_omp_for_combined_p()

bool gimple_omp_for_combined_p ( const gimple * g)
inline 
Return true if OMP_FOR statement G has the
GF_OMP_FOR_COMBINED flag set.

References g, GF_OMP_FOR_COMBINED, GIMPLE_CHECK, and gimple_omp_subcode().

Referenced by check_omp_nesting_restrictions(), expand_omp(), expand_omp_for_generic(), expand_omp_for_init_vars(), expand_omp_for_static_chunk(), expand_omp_for_static_nochunk(), expand_omp_taskloop_for_inner(), lower_omp_for_scan(), and lower_omp_scan().

◆ gimple_omp_for_cond()

enum tree_code gimple_omp_for_cond ( const gimple * gs,
size_t i )
inline 
Return the condition code associated with the OMP_FOR statement GS.

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

Referenced by dump_gimple_omp_for(), gimple_copy(), gimplify_omp_for(), omp_extract_for_data(), and remap_gimple_stmt().

◆ gimple_omp_for_final()

tree gimple_omp_for_final ( const gimple * gs,
size_t i )
inline 
Return the final value for the OMP_FOR statement GS.

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

Referenced by dump_gimple_omp_for(), gimple_copy(), gimplify_omp_for(), omp_extract_for_data(), and remap_gimple_stmt().

◆ gimple_omp_for_final_ptr()

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

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

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

◆ gimple_omp_for_incr()

tree gimple_omp_for_incr ( const gimple * gs,
size_t i )
inline 
Return the increment value for the OMP_FOR statement GS.

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

Referenced by dump_gimple_omp_for(), gimple_copy(), gimplify_omp_for(), lower_omp_for(), omp_extract_for_data(), remap_gimple_stmt(), and walk_gimple_omp_for().

◆ gimple_omp_for_incr_ptr()

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

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

Referenced by scan_omp_for(), and walk_gimple_op().

◆ gimple_omp_for_index()

tree gimple_omp_for_index ( const gimple * gs,
size_t i )
inline 
Return the index variable for the OMP_FOR statement GS.

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

Referenced by add_taskreg_looptemp_clauses(), dump_gimple_omp_for(), expand_oacc_for(), gimple_copy(), gimplify_omp_for(), lower_omp_for(), lower_omp_for_lastprivate(), lower_rec_input_clauses(), omp_extract_for_data(), and remap_gimple_stmt().

◆ gimple_omp_for_index_ptr()

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

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

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

◆ gimple_omp_for_initial()

tree gimple_omp_for_initial ( const gimple * gs,
size_t i )
inline 
Return the initial value for the OMP_FOR statement GS.

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

Referenced by dump_gimple_omp_for(), gimple_copy(), gimplify_omp_for(), omp_extract_for_data(), and remap_gimple_stmt().

◆ gimple_omp_for_initial_ptr()

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

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

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

◆ gimple_omp_for_kind()

int gimple_omp_for_kind ( const gimple * g)
inline 
Return the kind of the OMP_FOR statemement G.

References g, GF_OMP_FOR_KIND_MASK, GIMPLE_CHECK, and gimple_omp_subcode().

Referenced by build_outer_var_ref(), check_omp_nesting_restrictions(), dump_gimple_omp_for(), expand_oacc_for(), expand_omp_for(), expand_omp_for_generic(), expand_omp_for_static_chunk(), expand_omp_for_static_nochunk(), expand_task_call(), is_gimple_omp_oacc(), is_taskloop_ctx(), lower_lastprivate_clauses(), lower_lastprivate_conditional_clauses(), lower_omp_for(), lower_omp_for_lastprivate(), lower_omp_scan(), lower_rec_input_clauses(), lower_reduction_clauses(), omp_extract_for_data(), omp_find_combined_for(), omp_find_scan(), remap_gimple_stmt(), scan_omp_1_stmt(), scan_sharing_clauses(), and workshare_safe_to_combine_p().

◆ gimple_omp_for_pre_body()

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

References gimple_omp_for_pre_body_ptr().

Referenced by diagnose_sb_1(), dump_gimple_omp_for(), estimate_num_insns(), gimple_copy(), gimplify_omp_for(), lower_omp_for(), omp_find_stores_stmt(), remap_gimple_stmt(), and walk_gimple_omp_for().

◆ gimple_omp_for_pre_body_ptr()

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

References as_a(), and gomp_for::pre_body.

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

◆ gimple_omp_for_set_clauses()

void gimple_omp_for_set_clauses ( gimple * gs,
tree clauses )
inline 
Set CLAUSES to be the list of clauses associated with the OMP_FOR statement
GS.

References as_a(), and gomp_for::clauses.

Referenced by adjust_nested_loop_clauses(), gimple_build_omp_for(), gimple_copy(), gimplify_omp_for(), lower_omp_for(), lower_omp_for_scan(), lower_rec_input_clauses(), scan_omp_for(), scan_omp_simd(), transform_kernels_loop_clauses(), and visit_loops_in_gang_single_region().

◆ gimple_omp_for_set_combined_into_p()

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

References g, and GF_OMP_FOR_COMBINED_INTO.

Referenced by gimplify_omp_for().

◆ gimple_omp_for_set_combined_p()

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

References g, and GF_OMP_FOR_COMBINED.

Referenced by gimplify_omp_for().

◆ gimple_omp_for_set_cond()

void gimple_omp_for_set_cond ( gimple * gs,
size_t i,
enum tree_code cond )
inline 
Set COND to be the condition code for the OMP_FOR statement GS.

References as_a(), gimple_omp_for_iter::cond, gcc_gimple_checking_assert, i, gomp_for::iter, tcc_comparison, and TREE_CODE_CLASS.

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

◆ gimple_omp_for_set_final()

void gimple_omp_for_set_final ( gimple * gs,
size_t i,
tree final )
inline 
Set FINAL to be the final value for the OMP_FOR statement GS.

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

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

◆ gimple_omp_for_set_incr()

void gimple_omp_for_set_incr ( gimple * gs,
size_t i,
tree incr )
inline 
Set INCR to be the increment value for the OMP_FOR statement GS.

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

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

◆ gimple_omp_for_set_index()

void gimple_omp_for_set_index ( gimple * gs,
size_t i,
tree index )
inline 
Set INDEX to be the index variable for the OMP_FOR statement GS.

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

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

◆ gimple_omp_for_set_initial()

void gimple_omp_for_set_initial ( gimple * gs,
size_t i,
tree initial )
inline 
Set INITIAL to be the initial value for the OMP_FOR statement GS.

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

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

◆ gimple_omp_for_set_kind()

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

References g, and GF_OMP_FOR_KIND_MASK.

Referenced by gimple_build_omp_for().

◆ gimple_omp_for_set_pre_body()

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

References as_a(), and gomp_for::pre_body.

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

◆ gimple_omp_interop_clauses()

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

References GIMPLE_CHECK.

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

◆ gimple_omp_interop_clauses_ptr()

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

References GIMPLE_CHECK.

Referenced by lower_omp_interop().

◆ gimple_omp_interop_set_clauses()

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

References GIMPLE_CHECK.

Referenced by gimple_build_omp_interop(), and gimple_copy().

◆ gimple_omp_masked_clauses()

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

References GIMPLE_CHECK.

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

◆ gimple_omp_masked_clauses_ptr()

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

References GIMPLE_CHECK.

◆ gimple_omp_masked_set_clauses()

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

References GIMPLE_CHECK.

Referenced by gimple_build_omp_masked(), and gimple_copy().

◆ gimple_omp_ordered_clauses()

tree gimple_omp_ordered_clauses ( const gomp_ordered * ord_stmt)
inline 
Return the clauses associated with OMP_ORDERED statement ORD_STMT.

References gimple_statement_omp_single_layout::clauses.

Referenced by check_omp_nesting_restrictions(), dump_gimple_omp_ordered(), expand_omp_ordered_source_sink(), gimple_copy(), lower_omp_ordered(), lower_omp_ordered_clauses(), and remap_gimple_stmt().

◆ gimple_omp_ordered_clauses_ptr()

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

References gimple_statement_omp_single_layout::clauses.

Referenced by lower_omp_ordered_clauses(), and walk_gimple_op().

◆ gimple_omp_ordered_set_clauses()

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

References gimple_statement_omp_single_layout::clauses.

Referenced by gimple_build_omp_ordered(), and gimple_copy().

◆ gimple_omp_ordered_standalone()

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

References g, GF_OMP_ORDERED_STANDALONE, and GIMPLE_CHECK.

Referenced by gimplify_expr().

◆ gimple_omp_ordered_standalone_p()

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

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

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

◆ gimple_omp_parallel_child_fn()

tree gimple_omp_parallel_child_fn ( const gomp_parallel * omp_parallel_stmt)
inline 
Return the child function used to hold the body of OMP_PARALLEL_STMT.

References gimple_statement_omp_parallel_layout::child_fn.

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

◆ gimple_omp_parallel_child_fn_ptr()

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

References gimple_statement_omp_parallel_layout::child_fn.

Referenced by walk_gimple_op().

◆ gimple_omp_parallel_clauses()

tree gimple_omp_parallel_clauses ( const gimple * gs)
inline 
Return the clauses associated with OMP_PARALLEL GS.

References as_a(), and gimple_statement_omp_parallel_layout::clauses.

Referenced by add_taskreg_looptemp_clauses(), determine_parallel_type(), dump_gimple_omp_parallel(), expand_omp_for_static_chunk(), expand_omp_for_static_nochunk(), expand_parallel_call(), finish_taskreg_scan(), get_ws_args_for(), gimple_copy(), lower_lastprivate_clauses(), lower_omp_task_reductions(), lower_omp_taskreg(), remap_gimple_stmt(), and scan_omp_parallel().

◆ gimple_omp_parallel_clauses_ptr()

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

References gimple_statement_omp_parallel_layout::clauses.

Referenced by walk_gimple_op().

◆ gimple_omp_parallel_combined_p()

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

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

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

◆ gimple_omp_parallel_data_arg()

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

References gimple_statement_omp_parallel_layout::data_arg.

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

◆ gimple_omp_parallel_data_arg_ptr()

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

References gimple_statement_omp_parallel_layout::data_arg.

Referenced by walk_gimple_op().

◆ gimple_omp_parallel_set_child_fn()

void gimple_omp_parallel_set_child_fn ( gomp_parallel * omp_parallel_stmt,
tree child_fn )
inline 
Set CHILD_FN to be the child function for OMP_PARALLEL_STMT.

References gimple_statement_omp_parallel_layout::child_fn.

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

◆ gimple_omp_parallel_set_clauses()

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

References gimple_statement_omp_parallel_layout::clauses.

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

◆ gimple_omp_parallel_set_combined_p()

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

References g, GF_OMP_PARALLEL_COMBINED, and GIMPLE_CHECK.

Referenced by lower_omp_taskreg().

◆ gimple_omp_parallel_set_data_arg()

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

References gimple_statement_omp_parallel_layout::data_arg.

Referenced by gimple_build_omp_parallel(), and gimple_copy().

◆ gimple_omp_return_lhs()

tree gimple_omp_return_lhs ( const gimple * g)
inline 
Get the LHS of OMP return.

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

Referenced by dump_gimple_omp_return(), expand_omp_for_generic(), expand_omp_for_static_chunk(), expand_omp_for_static_nochunk(), expand_omp_sections(), and expand_omp_single().

◆ gimple_omp_return_lhs_ptr()

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

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

Referenced by walk_gimple_op().

◆ gimple_omp_return_nowait_p()

bool gimple_omp_return_nowait_p ( const gimple * g)
inline 
Return true if OMP return statement G has the GF_OMP_RETURN_NOWAIT
flag set.

References g, GF_OMP_RETURN_NOWAIT, GIMPLE_CHECK, and gimple_omp_subcode().

Referenced by dump_gimple_omp_return(), expand_omp_for_generic(), expand_omp_for_static_chunk(), expand_omp_for_static_nochunk(), expand_omp_sections(), expand_omp_single(), maybe_add_implicit_barrier_cancel(), and remove_exit_barrier().

◆ gimple_omp_return_set_lhs()

void gimple_omp_return_set_lhs ( gimple * g,
tree lhs )
inline 
Set the LHS of OMP return.

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

Referenced by maybe_add_implicit_barrier_cancel().

◆ gimple_omp_return_set_nowait()

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

References GF_OMP_RETURN_NOWAIT, GIMPLE_CHECK, and gimple::subcode.

Referenced by gimple_build_omp_return(), and remove_exit_barrier().

◆ gimple_omp_scan_clauses()

tree gimple_omp_scan_clauses ( const gomp_scan * scan_stmt)
inline 
Return the clauses associated with OMP_SCAN statement SCAN_STMT.

References gimple_statement_omp_single_layout::clauses.

Referenced by dump_gimple_omp_scan(), gimple_copy(), lower_omp_scan(), remap_gimple_stmt(), scan_omp_1_stmt(), and scan_omp_simd_scan().

◆ gimple_omp_scan_clauses_ptr()

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

References gimple_statement_omp_single_layout::clauses.

Referenced by walk_gimple_op().

◆ gimple_omp_scan_set_clauses()

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

References gimple_statement_omp_single_layout::clauses.

Referenced by gimple_build_omp_scan(), and gimple_copy().

◆ gimple_omp_scope_clauses()

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

References GIMPLE_CHECK.

Referenced by dump_gimple_omp_scope(), gimple_copy(), lower_omp_scope(), lower_omp_task_reductions(), remap_gimple_stmt(), and scan_omp_1_stmt().

◆ gimple_omp_scope_clauses_ptr()

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

References GIMPLE_CHECK.

Referenced by convert_local_reference_stmt(), and convert_nonlocal_reference_stmt().

◆ gimple_omp_scope_set_clauses()

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

References GIMPLE_CHECK.

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

◆ gimple_omp_section_last_p()

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

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

Referenced by expand_omp_sections().

◆ gimple_omp_section_set_last()

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

References g, GF_OMP_SECTION_LAST, and GIMPLE_CHECK.

Referenced by lower_omp_sections().

◆ gimple_omp_sections_clauses()

tree gimple_omp_sections_clauses ( const gimple * gs)
inline 
Return the clauses associated with OMP_SECTIONS GS.

References as_a(), and gomp_sections::clauses.

Referenced by check_omp_nesting_restrictions(), determine_parallel_type(), dump_gimple_omp_sections(), expand_omp_sections(), gimple_copy(), lower_omp_1(), lower_omp_sections(), lower_omp_task_reductions(), remap_gimple_stmt(), and scan_omp_sections().

◆ gimple_omp_sections_clauses_ptr()

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

References as_a(), and gomp_sections::clauses.

Referenced by convert_local_reference_stmt(), convert_nonlocal_reference_stmt(), lower_omp_sections(), and walk_gimple_op().

◆ gimple_omp_sections_control()

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

References as_a(), and gomp_sections::control.

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

◆ gimple_omp_sections_control_ptr()

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

References as_a(), and gomp_sections::control.

Referenced by walk_gimple_op().

◆ gimple_omp_sections_set_clauses()

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

References as_a(), and gomp_sections::clauses.

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

◆ gimple_omp_sections_set_control()

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

References as_a(), and gomp_sections::control.

Referenced by gimple_copy(), and lower_omp_sections().

◆ gimple_omp_set_body()

void gimple_omp_set_body ( gimple * gs,
gimple_seq body )
inline 
Set BODY to be the body for the OMP statement GS.

Referenced by gimple_build_omp_critical(), gimple_build_omp_dispatch(), gimple_build_omp_for(), gimple_build_omp_masked(), gimple_build_omp_master(), gimple_build_omp_ordered(), gimple_build_omp_parallel(), gimple_build_omp_scan(), gimple_build_omp_scope(), gimple_build_omp_section(), gimple_build_omp_sections(), gimple_build_omp_single(), gimple_build_omp_structured_block(), gimple_build_omp_target(), gimple_build_omp_task(), gimple_build_omp_taskgroup(), gimple_build_omp_teams(), gimple_copy(), lower_omp_critical(), lower_omp_directive(), lower_omp_for(), lower_omp_for_scan(), 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_seq(), maybe_build_inner_data_region(), omp_oacc_kernels_decompose_1(), scan_omp_simd_scan(), and scan_omp_target().

◆ gimple_omp_set_subcode()

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

References gcc_gimple_checking_assert, and gimple::subcode.

Referenced by expand_omp_taskreg(), and gimplify_omp_parallel().

◆ gimple_omp_single_clauses()

tree gimple_omp_single_clauses ( const gimple * gs)
inline 
Return the clauses associated with OMP_SINGLE GS.

References as_a(), and gimple_statement_omp_single_layout::clauses.

Referenced by dump_gimple_omp_single(), gimple_copy(), lower_omp_single(), lower_omp_single_copy(), remap_gimple_stmt(), and scan_omp_single().

◆ gimple_omp_single_clauses_ptr()

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

References as_a(), and gimple_statement_omp_single_layout::clauses.

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

◆ gimple_omp_single_set_clauses()

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

References gimple_statement_omp_single_layout::clauses.

Referenced by gimple_build_omp_single(), and gimple_copy().

◆ gimple_omp_subcode()

unsigned gimple_omp_subcode ( const gimple * s)
inline 
Return the subcode for OMP statement S.

References gcc_gimple_checking_assert, and gimple::subcode.

Referenced by gimple_omp_atomic_memory_order(), gimple_omp_atomic_need_value_p(), gimple_omp_atomic_weak_p(), gimple_omp_for_combined_into_p(), gimple_omp_for_combined_p(), gimple_omp_for_kind(), gimple_omp_ordered_standalone_p(), gimple_omp_parallel_combined_p(), gimple_omp_return_nowait_p(), gimple_omp_section_last_p(), gimple_omp_target_kind(), gimple_omp_task_taskloop_p(), gimple_omp_task_taskwait_p(), and gimple_omp_teams_host().

◆ gimple_omp_target_child_fn()

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

References gimple_statement_omp_parallel_layout::child_fn.

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

◆ gimple_omp_target_child_fn_ptr()

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

References gimple_statement_omp_parallel_layout::child_fn.

Referenced by walk_gimple_op().

◆ gimple_omp_target_clauses()

tree gimple_omp_target_clauses ( const gimple * gs)
inline 
Return the clauses associated with OMP_TARGET GS.

References as_a(), and gimple_statement_omp_parallel_layout::clauses.

Referenced by add_async_clauses_and_wait(), check_omp_nesting_restrictions(), convert_gimple_call(), convert_local_reference_stmt(), convert_nonlocal_reference_stmt(), convert_tramp_reference_stmt(), dump_gimple_omp_target(), expand_omp_target(), get_target_arguments(), gimple_copy(), lower_oacc_reductions(), lower_omp_target(), omp_oacc_kernels_decompose_1(), remap_gimple_stmt(), scan_omp_1_stmt(), scan_omp_target(), and use_pointer_for_field().

◆ gimple_omp_target_clauses_ptr()

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

References as_a(), and gimple_statement_omp_parallel_layout::clauses.

Referenced by convert_local_reference_stmt(), convert_nonlocal_reference_stmt(), lower_omp_target(), and walk_gimple_op().

◆ gimple_omp_target_data_arg()

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

References gimple_statement_omp_parallel_layout::data_arg.

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

◆ gimple_omp_target_data_arg_ptr()

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

References gimple_statement_omp_parallel_layout::data_arg.

Referenced by walk_gimple_op().

◆ gimple_omp_target_kind()

int gimple_omp_target_kind ( const gimple * g)
inline 
Return the kind of the OMP_TARGET G.

References g, GF_OMP_TARGET_KIND_MASK, GIMPLE_CHECK, and gimple_omp_subcode().

Referenced by build_omp_regions_1(), check_omp_nesting_restrictions(), ctx_in_oacc_kernels_region(), dump_gimple_omp_target(), expand_omp_target(), is_gimple_omp_oacc(), is_gimple_omp_offloaded(), is_oacc_kernels(), is_oacc_kernels_decomposed_part(), is_oacc_parallel_or_serial(), is_omp_target(), lower_omp_1(), lower_omp_target(), omp_make_gimple_edges(), omp_oacc_kernels_decompose_1(), omp_oacc_kernels_decompose_callback_stmt(), remap_gimple_stmt(), and scan_omp_1_stmt().

◆ gimple_omp_target_set_child_fn()

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

References gimple_statement_omp_parallel_layout::child_fn.

Referenced by scan_omp_target().

◆ gimple_omp_target_set_clauses()

void gimple_omp_target_set_clauses ( gomp_target * omp_target_stmt,
tree clauses )
inline 
Set CLAUSES to be the clauses associated with OMP_TARGET_STMT.

References gimple_statement_omp_parallel_layout::clauses.

Referenced by add_async_clauses_and_wait(), convert_gimple_call(), convert_local_reference_stmt(), convert_nonlocal_reference_stmt(), convert_tramp_reference_stmt(), gimple_build_omp_target(), and gimple_copy().

◆ gimple_omp_target_set_data_arg()

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

References gimple_statement_omp_parallel_layout::data_arg.

Referenced by gimple_copy(), and lower_omp_target().

◆ gimple_omp_target_set_kind()

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

References g, and GF_OMP_TARGET_KIND_MASK.

Referenced by gimple_build_omp_target().

◆ gimple_omp_task_arg_align()

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

References gomp_task::arg_align, and as_a().

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

◆ gimple_omp_task_arg_align_ptr()

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

References gomp_task::arg_align, and as_a().

Referenced by walk_gimple_op().

◆ gimple_omp_task_arg_size()

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

References gomp_task::arg_size, and as_a().

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

◆ gimple_omp_task_arg_size_ptr()

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

References gomp_task::arg_size, and as_a().

Referenced by walk_gimple_op().

◆ gimple_omp_task_child_fn()

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

References as_a(), and gimple_statement_omp_parallel_layout::child_fn.

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

◆ gimple_omp_task_child_fn_ptr()

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

References as_a(), and gimple_statement_omp_parallel_layout::child_fn.

Referenced by walk_gimple_op().

◆ gimple_omp_task_clauses()

tree gimple_omp_task_clauses ( const gimple * gs)
inline 
Return the clauses associated with OMP_TASK GS.

References as_a(), and gimple_statement_omp_parallel_layout::clauses.

Referenced by add_taskreg_looptemp_clauses(), check_omp_nesting_restrictions(), create_task_copyfn(), dump_gimple_omp_task(), expand_omp_taskloop_for_outer(), expand_task_call(), expand_taskwait_call(), finish_taskreg_scan(), gimple_copy(), lower_omp_taskreg(), optimize_omp_library_calls(), remap_gimple_stmt(), and scan_omp_task().

◆ gimple_omp_task_clauses_ptr()

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

References as_a(), and gimple_statement_omp_parallel_layout::clauses.

Referenced by lower_omp_taskreg(), and walk_gimple_op().

◆ gimple_omp_task_copy_fn()

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

References as_a(), and gomp_task::copy_fn.

Referenced by create_task_copyfn(), dump_gimple_omp_task(), expand_task_call(), finalize_task_copyfn(), gimple_copy(), and remap_gimple_stmt().

◆ gimple_omp_task_copy_fn_ptr()

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

References as_a(), and gomp_task::copy_fn.

Referenced by walk_gimple_op().

◆ gimple_omp_task_data_arg()

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

References as_a(), and gimple_statement_omp_parallel_layout::data_arg.

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

◆ gimple_omp_task_data_arg_ptr()

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

References as_a(), and gimple_statement_omp_parallel_layout::data_arg.

Referenced by walk_gimple_op().

◆ gimple_omp_task_set_arg_align()

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

References gomp_task::arg_align, and as_a().

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

◆ gimple_omp_task_set_arg_size()

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

References gomp_task::arg_size, and as_a().

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

◆ gimple_omp_task_set_child_fn()

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

References as_a(), and gimple_statement_omp_parallel_layout::child_fn.

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

◆ gimple_omp_task_set_clauses()

void gimple_omp_task_set_clauses ( gimple * gs,
tree clauses )
inline 
Set CLAUSES to be the list of clauses associated with OMP_TASK
GS.

References as_a(), and gimple_statement_omp_parallel_layout::clauses.

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

◆ gimple_omp_task_set_copy_fn()

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

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

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

◆ gimple_omp_task_set_data_arg()

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

References as_a(), and gimple_statement_omp_parallel_layout::data_arg.

Referenced by gimple_build_omp_task(), and gimple_copy().

◆ gimple_omp_task_set_taskloop_p()

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

References g, GF_OMP_TASK_TASKLOOP, and GIMPLE_CHECK.

Referenced by gimplify_omp_for().

◆ gimple_omp_task_set_taskwait_p()

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

References g, GF_OMP_TASK_TASKWAIT, and GIMPLE_CHECK.

Referenced by gimplify_omp_task().

◆ gimple_omp_task_taskloop_p()

bool gimple_omp_task_taskloop_p ( const gimple * g)
inline 
Return true if OMP task statement G has the
GF_OMP_TASK_TASKLOOP flag set.

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

Referenced by check_omp_nesting_restrictions(), dump_gimple_omp_task(), expand_omp_taskloop_for_outer(), expand_task_call(), finish_taskreg_scan(), lower_omp_taskreg(), lower_send_clauses(), and scan_omp_task().

◆ gimple_omp_task_taskwait_p()

bool gimple_omp_task_taskwait_p ( const gimple * g)
inline 
Return true if OMP task statement G has the
GF_OMP_TASK_TASKWAIT flag set.

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

Referenced by build_omp_regions_1(), dump_gimple_omp_task(), expand_omp_taskreg(), lower_omp_taskreg(), omp_make_gimple_edges(), and scan_omp_task().

◆ gimple_omp_taskgroup_clauses()

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

References GIMPLE_CHECK.

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

◆ gimple_omp_taskgroup_clauses_ptr()

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

References GIMPLE_CHECK.

Referenced by convert_local_reference_stmt(), and convert_nonlocal_reference_stmt().

◆ gimple_omp_taskgroup_set_clauses()

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

References GIMPLE_CHECK.

Referenced by gimple_build_omp_taskgroup(), and gimple_copy().

◆ gimple_omp_taskreg_child_fn()

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

References as_a(), and gimple_statement_omp_parallel_layout::child_fn.

Referenced by adjust_context_and_scope(), and expand_omp_taskreg().

◆ gimple_omp_taskreg_child_fn_ptr()

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

References as_a(), and gimple_statement_omp_parallel_layout::child_fn.

◆ gimple_omp_taskreg_clauses()

tree gimple_omp_taskreg_clauses ( const gimple * gs)
inline 
Return the clauses associated with OMP_TASK GS.

References as_a(), and gimple_statement_omp_parallel_layout::clauses.

Referenced by add_taskreg_looptemp_clauses(), convert_gimple_call(), convert_local_reference_stmt(), convert_nonlocal_reference_stmt(), convert_tramp_reference_stmt(), expand_omp_for_init_vars(), finish_taskreg_scan(), lower_omp_for(), lower_omp_for_lastprivate(), lower_omp_task_reductions(), lower_omp_taskreg(), and use_pointer_for_field().

◆ gimple_omp_taskreg_clauses_ptr()

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

References as_a(), and gimple_statement_omp_parallel_layout::clauses.

Referenced by convert_local_reference_stmt(), and convert_nonlocal_reference_stmt().

◆ gimple_omp_taskreg_data_arg()

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

References as_a(), and gimple_statement_omp_parallel_layout::data_arg.

Referenced by expand_omp_taskreg().

◆ gimple_omp_taskreg_data_arg_ptr()

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

References as_a(), and gimple_statement_omp_parallel_layout::data_arg.

◆ gimple_omp_taskreg_set_child_fn()

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

References as_a(), and gimple_statement_omp_parallel_layout::child_fn.

◆ gimple_omp_taskreg_set_clauses()

void gimple_omp_taskreg_set_clauses ( gimple * gs,
tree clauses )
inline 
Set CLAUSES to be the list of clauses associated with OMP_TASK
GS.

References as_a(), and gimple_statement_omp_parallel_layout::clauses.

Referenced by add_taskreg_looptemp_clauses(), convert_gimple_call(), convert_local_reference_stmt(), convert_nonlocal_reference_stmt(), and convert_tramp_reference_stmt().

◆ gimple_omp_taskreg_set_data_arg()

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

References as_a(), and gimple_statement_omp_parallel_layout::data_arg.

Referenced by lower_omp_taskreg().

◆ gimple_omp_teams_child_fn()

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

References gimple_statement_omp_parallel_layout::child_fn.

Referenced by expand_teams_call().

◆ gimple_omp_teams_child_fn_ptr()

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

References gimple_statement_omp_parallel_layout::child_fn.

◆ gimple_omp_teams_clauses()

tree gimple_omp_teams_clauses ( const gimple * gs)
inline 
Return the clauses associated with OMP_TEAMS GS.

References as_a(), and gimple_statement_omp_parallel_layout::clauses.

Referenced by dump_gimple_omp_teams(), expand_teams_call(), gimple_copy(), lower_omp_teams(), remap_gimple_stmt(), and scan_omp_teams().

◆ gimple_omp_teams_clauses_ptr()

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

References as_a(), and gimple_statement_omp_parallel_layout::clauses.

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

◆ gimple_omp_teams_data_arg()

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

References gimple_statement_omp_parallel_layout::data_arg.

Referenced by expand_teams_call().

◆ gimple_omp_teams_data_arg_ptr()

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

References gimple_statement_omp_parallel_layout::data_arg.

◆ gimple_omp_teams_host()

bool gimple_omp_teams_host ( const gomp_teams * omp_teams_stmt)
inline 
Return the host flag of an OMP_TEAMS_STMT.

References GF_OMP_TEAMS_HOST, and gimple_omp_subcode().

Referenced by convert_gimple_call(), convert_local_reference_stmt(), convert_nonlocal_reference_stmt(), convert_tramp_reference_stmt(), expand_omp_synch(), is_host_teams_ctx(), lower_omp_1(), scan_omp_1_stmt(), and scan_omp_teams().

◆ gimple_omp_teams_set_child_fn()

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

References gimple_statement_omp_parallel_layout::child_fn.

Referenced by scan_omp_teams().

◆ gimple_omp_teams_set_clauses()

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

References gimple_statement_omp_parallel_layout::clauses.

Referenced by gimple_build_omp_teams(), and gimple_copy().

◆ gimple_omp_teams_set_data_arg()

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

References gimple_statement_omp_parallel_layout::data_arg.

◆ gimple_omp_teams_set_host()

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

References GF_OMP_TEAMS_HOST, and gimple::subcode.

Referenced by gimplify_omp_workshare().

◆ gimple_op()

tree gimple_op ( const gimple * gs,
unsigned i )
inline 
Return operand I for statement GS.

References CONST_CAST_GIMPLE, gcc_gimple_checking_assert, gimple_has_ops(), gimple_num_ops(), gimple_ops(), i, and NULL_TREE.

Referenced by analyze_function_body(), check_call(), ipa_icf_gimple::func_checker::compare_gimple_assign(), hybrid_jt_simplifier::compute_exit_dependencies(), decompose_param_expr(), estimate_num_insns(), expand_complex_operations_1(), find_func_aliases(), find_tail_calls(), gimple_arg(), gimple_assign_copy_p(), gimple_copy(), gimple_could_trap_p_1(), gimple_debug_bind_get_value(), gimple_debug_bind_get_var(), gimple_debug_bind_has_value_p(), gimple_debug_source_bind_get_value(), gimple_debug_source_bind_get_var(), gimple_duplicate_bb(), gimple_goto_dest(), gimple_lower_bitint(), gimple_regimplify_operands(), ipa_icf::sem_function::hash_stmt(), init_dont_simulate_again(), init_vn_nary_op_from_stmt(), is_feasible_trace(), likely_value(), op_iter_next_tree(), vars_ssa_cache::operator()(), output_gimple_stmt(), predicate_rhs_code(), reorder_operands(), replace_uses_by(), rewrite_to_defined_unconditional(), stmt_could_throw_1_p(), update_epilogue_loop_vinfo(), vect_determine_mask_precision(), vect_determine_precisions_from_range(), vect_determine_precisions_from_users(), vect_is_simple_use(), vect_mark_stmts_to_be_vectorized(), vect_recog_over_widening_pattern(), vect_slp_linearize_chain(), walk_stmt_load_store_addr_ops(), and will_be_nonconstant_predicate().

◆ gimple_op_ptr()

tree * gimple_op_ptr ( gimple * gs,
unsigned i )
inline 
Return a pointer to operand I for statement GS.

References gcc_gimple_checking_assert, gimple_has_ops(), gimple_num_ops(), gimple_ops(), i, and NULL.

Referenced by clear_unused_block_pointer(), gimple_arg_ptr(), gimple_debug_bind_get_value_ptr(), gimple_debug_source_bind_get_value_ptr(), input_gimple_stmt(), maybe_record_in_goto_queue(), op_iter_next_def(), operands_scanner::parse_ssa_operands(), remap_gimple_stmt(), remove_unused_locals(), replace_goto_queue_1(), and walk_gimple_op().

◆ gimple_ops()

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

References gcc_gimple_checking_assert, gimple_ops_offset_, and gimple_statement_structure().

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

◆ gimple_or_expr_nonartificial_location()

location_t gimple_or_expr_nonartificial_location ( gimple * stmt,
tree expr )
extern 
Return a non-artificial location for STMT.  If STMT does not have
location information, get the location from EXPR.

References expansion_point_location_if_in_system_header(), EXPR_HAS_LOCATION, gimple_nonartificial_location(), tree_nonartificial_location(), and UNKNOWN_LOCATION.

Referenced by strlen_pass::handle_builtin_stxncpy_strncat(), maybe_diag_stxncpy_trunc(), strlen_pass::maybe_warn_overflow(), and maybe_warn_pointless_strcmp().

◆ gimple_phi_arg() [1/4]

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

References as_a(), and gimple_phi_arg().

◆ gimple_phi_arg() [2/4]

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

References gphi::args, and gcc_gimple_checking_assert.

◆ gimple_phi_arg() [3/4]

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

References as_a(), and gimple_phi_arg().

◆ gimple_phi_arg() [4/4]

struct phi_arg_d * gimple_phi_arg ( gphi * gs,
unsigned index )
inline 
Return the PHI argument corresponding to incoming edge INDEX for
GIMPLE_PHI GS.

References gphi::args, and gcc_gimple_checking_assert.

Referenced by check_for_plus_in_loops_1(), collect_object_sizes_for(), ipa_icf::sem_function::compare_phi_node(), path_range_query::compute_exit_dependencies(), get_range_strlen(), gimple_phi_arg(), gimple_phi_arg(), gimple_phi_arg_def(), gimple_phi_arg_def(), gimple_phi_arg_def_from_edge(), gimple_phi_arg_def_from_edge(), gimple_phi_arg_def_ptr(), gimple_phi_arg_imm_use_ptr(), gimple_phi_arg_imm_use_ptr_from_edge(), gimple_phi_arg_location(), gimple_phi_arg_location_from_edge(), gimple_phi_arg_location_ptr(), gimple_phi_arg_set_location(), lower_emutls_phi_arg(), phi_arg_index_from_use(), predicate_for_phi_result(), and ccp_propagate::visit_phi().

◆ gimple_phi_arg_def() [1/2]

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

References gimple_phi_arg().

◆ gimple_phi_arg_def() [2/2]

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

References gimple_phi_arg().

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

◆ gimple_phi_arg_def_from_edge() [1/2]

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

References gcc_checking_assert, gimple_bb(), and gimple_phi_arg().

◆ gimple_phi_arg_def_from_edge() [2/2]

tree gimple_phi_arg_def_from_edge ( const gphi * gs,
const_edge e )
inline 
Return the tree operand for the argument associated with
edge E of PHI node GS.

References gcc_checking_assert, gimple_bb(), and gimple_phi_arg().

Referenced by adjust_before_returns_twice_call(), constant_after_peeling(), edge_before_returns_twice_call(), find_tail_calls(), optimize_spaceship(), slpeel_tree_duplicate_loop_to_edge_cfg(), vect_analyze_slp(), and vect_do_peeling().

◆ gimple_phi_arg_def_ptr()

tree * gimple_phi_arg_def_ptr ( gphi * phi,
size_t index )
inline 
Return a pointer to the tree operand for argument I of phi node PHI.

References gimple_phi_arg().

Referenced by gimple_arg_ptr(), hardcfr_sibcall_search_preds(), make_phi_node(), optimize_va_list_gpr_fpr_size(), reserve_phi_args_for_new_edge(), resize_phi_node(), returning_call_p(), and walk_gimple_op().

◆ gimple_phi_arg_edge()

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

References EDGE_PRED, gimple_bb(), and i.

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

◆ gimple_phi_arg_has_location()

bool gimple_phi_arg_has_location ( const gphi * phi,
size_t i )
inline 
Return TRUE if argument I of phi node PHI has a location record.

References gimple_phi_arg_location(), i, and UNKNOWN_LOCATION.

Referenced by dump_gimple_phi(), insert_backedge_copies(), rewrite_update_phi_arguments(), walk_regimplify_phi(), and warn_uninitialized_phi().

◆ gimple_phi_arg_location()

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

References gimple_phi_arg(), and i.

Referenced by autofdo::afdo_set_bb_count(), cleanup_empty_eh_merge_phis(), copy_phi_arg_into_existing_phi(), copy_phi_args(), dump_gimple_phi(), emit_phi_nodes(), final_value_replacement_loop(), find_implicit_erroneous_behavior(), get_value_locus_in_path(), gimple_make_forwarder_block(), gimple_phi_arg_has_location(), ifcombine_replace_cond(), insert_backedge_copies(), move_block_to_fn(), output_phi(), remove_phi_arg_num(), remove_unused_locals(), rewrite_update_phi_arguments(), ssa_redirect_edge(), ter_is_replaceable_p(), vect_schedule_scc(), verify_gimple_in_cfg(), walk_regimplify_phi(), and warn_uninitialized_phi().

◆ gimple_phi_arg_location_from_edge()

location_t gimple_phi_arg_location_from_edge ( gphi * phi,
edge e )
inline 
Return the source location of the argument on edge E of phi node PHI.

References gimple_phi_arg().

Referenced by add_phi_args_after_copy_edge(), autofdo::afdo_set_bb_count(), copy_phis_for_bb(), create_parallel_loop(), edge_before_returns_twice_call(), eliminate_build(), tree_switch_conversion::switch_conversion::exp_index_transform(), expand_omp_for_generic(), expand_omp_for_static_chunk(), tree_switch_conversion::switch_conversion::gen_inbound_check(), gimple_lv_adjust_loop_header_phi(), phiprop_insert_phi(), remove_forwarder_block_with_phi(), slpeel_update_phi_nodes_for_guard1(), split_loop_exit_edge(), and vect_loop_versioning().

◆ gimple_phi_arg_location_ptr()

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

References gimple_phi_arg(), and i.

Referenced by input_phi().

◆ gimple_phi_arg_set_location()

void gimple_phi_arg_set_location ( gphi * phi,
size_t i,
location_t loc )
inline 
Set the source location of gimple argument I of phi node PHI to LOC.

References gimple_phi_arg(), and i.

Referenced by add_phi_arg(), copy_phi_arg_into_existing_phi(), make_phi_node(), move_block_to_fn(), remove_phi_arg_num(), reserve_phi_args_for_new_edge(), and rewrite_update_phi_arguments().

◆ gimple_phi_capacity()

unsigned gimple_phi_capacity ( const gimple * gs)
inline 
Return the maximum number of arguments supported by GIMPLE_PHI GS.

References as_a(), and gphi::capacity.

Referenced by add_phi_arg(), allocate_phi_node(), phi_arg_index_from_use(), release_phi_node(), reserve_phi_args_for_new_edge(), and resize_phi_node().

◆ gimple_phi_num_args()

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

References as_a(), and gphi::nargs.

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

◆ gimple_phi_result() [1/2]

tree gimple_phi_result ( const gimple * gs)
inline

References as_a(), and gimple_phi_result().

◆ gimple_phi_result() [2/2]

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

References gphi::result.

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

◆ gimple_phi_result_ptr() [1/2]

tree * gimple_phi_result_ptr ( gimple * gs)
inline

References as_a(), and gimple_phi_result_ptr().

◆ gimple_phi_result_ptr() [2/2]

tree * gimple_phi_result_ptr ( gphi * gs)
inline 
Return a pointer to the SSA name created by GIMPLE_PHI GS.

References gphi::result.

Referenced by add_exit_phi(), gimple_duplicate_bb(), gimple_phi_result_ptr(), op_iter_init_phidef(), sese_add_exit_phis_edge(), walk_gimple_op(), worker_single_copy(), and worker_single_simple().

◆ gimple_phi_set_arg()

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

References gphi::args, and gcc_gimple_checking_assert.

◆ gimple_phi_set_result()

void gimple_phi_set_result ( gphi * phi,
tree result )
inline 
Set RESULT to be the SSA name created by GIMPLE_PHI PHI.

References gphi::result, SSA_NAME_DEF_STMT, and TREE_CODE.

Referenced by edge_before_returns_twice_call(), gimple_make_forwarder_block(), make_phi_node(), ipa_param_body_adjustments::modify_cfun_body(), and sink_common_stores_to_bb().

◆ gimple_plf()

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

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

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

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

◆ gimple_references_memory_p()

bool gimple_references_memory_p ( gimple * stmt)
inline 
Return true if statement STMT may access memory.

References gimple_has_mem_ops(), and gimple_vuse().

Referenced by chain_of_csts_start(), execute_update_addresses_taken(), find_tail_calls(), likely_value(), record_equivalences_from_stmt(), and stmt_cost().

◆ gimple_resx_region()

int gimple_resx_region ( const gresx * resx_stmt)
inline 
Return the region number for GIMPLE_RESX RESX_STMT.

References gimple_statement_eh_ctrl::region.

Referenced by ipa_icf_gimple::func_checker::compare_gimple_resx(), dump_gimple_resx(), lower_resx(), mark_reachable_handlers(), move_stmt_r(), output_gimple_stmt(), and remap_gimple_stmt().

◆ gimple_resx_set_region()

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

References gimple_statement_eh_ctrl::region.

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

◆ gimple_return_retval()

tree gimple_return_retval ( const greturn * gs)
inline 
Return the return value for GIMPLE_RETURN GS.

References gimple_statement_with_memory_ops::op.

Referenced by adjust_return_value(), apply_return_prediction(), assume_query::assume_query(), cfun_returns(), ipa_icf_gimple::func_checker::compare_gimple_return(), create_coalesce_list_for_region(), dump_gimple_return(), execute_ranger_vrp(), expand_gimple_basic_block(), expand_gimple_stmt_1(), find_func_aliases(), find_func_clobbers(), find_return_bb(), find_retval(), find_tail_calls(), fold_stmt_1(), handle_return_addr_local_phi_arg(), infer_nonnull_range_by_attribute(), instrument_nonnull_return(), ipa_simd_modify_function_body(), isolate_path(), lower_function_body(), lower_gimple_return(), malloc_candidate_p(), propagate_necessity(), ref_maybe_used_by_stmt_p(), remap_gimple_stmt(), scan_function(), verify_gimple_return(), walk_stmt_load_store_addr_ops(), and warn_return_addr_local().

◆ gimple_return_retval_ptr()

tree * gimple_return_retval_ptr ( greturn * gs)
inline 
Return a pointer to the return value for GIMPLE_RETURN GS.

References gimple_statement_with_memory_ops::op.

Referenced by hardcfr_scan_block(), ipa_param_body_adjustments::modify_gimple_stmt(), and sra_modify_function_body().

◆ gimple_return_set_retval()

void gimple_return_set_retval ( greturn * gs,
tree retval )
inline 
Set RETVAL to be the return value for GIMPLE_RETURN GS.

References gimple_statement_with_memory_ops::op.

Referenced by adjust_return_value(), expand_complex_move(), find_assumption_locals_r(), fold_stmt_1(), gimple_build_return(), isolate_path(), split_function(), and warn_return_addr_local().

◆ gimple_seq_add_seq()

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

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

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

◆ gimple_seq_add_seq_without_update()

void gimple_seq_add_seq_without_update ( gimple_seq * dst_p,
gimple_seq src ) 
Append sequence SRC to the end of sequence *DST_P.  If *DST_P is
NULL, a new sequence is allocated.  This function is
similar to gimple_seq_add_seq, but does not scan the operands.

References gsi_insert_seq_after_without_update(), gsi_last(), GSI_NEW_STMT, NULL, and si.

Referenced by add_bb_predicate_gimplified_stmts(), compute_new_first_bound(), gimple_fold_builtin_strcat(), gimple_simplify_phiopt(), gimplify_body(), instrument_object_size(), maybe_instrument_pointer_overflow(), optimize_range_tests_to_bit_test(), pcom_worker::prepare_finalizers_chain(), pcom_worker::prepare_initializers_chain(), prepare_initializers_chain_store_elim(), remap_gimple_stmt(), and vect_recog_popcount_clz_ctz_ffs_pattern().

◆ gimple_seq_add_stmt()

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

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

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

◆ gimple_seq_add_stmt_without_update()

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

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

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

◆ gimple_seq_alloc_with_stmt()

gimple_seq gimple_seq_alloc_with_stmt ( gimple * stmt)
inline 
Allocate a new sequence and initialize its first element with STMT.

References gimple_seq_add_stmt(), and NULL.

Referenced by add_phi_node_to_bb(), expand_call_tm(), honor_protect_cleanup_actions(), lower_transaction(), and maybe_catch_exception().

◆ gimple_seq_copy()

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

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

Referenced by rt_bb_visited::check(), copy_gimple_seq_and_replace_locals(), duplicate_remap_omp_clause_seq(), gimple_copy(), gsi_insert_finally_seq_after_call(), replace_goto_queue_1(), and replace_goto_queue_cond_clause().

◆ gimple_seq_discard()

void gimple_seq_discard ( gimple_seq seq)
extern 
Release SSA_NAMEs in SEQ as well as the GIMPLE statements.

References ggc_free(), gsi_end_p(), gsi_remove(), gsi_start(), gsi_stmt(), and release_defs().

Referenced by create_expression_by_pieces(), eliminate_dom_walker::eliminate_insert(), expand_complex_div_wide(), fold_stmt_1(), gimple_simplify_phiopt(), optimize_range_tests_cmp_bitwise(), optimize_range_tests_to_bit_test(), pcom_worker::prepare_initializers_chain(), release_bb_predicate(), and pcom_worker::release_chain().

◆ gimple_seq_empty_p()

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

References NULL.

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

◆ gimple_seq_first()

gimple_seq_node gimple_seq_first ( gimple_seq s)
inline 
Return the first node in GIMPLE sequence S.

Referenced by gimple_seq_first_nondebug_stmt(), gimple_seq_first_stmt(), gimple_seq_first_stmt_as_a_bind(), gimple_seq_singleton_p(), gsi_commit_one_edge_insert(), gsi_insert_seq_after_without_update(), gsi_insert_seq_before_without_update(), gsi_insert_seq_on_edge_immediate(), gsi_start(), gsi_start_bb(), gsi_start_phis(), lower_function_body(), make_region_seq(), and ana::supernode::start_phis().

◆ gimple_seq_first_nondebug_stmt()

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

References gimple_seq_first(), is_gimple_debug(), and gimple::next.

Referenced by gimplify_body().

◆ gimple_seq_first_stmt()

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

References gimple_seq_first().

Referenced by bb_has_non_vop_phi(), collect_fallthrough_labels(), convert_local_reference_stmt(), convert_nonlocal_omp_clauses(), convert_nonlocal_reference_stmt(), convert_tramp_reference_stmt(), dump_function_to_file(), dump_gimple_omp_parallel(), dump_gimple_omp_target(), dump_gimple_omp_task(), dump_gimple_try(), eliminate_dom_walker::eliminate_insert(), expand_omp_atomic_pipeline(), finalize_nesting_tree_1(), get_eh_else(), gimple_add_tmp_var(), gimplify_and_return_first(), gimplify_body(), gimplify_scan_omp_clauses(), gsi_safe_insert_seq_before(), lower_eh_constructs_2(), lower_eh_filter(), lower_eh_must_not_throw(), lower_function_body(), lower_omp_for(), lower_omp_taskreg(), phiopt_early_allow(), replace_goto_queue_cond_clause(), top_level_omp_for_in_stmt(), vect_recog_bit_insert_pattern(), and vn_nary_build_or_lookup_1().

◆ gimple_seq_first_stmt_as_a_bind()

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

References as_a(), and gimple_seq_first().

Referenced by finalize_nesting_tree_1(), and lower_omp_target().

◆ gimple_seq_last()

gimple_seq_node gimple_seq_last ( gimple_seq s)
inline 
Return the last node in GIMPLE sequence S.

References NULL, and gimple::prev.

Referenced by asan_expand_check_ifn(), gimple_seq_last_nondebug_stmt(), gimple_seq_last_stmt(), gimple_seq_singleton_p(), gimplify_stmt(), gsi_end(), gsi_insert_seq_after_without_update(), gsi_insert_seq_before_without_update(), gsi_insert_seq_nodes_after(), gsi_insert_seq_nodes_before(), gsi_last(), gsi_last_bb(), gsi_split_seq_after(), gsi_split_seq_before(), lower_function_body(), and optimize_atomic_bit_test_and().

◆ gimple_seq_last_nondebug_stmt()

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

References gimple_seq_last(), is_gimple_debug(), NULL, and gimple::prev.

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

◆ gimple_seq_last_stmt()

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

References gimple_seq_last().

Referenced by adjust_return_value(), asan_expand_check_ifn(), collect_fallthrough_labels(), dump_function_to_file(), gimplify_assign(), gimplify_body(), gimplify_switch_expr(), gsi_safe_insert_seq_before(), lower_try_finally_switch(), optimize_atomic_bit_test_and(), and vect_create_epilog_for_reduction().

◆ gimple_seq_set_first()

void gimple_seq_set_first ( gimple_seq * ps,
gimple_seq_node first )
inline 
Set the first node in GIMPLE sequence *PS to FIRST.

Referenced by gsi_insert_seq_nodes_after(), gsi_insert_seq_nodes_before(), gsi_set_stmt(), gsi_split_seq_after(), and gsi_split_seq_before().

◆ gimple_seq_set_last()

void gimple_seq_set_last ( gimple_seq * ps,
gimple_seq_node last )
inline 
Set the last node in GIMPLE sequence *PS to LAST.

References last, and gimple::prev.

Referenced by gsi_insert_seq_nodes_after(), gsi_insert_seq_nodes_before(), gsi_remove(), gsi_set_stmt(), gsi_split_seq_after(), and gsi_split_seq_before().

◆ gimple_seq_set_location()

void gimple_seq_set_location ( gimple_seq seq,
location_t loc )
extern 
Set the location of all statements in SEQ to LOC.

References gimple_set_location(), gsi_end_p(), gsi_next(), gsi_start(), gsi_stmt(), and i.

Referenced by asan_expand_check_ifn(), tree_switch_conversion::jump_table_cluster::emit(), and insert_iv_increment().

◆ gimple_seq_singleton_p()

bool gimple_seq_singleton_p ( gimple_seq seq)
inline 
Determine whether SEQ is a singleton.

References gimple_seq_first(), gimple_seq_last(), and NULL.

Referenced by bb_has_non_vop_phi(), decompose_kernels_region_body(), eliminate_dom_walker::eliminate_insert(), get_eh_else(), phiopt_early_allow(), replace_goto_queue_cond_clause(), top_level_omp_for_in_stmt(), and vn_nary_build_or_lookup_1().

◆ gimple_set_bb()

void gimple_set_bb ( gimple * stmt,
basic_block bb ) 
Set BB to be the basic block holding G.

References as_a(), cfun, gimple_label_label(), LABEL_DECL_UID, label_to_block_map_for_fn, vec_safe_grow_cleared(), and vec_safe_length().

Referenced by add_phi_node_to_bb(), addsub_pattern::build(), complex_pattern::build(), combine_blocks(), vec_info::free_stmt_vec_info(), gimple_merge_blocks(), gimple_split_block(), gsi_remove(), gsi_replace(), make_blocks_1(), maybe_fold_comparisons_from_match_pd(), set_phi_nodes(), update_bb_for_stmts(), update_epilogue_loop_vinfo(), and vect_init_pattern_stmt().

◆ gimple_set_block()

void gimple_set_block ( gimple * g,
tree block )
inline 
Set BLOCK to be the lexical scope block holding statement G.

References g, gimple_set_location(), and set_block().

Referenced by clear_unused_block_pointer(), copy_debug_stmt(), finish_update_gimple_call(), gimple_build_call_from_tree(), gimple_build_debug_begin_stmt(), gimple_build_debug_inline_entry(), lower_eh_constructs_2(), lower_function_body(), lower_stmt(), lower_try_finally_dup_block(), lower_try_finally_onedest(), make_blocks_1(), ipa_param_adjustments::modify_call(), move_stmt_r(), remap_gimple_stmt(), and split_function().

◆ gimple_set_do_not_emit_location()

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

References g, GF_PLF_1, and gimple_set_plf().

Referenced by gimplify_cond_expr().

◆ gimple_set_has_volatile_ops()

void gimple_set_has_volatile_ops ( gimple * stmt,
bool volatilep )
inline 
Set the HAS_VOLATILE_OPS flag to VOLATILEP.

References gimple_has_mem_ops().

Referenced by operands_scanner::add_stmt_operand(), operands_scanner::build_ssa_operands(), operands_scanner::get_expr_operands(), operands_scanner::get_mem_ref_operands(), operands_scanner::get_tmr_operands(), and operands_scanner::verify_ssa_operands().

◆ gimple_set_lhs()

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

References gcc_unreachable, gimple_assign_set_lhs(), and gimple_call_set_lhs().

Referenced by build_and_insert_call(), convert_expand_mult_copysign(), convert_mult_to_fma_1(), gen_assign_counter_update(), gimple_lower_bitint(), gimple_regimplify_operands(), gimple_replace_ssa_lhs(), lower_eh_constructs_2(), lower_oacc_head_mark(), lower_oacc_head_tail(), lower_oacc_loop_marker(), make_blocks_1(), make_new_ssa_for_def(), reassociate_bb(), simplify_count_trailing_zeroes(), vect_create_vectorized_demotion_stmts(), vect_gen_widened_results_half(), vect_mark_pattern_stmts(), vect_transform_reduction(), vectorizable_conversion(), vectorizable_load(), vectorizable_store(), and vectorize_fold_left_reduction().

◆ gimple_set_location()

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

References copy_warning(), g, and UNKNOWN_LOCATION.

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

◆ gimple_set_modified()

void gimple_set_modified ( gimple * s,
bool modifiedp )
inline 
Set the MODIFIED flag to MODIFIEDP, iff the gimple statement G has
a MODIFIED field.

References gimple_has_ops(), and gimple::modified.

Referenced by add_bb_predicate_gimplified_stmts(), substitute_and_fold_dom_walker::before_dom_children(), cprop_operand(), eliminate_redundant_computations(), gimple_call_copy_skip_args(), gimple_copy(), gsi_remove(), gsi_replace(), gsi_replace_with_seq_vops(), input_gimple_stmt(), dom_opt_dom_walker::optimize_stmt(), reduce_vector_comparison_to_scalar_comparison(), rewrite_to_defined_unconditional(), dom_opt_dom_walker::test_for_singularity(), update_stmt(), update_stmt_fn(), update_stmt_operands(), and vect_finish_stmt_generation().

◆ gimple_set_no_warning()

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

References no_warning.

◆ gimple_set_num_ops()

void gimple_set_num_ops ( gimple * gs,
unsigned num_ops )
inline 
Set the number of operands for statement GS.

References gimple::num_ops.

Referenced by gimple_assign_set_rhs_with_ops(), gimple_fold_builtin_snprintf_chk(), gimple_fold_builtin_sprintf_chk(), gimple_init(), gimple_switch_set_num_labels(), maybe_remove_unused_call_args(), and simplify_permutation().

◆ gimple_set_op()

void gimple_set_op ( gimple * gs,
unsigned i,
tree op )
inline 
Set operand I of statement GS to OP.

References gcc_gimple_checking_assert, gimple_has_ops(), gimple_num_ops(), gimple_ops(), and i.

Referenced by gimple_build_call_1(), gimple_copy(), gimple_debug_bind_reset_value(), gimple_debug_bind_set_value(), gimple_debug_bind_set_var(), gimple_debug_source_bind_set_value(), gimple_debug_source_bind_set_var(), gimple_lower_bitint(), gimple_regimplify_operands(), input_gimple_stmt(), rewrite_to_defined_unconditional(), and update_epilogue_loop_vinfo().

◆ gimple_set_plf()

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

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

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

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

◆ gimple_set_uid()

void gimple_set_uid ( gimple * g,
unsigned uid )
inline 
Set the UID of statement.

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

References g.

Referenced by _bb_vec_info::_bb_vec_info(), _loop_vec_info::_loop_vec_info(), attempt_builtin_powi(), break_up_subtract_bb(), build_and_add_sum(), loop_distribution::create_rdg_vertices(), loop_distribution::execute(), free_rdg(), gather_scalar_reductions(), get_loop_body_in_if_conv_order(), gimple_duplicate_bb(), hoist_defs_of_uses(), if_convertible_loop_p_1(), init_loop_unswitch_info(), input_function(), insert_stmt_after(), insert_stmt_before_use(), linearize_expr(), lto_prepare_function_for_streaming(), make_new_ssa_for_def(), maybe_optimize_asan_check_ifn(), maybe_optimize_range_tests(), maybe_renumber_stmts_bb(), negate_value(), optimize_range_tests_var_bound(), reassoc_remove_stmt(), reassociate_bb(), renumber_gimple_stmt_uids_in_block(), reorder_operands(), vec_info::replace_stmt(), rewrite_expr_tree(), set_predicates_for_bb(), set_reduc_phi_uids(), set_uid_loop_bbs(), vec_info::set_vinfo_for_stmt(), should_duplicate_loop_header_p(), ssa_prop_init(), transform_to_exit_first_loop_alt(), try_vectorize_loop_1(), undistribute_bitref_for_vector(), update_ops(), update_range_test(), and _bb_vec_info::~_bb_vec_info().

◆ gimple_set_use_ops()

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

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

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

◆ gimple_set_vdef()

void gimple_set_vdef ( gimple * g,
tree vdef )
inline 
Set the single VDEF operand of the statement G.

References as_a(), g, and gimple_statement_with_memory_ops_base::vdef.

Referenced by expand_omp_atomic_mutex(), expand_omp_atomic_store(), operands_scanner::finalize_ssa_defs(), free_stmt_operands(), gimple_call_copy_skip_args(), gimple_copy(), gimple_ic(), gimple_move_vops(), gimple_stringop_fixed_value(), gsi_replace_with_seq_vops(), hoist_memory_references(), tree_loop_interchange::move_code_to_inner_loop(), optimize_mask_stores(), remap_gimple_stmt(), sink_common_stores_to_bb(), loop_cand::undo_simple_reduction(), and vect_finish_stmt_generation().

◆ gimple_set_visited()

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

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

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

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

◆ gimple_set_vuse()

void gimple_set_vuse ( gimple * g,
tree vuse )
inline 
Set the single VUSE operand of the statement G.

References as_a(), g, and gimple_statement_with_memory_ops_base::vuse.

Referenced by create_expression_by_pieces(), execute_update_addresses_taken(), expand_omp_atomic_load(), expand_omp_atomic_mutex(), expand_omp_atomic_store(), operands_scanner::finalize_ssa_uses(), fold_strstr_to_strncmp(), free_stmt_operands(), get_string_length(), gimple_call_copy_skip_args(), gimple_copy(), gimple_expand_vec_set_extract_expr(), gimple_fold_builtin_memory_op(), gimple_ic(), gimple_move_vops(), gimple_stringop_fixed_value(), gsi_replace_with_seq_vops(), strlen_pass::handle_integral_assign(), ifc_temp_var(), make_bit_field_load(), ipa_param_adjustments::modify_call(), tree_loop_interchange::move_code_to_inner_loop(), move_early_exit_stmts(), oacc_entry_exit_single_gang(), dom_opt_dom_walker::optimize_stmt(), phiprop_insert_phi(), predicate_load_or_store(), record_equivalences_from_stmt(), remap_gimple_stmt(), sink_common_stores_to_bb(), split_function(), loop_cand::undo_simple_reduction(), vect_finish_stmt_generation(), vect_setup_realignment(), and vectorizable_load().

◆ gimple_signed_type()

tree gimple_signed_type ( tree type)
extern 
Return a signed type the same as TYPE in other respects.

References gimple_signed_or_unsigned_type().

Referenced by gimple_get_alias_set(), and vect_recog_bitfield_ref_pattern().

◆ gimple_size()

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

References gss_for_code(), and gsstruct_code_size.

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

◆ gimple_statement_structure()

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

References gss_for_code().

Referenced by gimple_ops(), and walk_gimple_op().

◆ gimple_stmt_max_uid()

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

References function::last_stmt_uid.

Referenced by input_function(), and ssa_prop_init().

◆ gimple_store_p()

bool gimple_store_p ( const gimple * gs)
inline 
Return true if GS performs a store to its lhs.

References gimple_get_lhs(), and is_gimple_reg().

Referenced by auto_simd_check_stmt(), check_scan_store(), loop_cand::classify_simple_reduction(), ipa_icf_gimple::func_checker::compare_gimple_assign(), estimate_num_insns(), find_necessary_statements(), fold_stmt_1(), get_mem_ref_of_assignment(), gimple_lower_bitint(), has_stmt_been_instrumented_p(), ifcvt_can_use_mask_load_store(), ifcvt_local_dce(), instrument_gimple(), load_or_store_of_ptr_parameter(), maybe_instrument_assignment(), maybe_instrument_call(), maybe_remove_writeonly_store(), oacc_entry_exit_ok_1(), oacc_entry_exit_single_gang(), optimize_memcpy_to_memset(), vect_recog_cond_store_pattern(), and will_be_nonconstant_predicate().

◆ gimple_switch_default_label()

tree gimple_switch_default_label ( const gswitch * gs)
inline 
Return the default label for a switch statement.

References CASE_HIGH, CASE_LOW, gcc_checking_assert, and gimple_switch_label().

Referenced by clean_up_after_unswitching(), tree_switch_conversion::switch_conversion::expand(), expand_case(), expand_gimple_stmt_1(), find_case_label_for_value(), find_taken_edge_switch_expr(), predicate_bbs(), simplify_gimple_switch_label_vec(), simplify_using_ranges::simplify_switch_using_ranges(), and tree_switch_conversion::switch_decision_tree::try_switch_expansion().

◆ gimple_switch_index()

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

References gimple_statement_with_ops::op.

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

◆ gimple_switch_index_ptr()

tree * gimple_switch_index_ptr ( gswitch * gs)
inline 
Return a pointer to the index variable for the switch statement GS.

References gimple_statement_with_ops::op.

Referenced by gimple_regimplify_operands(), and propagate_tree_value_into_stmt().

◆ gimple_switch_label()

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

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

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

◆ gimple_switch_num_labels()

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

References gcc_gimple_checking_assert, GIMPLE_CHECK, and gimple_num_ops().

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

◆ gimple_switch_set_default_label()

void gimple_switch_set_default_label ( gswitch * gs,
tree label )
inline 
Set the default label for a switch statement.

References CASE_HIGH, CASE_LOW, gcc_checking_assert, and gimple_switch_set_label().

Referenced by gimple_build_switch_nlabels().

◆ gimple_switch_set_index()

void gimple_switch_set_index ( gswitch * gs,
tree index )
inline 
Set INDEX to be the index variable for switch statement GS.

References CONSTANT_CLASS_P, gcc_gimple_checking_assert, gimple_statement_with_ops::op, and SSA_VAR_P.

Referenced by execute_early_expand_coro_ifns(), tree_switch_conversion::switch_conversion::exp_index_transform(), generate_loops_for_partition(), gimple_build_switch_nlabels(), jump_threader::simplify_control_stmt_condition(), simplify_gimple_switch(), and simplify_loop_version().

◆ gimple_switch_set_label()

void gimple_switch_set_label ( gswitch * gs,
unsigned index,
tree label )
inline 
Set the label number INDEX to LABEL.  0 is always the default label.

References gcc_gimple_checking_assert, gimple_num_ops(), NULL_TREE, gimple_statement_with_ops::op, and TREE_CODE.

Referenced by clean_up_after_unswitching(), simplify_using_ranges::cleanup_edges_and_switches(), gimple_build_switch(), gimple_switch_set_default_label(), group_case_labels_stmt(), and simplify_gimple_switch_label_vec().

◆ gimple_switch_set_num_labels()

void gimple_switch_set_num_labels ( gswitch * g,
unsigned nlabels )
inline 
Set NLABELS to be the number of labels for the switch statement GS.

References g, GIMPLE_CHECK, and gimple_set_num_ops().

Referenced by clean_up_after_unswitching(), simplify_using_ranges::cleanup_edges_and_switches(), group_case_labels_stmt(), and simplify_gimple_switch_label_vec().

◆ gimple_transaction_body()

gimple_seq gimple_transaction_body ( const gtransaction * transaction_stmt)
inline 
Return the body for the GIMPLE_TRANSACTION statement TRANSACTION_STMT.

References gtransaction::body.

Referenced by diagnose_tm_1(), dump_gimple_transaction(), estimate_num_insns(), gimple_copy(), lower_transaction(), output_gimple_stmt(), remap_gimple_stmt(), and verify_gimple_transaction().

◆ gimple_transaction_body_ptr()

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

References gtransaction::body.

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

◆ gimple_transaction_label_norm()

tree gimple_transaction_label_norm ( const gtransaction * transaction_stmt)
inline 
Return the label associated with a GIMPLE_TRANSACTION.

References gtransaction::label_norm.

Referenced by cleanup_dead_labels(), dump_gimple_transaction(), make_edges_bb(), output_gimple_stmt(), remap_gimple_stmt(), and verify_gimple_transaction().

◆ gimple_transaction_label_norm_ptr()

tree * gimple_transaction_label_norm_ptr ( gtransaction * transaction_stmt)
inline

References gtransaction::label_norm.

Referenced by walk_gimple_op().

◆ gimple_transaction_label_over()

tree gimple_transaction_label_over ( const gtransaction * transaction_stmt)
inline

References gtransaction::label_over.

Referenced by cleanup_dead_labels(), dump_gimple_transaction(), make_edges_bb(), output_gimple_stmt(), remap_gimple_stmt(), and verify_gimple_transaction().

◆ gimple_transaction_label_over_ptr()

tree * gimple_transaction_label_over_ptr ( gtransaction * transaction_stmt)
inline

References gtransaction::label_over.

Referenced by walk_gimple_op().

◆ gimple_transaction_label_uninst()

tree gimple_transaction_label_uninst ( const gtransaction * transaction_stmt)
inline

References gtransaction::label_uninst.

Referenced by cleanup_dead_labels(), dump_gimple_transaction(), make_edges_bb(), output_gimple_stmt(), remap_gimple_stmt(), and verify_gimple_transaction().

◆ gimple_transaction_label_uninst_ptr()

tree * gimple_transaction_label_uninst_ptr ( gtransaction * transaction_stmt)
inline

References gtransaction::label_uninst.

Referenced by walk_gimple_op().

◆ gimple_transaction_set_body()

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

References gtransaction::body.

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

◆ gimple_transaction_set_label_norm()

void gimple_transaction_set_label_norm ( gtransaction * transaction_stmt,
tree label )
inline 
Set the label associated with a GIMPLE_TRANSACTION.

References gtransaction::label_norm.

Referenced by cleanup_dead_labels(), gimple_build_transaction(), gimple_redirect_edge_and_branch(), input_gimple_stmt(), lower_transaction(), and remap_gimple_stmt().

◆ gimple_transaction_set_label_over()

void gimple_transaction_set_label_over ( gtransaction * transaction_stmt,
tree label )
inline

References gtransaction::label_over.

Referenced by cleanup_dead_labels(), gimple_build_transaction(), gimple_redirect_edge_and_branch(), input_gimple_stmt(), lower_transaction(), and remap_gimple_stmt().

◆ gimple_transaction_set_label_uninst()

void gimple_transaction_set_label_uninst ( gtransaction * transaction_stmt,
tree label )
inline

References gtransaction::label_uninst.

Referenced by cleanup_dead_labels(), gimple_build_transaction(), gimple_redirect_edge_and_branch(), input_gimple_stmt(), lower_transaction(), and remap_gimple_stmt().

◆ gimple_transaction_set_subcode()

void gimple_transaction_set_subcode ( gtransaction * transaction_stmt,
unsigned int subcode )
inline 
Set the subcode associated with a GIMPLE_TRANSACTION.

References gimple::subcode.

Referenced by generate_tm_state(), gimplify_transaction(), lower_transaction(), propagate_tm_flags_out(), remap_gimple_stmt(), and transaction_subcode_ior().

◆ gimple_transaction_subcode()

unsigned int gimple_transaction_subcode ( const gtransaction * transaction_stmt)
inline 
Return the subcode associated with a GIMPLE_TRANSACTION.

References gimple::subcode.

Referenced by diagnose_tm_1(), dump_gimple_transaction(), execute_tm_mark(), expand_transaction(), generate_tm_state(), ipa_tm_diagnose_transaction(), lower_transaction(), make_edges_bb(), propagate_tm_flags_out(), remap_gimple_stmt(), and transaction_subcode_ior().

◆ gimple_try_catch_is_cleanup()

bool gimple_try_catch_is_cleanup ( const gimple * gs)
inline 
Return the GIMPLE_TRY_CATCH_IS_CLEANUP flag.

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

Referenced by honor_protect_cleanup_actions().

◆ gimple_try_cleanup()

gimple_seq gimple_try_cleanup ( const gimple * gs)
inline 
Return the sequence of statements used as the cleanup body for
GIMPLE_TRY GS.

References gimple_try_cleanup_ptr().

Referenced by collect_finally_tree(), decompose_kernels_region_body(), do_warn_unused_result(), dump_gimple_try(), estimate_num_insns(), frob_into_branch_around(), gimple_copy(), gimple_stmt_may_fallthru(), honor_protect_cleanup_actions(), last_stmt_in_scope(), lower_catch(), lower_eh_constructs_2(), lower_eh_filter(), lower_eh_must_not_throw(), lower_try_finally(), lower_try_finally_copy(), lower_try_finally_nofallthru(), lower_try_finally_onedest(), lower_try_finally_switch(), optimize_double_finally(), refactor_eh_r(), remap_gimple_stmt(), and verify_gimple_in_seq_2().

◆ gimple_try_cleanup_ptr()

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

References as_a(), and gtry::cleanup.

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

◆ gimple_try_eval()

gimple_seq gimple_try_eval ( const gimple * gs)
inline 
Return the sequence of statements used as the body for GIMPLE_TRY GS.

References gimple_try_eval_ptr().

Referenced by collect_finally_tree(), decompose_kernels_region_body(), do_warn_unused_result(), dump_gimple_try(), estimate_num_insns(), frob_into_branch_around(), gimple_copy(), gimple_stmt_may_fallthru(), gimple_try_catch_may_fallthru(), honor_protect_cleanup_actions(), last_stmt_in_scope(), lower_catch(), lower_cleanup(), lower_eh_constructs_2(), lower_eh_filter(), lower_eh_must_not_throw(), lower_try_finally(), lower_try_finally_copy(), lower_try_finally_nofallthru(), lower_try_finally_onedest(), lower_try_finally_switch(), optimize_double_finally(), refactor_eh_r(), remap_gimple_stmt(), top_level_omp_for_in_stmt(), verify_gimple_in_seq_2(), and warn_switch_unreachable_and_auto_init_r().

◆ gimple_try_eval_ptr()

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

References as_a(), and gtry::eval.

Referenced by gimple_try_eval(), lower_catch(), lower_cleanup(), lower_eh_filter(), lower_eh_must_not_throw(), lower_omp_1(), lower_stmt(), lower_try_catch(), lower_try_finally(), replace_goto_queue_1(), and walk_gimple_stmt().

◆ gimple_try_kind()

enum gimple_try_flags gimple_try_kind ( const gimple * gs)
inline 
GIMPLE_TRY accessors.  
Return the kind of try block represented by GIMPLE_TRY GS.  This is
either GIMPLE_TRY_CATCH or GIMPLE_TRY_FINALLY.

References GIMPLE_CHECK, GIMPLE_TRY_KIND, and gimple::subcode.

Referenced by collect_finally_tree(), dump_gimple_try(), gimple_stmt_may_fallthru(), gimple_try_catch_is_cleanup(), gimple_try_catch_may_fallthru(), gimple_try_set_catch_is_cleanup(), gimple_try_set_kind(), honor_protect_cleanup_actions(), last_stmt_in_scope(), lower_eh_constructs_2(), lower_stmt(), lower_try_catch(), optimize_double_finally(), refactor_eh_r(), and remap_gimple_stmt().

◆ gimple_try_set_catch_is_cleanup()

void gimple_try_set_catch_is_cleanup ( gtry * g,
bool catch_is_cleanup )
inline 
Set the GIMPLE_TRY_CATCH_IS_CLEANUP flag.

References g, gcc_gimple_checking_assert, GIMPLE_TRY_CATCH, GIMPLE_TRY_CATCH_IS_CLEANUP, and gimple_try_kind().

Referenced by gimplify_expr().

◆ gimple_try_set_cleanup()

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

References gtry::cleanup.

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

◆ gimple_try_set_eval()

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

References gtry::eval.

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

◆ gimple_try_set_kind()

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

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

Referenced by optimize_double_finally().

◆ gimple_uid()

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

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

References g.

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

◆ gimple_unsigned_type()

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

References gimple_signed_or_unsigned_type().

◆ gimple_use_ops()

struct use_optype_d * gimple_use_ops ( const gimple * g)
inline 
Return the set of USE operands for statement G.

References dyn_cast(), g, NULL, and gimple_statement_with_ops_base::use_ops.

Referenced by operands_scanner::finalize_ssa_uses(), free_stmt_operands(), op_iter_init(), ssa_vuse_operand(), and swap_ssa_operands().

◆ gimple_vdef()

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

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

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

◆ gimple_vdef_ptr()

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

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

Referenced by op_iter_next_def().

◆ gimple_visited_p()

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

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

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

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

◆ gimple_vuse()

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

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

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

◆ gimple_vuse_ptr()

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

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

Referenced by operands_scanner::finalize_ssa_uses().

◆ gimple_wce_cleanup()

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

References gimple_wce_cleanup_ptr().

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

◆ gimple_wce_cleanup_eh_only()

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

References GIMPLE_CHECK, and gimple::subcode.

Referenced by gimplify_cleanup_point_expr().

◆ gimple_wce_cleanup_ptr()

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

References as_a(), and gimple_statement_wce::cleanup.

Referenced by gimple_wce_cleanup(), and walk_gimple_stmt().

◆ gimple_wce_set_cleanup()

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

References as_a(), and gimple_statement_wce::cleanup.

Referenced by gimple_build_wce(), and gimple_copy().

◆ gimple_wce_set_cleanup_eh_only()

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

References GIMPLE_CHECK, and gimple::subcode.

Referenced by gimple_push_cleanup().

◆ gss_for_code()

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

References gcc_gimple_checking_assert, and gss_for_code_.

Referenced by gimple_size(), and gimple_statement_structure().

◆ inc_gimple_stmt_max_uid()

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

References function::last_stmt_uid.

Referenced by input_function(), lto_prepare_function_for_streaming(), renumber_gimple_stmt_uids_in_block(), and ssa_prop_init().

◆ infer_nonnull_range()

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

References infer_nonnull_range_by_attribute(), and infer_nonnull_range_by_dereference().

◆ infer_nonnull_range_by_attribute()

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

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

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

◆ infer_nonnull_range_by_dereference()

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

References check_loadstore(), gimple_clobber_p(), POINTER_TYPE_P, TREE_TYPE, and walk_stmt_load_store_ops().

Referenced by analyze_function(), infer_nonnull_range(), stmt_uses_0_or_null_in_undefined_way(), and stmt_uses_name_in_undefined_way().

◆ is_gimple_assign()

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

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

◆ is_gimple_call()

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

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

◆ is_gimple_debug()

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

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

◆ is_gimple_omp()

bool is_gimple_omp ( const gimple * stmt)
inline

References CASE_GIMPLE_OMP.

Referenced by build_omp_regions_1(), check_omp_nesting_restrictions(), diagnose_sb_0(), is_gimple_omp_oacc(), is_gimple_omp_offloaded(), is_in_offload_region(), lower_omp_1(), move_stmt_r(), and scan_omp_1_stmt().

◆ is_gimple_omp_oacc()

bool is_gimple_omp_oacc ( const gimple * stmt)
inline 
Return true if the OMP gimple statement STMT is any of the OpenACC types
specifically.

References gcc_assert, gcc_unreachable, GF_OMP_FOR_KIND_OACC_LOOP, GF_OMP_TARGET_KIND_OACC_DATA, GF_OMP_TARGET_KIND_OACC_DATA_KERNELS, GF_OMP_TARGET_KIND_OACC_DECLARE, GF_OMP_TARGET_KIND_OACC_ENTER_DATA, GF_OMP_TARGET_KIND_OACC_EXIT_DATA, GF_OMP_TARGET_KIND_OACC_HOST_DATA, GF_OMP_TARGET_KIND_OACC_KERNELS, GF_OMP_TARGET_KIND_OACC_PARALLEL, GF_OMP_TARGET_KIND_OACC_PARALLEL_KERNELS_GANG_SINGLE, GF_OMP_TARGET_KIND_OACC_PARALLEL_KERNELS_PARALLELIZED, GF_OMP_TARGET_KIND_OACC_SERIAL, GF_OMP_TARGET_KIND_OACC_UPDATE, gimple_omp_for_kind(), gimple_omp_target_kind(), and is_gimple_omp().

Referenced by check_omp_nesting_restrictions(), create_omp_child_function(), diagnose_sb_0(), expand_omp_target(), install_var_field(), lower_omp_1(), lower_omp_for(), lower_omp_target(), lower_rec_input_clauses(), lower_reduction_clauses(), scan_omp_for(), scan_sharing_clauses(), and use_pointer_for_field().

◆ is_gimple_omp_offloaded()

bool is_gimple_omp_offloaded ( const gimple * stmt)
inline 
Return true if the OMP gimple statement STMT is offloaded.

References gcc_assert, GF_OMP_TARGET_KIND_OACC_KERNELS, GF_OMP_TARGET_KIND_OACC_PARALLEL, GF_OMP_TARGET_KIND_OACC_PARALLEL_KERNELS_GANG_SINGLE, GF_OMP_TARGET_KIND_OACC_PARALLEL_KERNELS_PARALLELIZED, GF_OMP_TARGET_KIND_OACC_SERIAL, GF_OMP_TARGET_KIND_REGION, gimple_omp_target_kind(), and is_gimple_omp().

Referenced by check_omp_nesting_restrictions(), convert_gimple_call(), convert_local_reference_stmt(), convert_nonlocal_reference_stmt(), convert_tramp_reference_stmt(), create_omp_child_function(), expand_omp_target(), fixup_child_record_type(), is_in_offload_region(), lower_oacc_reductions(), lower_omp_critical(), lower_omp_target(), omp_maybe_offloaded_ctx(), scan_omp_1_stmt(), scan_omp_target(), scan_sharing_clauses(), and use_pointer_for_field().

◆ is_gimple_resx()

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

Referenced by cleanup_empty_eh(), and empty_eh_cleanup().

◆ maybe_remove_unused_call_args()

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

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

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

◆ nonbarrier_call_p()

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

References ECF_CONST, ECF_PURE, and gimple_call_flags().

Referenced by nontrapping_dom_walker::before_dom_children().

◆ nonfreeing_call_p()

bool nonfreeing_call_p ( gimple * call)
extern 
Return true when CALL is a call stmt that definitely doesn't
free any memory or makes it unavailable otherwise.

References AVAIL_INTERPOSABLE, BUILT_IN_NORMAL, DECL_FUNCTION_CODE(), ECF_LEAF, cgraph_node::function_symbol(), cgraph_node::get(), gimple_call_arg(), gimple_call_builtin_p(), gimple_call_flags(), gimple_call_fndecl(), gimple_call_internal_fn(), gimple_call_internal_p(), cgraph_node::nonfreeing_fn, and tree_to_uhwi().

Referenced by nontrapping_dom_walker::before_dom_children(), check_call(), imm_dom_path_with_freeing_call(), sanopt_optimize_walker(), and transform_statements().

◆ phi_nodes()

gimple_seq phi_nodes ( const_basic_block bb)
inline 
Return the PHI nodes for basic block BB, or NULL if there are no
PHI nodes.

References basic_block_def::flags, gcc_checking_assert, basic_block_def::basic_block_il_dependent::gimple, basic_block_def::il, and gimple_bb_info::phi_nodes.

Referenced by ana::supergraph::add_node(), add_phi_args_after_copy_edge(), add_phi_node_to_bb(), bb_has_non_vop_phi(), compute_antic_aux(), compute_partial_antic_aux(), cond_only_block_p(), cond_store_replacement(), do_hoist_insertion(), empty_bb_or_one_feeding_into_p(), expand_omp_atomic_pipeline(), expand_omp_for_generic(), expand_phi_nodes(), expand_transaction(), factor_out_conditional_operation(), gimple_empty_block_p(), gimple_execute_on_growing_pred(), gimple_execute_on_shrinking_pred(), gimple_find_edge_insert_loc(), gimple_split_edge(), ifcvt_split_critical_edges(), lower_emutls_function_body(), maybe_register_def(), minmax_replacement(), neuter_worker_single(), no_side_effect_bb(), output_bb(), phi_translate_set(), remove_forwarder_block(), single_block_loop_p(), split_critical_edges(), ana::supernode::supernode(), tree_forwarder_block_p(), tree_optimize_tail_calls_1(), try_transform_to_exit_first_loop_alt(), uncprop_into_successor_phis(), unsplit_eh(), value_replacement(), and vect_analyze_loop_form().

◆ phi_nodes_ptr()

gimple_seq * phi_nodes_ptr ( basic_block bb)
inline 
Return a pointer to the PHI nodes for basic block BB.

References basic_block_def::flags, gcc_checking_assert, basic_block_def::basic_block_il_dependent::gimple, basic_block_def::il, and gimple_bb_info::phi_nodes.

Referenced by gsi_start_phis().

◆ preprocess_case_label_vec_for_gimple()

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

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

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

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

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

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

Referenced by gimplify_switch_expr(), and simplify_gimple_switch_label_vec().

◆ set_bb_seq()

void set_bb_seq ( basic_block bb,
gimple_seq seq )
inline 
Sets the sequence of statements in BB to SEQ.

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

Referenced by combine_blocks(), create_bb(), gimple_merge_blocks(), gimple_split_block(), and ssa_create_duplicates().

◆ set_gimple_stmt_max_uid()

void set_gimple_stmt_max_uid ( struct function * fn,
unsigned int maxid )
inline 
Set the number of the next statement uid to be allocated.

References function::last_stmt_uid.

Referenced by input_function(), lto_prepare_function_for_streaming(), renumber_gimple_stmt_uids(), renumber_gimple_stmt_uids_in_blocks(), and ssa_prop_init().

◆ sort_case_labels()

void sort_case_labels ( vec< tree > & label_vec)
extern 
Sort the case labels in LABEL_VEC in place in ascending order.

References compare_case_labels().

Referenced by lower_eh_dispatch(), lower_try_finally_switch(), and preprocess_case_label_vec_for_gimple().

◆ stmt_can_terminate_bb_p()

bool stmt_can_terminate_bb_p ( gimple * t)
extern 
Return true if statement T may terminate execution of BB in ways not
explicitly represtented in the CFG.

References cfun, dyn_cast(), ECF_CONST, ECF_LOOPING_CONST_OR_PURE, ECF_NORETURN, ECF_NOTHROW, ECF_PURE, ECF_RETURNS_TWICE, fndecl_built_in_p(), FOR_EACH_EDGE, gimple_asm_basic_p(), gimple_asm_volatile_p(), gimple_bb(), gimple_call_flags(), gimple_call_fndecl(), is_gimple_call(), NULL_TREE, stmt_can_throw_external(), and basic_block_def::succs.

Referenced by determine_unlikely_bbs(), force_edge_cold(), gimple_flow_call_edges_add(), isolate_path(), loop_only_exit_p(), unlikely_executed_bb_p(), and want_merge_blocks_p().

◆ suppress_warning()

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

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

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

◆ warning_suppressed_p()

bool warning_suppressed_p ( const gimple * stmt,
opt_code opt )
extern 
Return the disposition for a warning (or all warnings by default)
for a statement.   
Return true if warning OPT is suppressed for statement STMT.
By default tests the disposition for any warning.

References gcc_assert, get_no_warning_bit(), and get_nowarn_spec().

Referenced by c_strlen(), check_access(), array_bounds_checker::check_addr_expr(), array_bounds_checker::check_array_ref(), check_bounds_or_overlap(), check_global_declaration(), array_bounds_checker::check_mem_ref(), combine_cond_expr_cond(), compare_values_warnv(), do_warn_nonnull_compare(), expand_vector_comparison(), expand_vector_condition(), expand_vector_conversion(), expand_vector_parallel(), expand_vector_piecewise(), find_tail_calls(), fold_stmt_1(), fold_undefer_overflow_warnings(), get_no_uninit_warning(), gimple_fold_builtin_stpcpy(), gimple_fold_builtin_strcpy(), gimple_fold_builtin_strncat(), gimple_fold_builtin_stxcpy_chk(), lower_vec_perm(), maybe_diag_stxncpy_trunc(), maybe_warn_for_bound(), maybe_warn_nonstring_arg(), strlen_pass::maybe_warn_overflow(), warn_string_no_nul(), and warn_uninit().

Variable Documentation

◆ currently_expanding_gimple_stmt

gimple* currently_expanding_gimple_stmt
extern 
This variable holds the currently expanded gimple statement for purposes
of comminucating the profile info to the builtin expanders.

Referenced by expand_builtin_memory_copy_args(), expand_builtin_memset_args(), and expand_gimple_basic_block().

◆ gimple_alloc_counts

uint64_t gimple_alloc_counts[]
extern 
Gimple stats.

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

◆ gimple_alloc_sizes

uint64_t gimple_alloc_sizes[]
extern

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

◆ gimple_code_name

const char* const gimple_code_name[]
extern

Referenced by decompose_kernels_region_body(), do_niy(), dump_gimple_fmt(), dump_omp_region(), and lto_tag_name().

◆ gimple_ops_offset_

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

Referenced by gimple_ops().

◆ gimple_rhs_class_table

const unsigned char gimple_rhs_class_table[]
extern

Referenced by get_gimple_rhs_class().

◆ gss_for_code_

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

Referenced by gss_for_code().