GCC Middle and Back End API Reference
gimple.cc File Reference
#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "backend.h"
#include "tree.h"
#include "gimple.h"
#include "ssa.h"
#include "cgraph.h"
#include "diagnostic.h"
#include "alias.h"
#include "fold-const.h"
#include "calls.h"
#include "stor-layout.h"
#include "internal-fn.h"
#include "tree-eh.h"
#include "gimple-iterator.h"
#include "gimple-walk.h"
#include "gimplify.h"
#include "target.h"
#include "builtins.h"
#include "selftest.h"
#include "gimple-pretty-print.h"
#include "stringpool.h"
#include "attribs.h"
#include "asan.h"
#include "ubsan.h"
#include "langhooks.h"
#include "attr-fnspec.h"
#include "ipa-modref-tree.h"
#include "ipa-modref.h"
#include "dbgcnt.h"
#include "gsstruct.def"
#include "gimple.def"
#include "all-tree.def"
Include dependency graph for gimple.cc:

Macros

#define DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP)    (HAS_TREE_OP ? sizeof (struct STRUCT) - sizeof (tree) : 0),
 
#define DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP)   sizeof (struct STRUCT),
 
#define DEFGSCODE(SYM, NAME, GSSCODE)   NAME,
 
#define DEFGSCODE(SYM, NAME, GSSCODE)   GSSCODE,
 
#define gimple_build_with_ops(c, s, n)    gimple_build_with_ops_stat (c, s, n MEM_STAT_INFO)
 
#define DEFTREECODE(SYM, STRING, TYPE, NARGS)
 
#define END_OF_BASE_TREE_CODES   (unsigned char) GIMPLE_INVALID_RHS,
 
#define GIMPLE_FIXED_TYPES(NAME)
 
#define GIMPLE_FIXED_MODE_TYPES(NAME)
 
#define GIMPLE_FIXED_TYPES_SAT(NAME)
 
#define GIMPLE_FIXED_MODE_TYPES_SAT(NAME)
 
#define TYPE_OK(node)
 

Functions

static void gimple_set_code (gimple *g, enum gimple_code code)
 
size_t gimple_size (enum gimple_code code, unsigned num_ops)
 
void gimple_init (gimple *g, enum gimple_code code, unsigned num_ops)
 
gimplegimple_alloc (enum gimple_code code, unsigned num_ops MEM_STAT_DECL)
 
static void gimple_set_subcode (gimple *g, unsigned subcode)
 
static gimplegimple_build_with_ops_stat (enum gimple_code code, unsigned subcode, unsigned num_ops MEM_STAT_DECL)
 
greturngimple_build_return (tree retval)
 
void gimple_call_reset_alias_info (gcall *s)
 
static gcallgimple_build_call_1 (tree fn, unsigned nargs)
 
gcallgimple_build_call_vec (tree fn, const vec< tree > &args)
 
gcallgimple_build_call (tree fn, unsigned nargs,...)
 
gcallgimple_build_call_valist (tree fn, unsigned nargs, va_list ap)
 
static gcallgimple_build_call_internal_1 (enum internal_fn fn, unsigned nargs)
 
gcallgimple_build_call_internal (enum internal_fn fn, unsigned nargs,...)
 
gcallgimple_build_call_internal_vec (enum internal_fn fn, const vec< tree > &args)
 
gcallgimple_build_call_from_tree (tree t, tree fnptrtype)
 
gcallgimple_build_builtin_unreachable (location_t loc)
 
gassigngimple_build_assign (tree lhs, tree rhs MEM_STAT_DECL)
 
static gassigngimple_build_assign_1 (tree lhs, enum tree_code subcode, tree op1, tree op2, tree op3 MEM_STAT_DECL)
 
gassigngimple_build_assign (tree lhs, enum tree_code subcode, tree op1, tree op2, tree op3 MEM_STAT_DECL)
 
gassigngimple_build_assign (tree lhs, enum tree_code subcode, tree op1, tree op2 MEM_STAT_DECL)
 
gassigngimple_build_assign (tree lhs, enum tree_code subcode, tree op1 MEM_STAT_DECL)
 
gcondgimple_build_cond (enum tree_code pred_code, tree lhs, tree rhs, tree t_label, tree f_label)
 
gcondgimple_build_cond_from_tree (tree cond, tree t_label, tree f_label)
 
void gimple_cond_set_condition_from_tree (gcond *stmt, tree cond)
 
glabelgimple_build_label (tree label)
 
ggotogimple_build_goto (tree dest)
 
gimplegimple_build_nop (void)
 
gbindgimple_build_bind (tree vars, gimple_seq body, tree block)
 
static gasmgimple_build_asm_1 (const char *string, unsigned ninputs, unsigned noutputs, unsigned nclobbers, unsigned nlabels)
 
gasmgimple_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)
 
gcatchgimple_build_catch (tree types, gimple_seq handler)
 
geh_filtergimple_build_eh_filter (tree types, gimple_seq failure)
 
geh_mntgimple_build_eh_must_not_throw (tree decl)
 
geh_elsegimple_build_eh_else (gimple_seq n_body, gimple_seq e_body)
 
gtrygimple_build_try (gimple_seq eval, gimple_seq cleanup, enum gimple_try_flags kind)
 
gimplegimple_build_wce (gimple_seq cleanup)
 
gresxgimple_build_resx (int region)
 
gswitchgimple_build_switch_nlabels (unsigned nlabels, tree index, tree default_label)
 
