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

gimple *	gimple_alloc (enum gimple_code code, unsigned num_ops MEM_STAT_DECL)

static void	gimple_set_subcode (gimple *g, unsigned subcode)

static gimple *	gimple_build_with_ops_stat (enum gimple_code code, unsigned subcode, unsigned num_ops MEM_STAT_DECL)

greturn *	gimple_build_return (tree retval)

void	gimple_call_reset_alias_info (gcall *s)

static gcall *	gimple_build_call_1 (tree fn, unsigned nargs)

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

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

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

static gcall *	gimple_build_call_internal_1 (enum internal_fn fn, unsigned nargs)

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

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

gcall *	gimple_build_call_from_tree (tree t, tree fnptrtype)

gcall *	gimple_build_builtin_unreachable (location_t loc)

gassign *	gimple_build_assign (tree lhs, tree rhs MEM_STAT_DECL)

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

gassign *	gimple_build_assign (tree lhs, enum tree_code subcode, tree op1, tree op2, tree op3 MEM_STAT_DECL)

gassign *	gimple_build_assign (tree lhs, enum tree_code subcode, tree op1, tree op2 MEM_STAT_DECL)

gassign *	gimple_build_assign (tree lhs, enum tree_code subcode, tree op1 MEM_STAT_DECL)

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

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

void	gimple_cond_set_condition_from_tree (gcond *stmt, tree cond)

glabel *	gimple_build_label (tree label)

ggoto *	gimple_build_goto (tree dest)

gimple *	gimple_build_nop (void)

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

static gasm *	gimple_build_asm_1 (const char *string, unsigned ninputs, unsigned noutputs, unsigned nclobbers, unsigned nlabels)

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)

gcatch *	gimple_build_catch (tree types, gimple_seq handler)

geh_filter *	gimple_build_eh_filter (tree types, gimple_seq failure)

geh_mnt *	gimple_build_eh_must_not_throw (tree decl)

geh_else *	gimple_build_eh_else (gimple_seq n_body, gimple_seq e_body)

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

gimple *	gimple_build_wce (gimple_seq cleanup)

gresx *	gimple_build_resx (int region)

gswitch *	gimple_build_switch_nlabels (unsigned nlabels, tree index, tree default_label)

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

geh_dispatch *	gimple_build_eh_dispatch (int region)

gdebug *	gimple_build_debug_bind (tree var, tree value, gimple *stmt MEM_STAT_DECL)

gdebug *	gimple_build_debug_source_bind (tree var, tree value, gimple *stmt MEM_STAT_DECL)

gdebug *	gimple_build_debug_begin_stmt (tree block, location_t location MEM_STAT_DECL)

gdebug *	gimple_build_debug_inline_entry (tree block, location_t location MEM_STAT_DECL)

gomp_critical *	gimple_build_omp_critical (gimple_seq body, tree name, tree clauses)

gomp_for *	gimple_build_omp_for (gimple_seq body, int kind, tree clauses, size_t collapse, gimple_seq pre_body)

gomp_parallel *	gimple_build_omp_parallel (gimple_seq body, tree clauses, tree child_fn, tree data_arg)

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)

gimple *	gimple_build_omp_section (gimple_seq body)

gimple *	gimple_build_omp_structured_block (gimple_seq body)

gimple *	gimple_build_omp_master (gimple_seq body)

gimple *	gimple_build_omp_masked (gimple_seq body, tree clauses)

gimple *	gimple_build_omp_taskgroup (gimple_seq body, tree clauses)

gomp_continue *	gimple_build_omp_continue (tree control_def, tree control_use)

gomp_ordered *	gimple_build_omp_ordered (gimple_seq body, tree clauses)

gimple *	gimple_build_omp_return (bool wait_p)

gomp_scan *	gimple_build_omp_scan (gimple_seq body, tree clauses)

gomp_sections *	gimple_build_omp_sections (gimple_seq body, tree clauses)

gimple *	gimple_build_omp_sections_switch (void)

gomp_single *	gimple_build_omp_single (gimple_seq body, tree clauses)

