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

Go to the source code of this file.

Data Structures

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

Macros

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

Typedefs

typedef gimplegimple_seq_node
 
typedef struct gimple_temp_hash_elt elt_t
 

Enumerations

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

Functions

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

Variables

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

Macro Definition Documentation

◆ CASE_GIMPLE_OMP

#define CASE_GIMPLE_OMP
Value:
Returns true when the gimple statement STMT is any of the OMP types.   

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

◆ DEFGSCODE

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

◆ DEFGSSTRUCT

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

◆ gcc_gimple_checking_assert

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

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

◆ GIMPLE_CHECK

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

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

◆ GIMPLE_DEBUG_BIND_NOVALUE

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

Referenced by gimple_debug_bind_has_value_p(), and gimple_debug_bind_reset_value().

◆ GTMA_DECLARATION_MASK

#define GTMA_DECLARATION_MASK   (GTMA_IS_OUTER | GTMA_IS_RELAXED)

◆ GTMA_DOES_GO_IRREVOCABLE

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

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

◆ GTMA_HAS_NO_INSTRUMENTATION

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

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

◆ GTMA_HAVE_ABORT

#define GTMA_HAVE_ABORT   (1u << 2)

◆ GTMA_HAVE_LOAD

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

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

◆ GTMA_HAVE_STORE

◆ GTMA_IS_OUTER

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

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

◆ GTMA_IS_RELAXED

#define GTMA_IS_RELAXED   (1u << 1)

◆ GTMA_MAY_ENTER_IRREVOCABLE

#define GTMA_MAY_ENTER_IRREVOCABLE   (1u << 5)

Typedef Documentation

◆ elt_t

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

◆ gimple_seq_node

Gimple IR definitions.

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

This file is part of GCC.

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

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

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

Enumeration Type Documentation

◆ gf_mask

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

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

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

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

◆ gimple_alloc_kind

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

◆ gimple_code

Enumerator
LAST_AND_UNUSED_GIMPLE_CODE 

◆ gimple_debug_subcode

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

◆ gimple_rhs_class

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

◆ gimple_statement_structure_enum

Enumerator
LAST_GSS_ENUM 

◆ gimple_try_flags

Kind of GIMPLE_TRY statements.   
Enumerator
GIMPLE_TRY_CATCH 
GIMPLE_TRY_FINALLY 
GIMPLE_TRY_KIND 
GIMPLE_TRY_CATCH_IS_CLEANUP 

◆ plf_mask

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

Function Documentation

◆ annotate_all_with_location()

void annotate_all_with_location ( gimple_seq stmt_p,
location_t location )
extern

◆ annotate_all_with_location_after()

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

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

Referenced by gimplify_expr().

◆ bb_seq()

◆ bb_seq_addr()

◆ copy_warning() [1/3]

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

References ggc_alloc().

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 ggc_alloc().

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

◆ 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, ggc_alloc(), 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 ggc_alloc(), gimple_alloc_counts, gimple_alloc_kind_all, gimple_alloc_kind_names, gimple_alloc_sizes, i, PRIu64, and SIZE_AMOUNT.

Referenced by dump_memory_report().

◆ empty_body_p()

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

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

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

◆ get_gimple_rhs_class()

◆ get_gimple_rhs_num_ops()

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

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

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

◆ get_lineno()

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

References ggc_alloc(), gimple_location(), LOCATION_LINE, and UNKNOWN_LOCATION.

Referenced by dump_gimple_bb_header().

◆ gimple_alloc()

gimple * gimple_alloc ( enum gimple_code,
unsigned CXX_MEM_STAT_INFO )

◆ gimple_alloc_kind()

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

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

◆ gimple_arg_ptr()

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

References ggc_alloc(), gimple_call_arg_ptr(), gimple_op_ptr(), gimple_phi_arg_def_ptr(), and i.

◆ gimple_asm_clobber_op()

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

◆ gimple_asm_clobbers_memory_p()

bool gimple_asm_clobbers_memory_p ( const gasm * stmt)
extern

◆ gimple_asm_inline_p()

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

References GF_ASM_INLINE, and ggc_alloc().

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

◆ gimple_asm_input_op()

◆ gimple_asm_input_p()

bool gimple_asm_input_p ( const gasm * asm_stmt)
inline

◆ gimple_asm_label_op()

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

◆ gimple_asm_nclobbers()

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

References ggc_alloc().

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

◆ gimple_asm_ninputs()

◆ gimple_asm_nlabels()

◆ gimple_asm_noutputs()

◆ gimple_asm_output_op()

◆ gimple_asm_set_clobber_op()

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

References gcc_gimple_checking_assert, ggc_alloc(), 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 ggc_alloc().

Referenced by gimplify_asm_expr().

◆ gimple_asm_set_input()

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

References GF_ASM_INPUT, and ggc_alloc().

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, ggc_alloc(), 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, ggc_alloc(), 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, ggc_alloc(), 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 ggc_alloc().

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 ggc_alloc().

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

◆ gimple_asm_volatile_p()

◆ gimple_assign_cast_p()

◆ gimple_assign_copy_p()

◆ gimple_assign_lhs() [1/2]

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

References ggc_alloc().

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

◆ gimple_assign_lhs() [2/2]

tree gimple_assign_lhs ( const gimple * gs)
inline

References ggc_alloc(), and gimple_assign_lhs().

◆ gimple_assign_lhs_ptr() [1/2]

◆ gimple_assign_lhs_ptr() [2/2]

tree * gimple_assign_lhs_ptr ( gimple * gs)
inline

◆ gimple_assign_load_p()

◆ gimple_assign_nontemporal_move_p()

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

References ggc_alloc().

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 ggc_alloc().

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

◆ gimple_assign_rhs1() [2/2]

tree gimple_assign_rhs1 ( const gimple * gs)
inline

◆ gimple_assign_rhs1_ptr() [1/2]

◆ gimple_assign_rhs1_ptr() [2/2]

tree * gimple_assign_rhs1_ptr ( gimple * gs)
inline

◆ gimple_assign_rhs2() [1/2]

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

References ggc_alloc(), gimple_num_ops(), and NULL_TREE.

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

◆ gimple_assign_rhs2() [2/2]

tree gimple_assign_rhs2 ( const gimple * gs)
inline

◆ gimple_assign_rhs2_ptr() [1/2]

◆ gimple_assign_rhs2_ptr() [2/2]

tree * gimple_assign_rhs2_ptr ( gimple * gs)
inline

◆ gimple_assign_rhs3() [1/2]

◆ gimple_assign_rhs3() [2/2]

tree gimple_assign_rhs3 ( const gimple * gs)
inline

◆ gimple_assign_rhs3_ptr()

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

References gcc_gimple_checking_assert, ggc_alloc(), and gimple_num_ops().

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

◆ gimple_assign_rhs_class()

◆ gimple_assign_rhs_code() [1/2]

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

References get_gimple_rhs_class(), ggc_alloc(), GIMPLE_SINGLE_RHS, and TREE_CODE.

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