gswitchgimple_build_switch (tree index, tree default_label, const vec< tree > &args)
 
geh_dispatchgimple_build_eh_dispatch (int region)
 
gdebuggimple_build_debug_bind (tree var, tree value, gimple *stmt MEM_STAT_DECL)
 
gdebuggimple_build_debug_source_bind (tree var, tree value, gimple *stmt MEM_STAT_DECL)
 
gdebuggimple_build_debug_begin_stmt (tree block, location_t location MEM_STAT_DECL)
 
gdebuggimple_build_debug_inline_entry (tree block, location_t location MEM_STAT_DECL)
 
gomp_criticalgimple_build_omp_critical (gimple_seq body, tree name, tree clauses)
 
gomp_forgimple_build_omp_for (gimple_seq body, int kind, tree clauses, size_t collapse, gimple_seq pre_body)
 
gomp_parallelgimple_build_omp_parallel (gimple_seq body, tree clauses, tree child_fn, tree data_arg)
 
gomp_taskgimple_build_omp_task (gimple_seq body, tree clauses, tree child_fn, tree data_arg, tree copy_fn, tree arg_size, tree arg_align)
 
gimplegimple_build_omp_section (gimple_seq body)
 
gimplegimple_build_omp_structured_block (gimple_seq body)
 
gimplegimple_build_omp_master (gimple_seq body)
 
gimplegimple_build_omp_masked (gimple_seq body, tree clauses)
 
gimplegimple_build_omp_taskgroup (gimple_seq body, tree clauses)
 
gomp_continuegimple_build_omp_continue (tree control_def, tree control_use)
 
gomp_orderedgimple_build_omp_ordered (gimple_seq body, tree clauses)
 
gimplegimple_build_omp_return (bool wait_p)
 
gomp_scangimple_build_omp_scan (gimple_seq body, tree clauses)
 
gomp_sectionsgimple_build_omp_sections (gimple_seq body, tree clauses)
 
gimplegimple_build_omp_sections_switch (void)
 
gomp_singlegimple_build_omp_single (gimple_seq body, tree clauses)
 
gimplegimple_build_omp_scope (gimple_seq body, tree clauses)
 
gomp_targetgimple_build_omp_target (gimple_seq body, int kind, tree clauses)
 
gomp_teamsgimple_build_omp_teams (gimple_seq body, tree clauses)
 
gomp_atomic_loadgimple_build_omp_atomic_load (tree lhs, tree rhs, enum omp_memory_order mo)
 
gomp_atomic_storegimple_build_omp_atomic_store (tree val, enum omp_memory_order mo)
 
gimplegimple_build_assume (tree guard, gimple_seq body)
 
gtransactiongimple_build_transaction (gimple_seq body)
 
void gimple_seq_add_stmt (gimple_seq *seq_p, gimple *gs)
 
void gimple_seq_add_stmt_without_update (gimple_seq *seq_p, gimple *gs)
 
void gimple_seq_add_seq (gimple_seq *dst_p, gimple_seq src)
 
void gimple_seq_add_seq_without_update (gimple_seq *dst_p, gimple_seq src)
 
static bool should_carry_location_p (gimple *gs)
 
static void annotate_one_with_location (gimple *gs, location_t location)
 
void annotate_all_with_location_after (gimple_seq seq, gimple_stmt_iterator gsi, location_t location)
 
void annotate_all_with_location (gimple_seq stmt_p, location_t location)
 
static bool empty_stmt_p (gimple *stmt)
 
bool empty_body_p (gimple_seq body)
 
gimple_seq gimple_seq_copy (gimple_seq src)
 
bool gimple_call_same_target_p (const gimple *c1, const gimple *c2)
 
int gimple_call_flags (const gimple *stmt)
 
attr_fnspec gimple_call_fnspec (const gcall *stmt)
 
int gimple_call_arg_flags (const gcall *stmt, unsigned arg)
 
int gimple_call_retslot_flags (const gcall *stmt)
 
int gimple_call_static_chain_flags (const gcall *stmt)
 
int gimple_call_return_flags (const gcall *stmt)
 
bool gimple_call_nonnull_result_p (gcall *call)
 
tree gimple_call_nonnull_arg (gcall *call)
 
bool gimple_assign_copy_p (gimple *gs)
 
bool gimple_assign_ssa_name_copy_p (gimple *gs)
 
bool gimple_assign_unary_nop_p (gimple *gs)
 
bool gimple_assign_load_p (const gimple *gs)
 
void gimple_set_bb (gimple *stmt, basic_block bb)
 
void gimple_assign_set_rhs_from_tree (gimple_stmt_iterator *gsi, tree expr)
 
void gimple_assign_set_rhs_with_ops (gimple_stmt_iterator *gsi, enum tree_code code, tree op1, tree op2, tree op3)
 
tree gimple_get_lhs (const gimple *stmt)
 
void gimple_set_lhs (gimple *stmt, tree lhs)
 
gimplegimple_copy (gimple *stmt)
 
void gimple_move_vops (gimple *new_stmt, gimple *old_stmt)
 
bool gimple_has_side_effects (const gimple *s)
 
bool gimple_could_trap_p_1 (const gimple *s, bool include_mem, bool include_stores)
 
bool gimple_could_trap_p (const gimple *s)
 
bool gimple_assign_rhs_could_trap_p (gimple *s)
 
void dump_gimple_statistics (void)
 
unsigned get_gimple_rhs_num_ops (enum tree_code code)
 