gimple *	gimple_build_omp_scope (gimple_seq body, tree clauses)

gomp_target *	gimple_build_omp_target (gimple_seq body, int kind, tree clauses)

gomp_teams *	gimple_build_omp_teams (gimple_seq body, tree clauses)

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

gomp_atomic_store *	gimple_build_omp_atomic_store (tree val, enum omp_memory_order mo)

gimple *	gimple_build_assume (tree guard, gimple_seq body)

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

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

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

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_unary ? GIMPLE_UNARY_RHS                                   \
   : ((TYPE) == tcc_binary                                                  \
      || (TYPE) == tcc_comparison) ? GIMPLE_BINARY_RHS                      \
   : ((TYPE) == tcc_constant                                                \
      || (TYPE) == tcc_declaration                                          \
      || (TYPE) == tcc_reference) ? GIMPLE_SINGLE_RHS                       \
   : ((SYM) == TRUTH_AND_EXPR                                               \
      || (SYM) == TRUTH_OR_EXPR                                             \
      || (SYM) == TRUTH_XOR_EXPR) ? GIMPLE_BINARY_RHS                       \
   : (SYM) == TRUTH_NOT_EXPR ? GIMPLE_UNARY_RHS                             \
   : ((SYM) == COND_EXPR                                                    \
      || (SYM) == WIDEN_MULT_PLUS_EXPR                                      \
      || (SYM) == WIDEN_MULT_MINUS_EXPR                                     \
      || (SYM) == DOT_PROD_EXPR                                             \
      || (SYM) == SAD_EXPR                                                  \
      || (SYM) == REALIGN_LOAD_EXPR                                         \
      || (SYM) == VEC_COND_EXPR                                             \
      || (SYM) == VEC_PERM_EXPR                                             \
      || (SYM) == BIT_INSERT_EXPR) ? GIMPLE_TERNARY_RHS                     \
   : ((SYM) == CONSTRUCTOR                                                  \
      || (SYM) == OBJ_TYPE_REF                                              \
      || (SYM) == ADDR_EXPR                                                 \
      || (SYM) == WITH_SIZE_EXPR                                            \
      || (SYM) == SSA_NAME) ? GIMPLE_SINGLE_RHS                             \
   : GIMPLE_INVALID_RHS),

◆ 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 ## _type_node;