◆ gimple_assign_rhs_code() [2/2]

enum tree_code gimple_assign_rhs_code ( const gimple * gs)
inline

◆ gimple_assign_rhs_could_trap_p()

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

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

Referenced by no_side_effect_bb().

◆ gimple_assign_set_lhs() [1/2]

◆ gimple_assign_set_lhs() [2/2]

void gimple_assign_set_lhs ( gimple * gs,
tree lhs )
inline

◆ gimple_assign_set_nontemporal_move()

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

References ggc_alloc(), and GIMPLE_CHECK.

Referenced by mark_nontemporal_store().

◆ gimple_assign_set_rhs1() [1/2]

◆ gimple_assign_set_rhs1() [2/2]

void gimple_assign_set_rhs1 ( gimple * gs,
tree rhs )
inline

◆ gimple_assign_set_rhs2() [1/2]

◆ gimple_assign_set_rhs2() [2/2]

void gimple_assign_set_rhs2 ( gimple * gs,
tree rhs )
inline

◆ gimple_assign_set_rhs3() [1/2]

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

References gcc_gimple_checking_assert, ggc_alloc(), and gimple_num_ops().

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

◆ gimple_assign_set_rhs3() [2/2]

void gimple_assign_set_rhs3 ( gimple * gs,
tree rhs )
inline

◆ gimple_assign_set_rhs_code()

◆ gimple_assign_set_rhs_from_tree()

void gimple_assign_set_rhs_from_tree ( gimple_stmt_iterator * gsi,
tree expr )
Modify the RHS of the assignment pointed-to by GSI using the
operands in the expression tree EXPR.

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

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

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

References extract_ops_from_tree(), ggc_alloc(), and gimple_assign_set_rhs_with_ops().

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

◆ gimple_assign_set_rhs_with_ops() [1/3]

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

◆ gimple_assign_set_rhs_with_ops() [2/3]

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

References gimple_assign_set_rhs_with_ops(), and NULL.

◆ gimple_assign_set_rhs_with_ops() [3/3]

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

References gimple_assign_set_rhs_with_ops(), and NULL.

◆ gimple_assign_single_p()

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

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

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

◆ gimple_assign_ssa_name_copy_p()

◆ gimple_assign_unary_nop_p()

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

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

References CONVERT_EXPR_CODE_P, error_mark_node, ggc_alloc(), 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 ggc_alloc().

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 ggc_alloc().

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 ggc_alloc().

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 ggc_alloc().

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 ggc_alloc().

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

◆ gimple_bind_add_seq()

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

References ggc_alloc(), 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 ggc_alloc(), 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(), ggc_alloc(), and pt_solution::vars.

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

◆ gimple_bind_block()

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

References ggc_alloc().

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

◆ gimple_bind_body()

◆ gimple_bind_body_ptr()

gimple_seq * gimple_bind_body_ptr ( gbind * bind_stmt)
inline

◆ gimple_bind_set_block()

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

References gcc_gimple_checking_assert, ggc_alloc(), NULL_TREE, and TREE_CODE.

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

◆ gimple_bind_set_body()

void gimple_bind_set_body ( gbind * bind_stmt,
gimple_seq seq )
inline

◆ gimple_bind_set_vars()

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

References ggc_alloc(), and pt_solution::vars.

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

◆ gimple_bind_vars()

◆ gimple_block()

◆ gimple_build_asm_vec()

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

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

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

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

◆ gimple_build_assign() [1/4]

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

◆ gimple_build_assign() [2/4]

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

◆ gimple_build_assign() [3/4]

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

◆ gimple_build_assign() [4/4]

gassign * gimple_build_assign ( tree ,
tree CXX_MEM_STAT_INFO )

◆ gimple_build_assume()

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

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

Referenced by gimplify_call_expr(), and remap_gimple_stmt().

◆ gimple_build_bind()

◆ gimple_build_builtin_unreachable()

gcall * gimple_build_builtin_unreachable ( location_t loc)

◆ gimple_build_call()

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

References ap, gcc_assert, ggc_alloc(), 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_fold_builtin_bcmp(), gimple_fold_builtin_bcopy(), gimple_fold_builtin_bzero(), gimple_fold_builtin_fprintf(), gimple_fold_builtin_fputs(), gimple_fold_builtin_memory_chk(), gimple_fold_builtin_printf(), gimple_fold_builtin_realloc(), gimple_fold_builtin_snprintf(), gimple_fold_builtin_sprintf(), gimple_fold_builtin_stpcpy(), gimple_fold_builtin_strcat(), gimple_fold_builtin_strcat_chk(), gimple_fold_builtin_strchr(), gimple_fold_builtin_strcpy(), gimple_fold_builtin_string_compare(), gimple_fold_builtin_strncat(), gimple_fold_builtin_strncat_chk(), gimple_fold_builtin_strncpy(), gimple_fold_builtin_strstr(), gimple_fold_builtin_stxcpy_chk(), gimple_fold_builtin_stxncpy_chk(), gimple_gen_average_profiler(), gimple_gen_ic_func_profiler(), gimple_gen_interval_profiler(), gimple_gen_ior_profiler(), gimple_gen_pow2_profiler(), gimple_gen_topn_values_profiler(), gimple_lower_bitint(), gimplify_expr(), gimplify_modify_expr_to_memcpy(), gimplify_modify_expr_to_memset(), gimplify_omp_workshare(), handle_builtin_alloca(), handle_builtin_stack_restore(), insert_check_and_trap(), insert_trap(), instrument_bool_enum_load(), instrument_builtin(), instrument_decisions(), instrument_expr(), instrument_func_entry(), instrument_func_exit(), instrument_nonnull_arg(), instrument_nonnull_return(), ipa_tm_insert_gettmclone_call(), ipa_tm_insert_irr_call(), issue_prefetch_ref(), lower_builtin_posix_memalign(), lower_builtin_setjmp(), lower_eh_dispatch(), lower_omp_for(), lower_omp_for_scan(), lower_omp_ordered(), lower_omp_scope(), lower_omp_sections(), lower_omp_single_simple(), lower_omp_task_reductions(), lower_omp_taskgroup(), lower_omp_teams(), lower_private_allocate(), lower_rec_input_clauses(), lower_reduction_clauses(), lower_resx(), lower_transaction(), make_data_region_try_statement(), maybe_instrument_call(), maybe_push_res_to_seq(), neuter_worker_single(), omp_build_barrier(), replace_func_exit(), simd_clone_adjust(), tm_log_emit_stmt(), ubsan_expand_bounds_ifn(), ubsan_expand_null_ifn(), ubsan_expand_objsize_ifn(), ubsan_expand_ptr_ifn(), ubsan_expand_vptr_ifn(), vect_build_one_gather_load_call(), vect_build_one_scatter_store_call(), vect_recog_pow_pattern(), vect_recog_rotate_pattern(), vect_setup_realignment(), verify_bb_vtables(), worker_single_copy(), and worker_single_simple().

◆ gimple_build_call_from_tree()