gcallgimple_call_copy_skip_args (gcall *stmt, bitmap args_to_skip)
 
bool gimple_compare_field_offset (tree f1, tree f2)
 
static tree gimple_signed_or_unsigned_type (bool unsignedp, tree type)
 
tree gimple_unsigned_type (tree type)
 
tree gimple_signed_type (tree type)
 
alias_set_type gimple_get_alias_set (tree t)
 
static bool gimple_ior_addresses_taken_1 (gimple *, tree addr, tree, void *data)
 
bool gimple_ior_addresses_taken (bitmap addresses_taken, gimple *stmt)
 
bool gimple_builtin_call_types_compatible_p (const gimple *stmt, tree fndecl)
 
bool gimple_call_operator_delete_p (const gcall *stmt)
 
bool gimple_call_builtin_p (const gimple *stmt)
 
bool gimple_call_builtin_p (const gimple *stmt, enum built_in_class klass)
 
bool gimple_call_builtin_p (const gimple *stmt, enum built_in_function code)
 
combined_fn gimple_call_combined_fn (const gimple *stmt)
 
bool gimple_asm_clobbers_memory_p (const gasm *stmt)
 
void dump_decl_set (FILE *file, bitmap set)
 
bool nonfreeing_call_p (gimple *call)
 
bool nonbarrier_call_p (gimple *call)
 
static bool check_loadstore (gimple *, tree op, tree, void *data)
 
bool infer_nonnull_range (gimple *stmt, tree op)
 
bool infer_nonnull_range_by_dereference (gimple *stmt, tree op)
 
bool infer_nonnull_range_by_attribute (gimple *stmt, tree op)
 
static int compare_case_labels (const void *p1, const void *p2)
 
void sort_case_labels (vec< tree > &label_vec)
 
void preprocess_case_label_vec_for_gimple (vec< tree > &labels, tree index_type, tree *default_casep)
 
void gimple_seq_set_location (gimple_seq seq, location_t loc)
 
void gimple_seq_discard (gimple_seq seq)
 
void maybe_remove_unused_call_args (struct function *fn, gimple *stmt)
 
bool gimple_inexpensive_call_p (gcall *stmt)
 
location_t gimple_or_expr_nonartificial_location (gimple *stmt, tree expr)
 

Variables

EXPORTED_CONST size_t gimple_ops_offset_ []
 
static const size_t gsstruct_code_size []
 
const char *const gimple_code_name []
 
EXPORTED_CONST enum gimple_statement_structure_enum gss_for_code_ []
 
uint64_t gimple_alloc_counts [(int) gimple_alloc_kind_all]
 
uint64_t gimple_alloc_sizes [(int) gimple_alloc_kind_all]
 
static const char *const gimple_alloc_kind_names []
 
enum gimple_code gassign
 
enum gimple_code gcall
 
enum gimple_code gcond
 
const unsigned char gimple_rhs_class_table []
 

Macro Definition Documentation

◆ DEFGSCODE [1/2]

#define DEFGSCODE ( SYM,
NAME,
GSSCODE )   NAME,

◆ DEFGSCODE [2/2]

#define DEFGSCODE ( SYM,
NAME,
GSSCODE )   GSSCODE,

◆ DEFGSSTRUCT [1/2]

#define DEFGSSTRUCT ( SYM,
STRUCT,
HAS_TREE_OP )    (HAS_TREE_OP ? sizeof (struct STRUCT) - sizeof (tree) : 0),
Gimple IR support functions.

   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/>.   
All the tuples have their operand vector (if present) at the very bottom
of the structure.  Therefore, the offset required to find the
operands vector the size of the structure minus the size of the 1
element tree array at the end (see gimple_ops).   

◆ DEFGSSTRUCT [2/2]

#define DEFGSSTRUCT ( SYM,
STRUCT,
HAS_TREE_OP )   sizeof (struct STRUCT),
Gimple IR support functions.

   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/>.   
All the tuples have their operand vector (if present) at the very bottom
of the structure.  Therefore, the offset required to find the
operands vector the size of the structure minus the size of the 1
element tree array at the end (see gimple_ops).   

◆ DEFTREECODE