◆ 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 \
                     : short_ ## NAME ## _type_node; \
  if (type1 == NAME ## _type_node \
      || type1 == unsigned_ ## NAME ## _type_node) \
    return unsignedp ? unsigned_ ## NAME ## _type_node \
                     : NAME ## _type_node; \
  if (type1 == long_ ## NAME ## _type_node \
      || type1 == unsigned_long_ ## NAME ## _type_node) \
    return unsignedp ? unsigned_long_ ## NAME ## _type_node \
                     : 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 \
                     : 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 \
                     : sat_ ## long_long_ ## NAME ## _type_node;

◆ TYPE_OK

#define TYPE_OK ( node )

Value:

(TYPE_MODE (type) == TYPE_MODE (node) \

&& TYPE_PRECISION (type) == TYPE_PRECISION (node))

type

Definition gengtype.h:252

TYPE_PRECISION

#define TYPE_PRECISION(NODE)

Definition tree.h:2245

TYPE_MODE

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

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

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

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

◆ annotate_all_with_location_after()

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

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

Set the location for gimple statement GS to LOCATION.

References ggc_alloc(), gimple_do_not_emit_location_p(), gimple_has_location(), gimple_set_location(), and should_carry_location_p().

Referenced by annotate_all_with_location(), and annotate_all_with_location_after().

◆ 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 * gimple_alloc	(	enum gimple_code	code,
		unsigned num_ops	MEM_STAT_DECL )

Allocate memory for a GIMPLE statement with code CODE and NUM_OPS
operands.

References ggc_alloc(), ggc_alloc_cleared_gimple_statement_stat(), gimple_alloc_counts, gimple_alloc_sizes, gimple_init(), gimple_size(), and PASS_MEM_STAT.

◆ gimple_asm_clobbers_memory_p()

bool gimple_asm_clobbers_memory_p ( const gasm * stmt )

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

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

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

◆ gimple_assign_copy_p()

bool gimple_assign_copy_p ( gimple * gs )

Return true if GS is a copy assignment.

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

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

◆ gimple_assign_load_p()

bool gimple_assign_load_p ( const gimple * gs )

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

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

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

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

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

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

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

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

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

◆ gimple_assign_ssa_name_copy_p()

bool gimple_assign_ssa_name_copy_p ( gimple * gs )

Return true if GS is a SSA_NAME copy assignment.

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

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

◆ gimple_assign_unary_nop_p()

bool gimple_assign_unary_nop_p ( gimple * gs )

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

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

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

◆ 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

Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operands
OP1, OP2 and OP3.

References gcc_assert, get_gimple_rhs_num_ops(), ggc_alloc(), gimple_assign_set_lhs(), gimple_assign_set_rhs1(), gimple_assign_set_rhs2(), gimple_assign_set_rhs3(), gimple_build_with_ops_stat(), and PASS_MEM_STAT.

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

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

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

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

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

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

◆ gimple_build_builtin_unreachable()

gcall * gimple_build_builtin_unreachable ( location_t loc )

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

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

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

◆ gimple_build_call()

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

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

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

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

gcall * gimple_build_call_from_tree	(	tree	t,
		tree	fnptrtype )

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

Referenced by gimplify_call_expr(), and gimplify_modify_expr().

◆ gimple_build_call_internal()

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

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

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

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

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

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

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

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

◆ gimple_build_call_valist()

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

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

References ap, gcc_assert, 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()

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

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

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

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

◆ gimple_build_catch()

gcatch * gimple_build_catch	(	tree	types,
		gimple_seq	handler )

Build a GIMPLE_CATCH statement.

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

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

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

References ggc_alloc(), gimple_build_cond(), and gimple_cond_get_ops_from_tree().

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

◆ gimple_build_debug_begin_stmt()

gdebug * gimple_build_debug_begin_stmt	(	tree	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()

gdebug * gimple_build_debug_bind	(	tree	var,
		tree	value,
		gimple *stmt	MEM_STAT_DECL )

Build a new GIMPLE_DEBUG_BIND statement.

VAR is bound to VALUE; block and location are taken from STMT.

References ggc_alloc(), gimple_build_with_ops_stat(), GIMPLE_DEBUG_BIND, gimple_debug_bind_set_value(), gimple_debug_bind_set_var(), gimple_location(), gimple_set_location(), and PASS_MEM_STAT.

Referenced by avoid_deep_ter_for_debug(), generate_subtree_copies(), gimple_merge_blocks(), init_subtree_with_zero(), insert_debug_temp_for_var_def(), insert_init_debug_bind(), insert_phi_nodes_for(), load_assign_lhs_subreplacements(), make_new_ssa_for_def(), maybe_move_debug_stmts_to_successors(), maybe_register_def(), ipa_param_adjustments::modify_call(), optimize_atomic_bit_test_and(), remap_gimple_stmt(), remove_dead_stmt(), remove_unused_ivs(), reset_debug_binding(), ipa_param_body_adjustments::reset_debug_stmts(), rewrite_stmt(), spaceship_replacement(), split_function(), sra_modify_assign(), sra_modify_expr(), tree_function_versioning(), and value_replacement().

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

gdebug * gimple_build_debug_source_bind	(	tree	var,
		tree	value,
		gimple *stmt	MEM_STAT_DECL )

Build a new GIMPLE_DEBUG_SOURCE_BIND statement.

VAR is bound to VALUE; block and location are taken from STMT.

References ggc_alloc(), gimple_build_with_ops_stat(), GIMPLE_DEBUG_SOURCE_BIND, gimple_debug_source_bind_set_value(), gimple_debug_source_bind_set_var(), gimple_location(), gimple_set_location(), and PASS_MEM_STAT.

Referenced by ipa_simd_modify_stmt_ops(), maybe_move_debug_stmts_to_successors(), remap_gimple_stmt(), remap_ssa_name(), ipa_param_body_adjustments::reset_debug_stmts(), rewrite_debug_stmt_uses(), and tree_function_versioning().

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

Build a GIMPLE_EH_MUST_NOT_THROW statement.

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

Referenced by honor_protect_cleanup_actions(), and maybe_catch_exception().

◆ gimple_build_goto()

ggoto * gimple_build_goto ( tree dest )

Build a GIMPLE_GOTO statement to label DEST.

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

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

◆ gimple_build_label()

glabel * gimple_build_label ( tree label )

Build a GIMPLE_LABEL statement for LABEL.

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

Referenced by build_instrumentation_call(), clear_padding_emit_loop(), convert_nl_goto_receiver(), emit_post_landing_pad(), frob_into_branch_around(), tree_switch_conversion::switch_conversion::gen_inbound_check(), gimple_block_label(), gimplify_case_label_expr(), gimplify_cond_expr(), gimplify_init_ctor_eval_range(), gimplify_label_expr(), gimplify_loop_expr(), gimplify_switch_expr(), handle_abnormal_edges(), label_to_block(), lower_assumption(), lower_builtin_posix_memalign(), lower_builtin_setjmp(), lower_catch(), lower_cleanup(), lower_eh_filter(), lower_function_body(), lower_lastprivate_clauses(), lower_omp_1(), lower_omp_for(), lower_omp_for_scan(), lower_omp_master(), lower_omp_ordered(), lower_omp_sections(), lower_omp_single_copy(), lower_omp_single_simple(), lower_omp_target(), lower_omp_task_reductions(), lower_omp_taskreg(), lower_omp_teams(), lower_rec_input_clauses(), lower_reduction_clauses(), lower_transaction(), lower_try_finally(), lower_try_finally_copy(), lower_try_finally_nofallthru(), lower_try_finally_onedest(), lower_try_finally_switch(), maybe_add_implicit_barrier_cancel(), replace_goto_queue_cond_clause(), and scan_omp_simd().

◆ gimple_build_nop()

gimple * gimple_build_nop ( void )

Build a GIMPLE_NOP statement.

References ggc_alloc(), and gimple_alloc().

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

◆ gimple_build_omp_atomic_load()

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

Build a GIMPLE_OMP_ATOMIC_LOAD statement.

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

Referenced by create_call_for_reduction_1(), and gimplify_omp_atomic().

◆ gimple_build_omp_atomic_store()

gomp_atomic_store * gimple_build_omp_atomic_store	(	tree	val,
		enum omp_memory_order	mo )

Build a GIMPLE_OMP_ATOMIC_STORE statement.

VAL is the value we are storing.

References 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 * gimple_build_omp_return ( bool wait_p )

Build a GIMPLE_OMP_RETURN statement.
WAIT_P is true if this is a non-waiting return.

References ggc_alloc(), gimple_alloc(), and gimple_omp_return_set_nowait().

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

◆ gimple_build_omp_scan()

gomp_scan * gimple_build_omp_scan	(	gimple_seq	body,
		tree	clauses )

Build a GIMPLE_OMP_SCAN statement.

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

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

greturn * gimple_build_return ( tree retval )

Build a GIMPLE_RETURN statement returning RETVAL.

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

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

◆ gimple_build_switch()

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

Build a GIMPLE_SWITCH statement.

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

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

gtransaction * gimple_build_transaction ( gimple_seq body )

Build a GIMPLE_TRANSACTION statement.

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

Referenced by gimplify_transaction(), and remap_gimple_stmt().

◆ gimple_build_try()

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

Build a GIMPLE_TRY statement.

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

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

static gimple * gimple_build_with_ops_stat	(	enum gimple_code	code,
		unsigned	subcode,
		unsigned num_ops	MEM_STAT_DECL )

static

References gimple_alloc(), gimple_set_subcode(), and PASS_MEM_STAT.

Referenced by gimple_build_assign_1(), gimple_build_debug_begin_stmt(), gimple_build_debug_bind(), gimple_build_debug_inline_entry(), and gimple_build_debug_source_bind().

◆ gimple_builtin_call_types_compatible_p()

bool gimple_builtin_call_types_compatible_p	(	const gimple *	stmt,
		tree	fndecl )

Return true when STMTs arguments and return value match those of FNDECL,
a decl of a builtin function.

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

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

◆ gimple_call_arg_flags()

int gimple_call_arg_flags	(	const gcall *	stmt,
		unsigned	arg )

Detects argument flags for argument number ARG on call STMT.

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

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

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

combined_fn gimple_call_combined_fn ( const gimple * stmt )

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

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

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

◆ gimple_call_copy_skip_args()

gcall * gimple_call_copy_skip_args	(	gcall *	stmt,
		bitmap	args_to_skip )

Build a GIMPLE_CALL identical to STMT but skipping the arguments in
the positions marked by the set ARGS_TO_SKIP.

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

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

attr_fnspec gimple_call_fnspec ( const gcall * stmt )

Return the "fn spec" string for call STMT.

References BUILT_IN_NORMAL, builtin_fnspec(), DECL_IS_OPERATOR_DELETE_P, DECL_IS_REPLACEABLE_OPERATOR, DECL_IS_REPLACEABLE_OPERATOR_NEW_P, gimple_call_builtin_p(), gimple_call_fndecl(), gimple_call_fntype(), gimple_call_from_new_or_delete(), gimple_call_internal_fn(), gimple_call_internal_p(), internal_fn_fnspec(), lookup_attribute(), TREE_VALUE, type(), and TYPE_ATTRIBUTES.

Referenced by check_fnspec(), determine_global_memory_access(), gimple_call_arg_flags(), gimple_call_return_array(), gimple_call_return_flags(), ipa_compute_jump_functions_for_bb(), and gimple_range_op_handler::maybe_builtin_call().

◆ gimple_call_nonnull_arg()

tree gimple_call_nonnull_arg ( gcall * call )

If CALL returns a non-null result in an argument, return that arg.

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

Referenced by fold_using_range::range_of_call().

◆ gimple_call_nonnull_result_p()

bool gimple_call_nonnull_result_p ( gcall * call )

Return true if call STMT is known to return a non-zero result.

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

Referenced by fold_using_range::range_of_call().

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

void gimple_call_reset_alias_info ( gcall * s )

Reset alias information on call S.

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

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

◆ gimple_call_retslot_flags()

int gimple_call_retslot_flags ( const gcall * stmt )

Detects argument flags for return slot on call STMT.

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

Referenced by handle_rhs_call().

◆ gimple_call_return_flags()

int gimple_call_return_flags ( const gcall * stmt )

Detects return flags for the call STMT.

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

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

◆ gimple_call_same_target_p()

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

Return true if calls C1 and C2 are known to go to the same function.

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

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

◆ gimple_call_static_chain_flags()

int gimple_call_static_chain_flags ( const gcall * stmt )

Detects argument flags for static chain on call STMT.

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

Referenced by handle_rhs_call(), and sra_modify_function_body().

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

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

bool gimple_could_trap_p ( const gimple * s )

Return true if statement S can trap.

References gimple_could_trap_p_1().

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

◆ gimple_could_trap_p_1()

bool gimple_could_trap_p_1	(	const gimple *	s,
		bool	include_mem,
		bool	include_stores )

Helper for gimple_could_trap_p and gimple_assign_rhs_could_trap_p.
Return true if S can trap.  When INCLUDE_MEM is true, check whether
the memory operations could trap.  When INCLUDE_STORES is true and
S is a GIMPLE_ASSIGN, the LHS of the assignment is also checked.

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

bool gimple_has_side_effects ( const gimple * s )

Return true if statement S has side-effects.  We consider a
statement to have side effects if:

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

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

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

◆ gimple_inexpensive_call_p()

bool gimple_inexpensive_call_p ( gcall * stmt )

Return false if STMT will likely expand to real function call.

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

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

◆ gimple_init()

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

Initialize GIMPLE statement G with CODE and NUM_OPS.

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

Referenced by gimple_alloc(), and maybe_fold_comparisons_from_match_pd().

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

void gimple_move_vops	(	gimple *	new_stmt,
		gimple *	old_stmt )

Move OLD_STMT's vuse and vdef operands to NEW_STMT, on the assumption
that OLD_STMT is about to be removed.

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

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

◆ gimple_or_expr_nonartificial_location()

location_t gimple_or_expr_nonartificial_location	(	gimple *	stmt,
		tree	expr )

Return a non-artificial location for STMT.  If STMT does not have
location information, get the location from EXPR.

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

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

◆ gimple_seq_add_seq()

void gimple_seq_add_seq	(	gimple_seq *	dst_p,
		gimple_seq	src )

Append sequence SRC to the end of sequence *DST_P.  If *DST_P is
NULL, a new sequence is allocated.

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

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

◆ gimple_seq_add_seq_without_update()

void gimple_seq_add_seq_without_update	(	gimple_seq *	dst_p,
		gimple_seq	src )

Append sequence SRC to the end of sequence *DST_P.  If *DST_P is
NULL, a new sequence is allocated.  This function is
similar to gimple_seq_add_seq, but does not scan the operands.

References ggc_alloc(), gsi_insert_seq_after_without_update(), gsi_last(), GSI_NEW_STMT, NULL, and si.

Referenced by add_bb_predicate_gimplified_stmts(), compute_new_first_bound(), gimple_fold_builtin_strcat(), gimple_simplify_phiopt(), gimplify_body(), instrument_object_size(), maybe_instrument_pointer_overflow(), optimize_range_tests_to_bit_test(), pcom_worker::prepare_finalizers_chain(), pcom_worker::prepare_initializers_chain(), prepare_initializers_chain_store_elim(), remap_gimple_stmt(), and vect_recog_popcount_clz_ctz_ffs_pattern().

◆ gimple_seq_add_stmt()

void gimple_seq_add_stmt	(	gimple_seq *	seq_p,
		gimple *	gs )

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

void gimple_seq_add_stmt_without_update	(	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.  This function is
similar to gimple_seq_add_stmt, but does not scan the operands.
During gimplification, we need to manipulate statement sequences
before the def/use vectors have been constructed.

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

◆ gimple_seq_copy()

gimple_seq gimple_seq_copy ( gimple_seq src )

Perform a deep copy of sequence SRC and return the result.

References ggc_alloc(), gimple_copy(), gimple_seq_add_stmt(), gsi_end_p(), gsi_next(), gsi_start(), gsi_stmt(), and NULL.

Referenced by rt_bb_visited::check(), copy_gimple_seq_and_replace_locals(), duplicate_remap_omp_clause_seq(), gimple_copy(), gsi_insert_finally_seq_after_call(), replace_goto_queue_1(), and replace_goto_queue_cond_clause().

◆ gimple_seq_discard()

void gimple_seq_discard ( gimple_seq seq )

Release SSA_NAMEs in SEQ as well as the GIMPLE statements.

References ggc_free(), gsi_end_p(), gsi_remove(), gsi_start(), gsi_stmt(), and release_defs().

Referenced by create_expression_by_pieces(), eliminate_dom_walker::eliminate_insert(), expand_complex_div_wide(), fold_stmt_1(), gimple_simplify_phiopt(), optimize_range_tests_cmp_bitwise(), optimize_range_tests_to_bit_test(), pcom_worker::prepare_initializers_chain(), release_bb_predicate(), and pcom_worker::release_chain().

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

void gimple_set_bb	(	gimple *	stmt,
		basic_block	bb )

Set BB to be the basic block holding G.

References gimple::bb, cfun, ggc_alloc(), gimple_label_label(), LABEL_DECL_UID, label_to_block_map_for_fn, vec_safe_grow_cleared(), and vec_safe_length().

Referenced by add_phi_node_to_bb(), addsub_pattern::build(), complex_pattern::build(), combine_blocks(), vec_info::free_stmt_vec_info(), gimple_merge_blocks(), gimple_split_block(), gsi_remove(), gsi_replace(), make_blocks_1(), maybe_fold_comparisons_from_match_pd(), set_phi_nodes(), update_bb_for_stmts(), update_epilogue_loop_vinfo(), and vect_init_pattern_stmt().

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

void gimple_set_lhs	(	gimple *	stmt,
		tree	lhs )

Set the LHS of a statement that performs an assignment,
either a GIMPLE_ASSIGN or a GIMPLE_CALL.

References gcc_unreachable, ggc_alloc(), gimple_assign_set_lhs(), and gimple_call_set_lhs().

Referenced by build_and_insert_call(), convert_expand_mult_copysign(), convert_mult_to_fma_1(), gen_assign_counter_update(), gimple_lower_bitint(), gimple_regimplify_operands(), gimple_replace_ssa_lhs(), lower_eh_constructs_2(), lower_oacc_head_mark(), lower_oacc_head_tail(), lower_oacc_loop_marker(), make_blocks_1(), make_new_ssa_for_def(), reassociate_bb(), simplify_count_trailing_zeroes(), vect_create_vectorized_demotion_stmts(), vect_gen_widened_results_half(), vect_mark_pattern_stmts(), vect_transform_reduction(), vectorizable_conversion(), vectorizable_load(), vectorizable_store(), and vectorize_fold_left_reduction().

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

static tree gimple_signed_or_unsigned_type	(	bool	unsignedp,
		tree	type )

static

Return a type the same as TYPE except unsigned or
signed according to UNSIGNEDP.

References int_n_data_t::bitsize, build_nonstandard_integer_type(), char_type_node, ggc_alloc(), GIMPLE_FIXED_MODE_TYPES, GIMPLE_FIXED_MODE_TYPES_SAT, GIMPLE_FIXED_TYPES, GIMPLE_FIXED_TYPES_SAT, i, int_n_data, int_n_enabled_p, int_n_trees, intDI_type_node, integer_type_node, INTEGRAL_TYPE_P, intHI_type_node, intQI_type_node, intSI_type_node, intTI_type_node, long_integer_type_node, long_long_integer_type_node, long_long_unsigned_type_node, long_unsigned_type_node, int_n_data_t::m, short_integer_type_node, short_unsigned_type_node, signed_char_type_node, int_n_trees_t::signed_type, type(), TYPE_MAIN_VARIANT, TYPE_MODE, TYPE_OK, TYPE_PRECISION, TYPE_UNSIGNED, unsigned_char_type_node, unsigned_intDI_type_node, unsigned_intHI_type_node, unsigned_intQI_type_node, unsigned_intSI_type_node, unsigned_intTI_type_node, int_n_trees_t::unsigned_type, and unsigned_type_node.

Referenced by gimple_signed_type(), and gimple_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()

bool infer_nonnull_range_by_attribute	(	gimple *	stmt,
		tree	op )

Return true if OP can be inferred to be a non-NULL after STMT
executes by using attributes.

References attrs, current_function_decl, ggc_alloc(), gimple_call_arg(), gimple_call_fntype(), gimple_call_internal_p(), gimple_call_num_args(), gimple_return_retval(), i, is_gimple_call(), lookup_attribute(), NULL_TREE, operand_equal_p(), POINTER_TYPE_P, TREE_CHAIN, TREE_INT_CST_LOW, TREE_TYPE, TREE_VALUE, and TYPE_ATTRIBUTES.

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

◆ infer_nonnull_range_by_dereference()

bool infer_nonnull_range_by_dereference	(	gimple *	stmt,
		tree	op )

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

bool nonfreeing_call_p ( gimple * call )

Return true when CALL is a call stmt that definitely doesn't
free any memory or makes it unavailable otherwise.

References AVAIL_INTERPOSABLE, BUILT_IN_NORMAL, DECL_FUNCTION_CODE(), ECF_LEAF, cgraph_node::function_symbol(), cgraph_node::get(), ggc_alloc(), gimple_call_arg(), gimple_call_builtin_p(), gimple_call_flags(), gimple_call_fndecl(), gimple_call_internal_fn(), gimple_call_internal_p(), cgraph_node::nonfreeing_fn, and tree_to_uhwi().

Referenced by nontrapping_dom_walker::before_dom_children(), check_call(), imm_dom_path_with_freeing_call(), sanopt_optimize_walker(), and transform_statements().

◆ 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

enum gimple_code gcall

Referenced by build_tm_load(), and build_tm_store().

◆ gcond

enum gimple_code 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

uint64_t gimple_alloc_sizes[(int) gimple_alloc_kind_all]

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

◆ gimple_code_name

const char* const gimple_code_name[]

Initial value:

= {

}

Referenced by decompose_kernels_region_body(), do_niy(), dump_gimple_fmt(), dump_omp_region(), and lto_tag_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_

EXPORTED_CONST enum gimple_statement_structure_enum 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().

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 []

Macros

Functions

Variables

Macro Definition Documentation

◆ DEFGSCODE [1/2]

◆ DEFGSCODE [2/2]

◆ DEFGSSTRUCT [1/2]

◆ DEFGSSTRUCT [2/2]

◆ DEFTREECODE

◆ END_OF_BASE_TREE_CODES

◆ gimple_build_with_ops

◆ GIMPLE_FIXED_MODE_TYPES

◆ GIMPLE_FIXED_MODE_TYPES_SAT

◆ GIMPLE_FIXED_TYPES

◆ GIMPLE_FIXED_TYPES_SAT

◆ TYPE_OK

Function Documentation

◆ annotate_all_with_location()

◆ annotate_all_with_location_after()

◆ annotate_one_with_location()

◆ check_loadstore()

◆ compare_case_labels()

◆ dump_decl_set()

◆ dump_gimple_statistics()

◆ empty_body_p()

◆ empty_stmt_p()

◆ get_gimple_rhs_num_ops()

◆ gimple_alloc()

◆ gimple_asm_clobbers_memory_p()

◆ gimple_assign_copy_p()

◆ gimple_assign_load_p()

◆ gimple_assign_rhs_could_trap_p()

◆ gimple_assign_set_rhs_from_tree()

◆ gimple_assign_set_rhs_with_ops()

◆ gimple_assign_ssa_name_copy_p()

◆ gimple_assign_unary_nop_p()

◆ gimple_build_asm_1()

◆ gimple_build_asm_vec()

◆ gimple_build_assign() [1/4]

◆ gimple_build_assign() [2/4]

◆ gimple_build_assign() [3/4]

◆ gimple_build_assign() [4/4]

◆ gimple_build_assign_1()

◆ gimple_build_assume()

◆ gimple_build_bind()

◆ gimple_build_builtin_unreachable()

◆ gimple_build_call()

◆ gimple_build_call_1()

◆ gimple_build_call_from_tree()

◆ gimple_build_call_internal()

◆ gimple_build_call_internal_1()

◆ gimple_build_call_internal_vec()

◆ gimple_build_call_valist()

◆ gimple_build_call_vec()

◆ gimple_build_catch()

◆ gimple_build_cond()

◆ gimple_build_cond_from_tree()

◆ gimple_build_debug_begin_stmt()

◆ gimple_build_debug_bind()

◆ gimple_build_debug_inline_entry()

◆ gimple_build_debug_source_bind()

◆ gimple_build_eh_dispatch()

◆ gimple_build_eh_else()

◆ gimple_build_eh_filter()

◆ gimple_build_eh_must_not_throw()

◆ gimple_build_goto()

◆ gimple_build_label()

◆ gimple_build_nop()

◆ gimple_build_omp_atomic_load()

◆ gimple_build_omp_atomic_store()

◆ gimple_build_omp_continue()

◆ gimple_build_omp_critical()

◆ gimple_build_omp_for()

◆ gimple_build_omp_masked()

◆ gimple_build_omp_master()

◆ gimple_build_omp_ordered()

◆ gimple_build_omp_parallel()

◆ gimple_build_omp_return()

◆ gimple_build_omp_scan()

◆ gimple_build_omp_scope()