◆ gimple_build_call_internal()

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

References ap, ggc_alloc(), 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(), 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_arith(), match_single_bit_test(), match_uaddc_usubc(), maybe_add_asan_poison_write(), oacc_dim_call(), oacc_entry_exit_single_gang(), ompdevlow_adjust_simt_enter(), optimize_atomic_bit_test_and(), optimize_atomic_op_fetch_cmp_0(), optimize_spaceship(), predicate_load_or_store(), scan_omp_simd(), simplify_count_trailing_zeroes(), split_function(), use_internal_fn(), vect_create_epilog_for_reduction(), vect_gen_loop_len_mask(), vect_gen_while(), vect_gimple_build(), vect_recog_abd_pattern(), vect_recog_average_pattern(), vect_recog_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_add_pattern(), vect_recog_widen_abd_pattern(), vect_transform_reduction(), vectorizable_condition(), vectorizable_load(), vectorizable_store(), vectorize_fold_left_reduction(), version_loop_by_alias_check(), and version_loop_for_if_conversion().

◆ gimple_build_call_internal_vec()

◆ gimple_build_call_valist()

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

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

Referenced by update_gimple_call().

◆ gimple_build_call_vec()

◆ gimple_build_catch()

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

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

References ggc_alloc(), 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 gcc_assert, ggc_alloc(), gimple_build_with_ops, gimple_cond_set_false_label(), gimple_cond_set_lhs(), gimple_cond_set_rhs(), gimple_cond_set_true_label(), tcc_comparison, and TREE_CODE_CLASS.

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

◆ gimple_build_cond_from_tree()

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

◆ gimple_build_debug_begin_stmt()

gdebug * gimple_build_debug_begin_stmt ( tree ,
location_t CXX_MEM_STAT_INFO )

◆ gimple_build_debug_bind()

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

◆ gimple_build_debug_inline_entry()

gdebug * gimple_build_debug_inline_entry ( tree ,
location_t CXX_MEM_STAT_INFO )

◆ gimple_build_debug_source_bind()

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

◆ gimple_build_eh_dispatch()

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

References ggc_alloc(), 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 ggc_alloc(), 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 failure, ggc_alloc(), gimple_alloc(), gimple_eh_filter_set_failure(), and gimple_eh_filter_set_types().

Referenced by gimplify_expr(), and remap_gimple_stmt().

◆ gimple_build_eh_must_not_throw()

geh_mnt * gimple_build_eh_must_not_throw ( tree decl)

◆ gimple_build_goto()

◆ gimple_build_label()

◆ gimple_build_nop()

◆ gimple_build_omp_atomic_load()

◆ 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 ggc_alloc(), 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 ggc_alloc(), 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 ggc_alloc(), gimple_alloc(), gimple_omp_critical_set_clauses(), gimple_omp_critical_set_name(), and gimple_omp_set_body().

Referenced by gimplify_expr(), and remap_gimple_stmt().

◆ gimple_build_omp_for()

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

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

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

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

◆ gimple_build_omp_masked()

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

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

References ggc_alloc(), 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 ggc_alloc(), 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 ggc_alloc(), 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 ggc_alloc(), 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_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 ggc_alloc(), 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 ggc_alloc(), 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 ggc_alloc(), 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 ggc_alloc(), 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 ggc_alloc(), and 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 ggc_alloc(), 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 ggc_alloc(), 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 ggc_alloc(), 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 copy_fn(), ggc_alloc(), 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 ggc_alloc(), 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 ggc_alloc(), 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 ggc_alloc(), gimple_build_with_ops, and gimple_statement_eh_ctrl::region.

Referenced by emit_resx(), and gsi_insert_finally_seq_after_call().

◆ gimple_build_return()

◆ gimple_build_switch()

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

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

References ggc_alloc(), 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 gcc_checking_assert, ggc_alloc(), gimple_build_with_ops, gimple_switch_set_default_label(), and gimple_switch_set_index().

Referenced by gimple_build_switch().

◆ gimple_build_transaction()

◆ 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 gcc_assert, ggc_alloc(), 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 ggc_alloc(), gimple_alloc(), and gimple_wce_set_cleanup().

Referenced by gimple_push_cleanup(), and remap_gimple_stmt().

◆ gimple_builtin_call_types_compatible_p()

◆ gimple_call_alloca_for_var_p() [1/2]

bool gimple_call_alloca_for_var_p ( gcall * s)
inline

◆ gimple_call_alloca_for_var_p() [2/2]

bool gimple_call_alloca_for_var_p ( gimple * s)
inline

◆ gimple_call_arg() [1/2]

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

References gcc_gimple_checking_assert, ggc_alloc(), and gimple_num_ops().

Referenced by _loop_vec_info::_loop_vec_info(), acceptable_pow_call(), add_mask_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_arith_overflow(), expand_BITINTTOFLOAT(), expand_bitquery(), expand_block_edges(), expand_BUILTIN_EXPECT(), expand_call_inline(), expand_call_mem_ref(), expand_call_stmt(), 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_UADDC(), expand_UBSAN_CHECK_ADD(), expand_UBSAN_CHECK_MUL(), expand_UBSAN_CHECK_SUB(), expand_UNIQUE(), expand_vec_cond_mask_optab_fn(), expand_vec_cond_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_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_pta_execute(), is_addr_local(), is_asan_mark_p(), is_copysign_call_with_1(), is_exit_with_zero_arg(), 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(), 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(), 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_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_get_vector_types_for_stmt(), vect_is_simple_use(), vect_loop_dist_alias_call(), vect_loop_vectorized_call(), vect_mark_stmts_to_be_vectorized(), vect_recog_ctz_ffs_pattern(), vect_recog_mask_conversion_pattern(), vect_recog_popcount_clz_ctz_ffs_pattern(), vect_recog_pow_pattern(), vect_recog_rotate_pattern(), vect_recog_sad_pattern(), vect_recog_widen_abd_pattern(), vect_simd_lane_linear(), vect_transform_loop(), vectorizable_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 ggc_alloc(), and gimple_call_arg().

◆ gimple_call_arg_flags()

◆ gimple_call_arg_ptr() [1/2]

◆ gimple_call_arg_ptr() [2/2]

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

◆ gimple_call_builtin_p() [1/3]

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

References DECL_BUILT_IN_CLASS, gimple_builtin_call_types_compatible_p(), gimple_call_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(), 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(), 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(), fixup_noreturn_call(), ccp_folder::fold_stmt(), fold_strstr_to_strncmp(), get_mem_refs_of_builtin_call(), 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(), 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(), 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, ggc_alloc(), 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]

◆ gimple_call_chain() [2/2]

tree gimple_call_chain ( const gimple * gs)
inline

References ggc_alloc(), and gimple_call_chain().

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

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

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

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

Referenced by cleanup_call_ctrl_altering_flag(), ipa_icf_gimple::func_checker::compare_gimple_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

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