#define DEFTREECODE ( SYM,
STRING,
TYPE,
NARGS )
Value:
(unsigned char) \
: ((TYPE) == tcc_binary \
: ((TYPE) == tcc_constant \
: ((SYM) == TRUTH_AND_EXPR \
|| (SYM) == TRUTH_OR_EXPR \
: ((SYM) == COND_EXPR \
|| (SYM) == DOT_PROD_EXPR \
|| (SYM) == SAD_EXPR \
|| (SYM) == VEC_COND_EXPR \
|| (SYM) == VEC_PERM_EXPR \
: ((SYM) == CONSTRUCTOR \
|| (SYM) == OBJ_TYPE_REF \
|| (SYM) == ADDR_EXPR \
|| (SYM) == WITH_SIZE_EXPR \
|| (SYM) == SSA_NAME) ? GIMPLE_SINGLE_RHS \
T * ggc_alloc(ALONE_CXX_MEM_STAT_INFO)
Definition ggc.h:184
@ GIMPLE_TERNARY_RHS
Definition gimple.h:119
@ GIMPLE_INVALID_RHS
Definition gimple.h:118
@ GIMPLE_SINGLE_RHS
Definition gimple.h:122
@ GIMPLE_UNARY_RHS
Definition gimple.h:121
@ GIMPLE_BINARY_RHS
Definition gimple.h:120
@ tcc_comparison
Definition tree-core.h:233
@ tcc_declaration
Definition tree-core.h:231
@ tcc_constant
Definition tree-core.h:228
@ tcc_unary
Definition tree-core.h:234
@ tcc_binary
Definition tree-core.h:235
@ tcc_reference
Definition tree-core.h:232

◆ END_OF_BASE_TREE_CODES

#define END_OF_BASE_TREE_CODES   (unsigned char) GIMPLE_INVALID_RHS,

◆ gimple_build_with_ops

#define gimple_build_with_ops ( c,
s,
n )    gimple_build_with_ops_stat (c, s, n MEM_STAT_INFO)
Build a tuple with operands.  CODE is the statement to build (which
must be one of the GIMPLE_WITH_OPS tuples).  SUBCODE is the subcode
for the new tuple.  NUM_OPS is the number of operands to allocate.   

Referenced by gimple_build_asm_1(), gimple_build_call_1(), gimple_build_call_internal_1(), gimple_build_cond(), gimple_build_eh_dispatch(), gimple_build_goto(), gimple_build_label(), gimple_build_resx(), gimple_build_return(), and gimple_build_switch_nlabels().

◆ GIMPLE_FIXED_MODE_TYPES

#define GIMPLE_FIXED_MODE_TYPES ( NAME)
Value:
if (type1 == NAME ## _type_node \
|| type1 == u ## NAME ## _type_node) \
return unsignedp ? u ## NAME ## _type_node \
@ NAME
Definition tree-ssa-pre.cc:242

◆ GIMPLE_FIXED_MODE_TYPES_SAT

#define GIMPLE_FIXED_MODE_TYPES_SAT ( NAME)
Value:
if (type1 == sat_ ## NAME ## _type_node \
|| type1 == sat_ ## u ## NAME ## _type_node) \
return unsignedp ? sat_ ## u ## NAME ## _type_node \
: sat_ ## NAME ## _type_node;

◆ GIMPLE_FIXED_TYPES

#define GIMPLE_FIXED_TYPES ( NAME)
Value:
if (type1 == short_ ## NAME ## _type_node \
|| type1 == unsigned_short_ ## NAME ## _type_node) \
return unsignedp ? unsigned_short_ ## NAME ## _type_node \
if (type1 == NAME ## _type_node \
|| type1 == unsigned_ ## NAME ## _type_node) \
return unsignedp ? unsigned_ ## NAME ## _type_node \
if (type1 == long_ ## NAME ## _type_node \
|| type1 == unsigned_long_ ## NAME ## _type_node) \
return unsignedp ? unsigned_long_ ## NAME ## _type_node \
if (type1 == long_long_ ## NAME ## _type_node \
|| type1 == unsigned_long_long_ ## NAME ## _type_node) \
return unsignedp ? unsigned_long_long_ ## NAME ## _type_node \

◆ GIMPLE_FIXED_TYPES_SAT

#define GIMPLE_FIXED_TYPES_SAT ( NAME)
Value:
if (type1 == sat_ ## short_ ## NAME ## _type_node \
|| type1 == sat_ ## unsigned_short_ ## NAME ## _type_node) \
return unsignedp ? sat_ ## unsigned_short_ ## NAME ## _type_node \
: sat_ ## short_ ## NAME ## _type_node; \
if (type1 == sat_ ## NAME ## _type_node \
|| type1 == sat_ ## unsigned_ ## NAME ## _type_node) \
return unsignedp ? sat_ ## unsigned_ ## NAME ## _type_node \
: sat_ ## NAME ## _type_node; \
if (type1 == sat_ ## long_ ## NAME ## _type_node \
|| type1 == sat_ ## unsigned_long_ ## NAME ## _type_node) \
return unsignedp ? sat_ ## unsigned_long_ ## NAME ## _type_node \
: sat_ ## long_ ## NAME ## _type_node; \
if (type1 == sat_ ## long_long_ ## NAME ## _type_node \
|| type1 == sat_ ## unsigned_long_long_ ## NAME ## _type_node) \
return unsignedp ? sat_ ## unsigned_long_long_ ## NAME ## _type_node \

◆ TYPE_OK

#define TYPE_OK ( node)
Value:
(TYPE_MODE (type) == TYPE_MODE (node) \
Definition gengtype.h:252
#define TYPE_PRECISION(NODE)
Definition tree.h:2245
#define TYPE_MODE(NODE)
Definition tree.h:2254

Function Documentation

◆ annotate_all_with_location()

void annotate_all_with_location ( gimple_seq stmt_p,
location_t location )

◆ annotate_all_with_location_after()

void annotate_all_with_location_after ( gimple_seq seq,
gimple_stmt_iterator gsi,
location_t location )
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().

◆ annotate_one_with_location()

static void annotate_one_with_location ( gimple * gs,
location_t location )
static

◆ check_loadstore()

static bool check_loadstore ( gimple * ,
tree op,
tree ,
void * data )
static
Callback for walk_stmt_load_store_ops.

Return TRUE if OP will dereference the tree stored in DATA, FALSE
otherwise.

This routine only makes a superficial check for a dereference.  Thus
it must only be used if it is safe to return a false negative.   

References ggc_alloc(), operand_equal_p(), targetm, TREE_CODE, TREE_OPERAND, TREE_TYPE, and TYPE_ADDR_SPACE.

Referenced by infer_nonnull_range_by_dereference().

◆ compare_case_labels()

static int compare_case_labels ( const void * p1,
const void * p2 )
static
Compare two case labels.  Because the front end should already have
made sure that case ranges do not overlap, it is enough to only compare
the CASE_LOW values of each case label.   

References CASE_LOW, ggc_alloc(), and tree_int_cst_compare().

Referenced by sort_case_labels().

◆ dump_decl_set()

void dump_decl_set ( FILE * file,
bitmap set )
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 )
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().

◆ empty_stmt_p()

static bool empty_stmt_p ( gimple * stmt)
static
Helper function of empty_body_p.  Return true if STMT is an empty
statement.   

References empty_body_p(), ggc_alloc(), and gimple_bind_body().

Referenced by empty_body_p().

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

◆ gimple_alloc()

◆ gimple_asm_clobbers_memory_p()

bool gimple_asm_clobbers_memory_p ( const gasm * stmt)

◆ gimple_assign_copy_p()

◆ gimple_assign_load_p()

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

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

static gasm * gimple_build_asm_1 ( const char * string,
unsigned ninputs,
unsigned noutputs,
unsigned nclobbers,
unsigned nlabels )
inlinestatic
Helper function to set the simple fields of a asm stmt.

STRING is a pointer to a string that is the asm blocks assembly code.
NINPUT is the number of register inputs.
NOUTPUT is the number of register outputs.
NCLOBBERS is the number of clobbered registers.

References ggc_alloc(), ggc_alloc_string(), gimple_alloc_sizes, gimple_build_with_ops, gasm::nc, gasm::ni, gasm::nl, gasm::no, and gasm::string.

Referenced by gimple_build_asm_vec().

◆ 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 lhs,
enum tree_code subcode,
tree op1 MEM_STAT_DECL )
Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operand OP1.   

References gimple_build_assign_1(), NULL_TREE, and PASS_MEM_STAT.

◆ gimple_build_assign() [2/4]

gassign * gimple_build_assign ( tree lhs,
enum tree_code subcode,
tree op1,
tree op2 MEM_STAT_DECL )
Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operands
OP1 and OP2.   

References gimple_build_assign_1(), NULL_TREE, and PASS_MEM_STAT.

◆ gimple_build_assign() [3/4]

gassign * gimple_build_assign ( tree lhs,
enum tree_code subcode,
tree op1,
tree op2,
tree op3 MEM_STAT_DECL )
Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operands
OP1, OP2 and OP3.   

References ggc_alloc(), gimple_build_assign_1(), and PASS_MEM_STAT.

◆ gimple_build_assign() [4/4]

gassign * gimple_build_assign ( tree lhs,
tree rhs MEM_STAT_DECL )
Build a GIMPLE_ASSIGN statement.

LHS of the assignment.
RHS of the assignment which can be unary or binary.   

References extract_ops_from_tree(), ggc_alloc(), gimple_build_assign(), and PASS_MEM_STAT.

Referenced by add_clobbers_to_eh_landing_pad(), adjust_bool_pattern(), adjust_bool_pattern_cast(), adjust_return_value_with_ops(), apply_binop_and_append_stmt(), asan_expand_check_ifn(), asan_expand_mark_ifn(), asan_store_shadow_bytes(), attempt_builtin_copysign(), attempt_builtin_powi(), eliminate_dom_walker::before_dom_children(), build_and_add_sum(), build_and_insert_binop(), build_and_insert_cast(), build_and_insert_ref(), tree_switch_conversion::switch_conversion::build_arrays(), build_assign(), build_assign(), rt_bb_visited::build_block_check(), build_mask_conversion(), tree_switch_conversion::switch_conversion::build_one_array(), build_ref_for_offset(), build_shadow_mem_access(), build_tm_load(), build_tm_store(), build_type_cast(), build_vect_cond_expr(), bump_vector_ptr(), rt_bb_visited::check(), clear_padding_emit_loop(), clear_padding_flush(), clear_padding_type(), clobber_subtree(), ipa_param_body_adjustments::common_initialization(), cond_if_else_store_replacement_1(), cond_store_replacement(), convert_atomic_bit_not(), convert_mult_to_highpart(), convert_scalar_cond_reduction(), copy_bb(), create_add_on_incoming_edge(), create_expression_by_pieces(), create_final_loads_for_reduction(), create_iv(), create_loads_and_stores_for_name(), create_loads_for_reductions(), create_parallel_loop(), create_stores_for_reduction(), declare_return_variable(), default_goacc_reduction(), delete_dead_or_redundant_call(), detach_value(), do_pre_regular_insertion(), duplicate_and_interleave(), early_object_sizes_execute_one(), eliminate_dom_walker::eliminate_cleanup(), tree_switch_conversion::bit_test_cluster::emit(), execute_cse_sincos_1(), execute_early_expand_coro_ifns(), execute_oacc_device_lower(), execute_omp_device_lower(), execute_sm(), execute_sm_exit(), execute_sm_if_changed(), execute_update_addresses_taken(), expand_assign_tm(), expand_call_inline(), expand_call_tm(), expand_complex_div_wide(), expand_complex_move(), expand_oacc_collapse_vars(), expand_oacc_for(), expand_omp_atomic_cas(), expand_omp_atomic_load(), expand_omp_atomic_mutex(), expand_omp_atomic_pipeline(), expand_omp_atomic_store(), expand_omp_build_assign(), expand_omp_for_generic(), expand_omp_for_init_counts(), expand_omp_for_init_vars(), expand_omp_for_static_chunk(), expand_omp_for_static_nochunk(), expand_omp_simd(), expand_omp_target(), expand_omp_taskloop_for_inner(), expand_omp_taskloop_for_outer(), expand_thunk(), expand_transaction(), expand_vector_conversion(), expand_vector_divmod(), extract_omp_for_update_vars(), factor_out_conditional_operation(), final_value_replacement_loop(), finalize_eliminated_stores(), finalize_nesting_tree_1(), find_assumption_locals_r(), fold_builtin_atomic_compare_exchange(), fold_strstr_to_strncmp(), force_into_ssa_name(), gen_assign_counter_update(), gen_conditions_for_pow_int_base(), gen_counter_update(), tree_switch_conversion::switch_conversion::gen_def_assigns(), gen_one_condition(), gen_phi_nest_statement(), generate_memset_builtin(), generate_rawmemchr_builtin(), generate_strlen_builtin_1(), generate_strlen_builtin_using_rawmemchr(), generate_subtree_copies(), get_last_alloca_addr(), get_string_length(), get_target_arguments(), gimple_build(), gimple_build(), gimple_build(), gimple_build_assign(), gimple_build_vector(), gimple_build_vector_from_val(), gimple_divmod_fixed_value(), gimple_expand_vec_cond_expr(), gimple_expand_vec_set_extract_expr(), gimple_fold_builtin_acc_on_device(), gimple_fold_builtin_clear_padding(), gimple_fold_builtin_memchr(), gimple_fold_builtin_memory_op(), gimple_fold_builtin_memset(), 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_strstr(), gimple_fold_call(), gimple_fold_partial_load(), gimple_fold_partial_store(), gimple_gen_ic_profiler(), gimple_ic(), gimple_load_first_char(), gimple_lower_bitint(), gimple_merge_blocks(), gimple_mod_pow2(), gimple_mod_subtract(), gimple_push_cleanup(), gimple_regimplify_operands(), gimple_stringop_fixed_value(), gimplify_and_update_call_from_tree(), gimplify_bind_expr(), gimplify_function_tree(), gimplify_init_constructor(), gimplify_init_ctor_eval_range(), gimplify_modify_expr(), gimplify_modify_expr_complex_part(), gimplify_omp_depend(), gimplify_omp_for(), gimplify_parameters(), handle_abnormal_edges(), handle_builtin_alloca(), strlen_pass::handle_builtin_memset(), handle_builtin_stack_restore(), ifc_temp_var(), increment_start_addr(), init_subtree_with_zero(), init_tmp_var(), initialize_constant_pool_replacements(), initialize_inlined_parameters(), initialize_root_vars_lm(), initialize_root_vars_store_elim_2(), insert_backedge_copies(), insert_clobber_before_stack_restore(), rt_bb_visited::insert_exit_check_on_edge(), insert_initializers(), insert_reciprocals(), instrument_bool_enum_load(), instrument_builtin(), instrument_builtin_call(), instrument_nonnull_arg(), introduce_cast_before_cand(), ipa_simd_modify_function_body(), ipa_simd_modify_stmt_ops(), ipa_tm_insert_gettmclone_call(), linearize_expr(), load_assign_lhs_subreplacements(), lower_assumption(), lower_bitfield(), lower_builtin_posix_memalign(), lower_builtin_setjmp(), lower_coro_builtin(), lower_depend_clauses(), lower_eh_constructs_2(), lower_emutls_1(), lower_oacc_head_tail(), lower_omp_1(), lower_omp_for(), lower_omp_for_scan(), lower_omp_ordered(), lower_omp_scope(), lower_omp_sections(), lower_omp_single(), lower_omp_target(), lower_omp_task_reductions(), lower_omp_taskreg(), lower_omp_teams(), lower_rec_input_clauses(), lower_rec_simd_input_clauses(), lower_reduction_clauses(), lower_try_finally_switch(), make_blocks_1(), match_arith_overflow(), match_single_bit_test(), match_uaddc_usubc(), maybe_cast_to_ptrmode(), maybe_create_ssa_name(), maybe_optimize_range_tests(), maybe_push_res_to_seq(), merge_with_identity(), ipa_param_adjustments::modify_call(), move_computations_worker(), negate_value(), oacc_rewrite_var_decl(), omp_sese_split_blocks(), ompdevlow_adjust_simt_enter(), sm_set_flag_if_changed::operator()(), optimize_atomic_bit_test_and(), optimize_range_tests_cmp_bitwise(), optimize_range_tests_to_bit_test(), optimize_range_tests_var_bound(), optimize_recip_sqrt(), dom_opt_dom_walker::optimize_stmt(), optimize_vector_constructor(), optimize_vector_load(), permute_vec_elements(), phiprop_insert_phi(), powi_as_mults(), powi_as_mults_1(), predicate_scalar_phi(), prepare_target_mem_ref_lvalue(), prepare_vec_mask(), read_vector_array(), reassociate_bb(), pcom_worker::reassociate_to_the_same_stmt(), record_equivalences_from_stmt(), remap_gimple_stmt(), remap_ssa_name(), replace_abnormal_ssa_names(), replace_call_with_value(), replace_loop_annotate(), replace_loop_annotate_in_block(), replace_mult_candidate(), replace_one_candidate(), replace_ref_with(), repropagate_negates(), rewrite_bittest(), rewrite_expr_tree(), rewrite_phi_with_iv(), rewrite_reciprocal(), rewrite_to_defined_overflow(), rewrite_use_nonlinear_expr(), rt_bb_visited::rt_bb_visited(), save_tmp_var(), set_component_ssa_name(), setup_one_parameter(), simd_clone_adjust(), simd_clone_linear_addend(), simplify_builtin_call(), simplify_count_trailing_zeroes(), simplify_using_ranges::simplify_float_conversion_using_ranges(), simplify_using_ranges::simplify_internal_call_using_ranges(), simplify_permutation(), simplify_rotate(), simplify_using_ranges::simplify_truth_ops_using_ranges(), simplify_vector_constructor(), split_function(), sra_modify_expr(), strip_predict_hints(), synth_lshift_by_additions(), take_address_of(), task_reduction_read(), thunk_adjust(), tm_log_emit_restores(), tm_log_emit_saves(), transform_add_to_multiply(), transform_to_exit_first_loop(), tree_vec_extract(), ubsan_expand_null_ifn(), ubsan_expand_objsize_ifn(), ubsan_expand_ptr_ifn(), ubsan_expand_vptr_ifn(), undistribute_bitref_for_vector(), loop_cand::undo_simple_reduction(), update_accumulator_with_ops(), update_ops(), vect_add_conversion_to_pattern(), vect_add_slp_permutation(), vect_adjust_loop_lens_control(), vect_build_one_gather_load_call(), vect_build_one_scatter_store_call(), vect_clobber_variable(), vect_convert_input(), vect_convert_output(), vect_create_cond_for_align_checks(), vect_create_constant_vectors(), vect_create_epilog_for_reduction(), vect_create_half_widening_stmts(), vect_create_partial_epilog(), vect_do_peeling(), vect_emulate_mixed_dot_prod(), vect_expand_fold_left(), vect_gen_len(), vect_get_loop_variant_data_ptr_increment(), vect_gimple_build(), vect_init_vector(), vect_maybe_permute_loop_masks(), vect_permute_load_chain(), vect_permute_store_chain(), vect_recog_average_pattern(), vect_recog_bit_insert_pattern(), vect_recog_bitfield_ref_pattern(), vect_recog_bool_pattern(), vect_recog_cast_forwprop_pattern(), vect_recog_cond_expr_convert_pattern(), vect_recog_ctz_ffs_pattern(), vect_recog_divmod_pattern(), vect_recog_dot_prod_pattern(), vect_recog_gcond_pattern(), vect_recog_mask_conversion_pattern(), vect_recog_mixed_size_cond_pattern(), vect_recog_over_widening_pattern(), vect_recog_popcount_clz_ctz_ffs_pattern(), vect_recog_pow_pattern(), vect_recog_rotate_pattern(), vect_recog_sad_pattern(), vect_recog_vector_vector_shift_pattern(), vect_recog_widen_sum_pattern(), vect_remove_slp_scalar_calls(), vect_set_loop_condition_normal(), vect_set_loop_condition_partial_vectors(), vect_set_loop_condition_partial_vectors_avx512(), vect_set_loop_controls_directly(), vect_setup_realignment(), vect_shift_permute_load_chain(), vect_split_statement(), vect_synth_mult_by_constant(), vect_transform_loop(), vect_transform_reduction(), vect_transform_slp_perm_load_1(), vector_element(), vectorizable_assignment(), vectorizable_bswap(), vectorizable_call(), vectorizable_comparison_1(), vectorizable_condition(), vectorizable_early_exit(), vectorizable_induction(), vectorizable_live_operation(), vectorizable_load(), vectorizable_operation(), vectorizable_recurr(), vectorizable_scan_store(), vectorizable_shift(), vectorizable_simd_clone_call(), vectorizable_store(), vectorize_fold_left_reduction(), vectorize_slp_instance_root_stmt(), rt_bb_visited::vindex(), rt_bb_visited::visit(), rt_bb_visited::vset(), walk_regimplify_phi(), worker_single_copy(), worker_single_simple(), and write_vector_array().

◆ gimple_build_assign_1()

static gassign * gimple_build_assign_1 ( tree lhs,
enum tree_code subcode,
tree op1,
tree op2,
tree op3 MEM_STAT_DECL )
inlinestatic

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

static gcall * gimple_build_call_1 ( tree fn,
unsigned nargs )
inlinestatic
Helper for gimple_build_call, gimple_build_call_valist,
gimple_build_call_vec and gimple_build_call_from_tree.  Build the basic
components of a GIMPLE_CALL statement to function FN with NARGS
arguments.   

References build_fold_addr_expr, ggc_alloc(), gimple_build_with_ops, gimple_call_reset_alias_info(), gimple_call_set_fntype(), gimple_set_op(), TREE_CODE, and TREE_TYPE.

Referenced by gimple_build_call(), gimple_build_call_from_tree(), gimple_build_call_valist(), and gimple_build_call_vec().

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

static gcall * gimple_build_call_internal_1 ( enum internal_fn fn,
unsigned nargs )
inlinestatic
Helper for gimple_build_call_internal and gimple_build_call_internal_vec.
Build the basic components of a GIMPLE_CALL statement to internal
function FN with NARGS arguments.   

References GF_CALL_INTERNAL, ggc_alloc(), gimple_build_with_ops, gimple_call_reset_alias_info(), gimple_call_set_internal_fn(), and gimple::subcode.

Referenced by gimple_build_call_from_tree(), gimple_build_call_internal(), and gimple_build_call_internal_vec().

◆ 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 block,
location_t location MEM_STAT_DECL )
Build a new GIMPLE_DEBUG_BEGIN_STMT statement in BLOCK at
LOCATION.   

References cfun, ggc_alloc(), gimple_build_with_ops_stat(), GIMPLE_DEBUG_BEGIN_STMT, gimple_set_block(), gimple_set_location(), and PASS_MEM_STAT.

Referenced by gimplify_expr().

◆ gimple_build_debug_bind()

◆ gimple_build_debug_inline_entry()

gdebug * gimple_build_debug_inline_entry ( tree block,
location_t location MEM_STAT_DECL )
Build a new GIMPLE_DEBUG_INLINE_ENTRY statement in BLOCK at
LOCATION.  The BLOCK links to the inlined function.   

References cfun, ggc_alloc(), gimple_build_with_ops_stat(), GIMPLE_DEBUG_INLINE_ENTRY, gimple_set_block(), gimple_set_location(), and PASS_MEM_STAT.

Referenced by expand_call_inline().

◆ gimple_build_debug_source_bind()

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

◆ gimple_builtin_call_types_compatible_p()

◆ gimple_call_arg_flags()

◆ gimple_call_builtin_p() [1/3]

bool gimple_call_builtin_p ( const gimple * stmt)
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 )
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 )
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_combined_fn()

◆ gimple_call_copy_skip_args()

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

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

bool gimple_call_operator_delete_p ( const gcall * stmt)
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_same_target_p()

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

◆ gimple_call_static_chain_flags()

int gimple_call_static_chain_flags ( const gcall * stmt)

◆ gimple_compare_field_offset()

bool gimple_compare_field_offset ( tree f1,
tree f2 )
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_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_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_get_alias_set()

alias_set_type gimple_get_alias_set ( tree t)
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(), 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_has_side_effects()

◆ gimple_inexpensive_call_p()

bool gimple_inexpensive_call_p ( gcall * stmt)

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

bool gimple_ior_addresses_taken ( bitmap addresses_taken,
gimple * stmt )
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_ior_addresses_taken_1()

static bool gimple_ior_addresses_taken_1 ( gimple * ,
tree addr,
tree ,
void * data )
static
Helper for gimple_ior_addresses_taken_1.   

References bitmap_set_bit, DECL_P, DECL_UID, get_base_address(), and ggc_alloc().

Referenced by gimple_ior_addresses_taken().

◆ gimple_move_vops()

◆ gimple_or_expr_nonartificial_location()

location_t gimple_or_expr_nonartificial_location ( gimple * stmt,
tree expr )

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

◆ gimple_seq_discard()

◆ gimple_seq_set_location()

void gimple_seq_set_location ( gimple_seq seq,
location_t loc )
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_set_bb()

◆ gimple_set_code()

static void gimple_set_code ( gimple * g,
enum gimple_code code )
inlinestatic
Gimple tuple constructors.
Note: Any constructor taking a ``gimple_seq'' as a parameter, can
be passed a NULL to start with an empty sequence.   
Set the code for statement G to CODE.   

References g.

Referenced by gimple_init().

◆ gimple_set_lhs()

◆ gimple_set_subcode()

static void gimple_set_subcode ( gimple * g,
unsigned subcode )
inlinestatic
Set SUBCODE to be the code of the expression computed by statement G.   

References g, and gcc_assert.

Referenced by gimple_assign_set_rhs_with_ops(), gimple_build_try(), and gimple_build_with_ops_stat().

◆ gimple_signed_or_unsigned_type()

◆ gimple_signed_type()

tree gimple_signed_type ( tree type)
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_unsigned_type()

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

References gimple_signed_or_unsigned_type().

◆ infer_nonnull_range()

bool infer_nonnull_range ( gimple * stmt,
tree op )
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 )
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().

◆ maybe_remove_unused_call_args()

void maybe_remove_unused_call_args ( struct function * fn,
gimple * stmt )
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)
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()

◆ preprocess_case_label_vec_for_gimple()

void preprocess_case_label_vec_for_gimple ( vec< tree > & labels,
tree index_type,
tree * default_casep )
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().

◆ should_carry_location_p()

static bool should_carry_location_p ( gimple * gs)
static
Determine whether to assign a location to the statement GS.   

References ggc_alloc().

Referenced by annotate_one_with_location().

◆ sort_case_labels()

void sort_case_labels ( vec< tree > & label_vec)
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().

Variable Documentation

◆ gassign

enum gimple_code gassign
Static gimple tuple members.   

◆ gcall

Referenced by build_tm_load(), and build_tm_store().

◆ gcond

◆ gimple_alloc_counts

uint64_t gimple_alloc_counts[(int) gimple_alloc_kind_all]
Gimple stats.   

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

◆ gimple_alloc_kind_names

const char* const gimple_alloc_kind_names[]
static
Initial value:
= {
"assignments",
"phi nodes",
"conditionals",
"everything else"
}
Keep in sync with gimple.h:enum gimple_alloc_kind.   

Referenced by dump_gimple_statistics().

◆ gimple_alloc_sizes

◆ gimple_code_name

const char* const gimple_code_name[]

◆ gimple_ops_offset_

EXPORTED_CONST size_t gimple_ops_offset_[]
Initial value:
= {
}
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[]
Initial value:
= {
}

Referenced by get_gimple_rhs_class().

◆ gss_for_code_

Initial value:
= {
}
Map GIMPLE codes to GSS codes.   

Referenced by gss_for_code().

◆ gsstruct_code_size

const size_t gsstruct_code_size[]
static
Initial value:
= {
}

Referenced by gimple_size().