Referenced by auto_simd_check_stmt(), branch_prob(), 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_pta_execute(), is_tm_pure_call(), make_edges(), mark_stmt_if_obviously_necessary(), 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 ggc_alloc().

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 ggc_alloc(), and gimple_call_fn().

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

Referenced by gimple_call_fn_ptr(), and walk_gimple_op().

◆ gimple_call_fn_ptr() [2/2]

tree * gimple_call_fn_ptr ( gimple * gs)
inline

◆ gimple_call_fndecl() [1/2]

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

References ggc_alloc(), 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(), ipa_icf_gimple::func_checker::compare_gimple_call(), 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(), eliminate_unnecessary_stmts(), 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_cxa_atexit_call(), is_strlen_related_p(), is_sync_builtin_call(), is_tm_ending(), is_tm_load(), is_tm_simple_load(), is_tm_simple_store(), is_tm_store(), loop_body_includes_call(), lower_coro_builtin(), lower_eh_constructs_2(), lower_omp_1(), lower_stmt(), malloc_candidate_p_1(), mark_all_reaching_defs_necessary_1(), mark_stmt_if_obviously_necessary(), 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

◆ gimple_call_fntype() [1/2]

◆ gimple_call_fntype() [2/2]

tree gimple_call_fntype ( const gimple * gs)
inline

◆ gimple_call_from_new_or_delete()

bool gimple_call_from_new_or_delete ( const gcall * s)
inline
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(), 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, ggc_alloc(), and gimple_call_internal_p().

Referenced by _loop_vec_info::_loop_vec_info(), inchash::add_hashable_expr(), add_mask_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(), 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(), strip_predict_hints(), try_vectorize_loop_1(), 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_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

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

Referenced by _loop_vec_info::_loop_vec_info(), 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(), 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(), 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(), 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_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_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_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(), vect_transform_loop_stmt(), vectorizable_call(), vectorizable_conversion(), vectorizable_load(), vectorizable_simd_clone_call(), vectorizable_store(), verify_gimple_call(), visit_stmt(), vn_reference_lookup_3(), warn_implicit_fallthrough_r(), warn_switch_unreachable_and_auto_init_r(), warn_uninit(), and warn_uninitialized_vars().

◆ gimple_call_internal_p() [2/3]

bool gimple_call_internal_p ( const gimple * gs)
inline

◆ gimple_call_internal_p() [3/3]

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

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

◆ gimple_call_internal_unique_p() [1/2]

◆ gimple_call_internal_unique_p() [2/2]

bool gimple_call_internal_unique_p ( const gimple * gs)
inline

◆ gimple_call_lhs() [1/2]

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

References ggc_alloc().

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_arith_overflow(), expand_BITINTTOFLOAT(), expand_bitquery(), expand_BUILTIN_EXPECT(), expand_call_inline(), expand_call_stmt(), expand_call_tm(), expand_complex_move(), 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_UADDC(), expand_UBSAN_CHECK_ADD(), expand_UBSAN_CHECK_MUL(), expand_UBSAN_CHECK_SUB(), expand_UNIQUE(), expand_vec_cond_mask_optab_fn(), expand_vec_cond_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_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_stmt(), 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 ggc_alloc(), and gimple_call_lhs().

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

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

◆ 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 dump_gimple_call(), expand_call_stmt(), hardcfr_sibcall_search_block(), and returning_call_p().

◆ gimple_call_nocf_check_p()

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

References GF_CALL_NOCF_CHECK, and ggc_alloc().

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

◆ gimple_call_nonnull_arg()

tree gimple_call_nonnull_arg ( gcall * call)

◆ gimple_call_nonnull_result_p()

bool gimple_call_nonnull_result_p ( gcall * call)

◆ gimple_call_noreturn_p() [1/2]

◆ gimple_call_noreturn_p() [2/2]

bool gimple_call_noreturn_p ( const gimple * s)
inline

◆ gimple_call_nothrow_p()

◆ gimple_call_num_args() [1/2]

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

References ggc_alloc(), and gimple_num_ops().

Referenced by _loop_vec_info::_loop_vec_info(), alloc_object_size(), analyze_function_body(), bit_value_assume_aligned(), builtin_call_nomodifying_p(), call_nargs(), can_interpret_as_conditional_op_p(), 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(), is_addr_local(), 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(), 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

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

◆ gimple_call_retslot_flags()

int gimple_call_retslot_flags ( const gcall * stmt)

◆ gimple_call_return_flags()

◆ gimple_call_return_slot_opt_p()

◆ gimple_call_return_type()

◆ gimple_call_same_target_p()

bool gimple_call_same_target_p ( const gimple * c1,
const gimple * c2 )

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

Referenced by gimple_build_call_from_tree(), and gimplify_modify_expr_to_memcpy().

◆ gimple_call_set_arg() [1/2]

◆ gimple_call_set_arg() [2/2]

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

◆ gimple_call_set_by_descriptor()

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

References GF_CALL_BY_DESCRIPTOR, ggc_alloc(), and gimple::subcode.

Referenced by gimple_build_call_from_tree().

◆ gimple_call_set_chain()

◆ gimple_call_set_ctrl_altering() [1/2]

◆ gimple_call_set_ctrl_altering() [2/2]

void gimple_call_set_ctrl_altering ( gimple * s,
bool ctrl_altering_p )
inline

◆ gimple_call_set_expected_throw()

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, ggc_alloc(), and gimple::subcode.

Referenced by gimple_build_call_from_tree().

◆ gimple_call_set_fn()

void gimple_call_set_fn ( gcall * gs,
tree fn )
inline

◆ gimple_call_set_fndecl() [1/2]

◆ gimple_call_set_fndecl() [2/2]

void gimple_call_set_fndecl ( gimple * gs,
tree decl )
inline

◆ gimple_call_set_fntype()

◆ gimple_call_set_from_new_or_delete()

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

References GF_CALL_FROM_NEW_OR_DELETE, ggc_alloc(), 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, ggc_alloc(), 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 ggc_alloc(), 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_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_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_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(), 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_arith(), match_single_bit_test(), match_uaddc_usubc(), 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(), 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_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_add_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

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

Referenced by gimple_build_call_from_tree().

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

Referenced by gimple_build_call_from_tree().

◆ gimple_call_set_nothrow()

◆ gimple_call_set_return_slot_opt()

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

References GF_CALL_RETURN_SLOT_OPT, ggc_alloc(), 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, ggc_alloc(), and gimple::subcode.

Referenced by expand_block_edges(), expand_gimple_basic_block(), expand_thunk(), gimple_build_call_from_tree(), instrument_gimple(), 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, ggc_alloc(), 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)

◆ gimple_call_tail_p()

◆ gimple_call_use_set() [1/2]

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

References gcall::call_used.

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

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 ggc_alloc().

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 ggc_alloc().

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 ggc_alloc().

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 ggc_alloc().

Referenced by walk_gimple_op().

◆ GIMPLE_CHECK2() [1/2]

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

References ggc_alloc().

◆ GIMPLE_CHECK2() [2/2]

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

References ggc_alloc().

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

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, ggc_alloc(), 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 ggc_alloc().

Referenced by autofdo::afdo_propagate_circuit(), arith_overflow_check_p(), associate_equivalences_with_edges(), bound_difference(), strlen_pass::check_and_optimize_stmt(), check_forbidden_calls(), ipa_icf_gimple::func_checker::compare_gimple_cond(), compute_complex_ancestor_jump_func(), cond_removal_in_builtin_zero_pattern(), cond_stmts_equal_p(), 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_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(), 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(), 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_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 ggc_alloc(), and gimple_cond_code().

◆ gimple_cond_false_label()

tree gimple_cond_false_label ( const gcond * gs)
inline

◆ gimple_cond_false_p()

bool gimple_cond_false_p ( const gcond * gs)
inline

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

Referenced by autofdo::afdo_propagate_circuit(), arith_overflow_check_p(), associate_equivalences_with_edges(), bound_difference(), gori_map::calculate_gori(), strlen_pass::check_and_optimize_stmt(), 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(), 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_p(), gimple_cond_lhs(), 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(), 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_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(), 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_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 ggc_alloc(), 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 ggc_alloc().

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

◆ gimple_cond_make_false()

◆ gimple_cond_make_true()

◆ gimple_cond_rhs() [1/2]

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

References ggc_alloc().

Referenced by 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(), 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_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(), 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_p(), gimple_cond_rhs(), 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(), is_feasible_trace(), 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(), 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_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 ggc_alloc(), 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 ggc_alloc().

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

◆ gimple_cond_set_code()

◆ gimple_cond_set_condition()

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

◆ gimple_cond_set_condition_from_tree()

void gimple_cond_set_condition_from_tree ( gcond * stmt,
tree cond )
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_ifandif(), 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 ggc_alloc().

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

◆ gimple_cond_set_lhs()

◆ gimple_cond_set_rhs()

◆ gimple_cond_set_true_label()

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

References ggc_alloc().

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

◆ gimple_cond_true_label()

tree gimple_cond_true_label ( const gcond * gs)
inline

◆ gimple_cond_true_p()

bool gimple_cond_true_p ( const gcond * gs)
inline

◆ 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 cfun, gcc_unreachable, ggc_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_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_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, 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(), lower_omp_for_scan(), maybe_move_debug_stmts_to_successors(), propagate_threaded_block_debug_into(), remap_gimple_stmt(), jump_threader::simplify_control_stmt_condition(), and ssa_create_duplicates().

◆ gimple_could_trap_p()

◆ gimple_could_trap_p_1()

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 DECL_P, DECL_WEAK, FLOAT_TYPE_P, get_gimple_rhs_class(), ggc_alloc(), 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 expand_gimple_basic_block(), and lower_try_catch().

◆ gimple_debug_bind_get_value()

◆ gimple_debug_bind_get_value_ptr()

tree * gimple_debug_bind_get_value_ptr ( gimple * dbg)
inline

◆ gimple_debug_bind_get_var()

◆ gimple_debug_bind_has_value_p()

◆ gimple_debug_bind_p()

◆ gimple_debug_bind_reset_value()

◆ gimple_debug_bind_set_value()

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

References gcc_gimple_checking_assert, ggc_alloc(), 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, ggc_alloc(), 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()

◆ gimple_debug_source_bind_get_value()

tree gimple_debug_source_bind_get_value ( const gimple * dbg)
inline

◆ 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, ggc_alloc(), GIMPLE_CHECK, gimple_debug_source_bind_p(), and gimple_op_ptr().

Referenced by copy_debug_stmt().

◆ gimple_debug_source_bind_get_var()

◆ gimple_debug_source_bind_p()

◆ gimple_debug_source_bind_set_value()

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

References gcc_gimple_checking_assert, ggc_alloc(), 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

◆ 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

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

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

◆ gimple_eh_else_e_body()

◆ gimple_eh_else_e_body_ptr()

gimple_seq * gimple_eh_else_e_body_ptr ( geh_else * eh_else_stmt)
inline

◆ gimple_eh_else_n_body()

◆ gimple_eh_else_n_body_ptr()

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

References ggc_alloc().

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 ggc_alloc().

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 ggc_alloc().

Referenced by gimple_build_eh_else(), and gimple_copy().

◆ gimple_eh_filter_failure()

gimple_seq gimple_eh_filter_failure ( const gimple * gs)
inline

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

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 ggc_alloc().

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 ggc_alloc().

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 ggc_alloc().

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 ggc_alloc().

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 ggc_alloc().

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 ggc_alloc().

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 gcc_gimple_checking_assert, ggc_alloc(), 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(), ggc_alloc(), 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 ggc_alloc(), 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(), match_simplify_replacement(), maybe_remove_writeonly_store(), maybe_set_vectorized_backedge_value(), 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(), range_query::range_of_stmt(), gimple_ranger::range_of_stmt(), dom_ranger::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(), 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_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_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()

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

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

◆ gimple_has_lhs()

◆ gimple_has_location()

◆ gimple_has_mem_ops()

◆ gimple_has_ops()

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

References g, and ggc_alloc().

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

◆ gimple_has_side_effects()

◆ gimple_has_substatements()

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

References g, and ggc_alloc().

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

◆ 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

◆ 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 ggc_alloc(), gimple_ior_addresses_taken_1(), NULL, and walk_stmt_load_store_addr_ops().

Referenced by execute_update_addresses_taken().

◆ gimple_label_label()

◆ gimple_label_set_label()

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

References ggc_alloc().

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_bool_pattern(), 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_iv(), create_omp_child_function(), create_phi_for_local_result(), create_task_copyfn(), decompose_kernels_region_body(), diag_returned_locals(), 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(), tree_switch_conversion::switch_decision_tree::emit(), emit_warn_switch_unreachable(), 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_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(), 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_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(), 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_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_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(), 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_cast_forwprop_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_add_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()

◆ gimple_no_warning_p()

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

References gimple::no_warning.

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, ggc_alloc(), gimple_block(), gimple_location(), and NULL.

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

◆ gimple_nop_p()

◆ gimple_num_args()

unsigned gimple_num_args ( const gimple * gs)
inline

◆ gimple_num_ops()

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

References ggc_alloc().

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(), 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(), 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_overflow(), 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(), 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 ggc_alloc().

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 ggc_alloc().

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 ggc_alloc().

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 ggc_alloc().

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 ggc_alloc().

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 ggc_alloc().

Referenced by gimple_build_omp_atomic_load().

◆ gimple_omp_atomic_memory_order()

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

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

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 ggc_alloc().

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 ggc_alloc().

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, ggc_alloc(), 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_omp_body_ptr()

◆ gimple_omp_continue_control_def()

tree gimple_omp_continue_control_def ( const gomp_continue * cont_stmt)
inline

◆ 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

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

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 ggc_alloc().

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 ggc_alloc().

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 ggc_alloc().

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 ggc_alloc().

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 ggc_alloc().

Referenced by gimple_build_omp_critical(), and gimple_copy().

◆ gimple_omp_for_clauses()

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

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

◆ gimple_omp_for_collapse()

◆ gimple_omp_for_combined_into_p()

◆ gimple_omp_for_combined_p()

◆ gimple_omp_for_cond()

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

References gcc_gimple_checking_assert, ggc_alloc(), and i.

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 gcc_gimple_checking_assert, ggc_alloc(), and i.

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 gcc_gimple_checking_assert, ggc_alloc(), and i.

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

◆ 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 gcc_gimple_checking_assert, ggc_alloc(), and i.

Referenced by scan_omp_for(), and walk_gimple_op().

◆ gimple_omp_for_index()

◆ gimple_omp_for_index_ptr()

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

References gcc_gimple_checking_assert, ggc_alloc(), and i.

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 gcc_gimple_checking_assert, ggc_alloc(), and i.

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 gcc_gimple_checking_assert, ggc_alloc(), and i.

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

◆ gimple_omp_for_kind()

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

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

◆ gimple_omp_for_set_combined_into_p()

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

References g, GF_OMP_FOR_COMBINED_INTO, and ggc_alloc().

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, GF_OMP_FOR_COMBINED, and ggc_alloc().

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 gcc_gimple_checking_assert, ggc_alloc(), i, 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 gcc_gimple_checking_assert, ggc_alloc(), and i.

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 gcc_gimple_checking_assert, ggc_alloc(), and i.

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 gcc_gimple_checking_assert, ggc_alloc(), and i.

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 gcc_gimple_checking_assert, ggc_alloc(), and i.

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, GF_OMP_FOR_KIND_MASK, and ggc_alloc().

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 ggc_alloc().

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

◆ gimple_omp_masked_clauses()

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

References ggc_alloc(), and 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 ggc_alloc(), and 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 ggc_alloc(), and 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

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

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 ggc_alloc().

Referenced by walk_gimple_op().

◆ gimple_omp_parallel_clauses()

◆ gimple_omp_parallel_clauses_ptr()

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

References ggc_alloc().

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, ggc_alloc(), 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 ggc_alloc().

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 ggc_alloc().

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 ggc_alloc().

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 ggc_alloc().

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, ggc_alloc(), 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 ggc_alloc().

Referenced by gimple_build_omp_parallel(), and gimple_copy().

◆ gimple_omp_return_lhs()

◆ gimple_omp_return_lhs_ptr()

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

References g, and ggc_alloc().

Referenced by walk_gimple_op().

◆ gimple_omp_return_nowait_p()

◆ gimple_omp_return_set_lhs()

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

References g, and ggc_alloc().

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, ggc_alloc(), 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 ggc_alloc().

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 ggc_alloc().

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 ggc_alloc().

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 ggc_alloc(), and 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 ggc_alloc(), and 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 ggc_alloc(), and 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, ggc_alloc(), 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, ggc_alloc(), and GIMPLE_CHECK.

Referenced by lower_omp_sections().

◆ gimple_omp_sections_clauses()

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

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 ggc_alloc().

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 ggc_alloc().

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 ggc_alloc().

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 ggc_alloc().

Referenced by gimple_copy(), and lower_omp_sections().

◆ gimple_omp_set_body()

◆ gimple_omp_set_subcode()

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

References gcc_gimple_checking_assert, and gimple::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 ggc_alloc().

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 ggc_alloc().

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 ggc_alloc().

Referenced by gimple_build_omp_single(), and gimple_copy().

◆ gimple_omp_subcode()

◆ gimple_omp_target_child_fn()

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

References ggc_alloc().

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 ggc_alloc().

Referenced by walk_gimple_op().

◆ gimple_omp_target_clauses()

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

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 ggc_alloc().

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 ggc_alloc().

Referenced by walk_gimple_op().

◆ gimple_omp_target_kind()

◆ gimple_omp_target_set_child_fn()

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

References ggc_alloc().

Referenced by scan_omp_target().

◆ gimple_omp_target_set_clauses()

void gimple_omp_target_set_clauses ( gomp_target * omp_target_stmt,
tree clauses )
inline

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

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, GF_OMP_TARGET_KIND_MASK, and ggc_alloc().

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 ggc_alloc().

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 ggc_alloc().

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 ggc_alloc().

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 ggc_alloc().

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 ggc_alloc().

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 ggc_alloc().

Referenced by walk_gimple_op().

◆ gimple_omp_task_clauses()

◆ gimple_omp_task_clauses_ptr()

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

References ggc_alloc().

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 ggc_alloc().

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 ggc_alloc().

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 ggc_alloc().

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 ggc_alloc().

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 ggc_alloc().

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 ggc_alloc().

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 ggc_alloc().

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 ggc_alloc().

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 copy_fn(), and ggc_alloc().

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 ggc_alloc().

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, ggc_alloc(), 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, ggc_alloc(), and GIMPLE_CHECK.

Referenced by gimplify_omp_task().

◆ gimple_omp_task_taskloop_p()

bool gimple_omp_task_taskloop_p ( const gimple * g)
inline

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

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 ggc_alloc().

◆ gimple_omp_taskreg_clauses()

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

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 ggc_alloc().

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 ggc_alloc().

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

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

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 ggc_alloc().

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 ggc_alloc().

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 ggc_alloc().

◆ gimple_omp_teams_clauses()

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

References ggc_alloc().

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 ggc_alloc().

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 ggc_alloc().

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 ggc_alloc().

◆ gimple_omp_teams_host()

◆ gimple_omp_teams_set_child_fn()

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

References ggc_alloc().

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 ggc_alloc().

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 ggc_alloc().

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

Referenced by gimplify_omp_workshare().

◆ gimple_op()

tree gimple_op ( const gimple * gs,
unsigned i )
inline

◆ gimple_op_ptr()

◆ gimple_ops()

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

References gcc_gimple_checking_assert, ggc_alloc(), 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

◆ gimple_phi_arg() [1/4]

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

References ggc_alloc(), and gimple_phi_arg().

◆ gimple_phi_arg() [2/4]

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

◆ gimple_phi_arg() [3/4]

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

References ggc_alloc(), and gimple_phi_arg().

◆ gimple_phi_arg() [4/4]

◆ gimple_phi_arg_def() [1/2]

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

References ggc_alloc(), and 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 ggc_alloc(), and gimple_phi_arg().

Referenced by add_scope_conflicts_2(), 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(), 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(), ipa_icf::sem_function::init(), insert_backedge_copies(), ipa_simd_modify_function_body(), is_addr_local(), is_degenerate_phi(), is_feasible_trace(), is_maybe_undefined(), loop_has_phi_with_address_arg(), loop_iter_phi_semi_invariant_p(), make_forwarders_with_degenerate_phis(), malloc_candidate_p_1(), 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(), optimize_va_list_gpr_fpr_size(), or_comparisons_1(), output_phi(), phi_add_costs_1(), phi_alternatives_equal(), phi_args_equal_on_edges(), phi_convertible_by_degenerating_args(), phi_dynamic_object_size(), phi_incr_cost_1(), phi_rank(), predicate_scalar_phi(), predict_extra_loop_exits(), gimple_ranger::prefill_stmt_dependencies(), phi_analyzer::process_phi(), 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(), sccopy_propagate(), 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(), vectorizable_induction(), vectorizable_lc_phi(), verify_gimple_in_cfg(), verify_gimple_phi(), verify_live_on_entry(), verify_non_ssa_vars(), verify_ssaname_freelists(), visit_bb(), complex_propagate::visit_phi(), copy_prop::visit_phi(), walk_aliased_vdefs_1(), walk_regimplify_phi(), walk_ssa_copies(), walk_stmt_load_store_addr_ops(), and warn_uninitialized_phi().

◆ gimple_phi_arg_def_from_edge() [1/2]

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

◆ gimple_phi_arg_def_from_edge() [2/2]

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

◆ gimple_phi_arg_def_ptr()

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

◆ gimple_phi_arg_edge()

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

References EDGE_PRED, gimple_bb(), 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(), 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()

◆ gimple_phi_arg_location_from_edge()

◆ gimple_phi_arg_location_ptr()

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

References gimple_phi_arg(), 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 ggc_alloc().

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 ggc_alloc().

Referenced by add_phi_arg(), add_scope_conflicts_2(), 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_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(), 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(), 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(), is_maybe_undefined(), loop_has_phi_with_address_arg(), loop_iter_phi_semi_invariant_p(), make_forwarders_with_degenerate_phis(), malloc_candidate_p_1(), 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(), 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(), 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(), sccopy_propagate(), 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(), verify_gimple_in_cfg(), verify_gimple_phi(), verify_live_on_entry(), verify_phi_args(), verify_ssaname_freelists(), visit_bb(), complex_propagate::visit_phi(), ccp_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 ggc_alloc(), 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 ggc_alloc().

Referenced by scev_dfs::add_to_evolution_1(), and_comparisons_1(), bb_has_non_vop_phi(), rewrite_dom_walker::before_dom_children(), rewrite_update_dom_walker::before_dom_children(), substitute_and_fold_dom_walker::before_dom_children(), strlen_pass::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(), 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(), 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(), 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(), 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(), 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_simplify_replacement(), path_range_query::maybe_register_phi_relation(), ipa_param_body_adjustments::modify_cfun_body(), move_computations_worker(), move_early_exit_stmts(), movement_possibility_1(), op_iter_init_phiuse(), 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(), record_equivalences_from_phis(), tree_switch_conversion::switch_decision_tree::record_phi_operand_mapping(), jump_threader::record_temporary_equivalences_from_phis(), reduc_stmt_res(), relation_oracle::register_stmt(), release_last_vdef(), remove_dead_phis(), remove_phi_node(), remove_unused_locals(), replace_block_by(), 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(), sink_clobbers(), sink_common_stores_to_bb(), slpeel_tree_duplicate_loop_to_edge_cfg(), sm_seq_valid_bb(), split_function(), 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_phi_first_order_recurrence_p(), vect_transform_cycle_phi(), vect_update_ivs_after_vectorizer(), vectorizable_lc_phi(), 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(), complex_propagate::visit_phi(), ccp_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

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

Referenced by add_exit_phi(), gimple_duplicate_bb(), gimple_phi_result_ptr(), 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, gcc_gimple_checking_assert, and ggc_alloc().

◆ gimple_phi_set_result()

void gimple_phi_set_result ( gphi * phi,
tree result )
inline

◆ gimple_plf()

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

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

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

References gimple::plf.

Referenced by 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(), predicate_statements(), register_defs_p(), and remove_dead_phis().

◆ gimple_references_memory_p()

bool gimple_references_memory_p ( gimple * stmt)
inline

◆ gimple_resx_region()

int gimple_resx_region ( const gresx * resx_stmt)
inline

◆ gimple_resx_set_region()

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

References ggc_alloc().

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

◆ gimple_return_retval()

◆ gimple_return_retval_ptr()

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

References ggc_alloc().

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

◆ gimple_seq_add_seq()

void gimple_seq_add_seq ( gimple_seq * dst_p,
gimple_seq src )

◆ gimple_seq_add_seq_without_update()

◆ gimple_seq_add_stmt()

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

References ggc_alloc(), 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(), 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_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_overflow(), 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()

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

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

◆ gimple_seq_first()

◆ gimple_seq_first_nondebug_stmt()

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

References gimple_seq_first(), is_gimple_debug(), and gimple::next.

Referenced by gimplify_body().

◆ gimple_seq_first_stmt()

◆ gimple_seq_first_stmt_as_a_bind()

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

References ggc_alloc(), and gimple_seq_first().

Referenced by finalize_nesting_tree_1(), and lower_omp_target().

◆ gimple_seq_last()

◆ gimple_seq_last_nondebug_stmt()

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

References gimple_seq_last(), 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_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.   

References ggc_alloc().

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(), and tree_switch_conversion::jump_table_cluster::emit().

◆ gimple_seq_singleton_p()

◆ gimple_set_bb()

◆ gimple_set_block()

◆ gimple_set_do_not_emit_location()

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

References g, GF_PLF_1, and gimple_set_plf().

Referenced by gimplify_cond_expr().

◆ gimple_set_has_volatile_ops()

◆ gimple_set_lhs()

◆ gimple_set_location()

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

References copy_warning(), g, and UNKNOWN_LOCATION.

Referenced by add_wait(), adjust_bool_pattern(), annotate_one_with_location(), asan_expand_check_ifn(), asan_expand_mark_ifn(), asan_expand_poison_ifn(), 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_and_insert_ref(), 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_iv(), 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_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(), 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(), optimize_range_tests_to_bit_test(), 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_cast_forwprop_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_add_pattern(), vect_recog_widen_abd_pattern(), and walk_regimplify_phi().

◆ gimple_set_modified()

◆ gimple_set_no_warning()

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

References ggc_alloc(), gimple::no_warning, and no_warning.

◆ gimple_set_num_ops()

◆ gimple_set_op()

◆ gimple_set_plf()

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

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

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

References ggc_alloc(), and gimple::plf.

Referenced by eliminate_unnecessary_stmts(), find_deps_in_bb_for_stmt(), 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(), remove_dead_phis(), set_register_defs(), and visit_phi().

◆ gimple_set_uid()

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

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

◆ gimple_set_vdef()

◆ gimple_set_visited()

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

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

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

References ggc_alloc(), and gimple::visited.

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

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

◆ gimple_switch_default_label()

◆ gimple_switch_index()

tree gimple_switch_index ( const gswitch * gs)
inline

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

Referenced by gimple_regimplify_operands(), and propagate_tree_value_into_stmt().

◆ gimple_switch_label()

tree gimple_switch_label ( const gswitch * gs,
unsigned index )
inline

◆ 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, ggc_alloc(), 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::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(), make_gimple_switch_edges(), 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, ggc_alloc(), and gimple_switch_set_label().

Referenced by gimple_build_switch_nlabels().

◆ gimple_switch_set_index()

◆ gimple_switch_set_label()

◆ gimple_switch_set_num_labels()

void gimple_switch_set_num_labels ( gswitch * g,
unsigned nlabels )
inline

◆ gimple_transaction_body()

gimple_seq gimple_transaction_body ( const gtransaction * transaction_stmt)
inline
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

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

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

◆ 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

◆ gimple_transaction_set_label_over()

◆ gimple_transaction_set_label_uninst()

◆ gimple_transaction_set_subcode()

void gimple_transaction_set_subcode ( gtransaction * transaction_stmt,
unsigned int subcode )
inline
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()

◆ 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, ggc_alloc(), GIMPLE_TRY_CATCH, GIMPLE_TRY_CATCH_IS_CLEANUP, and gimple_try_kind().

Referenced by honor_protect_cleanup_actions().

◆ gimple_try_cleanup()

◆ gimple_try_cleanup_ptr()

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

References ggc_alloc().

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_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 ggc_alloc().

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

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

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 ggc_alloc().

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, ggc_alloc(), GIMPLE_TRY_CATCH, GIMPLE_TRY_FINALLY, and gimple_try_kind().

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_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(), rewrite_expr_tree(), set_autoinc_for_original_candidates(), vec_info::set_vinfo_for_stmt(), ssa_propagation_engine::simulate_stmt(), sort_after_uid(), 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(), and vect_stmt_dominates_stmt_p().

◆ 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 g, ggc_alloc(), and NULL.

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 g, ggc_alloc(), and NULL_TREE.

Referenced by 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(), 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_memory_op(), 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(), 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 g, ggc_alloc(), and NULL.

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.   

References gimple::visited.

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 g, ggc_alloc(), and NULL_TREE.

Referenced by strlen_pass::adjust_last_stmt(), bb_no_side_effects_p(), 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(), 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(), 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_memory_op(), 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(), is_maybe_undefined(), local_mem_dependence(), avail_exprs_stack::lookup_avail_expr(), 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(), 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(), select_best_block(), 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_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 g, ggc_alloc(), and NULL.

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 ggc_alloc(), and 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 ggc_alloc(), and GIMPLE_CHECK.

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 ggc_alloc().

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 ggc_alloc().

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 ggc_alloc(), and GIMPLE_CHECK.

Referenced by gimple_push_cleanup().

◆ gss_for_code()

Return the GSS code used by a GIMPLE code.   

References gcc_gimple_checking_assert, gss_for_code_, and LAST_AND_UNUSED_GIMPLE_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()

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

References ggc_alloc().

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(), find_candidates_dom_walker::before_dom_children(), branch_fixup(), break_up_subtract_bb(), build_bitint_stmt_ssa_conflicts(), build_ssa_conflict_graph(), can_propagate_from(), 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(), expand_call_inline(), expand_case(), expand_complex_move(), expand_complex_operations_1(), expand_expr_real_2(), expand_mul_overflow(), expand_omp_atomic_cas(), expand_omp_atomic_fetch_op(), expand_vector_comparison(), expr_coherent_p(), expr_expected_value_1(), extract_mem_content(), factor_out_conditional_operation(), final_range_test_p(), final_value_replacement_loop(), 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(), 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_computation_aff_1(), get_default_value(), get_min_precision(), get_name_for_bit_test(), 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_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_debug_temp_for_var_def(), 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_maybe_undefined(), is_reassociable_op(), is_strlen_related_p(), is_widening_mult_rhs_p(), legal_cast_p(), 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_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(), move_computations_worker(), 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(), 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(), spaceship_replacement(), split_loop(), 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(), type_conversion_p(), uaddc_is_cplxpart(), uaddc_ne0(), unadjusted_ptr_and_unit_offset(), undistribute_bitref_for_vector(), undistribute_ops_list(), update_range_test(), 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_mixed_size_cond_pattern(), vect_recog_mult_pattern(), vect_recog_rotate_pattern(), vect_recog_sat_add_pattern(), vect_recog_vector_vector_shift_pattern(), vect_simd_lane_linear(), vect_slp_check_for_roots(), vect_slp_linearize_chain(), vect_transform_slp_perm_load_1(), vect_widened_op_tree(), vector_element(), vectorizable_conversion(), copy_prop::visit_stmt(), vn_reference_lookup_3(), vn_reference_maybe_forwprop_address(), vuse_semi_invariant_p(), walk_stmt_load_store_addr_ops(), warn_uninit(), zero_one_minusone(), and zero_one_operation().

◆ is_gimple_call()

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

References ggc_alloc().

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_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(), ssa_is_replaceable_p(), 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(), try_special_add_to_ops(), unlikely_executed_stmt_p(), update_call_edge_frequencies(), update_gimple_call(), var_is_used_for_virtual_call_p(), 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_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_transform_loop_stmt(), vect_widened_op_tree(), vectorizable_conversion(), verify_bb_vtables(), cgraph_node::verify_node(), vn_reference_lookup_3(), and warn_dealloc_offset().

◆ is_gimple_debug()

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

References ggc_alloc().

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(), create_iv(), 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(), execute_update_addresses_taken(), expand_FALLTHROUGH_r(), expand_gimple_basic_block(), expand_omp_atomic_fetch_op(), expand_vector_comparison(), find_interesting_uses(), find_replaceable_in_bb(), find_return_bb(), 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_nondebug_singleton_p(), 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_init_stmt(), 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_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_precisions(), vect_determine_vectorization_factor(), vect_get_datarefs_in_loop(), vect_is_simple_reduction(), vect_loop_kill_debug_uses(), vect_mark_stmts_to_be_vectorized(), vect_pattern_recog(), 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()

◆ is_gimple_omp_oacc()

◆ is_gimple_omp_offloaded()

◆ is_gimple_resx()

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

References ggc_alloc().

Referenced by cleanup_empty_eh().

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

◆ phi_nodes()

◆ phi_nodes_ptr()

gimple_seq * phi_nodes_ptr ( basic_block bb)
inline

◆ preprocess_case_label_vec_for_gimple()

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

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

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

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

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

References build_case_label(), CASE_HIGH, CASE_LABEL, CASE_LOW, fold_convert, gcc_assert, gcc_checking_assert, ggc_alloc(), 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()

◆ set_gimple_stmt_max_uid()

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

◆ sort_case_labels()

void sort_case_labels ( vec< tree > & label_vec)
extern
Sort the case labels in LABEL_VEC in place in ascending order.   

References compare_case_labels(), and ggc_alloc().

Referenced by lower_eh_dispatch(), lower_try_finally_switch(), and preprocess_case_label_vec_for_gimple().

◆ stmt_can_terminate_bb_p()

◆ suppress_warning()

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

References get_location(), ggc_alloc(), 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(), 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(), test_for_singularity(), vectorizable_operation(), warn_for_access(), warn_string_no_nul(), and warn_uninit().

◆ warning_suppressed_p()

Variable Documentation

◆ currently_expanding_gimple_stmt

gimple* currently_expanding_gimple_stmt
extern
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

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